ADMITdetectOutliers

ADMITdetectOutliers searches for outlier candidates in the data set of an
infeasible problem.

outliers = ADMITdetectOutliers(problem)
outliers = ADMITdetectOutliers(problem, ops)
outliers = ADMITdetectOutliers(problem, boundSelection)
outliers = ADMITdetectOutliers(problem, boundSelection, ops)
outliers = ADMITdetectOutliers(problem, boundSelection, invertSelection)
outliers = ADMITdetectOutliers(problem, boundSelection, invertSelection, ops)

ADMITdetectOutliers searches for outliers in the explicit upper and lower
bounds by relaxing multiple bounds at once until the problem can no
longer proven to be infeasible. Afterwards a sensitivity analysis using
lagrangian multipliers is performed to determine the influence of the
constraints on the given problem.
This function utilizes the algorithm presented in [1].

NOTE

Usually ADMITdetectOutliers can only find one outlier candidate,
even if multiple outliers exist in the problem's data set. To find more,
the found outlier has to be corrected and ADMITdetectOutliers has to be
called again. See ADMITcorrectOutliers to learn how to do this
automatically.

Please note that only explicit bounds can be found as outliers by
ADMITdetectOutliers. Consider the following example
opt = ADMITproject() + ADMITvariable('x := {real, timeInvariant}') + ...
                       ADMITconstraint('x := [5 10]') + ...
                       ADMITconstraint('x < 3');
Then only the constraint x >= 5 is detected as an outlier, not x < 3,
since this constraint does not define an explicit bound for x.

Inputs
  problem:         A valid ADMITproject or ADMITinfo object describing an
                   infeasible problem. The problem must not contain
                   either binary or integer variables.
  ops:             A valid ADMIToptions object.
  boundSelection:  A char or cell array describing the set of bounds which
                   should be relaxed. ADMITdetectOutliers will only look
                   for outliers in this set of bounds. See the examples
                   below for the syntax.
                   If not given, all explicit upper and lower bounds are
                   selected.
  invertSelection: Logical value. If true, the boundSelection will be
                   inverted, i.e. ADMITdetectOutliers will only relax
                   those bounds which are not contained in
                   boundSelection.
                   Default value is false.

Returns
  outliers: Cell array containint the names and bounds of possible
            outliers. For example {{'x', 'lower'}, {'y(0.1)', 'upper'}}
  cminfo: ADMITcminfo object, for internal use.

Examples for boundSelection

Select the upper and lower bound of the time invariant variable x:
  ADMITdetectOutliers(optInfo, 'x');

Select the lower bounds of all variables:
  ADMITdetectOutliers(optInfo, {'*', 'lower'})

Select the lower bound of the time invariant variable x and all upper
bounds of the time variant variable y for all time points.
  ADMITdetectOutliers(optInfo, {{'x', 'lower'}, {'y(*)', 'upper'}})

Select the upper bound of the time variant variable y at time 0.1.
  ADMITdetectOutliers(optInfo, {'y(0.1), 'upper'})

Example

opt = ADMITproject() + ADMITvariable('x := {real, timeInvariant}') + ...
                       ADMITvariable('y := {real, timeInvariant}') + ...
                       ADMITconstraint('x := [5, 10]') + ...
                       ADMITconstraint('y := [2, 7]') + ...
                       ADMITconstraint('z := [5, 10]') + ...
                       ADMITconstraint('x+z == 18') + ...
                       ADMITconstraint('x+y == 18'); % either x or y too low
optInfo = ADMITcompose(opt);
ADMITdetectOutliers(optInfo);
  % => {{'x', 'upper'}, {'y', 'upper'}}
ADMITdetectOutliers(optInfo, 'x');
  % => {{'x', 'upper'}}
ADMITdetectOutliers(optInfo, 'y');
  % => {{'y', 'upper'}}
ADMITdetectOutliers(optInfo, 'z');
  % => error message