SoPlex

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 [103, 162, 258] 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:explicitviol Should violations of the original problem be explicitly computed in the decomposition simplex? 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:printcondition print condition number during the solve (0 - off, 1 - ratio estimate , 2 - sum estimate, 3 - product estimate, 4 - exact)
Range: [0, 4]
0
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)
Range: [0, 5]
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: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:objlimit_lower lower limit on objective value
Range: [-∞, ∞]
mindouble
real:objlimit_upper upper limit on objective value
Range: [-∞, ∞]
maxdouble
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