SCIP++ refs/heads/main
 
Loading...
Searching...
No Matches
scippp::params::LP Namespace Reference

Parameters with prefix lp. More...

Variables

constexpr Param< bool > ALWAYSGETDUALS { "lp/alwaysgetduals" }
 should the Farkas duals always be collected when an LP is found to be infeasible?
 
constexpr Param< bool > CHECKDUALFEAS { "lp/checkdualfeas" }
 should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur?
 
constexpr Param< bool > CHECKFARKAS { "lp/checkfarkas" }
 should infeasibility proofs from the LP be checked?
 
constexpr Param< bool > CHECKPRIMFEAS { "lp/checkprimfeas" }
 should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur?
 
constexpr Param< bool > CHECKSTABILITY { "lp/checkstability" }
 should LP solver's return status be checked for stability?
 
constexpr Param< bool > CLEANUPCOLS { "lp/cleanupcols" }
 should new non-basic columns be removed after LP solving?
 
constexpr Param< bool > CLEANUPCOLSROOT { "lp/cleanupcolsroot" }
 should new non-basic columns be removed after root LP solving?
 
constexpr Param< bool > CLEANUPROWS { "lp/cleanuprows" }
 should new basic rows be removed after LP solving?
 
constexpr Param< bool > CLEANUPROWSROOT { "lp/cleanuprowsroot" }
 should new basic rows be removed after root LP solving?
 
constexpr Param< bool > CLEARINITIALPROBINGLP { "lp/clearinitialprobinglp" }
 should lp state be cleared at the end of probing mode when lp was initially unsolved, e.g., when called right after presolving?
 
constexpr Param< int > COLAGELIMIT { "lp/colagelimit" }
 maximum age a dynamic column can reach before it is deleted from the LP (-1: don't delete columns due to aging)
 
constexpr Param< double > CONDITIONLIMIT { "lp/conditionlimit" }
 maximum condition number of LP basis counted as stable (-1.0: no limit)
 
constexpr Param< int > DISABLECUTOFF { "lp/disablecutoff" }
 disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto)
 
constexpr Param< int > FASTMIP { "lp/fastmip" }
 which FASTMIP setting of LP solver should be used? 0: off, 1: low
 
constexpr Param< bool > FREESOLVALBUFFERS { "lp/freesolvalbuffers" }
 should the buffers for storing LP solution values during diving be freed at end of diving?
 
constexpr Param< char > INITALGORITHM { "lp/initalgorithm" }
 LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)
 
constexpr Param< long long > ITERLIM { "lp/iterlim" }
 iteration limit for each single LP solve (-1: no limit)
 
constexpr Param< bool > LEXDUALALGO { "lp/lexdualalgo" }
 should the lexicographic dual algorithm be used?
 
constexpr Param< bool > LEXDUALBASIC { "lp/lexdualbasic" }
 choose fractional basic variables in lexicographic dual algorithm?
 
constexpr Param< int > LEXDUALMAXROUNDS { "lp/lexdualmaxrounds" }
 maximum number of rounds in the lexicographic dual algorithm (-1: unbounded)
 
constexpr Param< bool > LEXDUALROOTONLY { "lp/lexdualrootonly" }
 should the lexicographic dual algorithm be applied only at the root node
 
constexpr Param< bool > LEXDUALSTALLING { "lp/lexdualstalling" }
 turn on the lex dual algorithm only when stalling?
 
constexpr Param< double > MINMARKOWITZ { "lp/minmarkowitz" }
 minimal Markowitz threshold to control sparsity/stability in LU factorization
 
constexpr Param< bool > PRESOLVING { "lp/presolving" }
 should presolving of LP solver be used?
 
constexpr Param< char > PRICING { "lp/pricing" }
 LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial, 's'teepest edge pricing, 'q'uickstart steepest edge pricing, 'd'evex pricing)
 
constexpr Param< int > REFACTORINTERVAL { "lp/refactorinterval" }
 LP refactorization interval (0: auto)
 
