SoPlex (Sequential object-oriented simPlex) 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 |