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 [104, 170, 118, 119, 105, 266] 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.

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? | `0` |

bool:computedegen | should the degeneracy be computed for each basis? | `0` |

bool:decompositiondualsimplex | should the decomposition based dual simplex be used to solve the LP? | `0` |

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

bool:explicitviol | Should violations of the original problem be explicitly computed in the decomposition simplex? | `0` |

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

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

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

bool:persistentscaling | should persistent scaling be used? | `1` |

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

bool:ratfacjump | continue iterative refinement with exact basic solution if not optimal? | `0` |

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

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

bool:usecompdual | should the dual of the complementary problem be used in the decomposition simplex? | `0` |

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

int:decomp_displayfreq | the frequency that the decomposition based simplex status output is displayed. Range: { `1` , ..., ∞} | `50` |

int:decomp_iterlimit | the number of iterations before the decomposition simplex initialisation solve is terminated Range: { `1` , ..., ∞} | `100` |

int:decomp_maxaddedrows | maximum number of rows that are added to the reduced problem when using the decomposition based simplex Range: { `1` , ..., ∞} | `500` |

int:decomp_verbosity | the verbosity of decomposition based simplex (0 - error, 1 - warning, 2 - debug, 3 - normal, 4 - high, 5 - full). Range: { `1` , ..., `5` } | `0` |

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

int:factor_update_max | maximum number of LU updates without fresh factorization (0 - auto) | `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 | `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) Range: { `0` , ..., `1` } | `1` |

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: [ `1e-12` , `1` ] | `1e-09` |

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

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

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:minred | minimal reduction (sum of removed rows/cols) to continue simplification Range: [ `0` , `1` ] | `0.0001` |

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

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

real:objlimit_upper | upper limit on objective value Range: [-∞, ∞] | `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 | `1.2` |

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

real:timelimit | time limit in seconds | `GAMS reslim` |