constexpr Param< char > RESOLVEALGORITHM { "lp/resolvealgorithm" }
 LP algorithm for resolving LP relaxations if a starting basis exists (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)
 
constexpr Param< double > RESOLVEITERFAC { "lp/resolveiterfac" }
 factor of average LP iterations that is used as LP iteration limit for LP resolve (-1: unlimited)
 
constexpr Param< int > RESOLVEITERMIN { "lp/resolveitermin" }
 minimum number of iterations that are allowed for LP resolve
 
constexpr Param< bool > RESOLVERESTORE { "lp/resolverestore" }
 should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)?
 
constexpr Param< long long > ROOTITERLIM { "lp/rootiterlim" }
 iteration limit for initial root LP solve (-1: no limit)
 
constexpr Param< int > ROWAGELIMIT { "lp/rowagelimit" }
 maximum age a dynamic row can reach before it is deleted from the LP (-1: don't delete rows due to aging)
 
constexpr Param< double > ROWREPSWITCH { "lp/rowrepswitch" }
 simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value (-1.0 to disable row representation)
 
constexpr Param< int > SCALING { "lp/scaling" }
 LP scaling (0: none, 1: normal, 2: aggressive)
 
constexpr Param< int > SOLUTIONPOLISHING { "lp/solutionpolishing" }
 LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto)
 
constexpr Param< int > SOLVEDEPTH { "lp/solvedepth" }
 maximal depth for solving LP at the nodes (-1: no depth limit)
 
constexpr Param< int > SOLVEFREQ { "lp/solvefreq" }
 frequency for solving LP at the nodes (-1: never; 0: only root LP)
 
constexpr Param< int > THREADS { "lp/threads" }
 number of threads used for solving the LP (0: automatic)
 

Detailed Description

Parameters with prefix lp.

Variable Documentation

◆ ALWAYSGETDUALS

Param<bool> scippp::params::LP::ALWAYSGETDUALS { "lp/alwaysgetduals" }
constexpr

should the Farkas duals always be collected when an LP is found to be infeasible?

Definition at line 4778 of file parameters.hpp.

◆ CHECKDUALFEAS

Param<bool> scippp::params::LP::CHECKDUALFEAS { "lp/checkdualfeas" }
constexpr

should LP solutions be checked for dual feasibility, resolving LP when numerical troubles occur?

Definition at line 4743 of file parameters.hpp.

◆ CHECKFARKAS

Param<bool> scippp::params::LP::CHECKFARKAS { "lp/checkfarkas" }
constexpr

should infeasibility proofs from the LP be checked?

Definition at line 4745 of file parameters.hpp.

◆ CHECKPRIMFEAS

Param<bool> scippp::params::LP::CHECKPRIMFEAS { "lp/checkprimfeas" }
constexpr

should LP solutions be checked for primal feasibility, resolving LP when numerical troubles occur?

Definition at line 4741 of file parameters.hpp.

◆ CHECKSTABILITY

Param<bool> scippp::params::LP::CHECKSTABILITY { "lp/checkstability" }
constexpr

should LP solver's return status be checked for stability?

Definition at line 4735 of file parameters.hpp.

◆ CLEANUPCOLS

Param<bool> scippp::params::LP::CLEANUPCOLS { "lp/cleanupcols" }
constexpr

should new non-basic columns be removed after LP solving?

Definition at line 4727 of file parameters.hpp.

◆ CLEANUPCOLSROOT

Param<bool> scippp::params::LP::CLEANUPCOLSROOT { "lp/cleanupcolsroot" }
constexpr

should new non-basic columns be removed after root LP solving?

Definition at line 4729 of file parameters.hpp.

◆ CLEANUPROWS

Param<bool> scippp::params::LP::CLEANUPROWS { "lp/cleanuprows" }
constexpr

should new basic rows be removed after LP solving?

Definition at line 4731 of file parameters.hpp.

◆ CLEANUPROWSROOT

Param<bool> scippp::params::LP::CLEANUPROWSROOT { "lp/cleanuprowsroot" }
constexpr

