LPPresolver (patrimoine de base SIRIUS 4.13 API)

java.lang.Object
- fr.cnes.sirius.patrius.math.optim.joptimizer.optimizers.LPPresolver

```
public class LPPresolver
extends Object
```
Presolver for a linear problem in the form of: min(c) s.t. A.x = b lb <= x <= ub
Note 1: unboundedLBValue is the distinctive value of an unbounded lower bound. It must be one of the values:
1. Double.NaN (the default)
2. Double.NEGATIVE_INFINITY
Note 2: unboundedUBValue is the distinctive value of an unbounded upper bound. It must be one of the values:
1. Double.NaN (the default)
2. Double.POSITIVE_INFINITY
Note 3: if lb is null, each variable lower bound will be assigned the value of unboundedLBValue
Note 4: if ub is null, each variable upper bound will be assigned the value of unboundedUBValue
Since:

4.6

Author:

alberto trivellato (alberto.trivellato@gmail.com) Ssee E.D. Andersen, K.D. Andersen, "Presolving in linear programming" See Jacek Gondzio "Presolve analysis of linear programs prior to applying an interior point method" See Xin Huang, "Preprocessing and Postprocessing in Linear Optimization"

Field Summary

Fields
Modifier and Type	Field and Description
`static double`	`DEFAULT_UNBOUNDED_LOWER_BOUND` Default unbounded lower bound
`static double`	`DEFAULT_UNBOUNDED_UPPER_BOUND` Default unbounded upper bound

Constructor Summary

Constructors
Constructor and Description

LPPresolver()
Default constructor

LPPresolver(double unboundedLBVal, double unboundedUBVal)
Constructor

Constructors
Constructor and Description
`LPPresolver()` Default constructor
`LPPresolver(double unboundedLBVal, double unboundedUBVal)` Constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`double`	`getMaxRescaledUB()` Get the maximum rescaled lower bound
`double`	`getMinRescaledLB()` Get the minimum rescaled lower bound
`int`	`getOriginalMeq()` Get the original number of variables
`int`	`getOriginalN()` Get the original number of variables
`RealMatrix`	`getPresolvedA()` Get the presolved matrix A
`RealVector`	`getPresolvedB()` Get the presolved vector B
`RealVector`	`getPresolvedC()` Get the presolved vector C
`RealVector`	`getPresolvedLB()` Get the presolved lower bounds vector
`int`	`getPresolvedMeq()` Get the presolved number of variables
`int`	`getPresolvedN()` Get the presolved number of variables
`RealVector`	`getPresolvedUB()` Get the presolved upper bounds vector
`RealVector`	`getPresolvedYlb()` Get the presolved Y lower bounds vector
`RealVector`	`getPresolvedYub()` Get the presolved Y upper bounds vector
`RealVector`	`getPresolvedZlb()` Get the presolved Z lower bounds vector
`RealVector`	`getPresolvedZub()` Get the presolved Z upper bounds vector
`boolean`	`isAvoidIncreaseSparsity()` If true, no method for making normal equations sparser will be applied.
`boolean`	`isLBUnbounded(double lb)` Is the lower bound unbounded?
`boolean`	`isUBUnbounded(double ub)` Is the upper bound unbounded?
`double[]`	`postsolve(double[] x)` From the full x, gives back its postsolved elements.
`double[]`	`presolve(double[] x)` From the full x, gives back its presolved elements.
`void`	`presolve(double[] originalC, double[][] originalA, double[] originalB, double[] originalLB, double[] originalUB)` Presolve
`void`	`presolve(RealVector originalC, RealMatrix originalA, RealVector originalB, RealVector originalLB, RealVector originalUB)` Presolve
`void`	`setAvoidFillIn(boolean avoidFI)` Set true if no methods that cause fill-in in the original matrices will be called or false otherwise
`void`	`setAvoidIncreaseSparsity(boolean avoidIS)` Set true if no method for making normal equations sparser will be applied or false otherwise
`void`	`setAvoidScaling(boolean avoidS)` Set if the matrix scaling should be disabled (true) or not (false)
`void`	`setExpectedSolution(double[] sol)` Just for testing porpose
`void`	`setNOfSlackVariables(int nOfSlackVar)` Set the number of slack variables
`void`	`setZeroTolerance(double epsilon)` Set the value for zero-comparison: if \|a - b\| < eps then a - b = 0.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - DEFAULT_UNBOUNDED_LOWER_BOUND
```
public static final double DEFAULT_UNBOUNDED_LOWER_BOUND
```
    Default unbounded lower bound
    
    See Also:
    
    Constant Field Values
  - DEFAULT_UNBOUNDED_UPPER_BOUND
```
public static final double DEFAULT_UNBOUNDED_UPPER_BOUND
```
    Default unbounded upper bound
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - LPPresolver
```
public LPPresolver()
```
    Default constructor
  - LPPresolver
```
public LPPresolver(double unboundedLBVal,
                   double unboundedUBVal)
```
    Constructor
    
    Parameters:
    
    unboundedLBVal - unbounded lower bound
    
    unboundedUBVal - unbounded upper bound
- Method Detail
  - isAvoidIncreaseSparsity
```
public boolean isAvoidIncreaseSparsity()
```
    If true, no method for making normal equations sparser will be applied.
    
    Returns:
    
    true/false
  - setAvoidIncreaseSparsity
```
public void setAvoidIncreaseSparsity(boolean avoidIS)
```
    Set true if no method for making normal equations sparser will be applied or false otherwise
    
    Parameters:
    
    avoidIS - true/false
  - setAvoidFillIn
