SoPlex (**S**equential **o**bject-oriented sim**Plex**) is an optimization package for solving linear programming problems (LPs) based on an advanced implementation of the primal and dual revised simplex algorithm. SoPlex is developed at the Zuse-Institute Berlin.

For more detailed information, we refer to [73, 126, 87, 88, 74, 203] and the SoPlex web site.

# Usage

The following statement can be used inside your GAMS program to specify using SOPLEX

Option LP = SOPLEX; { or RMIP }

The above statement should appear before the Solve statement. If SoPlex was specified as the default solver during GAMS installation, the above statement is not necessary.

## Specification of SoPlex Options

GAMS/SoPlex supports the GAMS parameters reslim and iterlim.

To allow to run without an iteration limit (SoPlex default), the GAMS/SoPlex link does not pass on a setting of GAMS option iterlim to 2147483647.

Setting the GAMS option integer1 to a nonzero value enables writing of detailed solution statistics to the log.

Setting the GAMS option integer3 to a nonzero value leads to writing the model instance to a file in LP or MPS format before starting the solution process (`integer3=1`

writes an MPS file, `integer3=2`

writes an LP files, `integer3=4`

writes SoPlex state files (.mps, .bas, .set); sum these values to write several files). The name of the output file is chosen to be the name of the GAMS model file with the extension `.gms`

replaced. Setting the GAMS option integer2 to a nonzero value makes variable and equation names available when writing the LP or MPS files. These options may be useful for debugging purposes.

Options can be specified by a SoPlex options file. A SoPlex options file consists of one option or comment per line. A pound sign (`#`

) at the beginning of a line causes the entire line to be ignored. Otherwise, the line will be interpreted as an option name and value separated by an equal sign (`=`

) and any amount of white space (blanks or tabs).

A small example for a soplex.opt file is:

bool:rowboundflips = true int:algorithm = 0 real:feastol = 1e-5

It causes GAMS/SoPlex to use bound flipping also for row representations, use the primal simplex, and use a primal feasibility tolerance of 1e-5.

# List of SoPlex Options

In the following, we give a detailed list of all SoPlex options.

Option | Description | Default |
---|---|---|

bool:acceptcycling | should cycling solutions be accepted during iterative refinement? Range: boolean | 0 |

bool:ensureray | re-optimize the original problem to get a proof (ray) of infeasibility/unboundedness? Range: boolean | 0 |

bool:forcebasic | try to enforce that the optimal solution is a basic solution Range: boolean | 0 |

bool:fullperturbation | should perturbation be applied to the entire problem? Range: boolean | 0 |

bool:lifting | should lifting be used to reduce range of nonzero matrix coefficients? Range: boolean | 0 |

bool:persistentscaling | should persistent scaling be used? Range: boolean | 1 |

bool:powerscaling | round scaling factors for iterative refinement to powers of two? Range: boolean | 1 |

bool:rowboundflips | use bound flipping also for row representation? Range: boolean | 0 |

bool:simplifier_enable_domcol | enable presolver DominatedCols in PaPILO Range: boolean | 1 |

bool:simplifier_enable_dualfix | enable presolver DualFix in PaPILO Range: boolean | 1 |

bool:simplifier_enable_fixcontinuous | enable presolver FixContinuous in PaPILO Range: boolean | 1 |

bool:simplifier_enable_parallelcols | enable presolver ParallelColDetection in PaPILO Range: boolean | 1 |

bool:simplifier_enable_parallelrows | enable presolver ParallelRowDetection in PaPILO Range: boolean | 1 |

bool:simplifier_enable_propagation | enable presolver ConstraintPropagation in PaPILO Range: boolean | 1 |

bool:simplifier_enable_singletoncols | enable presolver SingletonCols in PaPILO Range: boolean | 1 |

bool:simplifier_enable_stuffing | enable presolver SingletonStuffing in PaPILO Range: boolean | 1 |

bool:testdualinf | should dual infeasibility be tested in order to try to return a dual solution even if primal infeasible? Range: boolean | 0 |

int:algorithm | type of algorithm (0 - primal, 1 - dual) Range: {0, ..., 1} | 1 |

int:displayfreq | display frequency Range: {1, ..., ∞} | 200 |

int:factor_update_max | maximum number of LU updates without fresh factorization (0 - auto) Range: {0, ..., ∞} | 0 |

int:factor_update_type | type of LU update (0 - eta update, 1 - Forrest-Tomlin update) Range: {0, ..., 1} | 1 |

int:hyperpricing | mode for hyper sparse pricing (0 - off, 1 - auto, 2 - always) Range: {0, ..., 2} | 1 |

int:iterlimit | iteration limit (-1 - no limit) Range: {-1, ..., ∞} | GAMS iterlim |

int:leastsq_maxrounds | maximum number of conjugate gradient iterations in least square scaling Range: {0, ..., ∞} | 50 |