should new basic rows be removed after root LP solving?

Definition at line 4733 of file parameters.hpp.

◆ CLEARINITIALPROBINGLP

Param<bool> scippp::params::LP::CLEARINITIALPROBINGLP { "lp/clearinitialprobinglp" }
constexpr

should lp state be cleared at the end of probing mode when lp was initially unsolved, e.g., when called right after presolving?

Definition at line 4717 of file parameters.hpp.

◆ COLAGELIMIT

Param<int> scippp::params::LP::COLAGELIMIT { "lp/colagelimit" }
constexpr

maximum age a dynamic column can reach before it is deleted from the LP (-1: don't delete columns due to aging)

Definition at line 4723 of file parameters.hpp.

◆ CONDITIONLIMIT

Param<double> scippp::params::LP::CONDITIONLIMIT { "lp/conditionlimit" }
constexpr

maximum condition number of LP basis counted as stable (-1.0: no limit)

Definition at line 4737 of file parameters.hpp.

◆ DISABLECUTOFF

Param<int> scippp::params::LP::DISABLECUTOFF { "lp/disablecutoff" }
constexpr

disable the cutoff bound in the LP solver? (0: enabled, 1: disabled, 2: auto)

Definition at line 4763 of file parameters.hpp.

◆ FASTMIP

Param<int> scippp::params::LP::FASTMIP { "lp/fastmip" }
constexpr

which FASTMIP setting of LP solver should be used? 0: off, 1: low

Definition at line 4747 of file parameters.hpp.

◆ FREESOLVALBUFFERS

Param<bool> scippp::params::LP::FREESOLVALBUFFERS { "lp/freesolvalbuffers" }
constexpr

should the buffers for storing LP solution values during diving be freed at end of diving?

Definition at line 4721 of file parameters.hpp.

◆ INITALGORITHM

Param<char> scippp::params::LP::INITALGORITHM { "lp/initalgorithm" }
constexpr

LP algorithm for solving initial LP relaxations (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)

Definition at line 4708 of file parameters.hpp.

◆ ITERLIM

Param<long long> scippp::params::LP::ITERLIM { "lp/iterlim" }
constexpr

iteration limit for each single LP solve (-1: no limit)

Definition at line 4701 of file parameters.hpp.

◆ LEXDUALALGO

Param<bool> scippp::params::LP::LEXDUALALGO { "lp/lexdualalgo" }
constexpr

should the lexicographic dual algorithm be used?

Definition at line 4753 of file parameters.hpp.

◆ LEXDUALBASIC

Param<bool> scippp::params::LP::LEXDUALBASIC { "lp/lexdualbasic" }
constexpr

choose fractional basic variables in lexicographic dual algorithm?

Definition at line 4759 of file parameters.hpp.

◆ LEXDUALMAXROUNDS

Param<int> scippp::params::LP::LEXDUALMAXROUNDS { "lp/lexdualmaxrounds" }
constexpr

maximum number of rounds in the lexicographic dual algorithm (-1: unbounded)

Definition at line 4757 of file parameters.hpp.

◆ LEXDUALROOTONLY

Param<bool> scippp::params::LP::LEXDUALROOTONLY { "lp/lexdualrootonly" }
constexpr

should the lexicographic dual algorithm be applied only at the root node

Definition at line 4755 of file parameters.hpp.

◆ LEXDUALSTALLING

Param<bool> scippp::params::LP::LEXDUALSTALLING { "lp/lexdualstalling" }
constexpr

turn on the lex dual algorithm only when stalling?

Definition at line 4761 of file parameters.hpp.

◆ MINMARKOWITZ

Param<double> scippp::params::LP::MINMARKOWITZ { "lp/minmarkowitz" }
constexpr

minimal Markowitz threshold to control sparsity/stability in LU factorization

Definition at line 4739 of file parameters.hpp.

◆ PRESOLVING

Param<bool> scippp::params::LP::PRESOLVING { "lp/presolving" }
constexpr

should presolving of LP solver be used?

Definition at line 4751 of file parameters.hpp.

◆ PRICING

Param<char> scippp::params::LP::PRICING { "lp/pricing" }
constexpr

LP pricing strategy ('l'pi default, 'a'uto, 'f'ull pricing, 'p'artial, 's'teepest edge pricing, 'q'uickstart steepest edge pricing, 'd'evex pricing)

Definition at line 4714 of file parameters.hpp.

◆ REFACTORINTERVAL

Param<int> scippp::params::LP::REFACTORINTERVAL { "lp/refactorinterval" }
constexpr

LP refactorization interval (0: auto)

Definition at line 4776 of file parameters.hpp.

◆ RESOLVEALGORITHM

Param<char> scippp::params::LP::RESOLVEALGORITHM { "lp/resolvealgorithm" }
constexpr

LP algorithm for resolving LP relaxations if a starting basis exists (automatic 's'implex, 'p'rimal simplex, 'd'ual simplex, 'b'arrier, barrier with 'c'rossover)

Definition at line 4711 of file parameters.hpp.

◆ RESOLVEITERFAC

Param<double> scippp::params::LP::RESOLVEITERFAC { "lp/resolveiterfac" }
constexpr

factor of average LP iterations that is used as LP iteration limit for LP resolve (-1: unlimited)

Definition at line 4770 of file parameters.hpp.

◆ RESOLVEITERMIN

Param<int> scippp::params::LP::RESOLVEITERMIN { "lp/resolveitermin" }
constexpr

minimum number of iterations that are allowed for LP resolve

Definition at line 4772 of file parameters.hpp.

◆ RESOLVERESTORE

Param<bool> scippp::params::LP::RESOLVERESTORE { "lp/resolverestore" }
constexpr

should the LP be resolved to restore the state at start of diving (if FALSE we buffer the solution values)?

Definition at line 4719 of file parameters.hpp.

◆ ROOTITERLIM

Param<long long> scippp::params::LP::ROOTITERLIM { "lp/rootiterlim" }
constexpr

iteration limit for initial root LP solve (-1: no limit)

Definition at line 4703 of file parameters.hpp.

◆ ROWAGELIMIT

Param<int> scippp::params::LP::ROWAGELIMIT { "lp/rowagelimit" }
constexpr

maximum age a dynamic row can reach before it is deleted from the LP (-1: don't delete rows due to aging)

Definition at line 4725 of file parameters.hpp.

◆ ROWREPSWITCH

Param<double> scippp::params::LP::ROWREPSWITCH { "lp/rowrepswitch" }
constexpr

simplex algorithm shall use row representation of the basis if number of rows divided by number of columns exceeds this value (-1.0 to disable row representation)

Definition at line 4766 of file parameters.hpp.

◆ SCALING

Param<int> scippp::params::LP::SCALING { "lp/scaling" }
constexpr

LP scaling (0: none, 1: normal, 2: aggressive)

Definition at line 4749 of file parameters.hpp.

◆ SOLUTIONPOLISHING

Param<int> scippp::params::LP::SOLUTIONPOLISHING { "lp/solutionpolishing" }
constexpr

LP solution polishing method (0: disabled, 1: only root, 2: always, 3: auto)

Definition at line 4774 of file parameters.hpp.

◆ SOLVEDEPTH

Param<int> scippp::params::LP::SOLVEDEPTH { "lp/solvedepth" }
constexpr

maximal depth for solving LP at the nodes (-1: no depth limit)

Definition at line 4705 of file parameters.hpp.

◆ SOLVEFREQ

Param<int> scippp::params::LP::SOLVEFREQ { "lp/solvefreq" }
constexpr

frequency for solving LP at the nodes (-1: never; 0: only root LP)

Definition at line 4699 of file parameters.hpp.

◆ THREADS

Param<int> scippp::params::LP::THREADS { "lp/threads" }
constexpr

number of threads used for solving the LP (0: automatic)

Definition at line 4768 of file parameters.hpp.