```
public void setAvoidFillIn(boolean avoidFI)
```
    Set true if no methods that cause fill-in in the original matrices will be called or false otherwise
    
    Parameters:
    
    avoidFI - true/false
  - setAvoidScaling
```
public void setAvoidScaling(boolean avoidS)
```
    Set if the matrix scaling should be disabled (true) or not (false)
    
    Parameters:
    
    avoidS - true/false
  - presolve
```
public void presolve(double[] originalC,
                     double[][] originalA,
                     double[] originalB,
                     double[] originalLB,
                     double[] originalUB)
```
    Presolve
    
    Parameters:
    
    originalC - original C vector
    
    originalA - original A matrix
    
    originalB - original B vector
    
    originalLB - original LB vector
    
    originalUB - original UB vector
  - presolve
```
public void presolve(RealVector originalC,
                     RealMatrix originalA,
                     RealVector originalB,
                     RealVector originalLB,
                     RealVector originalUB)
```
    Presolve
    
    Parameters:
    
    originalC - original C vector
    
    originalA - original A matrix
    
    originalB - original B vector
    
    originalLB - original LB vector
    
    originalUB - original UB vector
  - presolve
```
public double[] presolve(double[] x)
```
    From the full x, gives back its presolved elements.
    
    Parameters:
    
    x - full x
    
    Returns:
    
    presolved elements
  - postsolve
```
public double[] postsolve(double[] x)
```
    From the full x, gives back its postsolved elements.
    
    Parameters:
    
    x - full x
    
    Returns:
    
    postsolved elements
  - isLBUnbounded
```
public boolean isLBUnbounded(double lb)
```
    Is the lower bound unbounded?
    
    Parameters:
    
    lb - lower bound
    
    Returns:
    
    true/false
  - isUBUnbounded
```
public boolean isUBUnbounded(double ub)
```
    Is the upper bound unbounded?
    
    Parameters:
    
    ub - upper bound
    
    Returns:
    
    true/false
  - getOriginalN
```
public int getOriginalN()
```
    Get the original number of variables
    
    Returns:
    
    original number of variables
  - getOriginalMeq
```
public int getOriginalMeq()
```
    Get the original number of variables
    
    Returns:
    
    original number of variables
  - getPresolvedN
```
public int getPresolvedN()
```
    Get the presolved number of variables
    
    Returns:
    
    presolved number of variables
  - getPresolvedMeq
```
public int getPresolvedMeq()
```
    Get the presolved number of variables
    
    Returns:
    
    presolved number of variables
  - getPresolvedC
```
public RealVector getPresolvedC()
```
    Get the presolved vector C
    
    Returns:
    
    presolved vector C
  - getPresolvedA
```
public RealMatrix getPresolvedA()
```
    Get the presolved matrix A
    
    Returns:
    
    presolved matrix A
  - getPresolvedB
```
public RealVector getPresolvedB()
```
    Get the presolved vector B
    
    Returns:
    
    presolved vector B
  - getPresolvedLB
```
public RealVector getPresolvedLB()
```
    Get the presolved lower bounds vector
    
    Returns:
    
    presolved lower bounds vector
  - getPresolvedUB
```
public RealVector getPresolvedUB()
```
    Get the presolved upper bounds vector
    
    Returns:
    
    presolved ipper bounds vector
  - getPresolvedYlb
```
public RealVector getPresolvedYlb()
```
    Get the presolved Y lower bounds vector
    
    Returns:
    
    presolved Y lower bounds vector
  - getPresolvedYub
```
public RealVector getPresolvedYub()
```
    Get the presolved Y upper bounds vector
    
    Returns:
    
    presolved Y uppwer bounds vector
  - getPresolvedZlb
```
public RealVector getPresolvedZlb()
```
    Get the presolved Z lower bounds vector
    
    Returns:
    
    presolved Z lower bounds vector
  - getPresolvedZub
```
public RealVector getPresolvedZub()
```
    Get the presolved Z upper bounds vector
    
    Returns:
    
    presolved Z uppwer bounds vector
  - setNOfSlackVariables
```
public void setNOfSlackVariables(int nOfSlackVar)
```
    Set the number of slack variables
    
    Parameters:
    
    nOfSlackVar - number
  - setExpectedSolution
```
public void setExpectedSolution(double[] sol)
```
    Just for testing porpose
    
    Parameters:
    
    sol - solution
  - getMinRescaledLB
```
public double getMinRescaledLB()
```
    Get the minimum rescaled lower bound
    
    Returns:
    
    minimum rescaled lower bound
  - getMaxRescaledUB
```
public double getMaxRescaledUB()
```
    Get the maximum rescaled lower bound
    
    Returns:
    
    maximum rescaled lower bound
  - setZeroTolerance
```
public void setZeroTolerance(double epsilon)
```
    Set the value for zero-comparison:
    if |a - b| < eps then a - b = 0.
    Default is the double epsilon machine value.
    
    Parameters:
    
    epsilon - value

Class LPPresolver

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEFAULT_UNBOUNDED_LOWER_BOUND

DEFAULT_UNBOUNDED_UPPER_BOUND

Constructor Detail

LPPresolver

LPPresolver

Method Detail

isAvoidIncreaseSparsity

setAvoidIncreaseSparsity

setAvoidFillIn

setAvoidScaling

presolve

presolve

presolve

postsolve

isLBUnbounded

isUBUnbounded

getOriginalN

getOriginalMeq

getPresolvedN

getPresolvedMeq

getPresolvedC

getPresolvedA

getPresolvedB

getPresolvedLB

getPresolvedUB

getPresolvedYlb

getPresolvedYub

getPresolvedZlb

getPresolvedZub

setNOfSlackVariables

setExpectedSolution

getMinRescaledLB

getMaxRescaledUB

setZeroTolerance