int:pricer | pricing method (0 - auto, 1 - dantzig, 2 - parmult, 3 - devex, 4 - quicksteep, 5 - steep) Range: {0, ..., 5} | 0 |

int:printbasismetric | print basis metric during the solve (-1 - off, 0 - condition estimate , 1 - trace, 2 - determinant, 3 - condition) Range: {-1, ..., 3} | -1 |

int:ratiotester | method for ratio test (0 - textbook, 1 - harris, 2 - fast, 3 - boundflipping) Range: {0, ..., 3} | 3 |

int:reflimit | refinement limit (-1 - no limit) Range: {-1, ..., ∞} | -1 |

int:representation | type of computational form (0 - auto, 1 - column representation, 2 - row representation) Range: {0, ..., 2} | 0 |

int:scaler | scaling (0 - off, 1 - uni-equilibrium, 2 - bi-equilibrium, 3 - geometric, 4 - iterated geometric, 5 - least squares, 6 - geometric-equilibrium) Range: {0, ..., 6} | 2 |

int:simplifier | simplifier (0 - off, 1 - auto, 2 - PaPILO, 3 - internal) Range: {0, ..., 3} | 3 |

int:stallreflimit | stalling refinement limit (-1 - no limit) Range: {-1, ..., ∞} | -1 |

int:starter | crash basis generated when starting from scratch (0 - none, 1 - weight, 2 - sum, 3 - vector) Range: {0, ..., 3} | 0 |

int:stattimer | measure for statistics, e.g. factorization time (0 - off, 1 - user time, 2 - wallclock time) Range: {0, ..., 2} | 1 |

int:timer | type of timer (1 - cputime, aka. usertime, 2 - wallclock time, 0 - no timing) Range: {0, ..., 2} | 2 |

int:verbosity | verbosity level (0 - error, 1 - warning, 2 - debug, 3 - normal, 4 - high, 5 - full) Range: {0, ..., 5} | 3 |

real:epsilon_factorization | zero tolerance used in factorization Range: [0, 1] | 1e-20 |

real:epsilon_pivot | pivot zero tolerance used in factorization Range: [0, 1] | 1e-10 |

real:epsilon_update | zero tolerance used in update of the factorization Range: [0, 1] | 1e-16 |

real:epsilon_zero | general zero tolerance Range: [0, 1] | 1e-16 |

real:feastol | primal feasibility tolerance Range: [0, 1] | 1e-06 |

real:fpfeastol | working tolerance for feasibility in floating-point solver during iterative refinement Range: [0, 1] | 1e-09 |

real:fpopttol | working tolerance for optimality in floating-point solver during iterative refinement Range: [0, 1] | 1e-09 |

real:infty | infinity threshold Range: [1e+10, ∞] | ∞ |

real:leastsq_acrcy | accuracy of conjugate gradient method in least squares scaling (higher value leads to more iterations) Range: [1, ∞] | 1000 |

real:liftmaxval | lower threshold in lifting (nonzero matrix coefficients with smaller absolute value will be reformulated) Range: [10, ∞] | 1024 |

real:liftminval | lower threshold in lifting (nonzero matrix coefficients with smaller absolute value will be reformulated) Range: [0, 0.1] | 0.000976562 |

real:maxscaleincr | maximum increase of scaling factors between refinements Range: [1, ∞] | 1e+25 |

real:min_markowitz | minimal Markowitz threshold in LU factorization Range: [0.0001, 0.9999] | 0.01 |

real:minred | minimal reduction (sum of removed rows/cols) to continue simplification Range: [0, 1] | 0.0001 |

real:objlimit_lower | lower limit on objective value Range: real | GAMS cutoff, if maximizing, else -∞ |

real:objlimit_upper | upper limit on objective value Range: real | GAMS cutoff, if minimizing, else +∞ |

real:opttol | dual feasibility tolerance Range: [0, 1] | 1e-06 |

real:refac_basis_nnz | refactor threshold for nonzeros in last factorized basis matrix compared to updated basis matrix Range: [1, 100] | 10 |

real:refac_mem_factor | refactor threshold for memory growth in factorization since last refactorization Range: [1, 10] | 1.5 |

real:refac_update_fill | refactor threshold for fill-in in current factor update compared to fill-in in last factorization Range: [1, 100] | 5 |

real:representation_switch | threshold on number of rows vs. number of columns for switching from column to row representations in auto mode Range: [0, ∞] | 1.2 |

real:simplifier_modifyrowfac | modify constraints when the number of nonzeros or rows is at most this factor times the number of nonzeros or rows before presolving Range: [0, 1] | 1 |

real:sparsity_threshold | sparse pricing threshold (violations < dimension * SPARSITY_THRESHOLD activates sparse pricing) Range: [0, 1] | 0.6 |

real:timelimit | time limit in seconds Range: [0, ∞] | GAMS reslim |