Initializing help system before first use

XPRSprob.Controls

  • java.lang.Object
    • com.dashoptimization.XPRSprob.Controls

    • Method Detail

      • getExtraRows

        public int getExtraRows()
        Retrieves the value of the control XPRSconstants.EXTRAROWS. The initial number of extra rows to allow for in the matrix, including cuts. If rows are to be added to the matrix, then, for maximum efficiency, space should be reserved for the rows before the matrix is input by setting the EXTRAROWS control. If this is not done, resizing will occur automatically, but more space may be allocated than the user actually requires.

      • setExtraRows

        public void setExtraRows​(int newval)
        Sets the value of the control XPRSconstants.EXTRAROWS. The initial number of extra rows to allow for in the matrix, including cuts. If rows are to be added to the matrix, then, for maximum efficiency, space should be reserved for the rows before the matrix is input by setting the EXTRAROWS control. If this is not done, resizing will occur automatically, but more space may be allocated than the user actually requires.

      • getExtraCols

        public int getExtraCols()
        Retrieves the value of the control XPRSconstants.EXTRACOLS. The initial number of extra columns to allow for in the matrix. If columns are to be added to the matrix, then, for maximum efficiency, space should be reserved for the columns before the matrix is input by setting the EXTRACOLS control. If this is not done, resizing will occur automatically, but more space may be allocated than the user actually requires.

      • setExtraCols

        public void setExtraCols​(int newval)
        Sets the value of the control XPRSconstants.EXTRACOLS. The initial number of extra columns to allow for in the matrix. If columns are to be added to the matrix, then, for maximum efficiency, space should be reserved for the columns before the matrix is input by setting the EXTRACOLS control. If this is not done, resizing will occur automatically, but more space may be allocated than the user actually requires.

      • getExtraElems

        public long getExtraElems()
        Retrieves the value of the control XPRSconstants.EXTRAELEMS. The initial number of extra matrix elements to allow for in the matrix, including coefficients for cuts. If rows or columns are to be added to the matrix, then, for maximum efficiency, space should be reserved for the extra matrix elements before the matrix is input by setting the EXTRAELEMS control. If this is not done, resizing will occur automatically, but more space may be allocated than the user actually requires.

      • setExtraElems

        public void setExtraElems​(long newval)
        Sets the value of the control XPRSconstants.EXTRAELEMS. The initial number of extra matrix elements to allow for in the matrix, including coefficients for cuts. If rows or columns are to be added to the matrix, then, for maximum efficiency, space should be reserved for the extra matrix elements before the matrix is input by setting the EXTRAELEMS control. If this is not done, resizing will occur automatically, but more space may be allocated than the user actually requires.

      • getLPIterLimit

        public int getLPIterLimit()
        Retrieves the value of the control XPRSconstants.LPITERLIMIT. The maximum number of iterations that will be performed by primal simplex or dual simplex before the optimization process terminates. For MIP problems, this is the maximum total number of iterations over all nodes explored by the Branch and Bound method.

        This control is used in the following examples:

        • Tableau

      • setLPIterLimit

        public void setLPIterLimit​(int newval)
        Sets the value of the control XPRSconstants.LPITERLIMIT. The maximum number of iterations that will be performed by primal simplex or dual simplex before the optimization process terminates. For MIP problems, this is the maximum total number of iterations over all nodes explored by the Branch and Bound method.

        This control is used in the following examples:

        • Tableau

      • getLPLog

        public int getLPLog()
        Retrieves the value of the control XPRSconstants.LPLOG. Simplex: The frequency at which the simplex log is printed.

      • setLPLog

        public void setLPLog​(int newval)
        Sets the value of the control XPRSconstants.LPLOG. Simplex: The frequency at which the simplex log is printed.

      • resetLPLog

        public void resetLPLog()
        Resets to its default the value of control XPRSconstants.LPLOG

      • getScaling

        public int getScaling()
        Retrieves the value of the control XPRSconstants.SCALING. This bit vector control determines how the Optimizer will rescale a model internally before optimization. If set to 0, no scaling will take place. (Values are from the enumeration XPRSenumerations.Scaling)

      • setScaling

        public void setScaling​(int newval)
        Sets the value of the control XPRSconstants.SCALING. This bit vector control determines how the Optimizer will rescale a model internally before optimization. If set to 0, no scaling will take place. (Values are from the enumeration XPRSenumerations.Scaling)

      • setScaling

        public void setScaling​(XPRSenumerations.Scaling newval)
        Sets the value of the control XPRSconstants.SCALING. This bit vector control determines how the Optimizer will rescale a model internally before optimization. If set to <code>0</code>, no scaling will take place. (Values are from the enumeration XPRSenumerations.Scaling)

      • resetScaling

        public void resetScaling()
        Resets to its default the value of control XPRSconstants.SCALING

      • getPresolve

        public int getPresolve()
        Retrieves the value of the control XPRSconstants.PRESOLVE. This control determines whether presolving should be performed prior to starting the main algorithm. Presolve attempts to simplify the problem by detecting and removing redundant constraints, tightening variable bounds, etc. In some cases, infeasibility may even be determined at this stage, or the optimal solution found. (Values are from the enumeration XPRSenumerations.Presolve)

        This control is used in the following examples:

        • FixBV
        • Knapsack
        • Tableau
        • Trimloss

      • setPresolve

        public void setPresolve​(int newval)
        Sets the value of the control XPRSconstants.PRESOLVE. This control determines whether presolving should be performed prior to starting the main algorithm. Presolve attempts to simplify the problem by detecting and removing redundant constraints, tightening variable bounds, etc. In some cases, infeasibility may even be determined at this stage, or the optimal solution found. (Values are from the enumeration XPRSenumerations.Presolve)

        This control is used in the following examples:

        • FixBV
        • Knapsack
        • Tableau
        • Trimloss

      • setPresolve

        public void setPresolve​(XPRSenumerations.Presolve newval)
        Sets the value of the control XPRSconstants.PRESOLVE. This control determines whether presolving should be performed prior to starting the main algorithm. Presolve attempts to simplify the problem by detecting and removing redundant constraints, tightening variable bounds, etc. In some cases, infeasibility may even be determined at this stage, or the optimal solution found. (Values are from the enumeration XPRSenumerations.Presolve)

      • resetPresolve

        public void resetPresolve()
        Resets to its default the value of control XPRSconstants.PRESOLVE

      • getCrash

        public int getCrash()
        Retrieves the value of the control XPRSconstants.CRASH. Simplex: This determines the type of crash used when the algorithm begins. During the crash procedure, an initial basis is determined which is as close to feasibility and triangularity as possible. A good choice at this stage will significantly reduce the number of iterations required to find an optimal solution. The possible values increase proportionally to their time-consumption.

      • setCrash

        public void setCrash​(int newval)
        Sets the value of the control XPRSconstants.CRASH. Simplex: This determines the type of crash used when the algorithm begins. During the crash procedure, an initial basis is determined which is as close to feasibility and triangularity as possible. A good choice at this stage will significantly reduce the number of iterations required to find an optimal solution. The possible values increase proportionally to their time-consumption.

      • resetCrash

        public void resetCrash()
        Resets to its default the value of control XPRSconstants.CRASH

      • getPricingAlg

        public int getPricingAlg()
        Retrieves the value of the control XPRSconstants.PRICINGALG. Simplex: This determines the primal simplex pricing method. It is used to select which variable enters the basis on each iteration. In general Devex pricing requires more time on each iteration, but may reduce the total number of iterations, whereas partial pricing saves time on each iteration, but may result in more iterations. (Values are from the enumeration XPRSenumerations.Pricing)

      • setPricingAlg

        public void setPricingAlg​(int newval)
        Sets the value of the control XPRSconstants.PRICINGALG. Simplex: This determines the primal simplex pricing method. It is used to select which variable enters the basis on each iteration. In general Devex pricing requires more time on each iteration, but may reduce the total number of iterations, whereas partial pricing saves time on each iteration, but may result in more iterations. (Values are from the enumeration XPRSenumerations.Pricing)

      • setPricingAlg

        public void setPricingAlg​(XPRSenumerations.Pricing newval)
        Sets the value of the control XPRSconstants.PRICINGALG. Simplex: This determines the primal simplex pricing method. It is used to select which variable enters the basis on each iteration. In general Devex pricing requires more time on each iteration, but may reduce the total number of iterations, whereas partial pricing saves time on each iteration, but may result in more iterations. (Values are from the enumeration XPRSenumerations.Pricing)

      • getInvertFreq

        public int getInvertFreq()
        Retrieves the value of the control XPRSconstants.INVERTFREQ. Simplex: The frequency with which the basis will be inverted. The basis is maintained in a factorized form and on most simplex iterations it is incrementally updated to reflect the step just taken. This is considerably faster than computing the full inverted matrix at each iteration, although after a number of iterations the basis becomes less well-conditioned and it becomes necessary to compute the full inverted matrix. The value of INVERTFREQ specifies the maximum number of iterations between full inversions.

      • setInvertFreq

        public void setInvertFreq​(int newval)
        Sets the value of the control XPRSconstants.INVERTFREQ. Simplex: The frequency with which the basis will be inverted. The basis is maintained in a factorized form and on most simplex iterations it is incrementally updated to reflect the step just taken. This is considerably faster than computing the full inverted matrix at each iteration, although after a number of iterations the basis becomes less well-conditioned and it becomes necessary to compute the full inverted matrix. The value of INVERTFREQ specifies the maximum number of iterations between full inversions.

      • getInvertMin

        public int getInvertMin()
        Retrieves the value of the control XPRSconstants.INVERTMIN. Simplex: The minimum number of iterations between full inversions of the basis matrix. See the description of INVERTFREQ for details.

      • setInvertMin

        public void setInvertMin​(int newval)
        Sets the value of the control XPRSconstants.INVERTMIN. Simplex: The minimum number of iterations between full inversions of the basis matrix. See the description of INVERTFREQ for details.

      • getMaxNode

        public int getMaxNode()
        Retrieves the value of the control XPRSconstants.MAXNODE. Branch and Bound: The maximum number of nodes that will be explored.

        This control is used in the following examples:

        • AddMipSol

      • setMaxNode

        public void setMaxNode​(int newval)
        Sets the value of the control XPRSconstants.MAXNODE. Branch and Bound: The maximum number of nodes that will be explored.

        This control is used in the following examples:

        • AddMipSol

      • resetMaxNode

        public void resetMaxNode()
        Resets to its default the value of control XPRSconstants.MAXNODE

      • getMaxTime

        @Deprecated
public int getMaxTime()
        Deprecated.
        since 41.00
        Retrieves the value of the control XPRSconstants.MAXTIME. The maximum time in seconds that the Optimizer will run before it terminates, including the problem setup time and solution time. For MIP problems, this is the total time taken to solve all nodes.

      • setMaxTime

        @Deprecated
public void setMaxTime​(int newval)
        Deprecated.
        since 41.00
        Sets the value of the control XPRSconstants.MAXTIME. The maximum time in seconds that the Optimizer will run before it terminates, including the problem setup time and solution time. For MIP problems, this is the total time taken to solve all nodes.

      • resetMaxTime

        @Deprecated
public void resetMaxTime()
        Deprecated.
        Resets to its default the value of control XPRSconstants.MAXTIME

      • getMaxMIPSol

        public int getMaxMIPSol()
        Retrieves the value of the control XPRSconstants.MAXMIPSOL. Branch and Bound: This specifies a limit on the number of integer solutions to be found by the Optimizer. It is possible that during optimization the Optimizer will find the same objective solution from different nodes. However, MAXMIPSOL refers to the total number of integer solutions found, and not necessarily the number of distinct solutions.

        This control is used in the following examples:

        • AddMipSol

      • setMaxMIPSol

        public void setMaxMIPSol​(int newval)
        Sets the value of the control XPRSconstants.MAXMIPSOL. Branch and Bound: This specifies a limit on the number of integer solutions to be found by the Optimizer. It is possible that during optimization the Optimizer will find the same objective solution from different nodes. However, MAXMIPSOL refers to the total number of integer solutions found, and not necessarily the number of distinct solutions.

        This control is used in the following examples:

        • AddMipSol

      • getSiftPasses

        public int getSiftPasses()
        Retrieves the value of the control XPRSconstants.SIFTPASSES. Determines how quickly we allow to grow the worker problems during the sifting algorithm. Using larger values can increase the number of columns added to the worker problem which often results in increased solve times for the worker problems but the number of necessary sifting iterations may be reduced. .

      • setSiftPasses

        public void setSiftPasses​(int newval)
        Sets the value of the control XPRSconstants.SIFTPASSES. Determines how quickly we allow to grow the worker problems during the sifting algorithm. Using larger values can increase the number of columns added to the worker problem which often results in increased solve times for the worker problems but the number of necessary sifting iterations may be reduced. .

      • getVarSelection

        public int getVarSelection()
        Retrieves the value of the control XPRSconstants.VARSELECTION. Branch and Bound: This determines the formula used to calculate the estimate of each integer variable, and thus which integer variable is selected to be branched on at a given node. The variable selected to be branched on is the one with the maximum estimate. (Values are from the enumeration XPRSenumerations.VariableSelection)

      • setVarSelection

        public void setVarSelection​(int newval)
        Sets the value of the control XPRSconstants.VARSELECTION. Branch and Bound: This determines the formula used to calculate the estimate of each integer variable, and thus which integer variable is selected to be branched on at a given node. The variable selected to be branched on is the one with the maximum estimate. (Values are from the enumeration XPRSenumerations.VariableSelection)

      • setVarSelection

        public void setVarSelection​(XPRSenumerations.VariableSelection newval)
        Sets the value of the control XPRSconstants.VARSELECTION. Branch and Bound: This determines the formula used to calculate the estimate of each integer variable, and thus which integer variable is selected to be branched on at a given node. The variable selected to be branched on is the one with the maximum estimate. (Values are from the enumeration XPRSenumerations.VariableSelection)

      • getBackTrack

        public int getBackTrack()
        Retrieves the value of the control XPRSconstants.BACKTRACK. Branch and Bound: Specifies how to select the next node to work on when a full backtrack is performed. (Values are from the enumeration XPRSenumerations.BacktrackAlg)

      • setBackTrack

        public void setBackTrack​(int newval)
        Sets the value of the control XPRSconstants.BACKTRACK. Branch and Bound: Specifies how to select the next node to work on when a full backtrack is performed. (Values are from the enumeration XPRSenumerations.BacktrackAlg)

      • getMIPLog

        public int getMIPLog()
        Retrieves the value of the control XPRSconstants.MIPLOG. MIP log print control.

        This control is used in the following examples:

        • AddMipSol
        • Knapsack
        • MostViolated
        • RoundInt

      • setMIPLog

        public void setMIPLog​(int newval)
        Sets the value of the control XPRSconstants.MIPLOG. MIP log print control.

        This control is used in the following examples:

        • AddMipSol
        • Knapsack
        • MostViolated
        • RoundInt

      • resetMIPLog

        public void resetMIPLog()
        Resets to its default the value of control XPRSconstants.MIPLOG

      • getKeepNRows

        public int getKeepNRows()
        Retrieves the value of the control XPRSconstants.KEEPNROWS. How nonbinding rows should be handled by the MPS reader.

      • setKeepNRows

        public void setKeepNRows​(int newval)
        Sets the value of the control XPRSconstants.KEEPNROWS. How nonbinding rows should be handled by the MPS reader.

      • getMPSEcho

        public int getMPSEcho()
        Retrieves the value of the control XPRSconstants.MPSECHO. Determines whether comments in MPS matrix files are to be printed out during matrix input.

      • setMPSEcho

        public void setMPSEcho​(int newval)
        Sets the value of the control XPRSconstants.MPSECHO. Determines whether comments in MPS matrix files are to be printed out during matrix input.

      • resetMPSEcho

        public void resetMPSEcho()
        Resets to its default the value of control XPRSconstants.MPSECHO

      • getMaxPageLines

        public int getMaxPageLines()
        Retrieves the value of the control XPRSconstants.MAXPAGELINES. Number of lines between page breaks in printable output.

      • setMaxPageLines

        public void setMaxPageLines​(int newval)
        Sets the value of the control XPRSconstants.MAXPAGELINES. Number of lines between page breaks in printable output.

      • getOutputLog

        public int getOutputLog()
        Retrieves the value of the control XPRSconstants.OUTPUTLOG. This controls the level of output produced by the Optimizer during optimization. In the Console Optimizer, OUTPUTLOG controls which messages are sent to the screen ( stdout). When using the Optimizer library, no output is sent to the screen. If the user wishes output to be displayed, they must define a callback function and print messages to the screen themselves. In this case, OUTPUTLOG controls which messages are sent to the user output callback. (Values are from the enumeration XPRSenumerations.OutputDetail)

      • setOutputLog

        public void setOutputLog​(int newval)
        Sets the value of the control XPRSconstants.OUTPUTLOG. This controls the level of output produced by the Optimizer during optimization. In the Console Optimizer, OUTPUTLOG controls which messages are sent to the screen ( stdout). When using the Optimizer library, no output is sent to the screen. If the user wishes output to be displayed, they must define a callback function and print messages to the screen themselves. In this case, OUTPUTLOG controls which messages are sent to the user output callback. (Values are from the enumeration XPRSenumerations.OutputDetail)

      • setOutputLog

        public void setOutputLog​(XPRSenumerations.OutputDetail newval)
        Sets the value of the control XPRSconstants.OUTPUTLOG. This controls the level of output produced by the Optimizer during optimization. In the Console Optimizer, <code>OUTPUTLOG</code> controls which messages are sent to the screen (<code>stdout</code>). When using the Optimizer library, no output is sent to the screen. If the user wishes output to be displayed, they must define a callback function and print messages to the screen themselves. In this case, <code>OUTPUTLOG</code> controls which messages are sent to the user output callback. (Values are from the enumeration XPRSenumerations.OutputDetail)

      • getBarSolution

        public int getBarSolution()
        Retrieves the value of the control XPRSconstants.BARSOLUTION. This determines whether the barrier has to decide which is the best solution found or return the solution computed by the last barrier iteration.

      • setBarSolution

        public void setBarSolution​(int newval)
        Sets the value of the control XPRSconstants.BARSOLUTION. This determines whether the barrier has to decide which is the best solution found or return the solution computed by the last barrier iteration.

      • getCacheSize

        @Deprecated
public int getCacheSize()
        Deprecated.
        since 41.00
        Retrieves the value of the control XPRSconstants.CACHESIZE. Newton Barrier: L2 or L3 (see notes) cache size in kB (kilobytes) of the CPU. On Intel (or compatible) platforms a value of -1 may be used to determine the cache size automatically. If the CPU model is new then the cache size may not be correctly detected by an older release of the software.

      • setCacheSize

        @Deprecated
public void setCacheSize​(int newval)
        Deprecated.
        since 41.00
        Sets the value of the control XPRSconstants.CACHESIZE. Newton Barrier: L2 or L3 (see notes) cache size in kB (kilobytes) of the CPU. On Intel (or compatible) platforms a value of -1 may be used to determine the cache size automatically. If the CPU model is new then the cache size may not be correctly detected by an older release of the software.

      • resetCacheSize

        @Deprecated
public void resetCacheSize()
        Deprecated.
        Resets to its default the value of control XPRSconstants.CACHESIZE

      • getCrossOver

        public int getCrossOver()
        Retrieves the value of the control XPRSconstants.CROSSOVER. Newton barrier and hybrid gradient: This control determines whether the barrier method will cross over to the simplex method when at optimal solution has been found, to provide an end basis (see getBasis, writeBasis) and advanced sensitivity analysis information (see objsa, rHSsa, bndsa). (Values are from the enumeration XPRSenumerations.AlwaysNeverAutomatic)

      • setCrossOver

        public void setCrossOver​(int newval)
        Sets the value of the control XPRSconstants.CROSSOVER. Newton barrier and hybrid gradient: This control determines whether the barrier method will cross over to the simplex method when at optimal solution has been found, to provide an end basis (see getBasis, writeBasis) and advanced sensitivity analysis information (see objsa, rHSsa, bndsa). (Values are from the enumeration XPRSenumerations.AlwaysNeverAutomatic)

      • setCrossOver

        public void setCrossOver​(XPRSenumerations.AlwaysNeverAutomatic newval)
        Sets the value of the control XPRSconstants.CROSSOVER. Newton barrier and hybrid gradient: This control determines whether the barrier method will cross over to the simplex method when at optimal solution has been found, to provide an end basis (see <code>getBasis</code>, <code>writeBasis</code>) and advanced sensitivity analysis information (see <code>objsa</code>, <code>rHSsa</code>, <code>bndsa</code>). (Values are from the enumeration XPRSenumerations.AlwaysNeverAutomatic)

      • getBarIterLimit

        public int getBarIterLimit()
        Retrieves the value of the control XPRSconstants.BARITERLIMIT. Newton barrier: The maximum number of iterations. While the simplex method usually performs a number of iterations which is proportional to the number of constraints (rows) in a problem, the barrier method standardly finds the optimal solution to a given accuracy after a number of iterations which is independent of the problem size. The penalty is rather that the time for each iteration increases with the size of the problem. BARITERLIMIT specifies the maximum number of iterations which will be carried out by the barrier.

      • setBarIterLimit

        public void setBarIterLimit​(int newval)
        Sets the value of the control XPRSconstants.BARITERLIMIT. Newton barrier: The maximum number of iterations. While the simplex method usually performs a number of iterations which is proportional to the number of constraints (rows) in a problem, the barrier method standardly finds the optimal solution to a given accuracy after a number of iterations which is independent of the problem size. The penalty is rather that the time for each iteration increases with the size of the problem. BARITERLIMIT specifies the maximum number of iterations which will be carried out by the barrier.

      • getBarOutput

        public int getBarOutput()
        Retrieves the value of the control XPRSconstants.BAROUTPUT. Newton barrier and hybrid gradient: This specifies the level of solution output provided. Output is provided either after each iteration of the algorithm, or else can be turned off completely by this parameter.

      • setBarOutput

        public void setBarOutput​(int newval)
        Sets the value of the control XPRSconstants.BAROUTPUT. Newton barrier and hybrid gradient: This specifies the level of solution output provided. Output is provided either after each iteration of the algorithm, or else can be turned off completely by this parameter.

      • getExtraMIPEnts

        public int getExtraMIPEnts()
        Retrieves the value of the control XPRSconstants.EXTRAMIPENTS. The initial number of extra MIP entities to allow for.

      • setExtraMIPEnts

        public void setExtraMIPEnts​(int newval)
        Sets the value of the control XPRSconstants.EXTRAMIPENTS. The initial number of extra MIP entities to allow for.

      • getRefactor

        public int getRefactor()
        Retrieves the value of the control XPRSconstants.REFACTOR. Indicates whether the optimization should restart using the current representation of the factorization in memory.

      • setRefactor

        public void setRefactor​(int newval)
        Sets the value of the control XPRSconstants.REFACTOR. Indicates whether the optimization should restart using the current representation of the factorization in memory.

      • resetRefactor

        public void resetRefactor()
        Resets to its default the value of control XPRSconstants.REFACTOR

      • getBarThreads

        public int getBarThreads()
        Retrieves the value of the control XPRSconstants.BARTHREADS. If set to a positive integer it determines the number of threads implemented to run the Newton-barrier and hybrid gradient algorithms. If the value is set to the default value ( -1), the THREADS control will determine the number of threads used.

      • setBarThreads

        public void setBarThreads​(int newval)
        Sets the value of the control XPRSconstants.BARTHREADS. If set to a positive integer it determines the number of threads implemented to run the Newton-barrier and hybrid gradient algorithms. If the value is set to the default value ( -1), the THREADS control will determine the number of threads used.

      • getKeepBasis

        public int getKeepBasis()
        Retrieves the value of the control XPRSconstants.KEEPBASIS. Simplex: This determines whether the basis should be kept when reoptimizing a problem. The choice is between using a crash basis created at the beginning of simplex or using a basis from a previous solve (if such exists). By default, this control gets (re)set automatically in various situations. By default, it will be automatically set to 1 after a solve that produced a valid basis. This will automatically warmstart a subsequent solve. Explicitly loading a starting basis will also set this control to 1. If the control is explicitly set to 0, any existing basis will be ignored for a new solve, and the Optimizer will start from an ad-hoc crash basis.

      • setKeepBasis

        public void setKeepBasis​(int newval)
        Sets the value of the control XPRSconstants.KEEPBASIS. Simplex: This determines whether the basis should be kept when reoptimizing a problem. The choice is between using a crash basis created at the beginning of simplex or using a basis from a previous solve (if such exists). By default, this control gets (re)set automatically in various situations. By default, it will be automatically set to 1 after a solve that produced a valid basis. This will automatically warmstart a subsequent solve. Explicitly loading a starting basis will also set this control to 1. If the control is explicitly set to 0, any existing basis will be ignored for a new solve, and the Optimizer will start from an ad-hoc crash basis.

      • getCrossoverOps

        public int getCrossoverOps()
        Retrieves the value of the control XPRSconstants.CROSSOVEROPS. Newton barrier and hybrid gradient: a bit vector for adjusting the behavior of the crossover procedure.

      • setCrossoverOps

        public void setCrossoverOps​(int newval)
        Sets the value of the control XPRSconstants.CROSSOVEROPS. Newton barrier and hybrid gradient: a bit vector for adjusting the behavior of the crossover procedure.

      • getVersion

        public int getVersion()
        Retrieves the value of the control XPRSconstants.VERSION. The Optimizer version number, e.g. 1301 meaning release 13.01.

      • setVersion

        public void setVersion​(int newval)
        Sets the value of the control XPRSconstants.VERSION. The Optimizer version number, e.g. 1301 meaning release 13.01.

      • resetVersion

        public void resetVersion()
        Resets to its default the value of control XPRSconstants.VERSION

      • getCrossoverThreads

        public int getCrossoverThreads()
        Retrieves the value of the control XPRSconstants.CROSSOVERTHREADS. Determines the maximum number of threads that parallel crossover is allowed to use. If CROSSOVERTHREADS is set to the default value ( -1), the BARTHREADS control will determine the number of threads used.

      • setCrossoverThreads

        public void setCrossoverThreads​(int newval)
        Sets the value of the control XPRSconstants.CROSSOVERTHREADS. Determines the maximum number of threads that parallel crossover is allowed to use. If CROSSOVERTHREADS is set to the default value ( -1), the BARTHREADS control will determine the number of threads used.

      • getBigmMethod

        public int getBigmMethod()
        Retrieves the value of the control XPRSconstants.BIGMMETHOD. Simplex: This specifies whether to use the "Big M" method, or the standard phase I (achieving feasibility) and phase II (achieving optimality). In the "Big M" method, the objective coefficients of the variables are considered during the feasibility phase, possibly leading to an initial feasible basis which is closer to optimal. The side-effects involve possible round-off errors due to the presence of the "Big M" factor in the problem.

      • setBigmMethod

        public void setBigmMethod​(int newval)
        Sets the value of the control XPRSconstants.BIGMMETHOD. Simplex: This specifies whether to use the "Big M" method, or the standard phase I (achieving feasibility) and phase II (achieving optimality). In the "Big M" method, the objective coefficients of the variables are considered during the feasibility phase, possibly leading to an initial feasible basis which is closer to optimal. The side-effects involve possible round-off errors due to the presence of the "Big M" factor in the problem.

      • getMPSNameLength

        public int getMPSNameLength()

      • getElimFillIn

        public int getElimFillIn()
        Retrieves the value of the control XPRSconstants.ELIMFILLIN. Amount of fill-in allowed when performing an elimination in presolve .

      • setElimFillIn

        public void setElimFillIn​(int newval)
        Sets the value of the control XPRSconstants.ELIMFILLIN. Amount of fill-in allowed when performing an elimination in presolve .

      • getMIPPresolve

        public int getMIPPresolve()
        Retrieves the value of the control XPRSconstants.MIPPRESOLVE. Branch and Bound: Type of integer processing to be performed. If set to 0, no processing will be performed. (Values are from the enumeration XPRSenumerations.MipPresolve)

      • setMIPPresolve

        public void setMIPPresolve​(int newval)
        Sets the value of the control XPRSconstants.MIPPRESOLVE. Branch and Bound: Type of integer processing to be performed. If set to 0, no processing will be performed. (Values are from the enumeration XPRSenumerations.MipPresolve)

      • getMIPThreads

        public int getMIPThreads()
        Retrieves the value of the control XPRSconstants.MIPTHREADS. If set to a positive integer it determines the number of threads implemented to run the parallel MIP code. If MIPTHREADS is set to the default value ( -1), the THREADS control will determine the number of threads used.

        This control is used in the following examples:

        • AddMipSol
        • MostViolated

      • setMIPThreads

        public void setMIPThreads​(int newval)
        Sets the value of the control XPRSconstants.MIPTHREADS. If set to a positive integer it determines the number of threads implemented to run the parallel MIP code. If MIPTHREADS is set to the default value ( -1), the THREADS control will determine the number of threads used.

        This control is used in the following examples:

        • AddMipSol
        • MostViolated

      • resetBarOrder

        public void resetBarOrder()
        Resets to its default the value of control XPRSconstants.BARORDER

      • getBreadthFirst

        public int getBreadthFirst()
        Retrieves the value of the control XPRSconstants.BREADTHFIRST. The number of nodes to include in the best-first search before switching to the local first search ( NODESELECTION = 4).

      • setBreadthFirst

        public void setBreadthFirst​(int newval)
        Sets the value of the control XPRSconstants.BREADTHFIRST. The number of nodes to include in the best-first search before switching to the local first search ( NODESELECTION = 4).

      • getAutoPerturb

        public int getAutoPerturb()
        Retrieves the value of the control XPRSconstants.AUTOPERTURB. Simplex: This indicates whether automatic perturbation is performed. If this is set to 1, the problem will be perturbed whenever the simplex method encounters an excessive number of degenerate pivot steps, thus preventing the Optimizer being hindered by degeneracies. (Values are from the enumeration XPRSenumerations.OnOff)

      • setAutoPerturb

        public void setAutoPerturb​(int newval)
        Sets the value of the control XPRSconstants.AUTOPERTURB. Simplex: This indicates whether automatic perturbation is performed. If this is set to 1, the problem will be perturbed whenever the simplex method encounters an excessive number of degenerate pivot steps, thus preventing the Optimizer being hindered by degeneracies. (Values are from the enumeration XPRSenumerations.OnOff)

      • setAutoPerturb

        public void setAutoPerturb​(XPRSenumerations.OnOff newval)
        Sets the value of the control XPRSconstants.AUTOPERTURB. Simplex: This indicates whether automatic perturbation is performed. If this is set to <code>1</code>, the problem will be perturbed whenever the simplex method encounters an excessive number of degenerate pivot steps, thus preventing the Optimizer being hindered by degeneracies. (Values are from the enumeration XPRSenumerations.OnOff)

      • getDenseColLimit

        public int getDenseColLimit()
        Retrieves the value of the control XPRSconstants.DENSECOLLIMIT. Newton barrier: Columns with more than DENSECOLLIMIT elements are considered to be dense. Such columns will be handled specially in the Cholesky factorization of this matrix.

      • setDenseColLimit

        public void setDenseColLimit​(int newval)
        Sets the value of the control XPRSconstants.DENSECOLLIMIT. Newton barrier: Columns with more than DENSECOLLIMIT elements are considered to be dense. Such columns will be handled specially in the Cholesky factorization of this matrix.

      • getCallbackFromMasterThread

        public int getCallbackFromMasterThread()
        Retrieves the value of the control XPRSconstants.CALLBACKFROMMASTERTHREAD. Branch and Bound: specifies whether the MIP callbacks should only be called on the master thread.

      • setCallbackFromMasterThread

        public void setCallbackFromMasterThread​(int newval)
        Sets the value of the control XPRSconstants.CALLBACKFROMMASTERTHREAD. Branch and Bound: specifies whether the MIP callbacks should only be called on the master thread.

      • getMaxMCoeffBufferElems

        public int getMaxMCoeffBufferElems()
        Retrieves the value of the control XPRSconstants.MAXMCOEFFBUFFERELEMS. The maximum number of matrix coefficients to buffer before flushing into the internal representation of the problem. Buffering coefficients can offer a significant performance gain when you are building a matrix using chgCoef or chgMCoef, but can lead to a significant memory overhead for large matrices, which this control allows you to influence.

      • setMaxMCoeffBufferElems

        public void setMaxMCoeffBufferElems​(int newval)
        Sets the value of the control XPRSconstants.MAXMCOEFFBUFFERELEMS. The maximum number of matrix coefficients to buffer before flushing into the internal representation of the problem. Buffering coefficients can offer a significant performance gain when you are building a matrix using chgCoef or chgMCoef, but can lead to a significant memory overhead for large matrices, which this control allows you to influence.

      • getRefineOps

        public int getRefineOps()
        Retrieves the value of the control XPRSconstants.REFINEOPS. This specifies when the solution refiner should be executed to reduce solution infeasibilities. The refiner will attempt to satisfy the target tolerances for all original linear constraints before presolve or scaling has been applied.

      • setRefineOps

        public void setRefineOps​(int newval)
        Sets the value of the control XPRSconstants.REFINEOPS. This specifies when the solution refiner should be executed to reduce solution infeasibilities. The refiner will attempt to satisfy the target tolerances for all original linear constraints before presolve or scaling has been applied.

      • getLpRefineIterLimit

        public int getLpRefineIterLimit()
        Retrieves the value of the control XPRSconstants.LPREFINEITERLIMIT. This specifies the simplex iteration limit the solution refiner can spend in attempting to increase the accuracy of an LP solution.

      • setLpRefineIterLimit

        public void setLpRefineIterLimit​(int newval)
        Sets the value of the control XPRSconstants.LPREFINEITERLIMIT. This specifies the simplex iteration limit the solution refiner can spend in attempting to increase the accuracy of an LP solution.

      • getMipRefineIterLimit

        public int getMipRefineIterLimit()
        Retrieves the value of the control XPRSconstants.MIPREFINEITERLIMIT. This defines an effort limit expressed as simplex iterations for the MIP solution refiner. The limit is per reoptimizations in the MIP refiner.

      • setMipRefineIterLimit

        public void setMipRefineIterLimit​(int newval)
        Sets the value of the control XPRSconstants.MIPREFINEITERLIMIT. This defines an effort limit expressed as simplex iterations for the MIP solution refiner. The limit is per reoptimizations in the MIP refiner.

      • getDualizeOps

        public int getDualizeOps()
        Retrieves the value of the control XPRSconstants.DUALIZEOPS. Bit-vector control for adjusting the behavior when a problem is dualized.

      • setDualizeOps

        public void setDualizeOps​(int newval)
        Sets the value of the control XPRSconstants.DUALIZEOPS. Bit-vector control for adjusting the behavior when a problem is dualized.

      • getCrossoverIterLimit

        public int getCrossoverIterLimit()
        Retrieves the value of the control XPRSconstants.CROSSOVERITERLIMIT. Newton barrier and hybrid gradient: The maximum number of iterations that will be performed in the crossover procedure before the optimization process terminates.

      • setCrossoverIterLimit

        public void setCrossoverIterLimit​(int newval)
        Sets the value of the control XPRSconstants.CROSSOVERITERLIMIT. Newton barrier and hybrid gradient: The maximum number of iterations that will be performed in the crossover procedure before the optimization process terminates.

      • getPreBasisRed

        public int getPreBasisRed()
        Retrieves the value of the control XPRSconstants.PREBASISRED. Determines if a lattice basis reduction algorithm should be attempted as part of presolve

      • setPreBasisRed

        public void setPreBasisRed​(int newval)
        Sets the value of the control XPRSconstants.PREBASISRED. Determines if a lattice basis reduction algorithm should be attempted as part of presolve

      • getPreSort

        public int getPreSort()
        Retrieves the value of the control XPRSconstants.PRESORT. This bit vector control specifies whether to sort rows, columns and MIP entities by their names when starting the presolve. With the default value 0, no sorting will take place.

      • setPreSort

        public void setPreSort​(int newval)
        Sets the value of the control XPRSconstants.PRESORT. This bit vector control specifies whether to sort rows, columns and MIP entities by their names when starting the presolve. With the default value 0, no sorting will take place.

      • resetPreSort

        public void resetPreSort()
        Resets to its default the value of control XPRSconstants.PRESORT

      • getPrePermute

        public int getPrePermute()
        Retrieves the value of the control XPRSconstants.PREPERMUTE. This bit vector control specifies whether to randomly permute rows, columns and MIP entities when starting the presolve. With the default value 0, no permutation will take place.

      • setPrePermute

        public void setPrePermute​(int newval)
        Sets the value of the control XPRSconstants.PREPERMUTE. This bit vector control specifies whether to randomly permute rows, columns and MIP entities when starting the presolve. With the default value 0, no permutation will take place.

      • getPrePermuteSeed

        public int getPrePermuteSeed()
        Retrieves the value of the control XPRSconstants.PREPERMUTESEED. This control sets the seed for the pseudo-random number generator for permuting the problem when starting the presolve. This control only has effects when PREPERMUTE is enabled.

      • setPrePermuteSeed

        public void setPrePermuteSeed​(int newval)
        Sets the value of the control XPRSconstants.PREPERMUTESEED. This control sets the seed for the pseudo-random number generator for permuting the problem when starting the presolve. This control only has effects when PREPERMUTE is enabled.

      • getMaxMemorySoft

        public int getMaxMemorySoft()
        Retrieves the value of the control XPRSconstants.MAXMEMORYSOFT. When RESOURCESTRATEGY is enabled, this control sets the maximum amount of memory in megabytes the optimizer targets to allocate. This may change the solving path, but will not cause the solve to terminate early. To set a hard version of the same, please set MAXMEMORYHARD.

      • setMaxMemorySoft

        public void setMaxMemorySoft​(int newval)
        Sets the value of the control XPRSconstants.MAXMEMORYSOFT. When RESOURCESTRATEGY is enabled, this control sets the maximum amount of memory in megabytes the optimizer targets to allocate. This may change the solving path, but will not cause the solve to terminate early. To set a hard version of the same, please set MAXMEMORYHARD.

      • getCutFreq

        public int getCutFreq()
        Retrieves the value of the control XPRSconstants.CUTFREQ. Branch and Bound: This specifies the frequency at which cuts are generated in the tree search. If the depth of the node modulo CUTFREQ is zero, then cuts will be generated.

      • setCutFreq

        public void setCutFreq​(int newval)
        Sets the value of the control XPRSconstants.CUTFREQ. Branch and Bound: This specifies the frequency at which cuts are generated in the tree search. If the depth of the node modulo CUTFREQ is zero, then cuts will be generated.

      • resetCutFreq

        public void resetCutFreq()
        Resets to its default the value of control XPRSconstants.CUTFREQ

      • getSymSelect

        public int getSymSelect()
        Retrieves the value of the control XPRSconstants.SYMSELECT. Adjusts the overall amount of effort for symmetry detection.

      • setSymSelect

        public void setSymSelect​(int newval)
        Sets the value of the control XPRSconstants.SYMSELECT. Adjusts the overall amount of effort for symmetry detection.

      • getSymmetry

        public int getSymmetry()
        Retrieves the value of the control XPRSconstants.SYMMETRY. Adjusts the overall amount of effort for symmetry detection.

      • setSymmetry

        public void setSymmetry​(int newval)
        Sets the value of the control XPRSconstants.SYMMETRY. Adjusts the overall amount of effort for symmetry detection.

      • resetSymmetry

        public void resetSymmetry()
        Resets to its default the value of control XPRSconstants.SYMMETRY

      • getMaxMemoryHard

        public int getMaxMemoryHard()
        Retrieves the value of the control XPRSconstants.MAXMEMORYHARD. This control sets the maximum amount of memory in megabytes the optimizer should allocate. If this limit is exceeded, the solve will terminate. This control is designed to make the optimizer stop in a controlled manner, so that the problem object is valid once termination occurs. The solve state will be set to incomplete. This is different to an out of memory condition in which case the optimizer returns an error. The optimizer may still allocate memory once the limit is exceeded to be able to finsish the operations and stop in a controlled manner. When RESOURCESTRATEGY is enabled, the control also has the same effect as MAXMEMORYSOFT and will cause the optimizer to try preserving memory when possible.

      • setMaxMemoryHard

        public void setMaxMemoryHard​(int newval)
        Sets the value of the control XPRSconstants.MAXMEMORYHARD. This control sets the maximum amount of memory in megabytes the optimizer should allocate. If this limit is exceeded, the solve will terminate. This control is designed to make the optimizer stop in a controlled manner, so that the problem object is valid once termination occurs. The solve state will be set to incomplete. This is different to an out of memory condition in which case the optimizer returns an error. The optimizer may still allocate memory once the limit is exceeded to be able to finsish the operations and stop in a controlled manner. When RESOURCESTRATEGY is enabled, the control also has the same effect as MAXMEMORYSOFT and will cause the optimizer to try preserving memory when possible.

      • getMIQCPAlg

        public int getMIQCPAlg()
        Retrieves the value of the control XPRSconstants.MIQCPALG. This control determines which algorithm is to be used to solve mixed integer quadratic constrained and mixed integer second order cone problems.

      • setMIQCPAlg

        public void setMIQCPAlg​(int newval)
        Sets the value of the control XPRSconstants.MIQCPALG. This control determines which algorithm is to be used to solve mixed integer quadratic constrained and mixed integer second order cone problems.

      • resetMIQCPAlg

        public void resetMIQCPAlg()
        Resets to its default the value of control XPRSconstants.MIQCPALG

      • getQCCuts

        public int getQCCuts()
        Retrieves the value of the control XPRSconstants.QCCUTS. Branch and Bound: Limit on the number of rounds of outer approximation cuts generated for the root node, when solving a mixed integer quadratic constrained or mixed integer second order conic problem with outer approximation.

      • setQCCuts

        public void setQCCuts​(int newval)
        Sets the value of the control XPRSconstants.QCCUTS. Branch and Bound: Limit on the number of rounds of outer approximation cuts generated for the root node, when solving a mixed integer quadratic constrained or mixed integer second order conic problem with outer approximation.

      • resetQCCuts

        public void resetQCCuts()
        Resets to its default the value of control XPRSconstants.QCCUTS

      • getQCRootAlg

        public int getQCRootAlg()
        Retrieves the value of the control XPRSconstants.QCROOTALG. This control determines which algorithm is to be used to solve the root of a mixed integer quadratic constrained or mixed integer second order cone problem, when outer approximation is used.

      • setQCRootAlg

        public void setQCRootAlg​(int newval)
        Sets the value of the control XPRSconstants.QCROOTALG. This control determines which algorithm is to be used to solve the root of a mixed integer quadratic constrained or mixed integer second order cone problem, when outer approximation is used.

      • getPreConvertSeparable

        public int getPreConvertSeparable()
        Retrieves the value of the control XPRSconstants.PRECONVERTSEPARABLE. Presolve: reformulate problems with a non-diagonal quadratic objective and/or constraints as diagonal quadratic or second-order conic constraints.

      • setPreConvertSeparable

        public void setPreConvertSeparable​(int newval)
        Sets the value of the control XPRSconstants.PRECONVERTSEPARABLE. Presolve: reformulate problems with a non-diagonal quadratic objective and/or constraints as diagonal quadratic or second-order conic constraints.

      • getAlgAfterNetwork

        public int getAlgAfterNetwork()
        Retrieves the value of the control XPRSconstants.ALGAFTERNETWORK. The algorithm to be used for the clean up step after the network simplex solver.

      • setAlgAfterNetwork

        public void setAlgAfterNetwork​(int newval)
        Sets the value of the control XPRSconstants.ALGAFTERNETWORK. The algorithm to be used for the clean up step after the network simplex solver.

      • getTrace

        public int getTrace()
        Retrieves the value of the control XPRSconstants.TRACE. Display the infeasibility diagnosis during presolve. If non-zero, an explanation of the logical deductions made by presolve to deduce infeasibility or unboundedness will be displayed on screen or sent to the message callback function.

      • setTrace

        public void setTrace​(int newval)
        Sets the value of the control XPRSconstants.TRACE. Display the infeasibility diagnosis during presolve. If non-zero, an explanation of the logical deductions made by presolve to deduce infeasibility or unboundedness will be displayed on screen or sent to the message callback function.

      • resetTrace

        public void resetTrace()
        Resets to its default the value of control XPRSconstants.TRACE

      • getMaxIIS

        public int getMaxIIS()
        Retrieves the value of the control XPRSconstants.MAXIIS. This function controls the number of Irreducible Infeasible Sets to be found using the iISAll ( IIS -a).

      • setMaxIIS

        public void setMaxIIS​(int newval)
        Sets the value of the control XPRSconstants.MAXIIS. This function controls the number of Irreducible Infeasible Sets to be found using the iISAll ( IIS -a).

      • resetMaxIIS

        public void resetMaxIIS()
        Resets to its default the value of control XPRSconstants.MAXIIS

      • getCPUTime

        public int getCPUTime()
        Retrieves the value of the control XPRSconstants.CPUTIME. How time should be measured when timings are reported in the log and when checking against time limits

      • setCPUTime

        public void setCPUTime​(int newval)
        Sets the value of the control XPRSconstants.CPUTIME. How time should be measured when timings are reported in the log and when checking against time limits

      • resetCPUTime

        public void resetCPUTime()
        Resets to its default the value of control XPRSconstants.CPUTIME

      • getCoverCuts

        public int getCoverCuts()
        Retrieves the value of the control XPRSconstants.COVERCUTS. Branch and Bound: The number of rounds of lifted cover inequalities at the top node. A lifted cover inequality is an additional constraint that can be particularly effective at reducing the size of the feasible region without removing potential integral solutions. The process of generating these can be carried out a number of times, further reducing the feasible region, albeit incurring a time penalty. There is usually a good payoff from generating these at the top node, since these inequalities then apply to every subsequent node in the tree search.

      • setCoverCuts

        public void setCoverCuts​(int newval)
        Sets the value of the control XPRSconstants.COVERCUTS. Branch and Bound: The number of rounds of lifted cover inequalities at the top node. A lifted cover inequality is an additional constraint that can be particularly effective at reducing the size of the feasible region without removing potential integral solutions. The process of generating these can be carried out a number of times, further reducing the feasible region, albeit incurring a time penalty. There is usually a good payoff from generating these at the top node, since these inequalities then apply to every subsequent node in the tree search.

      • getGomCuts

        public int getGomCuts()
        Retrieves the value of the control XPRSconstants.GOMCUTS. Branch and Bound: The number of rounds of Gomory or lift-and-project cuts at the top node.

      • setGomCuts

        public void setGomCuts​(int newval)
        Sets the value of the control XPRSconstants.GOMCUTS. Branch and Bound: The number of rounds of Gomory or lift-and-project cuts at the top node.

      • resetGomCuts

        public void resetGomCuts()
        Resets to its default the value of control XPRSconstants.GOMCUTS

      • getLpFolding

        public int getLpFolding()
        Retrieves the value of the control XPRSconstants.LPFOLDING. Simplex and barrier: whether to fold an LP problem before solving it.

      • setLpFolding

        public void setLpFolding​(int newval)
        Sets the value of the control XPRSconstants.LPFOLDING. Simplex and barrier: whether to fold an LP problem before solving it.

      • getMPSFormat

        public int getMPSFormat()
        Retrieves the value of the control XPRSconstants.MPSFORMAT. Specifies the format of MPS files.

      • setMPSFormat

        public void setMPSFormat​(int newval)
        Sets the value of the control XPRSconstants.MPSFORMAT. Specifies the format of MPS files.

      • getCutStrategy

        public int getCutStrategy()
        Retrieves the value of the control XPRSconstants.CUTSTRATEGY. Branch and Bound: This specifies the cut strategy. A more aggressive cut strategy, generating a greater number of cuts, will result in fewer nodes to be explored, but with an associated time cost in generating the cuts. The fewer cuts generated, the less time taken, but the greater subsequent number of nodes to be explored. (Values are from the enumeration XPRSenumerations.CutStrategy)

        This control is used in the following examples:

        • AddMipSol
        • FixBV
        • Knapsack
        • MostViolated
        • RoundInt
        • SaveSol
        • Trimloss

      • setCutStrategy

        public void setCutStrategy​(int newval)
        Sets the value of the control XPRSconstants.CUTSTRATEGY. Branch and Bound: This specifies the cut strategy. A more aggressive cut strategy, generating a greater number of cuts, will result in fewer nodes to be explored, but with an associated time cost in generating the cuts. The fewer cuts generated, the less time taken, but the greater subsequent number of nodes to be explored. (Values are from the enumeration XPRSenumerations.CutStrategy)

        This control is used in the following examples:

        • AddMipSol
        • FixBV
        • Knapsack
        • MostViolated
        • RoundInt
        • SaveSol
        • Trimloss

      • setCutStrategy

        public void setCutStrategy​(XPRSenumerations.CutStrategy newval)
        Sets the value of the control XPRSconstants.CUTSTRATEGY. Branch and Bound: This specifies the cut strategy. A more aggressive cut strategy, generating a greater number of cuts, will result in fewer nodes to be explored, but with an associated time cost in generating the cuts. The fewer cuts generated, the less time taken, but the greater subsequent number of nodes to be explored. (Values are from the enumeration XPRSenumerations.CutStrategy)

      • getCutDepth

        public int getCutDepth()
        Retrieves the value of the control XPRSconstants.CUTDEPTH. Branch and Bound: Sets the maximum depth in the tree search at which cuts will be generated. Generating cuts can take a lot of time, and is often less important at deeper levels of the tree since tighter bounds on the variables have already reduced the feasible region. A value of 0 signifies that no cuts will be generated.

      • setCutDepth

        public void setCutDepth​(int newval)
        Sets the value of the control XPRSconstants.CUTDEPTH. Branch and Bound: Sets the maximum depth in the tree search at which cuts will be generated. Generating cuts can take a lot of time, and is often less important at deeper levels of the tree since tighter bounds on the variables have already reduced the feasible region. A value of 0 signifies that no cuts will be generated.

      • resetCutDepth

        public void resetCutDepth()
        Resets to its default the value of control XPRSconstants.CUTDEPTH

      • getTreeCoverCuts

        public int getTreeCoverCuts()
        Retrieves the value of the control XPRSconstants.TREECOVERCUTS. Branch and Bound: The number of rounds of lifted cover inequalities generated at nodes other than the top node in the tree. Compare with the description for COVERCUTS. A value of -1 indicates the number of rounds is determined automatically.

      • setTreeCoverCuts

        public void setTreeCoverCuts​(int newval)
        Sets the value of the control XPRSconstants.TREECOVERCUTS. Branch and Bound: The number of rounds of lifted cover inequalities generated at nodes other than the top node in the tree. Compare with the description for COVERCUTS. A value of -1 indicates the number of rounds is determined automatically.

      • getTreeGomCuts

        public int getTreeGomCuts()
        Retrieves the value of the control XPRSconstants.TREEGOMCUTS. Branch and Bound: The number of rounds of Gomory cuts generated at nodes other than the first node in the tree. Compare with the description for GOMCUTS. A value of -1 indicates the number of rounds is determined automatically.

      • setTreeGomCuts

        public void setTreeGomCuts​(int newval)
        Sets the value of the control XPRSconstants.TREEGOMCUTS. Branch and Bound: The number of rounds of Gomory cuts generated at nodes other than the first node in the tree. Compare with the description for GOMCUTS. A value of -1 indicates the number of rounds is determined automatically.

      • getCutSelect

        public int getCutSelect()
        Retrieves the value of the control XPRSconstants.CUTSELECT. A bit vector providing detailed control of the cuts created for the root node of a MIP solve. Use TREECUTSELECT to control cuts during the tree search. (Values are from the enumeration XPRSenumerations.CutSelect)

      • setCutSelect

        public void setCutSelect​(int newval)
        Sets the value of the control XPRSconstants.CUTSELECT. A bit vector providing detailed control of the cuts created for the root node of a MIP solve. Use TREECUTSELECT to control cuts during the tree search. (Values are from the enumeration XPRSenumerations.CutSelect)

      • getTreeCutSelect

        public int getTreeCutSelect()
        Retrieves the value of the control XPRSconstants.TREECUTSELECT. A bit vector providing detailed control of the cuts created during the tree search of a MIP solve. Use CUTSELECT to control cuts on the root node.

      • setTreeCutSelect

        public void setTreeCutSelect​(int newval)
        Sets the value of the control XPRSconstants.TREECUTSELECT. A bit vector providing detailed control of the cuts created during the tree search of a MIP solve. Use CUTSELECT to control cuts on the root node.

      • setDualize

        public void setDualize​(int newval)
        Sets the value of the control XPRSconstants.DUALIZE. For a linear problem or the initial linear relaxation of a MIP, determines whether to form and solve the dual problem. (Values are from the enumeration XPRSenumerations.AlwaysNeverAutomatic)

      • resetDualize

        public void resetDualize()
        Resets to its default the value of control XPRSconstants.DUALIZE

      • getSBIterLimit

        public int getSBIterLimit()
        Retrieves the value of the control XPRSconstants.SBITERLIMIT. Number of dual iterations to perform the strong branching for each entity.

      • setSBIterLimit

        public void setSBIterLimit​(int newval)
        Sets the value of the control XPRSconstants.SBITERLIMIT. Number of dual iterations to perform the strong branching for each entity.

      • getSBBest

        public int getSBBest()
        Retrieves the value of the control XPRSconstants.SBBEST. Number of infeasible MIP entities to initialize pseudo costs for on each node.

        This control is used in the following examples:

        • AddMipSol

      • setSBBest

        public void setSBBest​(int newval)
        Sets the value of the control XPRSconstants.SBBEST. Number of infeasible MIP entities to initialize pseudo costs for on each node.

        This control is used in the following examples:

        • AddMipSol

      • resetSBBest

        public void resetSBBest()
        Resets to its default the value of control XPRSconstants.SBBEST

      • getBarIndefLimit

        public int getBarIndefLimit()
        Retrieves the value of the control XPRSconstants.BARINDEFLIMIT. Newton Barrier. This limits the number of consecutive indefinite barrier iterations that will be performed. The optimizer will try to minimize (resp. maximize) a QP problem even if the Q matrix is not positive (resp. negative) semi-definite. However, the optimizer may detect that the Q matrix is indefinite and this can result in the optimizer not converging. This control specifies how many indefinite iterations may occur before the optimizer stops and reports that the problem is indefinite. It is usual to specify a value greater than one, and only stop after a series of indefinite matrices, as the problem may be found to be indefinite incorrectly on a few iterations for numerical reasons.

      • setBarIndefLimit

        public void setBarIndefLimit​(int newval)
        Sets the value of the control XPRSconstants.BARINDEFLIMIT. Newton Barrier. This limits the number of consecutive indefinite barrier iterations that will be performed. The optimizer will try to minimize (resp. maximize) a QP problem even if the Q matrix is not positive (resp. negative) semi-definite. However, the optimizer may detect that the Q matrix is indefinite and this can result in the optimizer not converging. This control specifies how many indefinite iterations may occur before the optimizer stops and reports that the problem is indefinite. It is usual to specify a value greater than one, and only stop after a series of indefinite matrices, as the problem may be found to be indefinite incorrectly on a few iterations for numerical reasons.

      • getHeurFreq

        public int getHeurFreq()
        Retrieves the value of the control XPRSconstants.HEURFREQ. Branch and Bound: This specifies the frequency at which heuristics are used in the tree search. Heuristics will only be used at a node if the depth of the node is a multiple of HEURFREQ.

      • setHeurFreq

        public void setHeurFreq​(int newval)
        Sets the value of the control XPRSconstants.HEURFREQ. Branch and Bound: This specifies the frequency at which heuristics are used in the tree search. Heuristics will only be used at a node if the depth of the node is a multiple of HEURFREQ.

      • resetHeurFreq

        public void resetHeurFreq()
        Resets to its default the value of control XPRSconstants.HEURFREQ

      • getHeurDepth

        public int getHeurDepth()
        Retrieves the value of the control XPRSconstants.HEURDEPTH. Branch and Bound: Sets the maximum depth in the tree search at which heuristics will be used to find MIP solutions. It may be worth stopping the heuristic search for solutions after a certain depth in the tree search. A value of 0 signifies that heuristics will not be used. This control no longer has any effect and will be removed from future releases.

      • setHeurDepth

        public void setHeurDepth​(int newval)
        Sets the value of the control XPRSconstants.HEURDEPTH. Branch and Bound: Sets the maximum depth in the tree search at which heuristics will be used to find MIP solutions. It may be worth stopping the heuristic search for solutions after a certain depth in the tree search. A value of 0 signifies that heuristics will not be used. This control no longer has any effect and will be removed from future releases.

      • getHeurMaxSol

        public int getHeurMaxSol()
        Retrieves the value of the control XPRSconstants.HEURMAXSOL. Branch and Bound: This specifies the maximum number of heuristic solutions that will be found in the tree search. This control no longer has any effect and will be removed from future releases.

      • setHeurMaxSol

        public void setHeurMaxSol​(int newval)
        Sets the value of the control XPRSconstants.HEURMAXSOL. Branch and Bound: This specifies the maximum number of heuristic solutions that will be found in the tree search. This control no longer has any effect and will be removed from future releases.

      • getHeurNodes

        public int getHeurNodes()
        Retrieves the value of the control XPRSconstants.HEURNODES. Branch and Bound: This specifies the maximum number of nodes at which heuristics are used in the tree search. This control no longer has any effect and will be removed from future releases.

      • setHeurNodes

        public void setHeurNodes​(int newval)
        Sets the value of the control XPRSconstants.HEURNODES. Branch and Bound: This specifies the maximum number of nodes at which heuristics are used in the tree search. This control no longer has any effect and will be removed from future releases.

      • getLNPBest

        public int getLNPBest()
        Retrieves the value of the control XPRSconstants.LNPBEST. Number of infeasible MIP entities to create lift-and-project cuts for during each round of Gomory cuts at the top node (see GOMCUTS).

      • setLNPBest

        public void setLNPBest​(int newval)
        Sets the value of the control XPRSconstants.LNPBEST. Number of infeasible MIP entities to create lift-and-project cuts for during each round of Gomory cuts at the top node (see GOMCUTS).

      • resetLNPBest

        public void resetLNPBest()
        Resets to its default the value of control XPRSconstants.LNPBEST

      • getLNPIterLimit

        public int getLNPIterLimit()
        Retrieves the value of the control XPRSconstants.LNPITERLIMIT. Number of iterations to perform in improving each lift-and-project cut.

      • setLNPIterLimit

        public void setLNPIterLimit​(int newval)
        Sets the value of the control XPRSconstants.LNPITERLIMIT. Number of iterations to perform in improving each lift-and-project cut.

      • getBranchChoice

        public int getBranchChoice()
        Retrieves the value of the control XPRSconstants.BRANCHCHOICE. Once a MIP entity has been selected for branching, this control determines which of the branches is solved first. (Values are from the enumeration XPRSenumerations.BranchChoice)

      • setBranchChoice

        public void setBranchChoice​(int newval)
        Sets the value of the control XPRSconstants.BRANCHCHOICE. Once a MIP entity has been selected for branching, this control determines which of the branches is solved first. (Values are from the enumeration XPRSenumerations.BranchChoice)

      • getBarRegularize

        public int getBarRegularize()
        Retrieves the value of the control XPRSconstants.BARREGULARIZE. This control determines how the barrier algorithm applies regularization on the KKT system.

      • setBarRegularize

        public void setBarRegularize​(int newval)
        Sets the value of the control XPRSconstants.BARREGULARIZE. This control determines how the barrier algorithm applies regularization on the KKT system.

      • getSBSelect

        public int getSBSelect()
        Retrieves the value of the control XPRSconstants.SBSELECT. The size of the candidate list of MIP entities for strong branching.

      • setSBSelect

        public void setSBSelect​(int newval)
        Sets the value of the control XPRSconstants.SBSELECT. The size of the candidate list of MIP entities for strong branching.

      • resetSBSelect

        public void resetSBSelect()
        Resets to its default the value of control XPRSconstants.SBSELECT

      • getIISLog

        public int getIISLog()
        Retrieves the value of the control XPRSconstants.IISLOG. Selects how much information should be printed during the IIS procedure. Please refer to Appendix for a more detailed description of the IIS logging format.

      • setIISLog

        public void setIISLog​(int newval)
        Sets the value of the control XPRSconstants.IISLOG. Selects how much information should be printed during the IIS procedure. Please refer to Appendix for a more detailed description of the IIS logging format.

      • resetIISLog

        public void resetIISLog()
        Resets to its default the value of control XPRSconstants.IISLOG

      • getLocalChoice

        public int getLocalChoice()
        Retrieves the value of the control XPRSconstants.LOCALCHOICE. Controls when to perform a local backtrack between the two child nodes during a dive in the branch and bound tree.

      • setLocalChoice

        public void setLocalChoice​(int newval)
        Sets the value of the control XPRSconstants.LOCALCHOICE. Controls when to perform a local backtrack between the two child nodes during a dive in the branch and bound tree.

      • getLocalBacktrack

        public int getLocalBacktrack()

      • getL1Cache

        @Deprecated
public int getL1Cache()
        Deprecated.
        since 41.00
        Retrieves the value of the control XPRSconstants.L1CACHE. Newton barrier: L1 cache size in kB (kilo bytes) of the CPU. On Intel (or compatible) platforms a value of -1 may be used to determine the cache size automatically.

      • setL1Cache

        @Deprecated
public void setL1Cache​(int newval)
        Deprecated.
        since 41.00
        Sets the value of the control XPRSconstants.L1CACHE. Newton barrier: L1 cache size in kB (kilo bytes) of the CPU. On Intel (or compatible) platforms a value of -1 may be used to determine the cache size automatically.

      • resetL1Cache

        @Deprecated
public void resetL1Cache()
        Deprecated.
        Resets to its default the value of control XPRSconstants.L1CACHE

      • getHeurDiveStrategy

        public int getHeurDiveStrategy()
        Retrieves the value of the control XPRSconstants.HEURDIVESTRATEGY. Branch and Bound: Chooses the strategy for the diving heuristic.

      • setHeurDiveStrategy

        public void setHeurDiveStrategy​(int newval)
        Sets the value of the control XPRSconstants.HEURDIVESTRATEGY. Branch and Bound: Chooses the strategy for the diving heuristic.

      • getHeurSelect

        public int getHeurSelect()

      • getBarStart

        public int getBarStart()
        Retrieves the value of the control XPRSconstants.BARSTART. Controls the computation of the starting point and warm-starting for the Newton barrier and the hybrid gradient algorithms.

      • setBarStart

        public void setBarStart​(int newval)
        Sets the value of the control XPRSconstants.BARSTART. Controls the computation of the starting point and warm-starting for the Newton barrier and the hybrid gradient algorithms.

      • resetBarStart

        public void resetBarStart()
        Resets to its default the value of control XPRSconstants.BARSTART

      • getPresolvePasses

        public int getPresolvePasses()
        Retrieves the value of the control XPRSconstants.PRESOLVEPASSES. Number of reduction rounds to be performed in presolve

      • setPresolvePasses

        public void setPresolvePasses​(int newval)
        Sets the value of the control XPRSconstants.PRESOLVEPASSES. Number of reduction rounds to be performed in presolve

      • getBarNumStability

        public int getBarNumStability()

      • getBarOrderThreads

        public int getBarOrderThreads()
        Retrieves the value of the control XPRSconstants.BARORDERTHREADS. If set to a positive integer it determines the number of concurrent threads for the sparse matrix ordering algorithm in the Newton-barrier method.

      • setBarOrderThreads

        public void setBarOrderThreads​(int newval)
        Sets the value of the control XPRSconstants.BARORDERTHREADS. If set to a positive integer it determines the number of concurrent threads for the sparse matrix ordering algorithm in the Newton-barrier method.

      • getExtraSets

        public int getExtraSets()
        Retrieves the value of the control XPRSconstants.EXTRASETS. The initial number of extra sets to allow for in the matrix. If sets are to be added to the matrix, then, for maximum efficiency, space should be reserved for the sets before the matrix is input by setting the EXTRASETS control. If this is not done, resizing will occur automatically, but more space may be allocated than the user actually requires.

      • setExtraSets

        public void setExtraSets​(int newval)
        Sets the value of the control XPRSconstants.EXTRASETS. The initial number of extra sets to allow for in the matrix. If sets are to be added to the matrix, then, for maximum efficiency, space should be reserved for the sets before the matrix is input by setting the EXTRASETS control. If this is not done, resizing will occur automatically, but more space may be allocated than the user actually requires.

      • getExtraSetElems

        public long getExtraSetElems()
        Retrieves the value of the control XPRSconstants.EXTRASETELEMS. The initial number of extra elements in sets to allow for in the matrix. If sets are to be added to the matrix, then, for maximum efficiency, space should be reserved for the set elements before the matrix is input by setting the EXTRASETELEMS control. If this is not done, resizing will occur automatically, but more space may be allocated than the user actually requires.

      • setExtraSetElems

        public void setExtraSetElems​(long newval)
        Sets the value of the control XPRSconstants.EXTRASETELEMS. The initial number of extra elements in sets to allow for in the matrix. If sets are to be added to the matrix, then, for maximum efficiency, space should be reserved for the set elements before the matrix is input by setting the EXTRASETELEMS control. If this is not done, resizing will occur automatically, but more space may be allocated than the user actually requires.

      • getPreCoefElim

        public int getPreCoefElim()
        Retrieves the value of the control XPRSconstants.PRECOEFELIM. Presolve: Specifies whether the optimizer should attempt to recombine constraints in order to reduce the number of non zero coefficients when presolving a mixed integer problem. (Values are from the enumeration XPRSenumerations.PresolveCoefElim)

      • setPreCoefElim

        public void setPreCoefElim​(int newval)
        Sets the value of the control XPRSconstants.PRECOEFELIM. Presolve: Specifies whether the optimizer should attempt to recombine constraints in order to reduce the number of non zero coefficients when presolving a mixed integer problem. (Values are from the enumeration XPRSenumerations.PresolveCoefElim)

      • getPreDomCol

        public int getPreDomCol()
        Retrieves the value of the control XPRSconstants.PREDOMCOL. Presolve: Determines the level of dominated column removal reductions to perform when presolving a mixed integer problem. Only binary columns will be checked. (Values are from the enumeration XPRSenumerations.PresolveDomColumn)

      • setPreDomCol

        public void setPreDomCol​(int newval)
        Sets the value of the control XPRSconstants.PREDOMCOL. Presolve: Determines the level of dominated column removal reductions to perform when presolving a mixed integer problem. Only binary columns will be checked. (Values are from the enumeration XPRSenumerations.PresolveDomColumn)

      • getHeurSearchFreq

        public int getHeurSearchFreq()
        Retrieves the value of the control XPRSconstants.HEURSEARCHFREQ. Branch and Bound: This specifies how often the local search heuristic should be run in the tree.

      • setHeurSearchFreq

        public void setHeurSearchFreq​(int newval)
        Sets the value of the control XPRSconstants.HEURSEARCHFREQ. Branch and Bound: This specifies how often the local search heuristic should be run in the tree.

      • getHeurDiveSpeedUp

        public int getHeurDiveSpeedUp()
        Retrieves the value of the control XPRSconstants.HEURDIVESPEEDUP. Branch and Bound: Changes the emphasis of the diving heuristic from solution quality to diving speed.

      • setHeurDiveSpeedUp

        public void setHeurDiveSpeedUp​(int newval)
        Sets the value of the control XPRSconstants.HEURDIVESPEEDUP. Branch and Bound: Changes the emphasis of the diving heuristic from solution quality to diving speed.

      • getSBEstimate

        public int getSBEstimate()
        Retrieves the value of the control XPRSconstants.SBESTIMATE. Branch and Bound: How to calculate pseudo costs from the local node when selecting an infeasible MIP entity to branch on. These pseudo costs are used in combination with local strong branching and history costs to select the branch candidate.

      • setSBEstimate

        public void setSBEstimate​(int newval)
        Sets the value of the control XPRSconstants.SBESTIMATE. Branch and Bound: How to calculate pseudo costs from the local node when selecting an infeasible MIP entity to branch on. These pseudo costs are used in combination with local strong branching and history costs to select the branch candidate.

      • getBarCores

        public int getBarCores()
        Retrieves the value of the control XPRSconstants.BARCORES. If set to a positive integer it determines the number of physical CPU cores assumed to be present in the system by the barrier and hybrid gradient algorithms. If the value is set to the default value ( -1), Xpress will automatically detect the number of cores.

      • setBarCores

        public void setBarCores​(int newval)
        Sets the value of the control XPRSconstants.BARCORES. If set to a positive integer it determines the number of physical CPU cores assumed to be present in the system by the barrier and hybrid gradient algorithms. If the value is set to the default value ( -1), Xpress will automatically detect the number of cores.

      • resetBarCores

        public void resetBarCores()
        Resets to its default the value of control XPRSconstants.BARCORES

      • getMaxChecksOnMaxTime

        public int getMaxChecksOnMaxTime()
        Retrieves the value of the control XPRSconstants.MAXCHECKSONMAXTIME. This control is intended for use where optimization runs that are terminated using the TIMELIMIT (or the deprecated MAXTIME) control are required to be reproduced exactly. This control is necessary because of the inherent difficulty in terminating algorithmic software in a consistent way using temporal criteria. The control value relates to the number of times the optimizer checks the TIMELIMIT criterion up to and including the check when the termination was activated. To use the control the user first must obtain the value of the CHECKSONMAXTIME attribute after the run returns. This attribute value is the number of times the optimizer checked the TIMELIMIT criterion during the last call to the optimization routine mipOptimize. Note that this attribute value will be negative if the optimizer terminated on the TIMELIMIT criterion. To ensure that a reproduction of a run terminates in the same way the user should first ensure that TIMELIMIT is set to its default value or to a large value so the run does not terminate again on TIMELIMIT and then simply set the control MAXCHECKSONMAXTIME to the absolute value of the CHECKSONMAXTIME value.

      • setMaxChecksOnMaxTime

        public void setMaxChecksOnMaxTime​(int newval)
        Sets the value of the control XPRSconstants.MAXCHECKSONMAXTIME. This control is intended for use where optimization runs that are terminated using the TIMELIMIT (or the deprecated MAXTIME) control are required to be reproduced exactly. This control is necessary because of the inherent difficulty in terminating algorithmic software in a consistent way using temporal criteria. The control value relates to the number of times the optimizer checks the TIMELIMIT criterion up to and including the check when the termination was activated. To use the control the user first must obtain the value of the CHECKSONMAXTIME attribute after the run returns. This attribute value is the number of times the optimizer checked the TIMELIMIT criterion during the last call to the optimization routine mipOptimize. Note that this attribute value will be negative if the optimizer terminated on the TIMELIMIT criterion. To ensure that a reproduction of a run terminates in the same way the user should first ensure that TIMELIMIT is set to its default value or to a large value so the run does not terminate again on TIMELIMIT and then simply set the control MAXCHECKSONMAXTIME to the absolute value of the CHECKSONMAXTIME value.

      • getMaxChecksOnMaxCutTime

        public int getMaxChecksOnMaxCutTime()
        Retrieves the value of the control XPRSconstants.MAXCHECKSONMAXCUTTIME. This control is intended for use where optimization runs that are terminated using the MAXCUTTIME control are required to be reproduced exactly. This control is necessary because of the inherent difficulty in terminating algorithmic software in a consistent way using temporal criteria. The control value relates to the number of times the optimizer checks the MAXCUTTIME criterion up to and including the check when the termination of cutting was activated. To use the control the user first must obtain the value of the CHECKSONMAXCUTTIME attribute after the run returns. This attribute value is the number of times the optimizer checked the MAXCUTTIME criterion during the last call to the optimization routine mipOptimize. Note that this attribute value will be negative if the optimizer terminated cutting on the MAXCUTTIME criterion. To ensure accurate reproduction of a run the user should first ensure that MAXCUTTIME is set to its default value or to a large value so the run does not terminate again on MAXCUTTIME and then simply set the control MAXCHECKSONMAXCUTTIME to the absolute value of the CHECKSONMAXCUTTIME value.

      • setMaxChecksOnMaxCutTime

        public void setMaxChecksOnMaxCutTime​(int newval)
        Sets the value of the control XPRSconstants.MAXCHECKSONMAXCUTTIME. This control is intended for use where optimization runs that are terminated using the MAXCUTTIME control are required to be reproduced exactly. This control is necessary because of the inherent difficulty in terminating algorithmic software in a consistent way using temporal criteria. The control value relates to the number of times the optimizer checks the MAXCUTTIME criterion up to and including the check when the termination of cutting was activated. To use the control the user first must obtain the value of the CHECKSONMAXCUTTIME attribute after the run returns. This attribute value is the number of times the optimizer checked the MAXCUTTIME criterion during the last call to the optimization routine mipOptimize. Note that this attribute value will be negative if the optimizer terminated cutting on the MAXCUTTIME criterion. To ensure accurate reproduction of a run the user should first ensure that MAXCUTTIME is set to its default value or to a large value so the run does not terminate again on MAXCUTTIME and then simply set the control MAXCHECKSONMAXCUTTIME to the absolute value of the CHECKSONMAXCUTTIME value.

      • getHistoryCosts

        public int getHistoryCosts()
        Retrieves the value of the control XPRSconstants.HISTORYCOSTS. Branch and Bound: How to update the pseudo cost for a MIP entity when a strong branch or a regular branch is applied.

      • setHistoryCosts

        public void setHistoryCosts​(int newval)
        Sets the value of the control XPRSconstants.HISTORYCOSTS. Branch and Bound: How to update the pseudo cost for a MIP entity when a strong branch or a regular branch is applied.

      • getAlgAfterCrossOver

        public int getAlgAfterCrossOver()
        Retrieves the value of the control XPRSconstants.ALGAFTERCROSSOVER. The algorithm to be used for the final clean up step after the crossover.

      • setAlgAfterCrossOver

        public void setAlgAfterCrossOver​(int newval)
        Sets the value of the control XPRSconstants.ALGAFTERCROSSOVER. The algorithm to be used for the final clean up step after the crossover.

      • getMutexCallBacks

        public int getMutexCallBacks()
        Retrieves the value of the control XPRSconstants.MUTEXCALLBACKS. Branch and Bound: This determines whether the callback routines are mutexed from within the optimizer.

        This control is used in the following examples:

        • MostViolated

      • setMutexCallBacks

        public void setMutexCallBacks​(int newval)
        Sets the value of the control XPRSconstants.MUTEXCALLBACKS. Branch and Bound: This determines whether the callback routines are mutexed from within the optimizer.

        This control is used in the following examples:

        • MostViolated

      • getBarCrash

        public int getBarCrash()
        Retrieves the value of the control XPRSconstants.BARCRASH. Newton barrier and hybrid gradient: This determines the type of crash used for the crossover. During the crash procedure, an initial basis is determined which attempts to speed up the crossover. A good choice at this stage will significantly reduce the number of iterations required to crossover to an optimal solution. The possible values increase proportionally to their time-consumption.

      • setBarCrash

        public void setBarCrash​(int newval)
        Sets the value of the control XPRSconstants.BARCRASH. Newton barrier and hybrid gradient: This determines the type of crash used for the crossover. During the crash procedure, an initial basis is determined which attempts to speed up the crossover. A good choice at this stage will significantly reduce the number of iterations required to crossover to an optimal solution. The possible values increase proportionally to their time-consumption.

      • resetBarCrash

        public void resetBarCrash()
        Resets to its default the value of control XPRSconstants.BARCRASH

      • getHeurDiveSoftRounding

        public int getHeurDiveSoftRounding()
        Retrieves the value of the control XPRSconstants.HEURDIVESOFTROUNDING. Branch and Bound: Enables a more cautious strategy for the diving heuristic, where it tries to push binaries and integer variables to their bounds using the objective, instead of directly fixing them. This can be useful when the default diving heuristics fail to find any feasible solutions.

      • setHeurDiveSoftRounding

        public void setHeurDiveSoftRounding​(int newval)
        Sets the value of the control XPRSconstants.HEURDIVESOFTROUNDING. Branch and Bound: Enables a more cautious strategy for the diving heuristic, where it tries to push binaries and integer variables to their bounds using the objective, instead of directly fixing them. This can be useful when the default diving heuristics fail to find any feasible solutions.

      • getHeurSearchRootSelect

        public int getHeurSearchRootSelect()
        Retrieves the value of the control XPRSconstants.HEURSEARCHROOTSELECT. A bit vector control for selecting which local search heuristics to apply on the root node of a MIP solve. Use HEURSEARCHTREESELECT to control local search heuristics during the tree search. (Values are from the enumeration XPRSenumerations.HeuristicSearchSelect)

      • setHeurSearchRootSelect

        public void setHeurSearchRootSelect​(int newval)
        Sets the value of the control XPRSconstants.HEURSEARCHROOTSELECT. A bit vector control for selecting which local search heuristics to apply on the root node of a MIP solve. Use HEURSEARCHTREESELECT to control local search heuristics during the tree search. (Values are from the enumeration XPRSenumerations.HeuristicSearchSelect)

      • getHeurSearchTreeSelect

        public int getHeurSearchTreeSelect()
        Retrieves the value of the control XPRSconstants.HEURSEARCHTREESELECT. A bit vector control for selecting which local search heuristics to apply during the tree search of a MIP solve. Use HEURSEARCHROOTSELECT to control local search heuristics on the root node. (Values are from the enumeration XPRSenumerations.HeuristicSearchSelect)

      • setHeurSearchTreeSelect

        public void setHeurSearchTreeSelect​(int newval)
        Sets the value of the control XPRSconstants.HEURSEARCHTREESELECT. A bit vector control for selecting which local search heuristics to apply during the tree search of a MIP solve. Use HEURSEARCHROOTSELECT to control local search heuristics on the root node. (Values are from the enumeration XPRSenumerations.HeuristicSearchSelect)

      • getMPS18Compatible

        public int getMPS18Compatible()
        Retrieves the value of the control XPRSconstants.MPS18COMPATIBLE. Provides compatibility of MPS file output for older MPS readers.

      • setMPS18Compatible

        public void setMPS18Compatible​(int newval)
        Sets the value of the control XPRSconstants.MPS18COMPATIBLE. Provides compatibility of MPS file output for older MPS readers.

      • setRootPresolve

        public void setRootPresolve​(int newval)
        Sets the value of the control XPRSconstants.ROOTPRESOLVE. Determines if presolving should be performed on the problem after the tree search has finished with root cutting and heuristics. (Values are from the enumeration XPRSenumerations.AlwaysNeverAutomatic)

      • getCrossOverDRP

        public int getCrossOverDRP()

      • getForceOutput

        public int getForceOutput()
        Retrieves the value of the control XPRSconstants.FORCEOUTPUT. Certain names in the problem object may be incompatible with different file formats (such as names containing spaces for LP files). If the optimizer might be unable to read back a problem because of non-standard names, it will first attempt to write it out using an extended naming convention. If the names would not be possible to extend so that they would be reproducible and recognizable, it will give an error message and won't create the file. If the optimizer might be unable to read back a problem because of non-standard names, it will give an error message and won't create the file. This option may be used to force output anyway.

      • setForceOutput

        public void setForceOutput​(int newval)
        Sets the value of the control XPRSconstants.FORCEOUTPUT. Certain names in the problem object may be incompatible with different file formats (such as names containing spaces for LP files). If the optimizer might be unable to read back a problem because of non-standard names, it will first attempt to write it out using an extended naming convention. If the names would not be possible to extend so that they would be reproducible and recognizable, it will give an error message and won't create the file. If the optimizer might be unable to read back a problem because of non-standard names, it will give an error message and won't create the file. This option may be used to force output anyway.

      • getPrimalOps

        public int getPrimalOps()
        Retrieves the value of the control XPRSconstants.PRIMALOPS. Primal simplex: allows fine tuning the variable selection in the primal simplex solver.

      • setPrimalOps

        public void setPrimalOps​(int newval)
        Sets the value of the control XPRSconstants.PRIMALOPS. Primal simplex: allows fine tuning the variable selection in the primal simplex solver.

      • getDeterministic

        public int getDeterministic()
        Retrieves the value of the control XPRSconstants.DETERMINISTIC. Selects whether to use a deterministic or opportunistic mode when solving a problem using multiple threads.

      • setDeterministic

        public void setDeterministic​(int newval)
        Sets the value of the control XPRSconstants.DETERMINISTIC. Selects whether to use a deterministic or opportunistic mode when solving a problem using multiple threads.

      • getPreProbing

        public int getPreProbing()
        Retrieves the value of the control XPRSconstants.PREPROBING. Presolve: Amount of probing to perform on binary variables during presolve. This is done by fixing a binary to each of its values in turn and analyzing the implications. (Values are from the enumeration XPRSenumerations.PreProbing)

      • setPreProbing

        public void setPreProbing​(int newval)
        Sets the value of the control XPRSconstants.PREPROBING. Presolve: Amount of probing to perform on binary variables during presolve. This is done by fixing a binary to each of its values in turn and analyzing the implications. (Values are from the enumeration XPRSenumerations.PreProbing)

      • getTreeMemoryLimit

        public int getTreeMemoryLimit()
        Retrieves the value of the control XPRSconstants.TREEMEMORYLIMIT. A soft limit, in megabytes, for the amount of memory to use in storing the branch and bound search tree. This doesn't include memory used for presolve, heuristics, solving the LP relaxation, etc. When set to 0 (the default), the optimizer will calculate a limit automatically based on the amount of free physical memory detected in the machine. When the memory used by the branch and bound tree exceeds this limit, the optimizer will try to reduce the memory usage by writing lower-rated sections of the tree to a file called the "tree file". Though the solve can continue if it cannot bring the tree memory usage below the specified limit, performance will be inhibited and a message will be printed to the log.

      • setTreeMemoryLimit

        public void setTreeMemoryLimit​(int newval)
        Sets the value of the control XPRSconstants.TREEMEMORYLIMIT. A soft limit, in megabytes, for the amount of memory to use in storing the branch and bound search tree. This doesn't include memory used for presolve, heuristics, solving the LP relaxation, etc. When set to 0 (the default), the optimizer will calculate a limit automatically based on the amount of free physical memory detected in the machine. When the memory used by the branch and bound tree exceeds this limit, the optimizer will try to reduce the memory usage by writing lower-rated sections of the tree to a file called the "tree file". Though the solve can continue if it cannot bring the tree memory usage below the specified limit, performance will be inhibited and a message will be printed to the log.

      • getTreeCompression

        public int getTreeCompression()
        Retrieves the value of the control XPRSconstants.TREECOMPRESSION. When writing nodes to the gloal file, the optimizer can try to use data-compression techniques to reduce the size of the tree file on disk. The TREECOMPRESSION control determines the strength of the data-compression algorithm used; higher values give superior data-compression at the affect of decreasing performance, while lower values compress quicker but not as effectively. Where TREECOMPRESSION is set to 0, no data compression will be used on the tree file.

      • setTreeCompression

        public void setTreeCompression​(int newval)
        Sets the value of the control XPRSconstants.TREECOMPRESSION. When writing nodes to the gloal file, the optimizer can try to use data-compression techniques to reduce the size of the tree file on disk. The TREECOMPRESSION control determines the strength of the data-compression algorithm used; higher values give superior data-compression at the affect of decreasing performance, while lower values compress quicker but not as effectively. Where TREECOMPRESSION is set to 0, no data compression will be used on the tree file.

      • getTreeDiagnostics

        public int getTreeDiagnostics()
        Retrieves the value of the control XPRSconstants.TREEDIAGNOSTICS. A bit vector providing control over how various tree-management-related messages get printed in the tree log file during the branch-and-bound search. (Values are from the enumeration XPRSenumerations.TreeDiagnostics)

      • setTreeDiagnostics

        public void setTreeDiagnostics​(int newval)
        Sets the value of the control XPRSconstants.TREEDIAGNOSTICS. A bit vector providing control over how various tree-management-related messages get printed in the tree log file during the branch-and-bound search. (Values are from the enumeration XPRSenumerations.TreeDiagnostics)

      • getMaxTreeFileSize

        public int getMaxTreeFileSize()
        Retrieves the value of the control XPRSconstants.MAXTREEFILESIZE. The maximum size, in megabytes, to which the tree file may grow, or 0 for no limit. When the tree file reaches this limit, a second tree file will be created. Useful if you are using a filesystem that puts a maximum limit on the size of a file.

      • setMaxTreeFileSize

        public void setMaxTreeFileSize​(int newval)
        Sets the value of the control XPRSconstants.MAXTREEFILESIZE. The maximum size, in megabytes, to which the tree file may grow, or 0 for no limit. When the tree file reaches this limit, a second tree file will be created. Useful if you are using a filesystem that puts a maximum limit on the size of a file.

      • getPreCliqueStrategy

        public int getPreCliqueStrategy()
        Retrieves the value of the control XPRSconstants.PRECLIQUESTRATEGY. Determines how much effort to spend on clique covers in presolve.

      • setPreCliqueStrategy

        public void setPreCliqueStrategy​(int newval)
        Sets the value of the control XPRSconstants.PRECLIQUESTRATEGY. Determines how much effort to spend on clique covers in presolve.

      • getRepairInfeasMaxTime

        @Deprecated
public int getRepairInfeasMaxTime()
        Deprecated.
        since 41.00
        Retrieves the value of the control XPRSconstants.REPAIRINFEASMAXTIME. Overall time limit for the repairinfeas tool

      • setRepairInfeasMaxTime

        @Deprecated
public void setRepairInfeasMaxTime​(int newval)
        Deprecated.
        since 41.00
        Sets the value of the control XPRSconstants.REPAIRINFEASMAXTIME. Overall time limit for the repairinfeas tool

      • resetRepairInfeasMaxTime

        @Deprecated
public void resetRepairInfeasMaxTime()
        Deprecated.
        Resets to its default the value of control XPRSconstants.REPAIRINFEASMAXTIME

      • getIfCheckConvexity

        public int getIfCheckConvexity()
        Retrieves the value of the control XPRSconstants.IFCHECKCONVEXITY. Determines if the convexity of the problem is checked before optimization. Applies to quadratic, mixed integer quadratic and quadratically constrained problems. Checking convexity takes some time, thus for problems that are known to be convex it might be reasonable to switch the checking off. (Values are from the enumeration XPRSenumerations.OnOff)

      • setIfCheckConvexity

        public void setIfCheckConvexity​(int newval)
        Sets the value of the control XPRSconstants.IFCHECKCONVEXITY. Determines if the convexity of the problem is checked before optimization. Applies to quadratic, mixed integer quadratic and quadratically constrained problems. Checking convexity takes some time, thus for problems that are known to be convex it might be reasonable to switch the checking off. (Values are from the enumeration XPRSenumerations.OnOff)

      • setIfCheckConvexity

        public void setIfCheckConvexity​(XPRSenumerations.OnOff newval)
        Sets the value of the control XPRSconstants.IFCHECKCONVEXITY. Determines if the convexity of the problem is checked before optimization. Applies to quadratic, mixed integer quadratic and quadratically constrained problems. Checking convexity takes some time, thus for problems that are known to be convex it might be reasonable to switch the checking off. (Values are from the enumeration XPRSenumerations.OnOff)

      • getMipRampup

        public int getMipRampup()
        Retrieves the value of the control XPRSconstants.MIPRAMPUP. Controls the strategy used by the parallel MIP solver during the ramp-up phase of a branch-and-bound tree search.

      • setMipRampup

        public void setMipRampup​(int newval)
        Sets the value of the control XPRSconstants.MIPRAMPUP. Controls the strategy used by the parallel MIP solver during the ramp-up phase of a branch-and-bound tree search.

      • getMaxLocalBacktrack

        public int getMaxLocalBacktrack()
        Retrieves the value of the control XPRSconstants.MAXLOCALBACKTRACK. Branch-and-Bound: How far back up the current dive path the optimizer is allowed to look for a local backtrack candidate node.

      • setMaxLocalBacktrack

        public void setMaxLocalBacktrack​(int newval)
        Sets the value of the control XPRSconstants.MAXLOCALBACKTRACK. Branch-and-Bound: How far back up the current dive path the optimizer is allowed to look for a local backtrack candidate node.

      • getUserSolHeuristic

        public int getUserSolHeuristic()
        Retrieves the value of the control XPRSconstants.USERSOLHEURISTIC. Determines how much effort to put into running a local search heuristic to find a feasible integer solution from a partial or infeasible user solution.

      • setUserSolHeuristic

        public void setUserSolHeuristic​(int newval)
        Sets the value of the control XPRSconstants.USERSOLHEURISTIC. Determines how much effort to put into running a local search heuristic to find a feasible integer solution from a partial or infeasible user solution.

      • getPreConvertObjToCons

        public int getPreConvertObjToCons()
        Retrieves the value of the control XPRSconstants.PRECONVERTOBJTOCONS. Presolve: convert a linear or quadratic objective function into an objective transfer constraint

      • setPreConvertObjToCons

        public void setPreConvertObjToCons​(int newval)
        Sets the value of the control XPRSconstants.PRECONVERTOBJTOCONS. Presolve: convert a linear or quadratic objective function into an objective transfer constraint

      • getForceParallelDual

        public int getForceParallelDual()
        Retrieves the value of the control XPRSconstants.FORCEPARALLELDUAL. Dual simplex: specifies whether the dual simplex solver should always use the parallel simplex algorithm. By default, when using a single thread, the dual simplex solver will execute a dedicated sequential simplex algorithm.

      • setForceParallelDual

        public void setForceParallelDual​(int newval)
        Sets the value of the control XPRSconstants.FORCEPARALLELDUAL. Dual simplex: specifies whether the dual simplex solver should always use the parallel simplex algorithm. By default, when using a single thread, the dual simplex solver will execute a dedicated sequential simplex algorithm.

      • getBacktrackTie

        public int getBacktrackTie()
        Retrieves the value of the control XPRSconstants.BACKTRACKTIE. Branch and Bound: Specifies how to break ties when selecting the next node to work on when a full backtrack is performed. The options are the same as for the BACKTRACK control. (Values are from the enumeration XPRSenumerations.BacktrackAlg)

      • setBacktrackTie

        public void setBacktrackTie​(int newval)
        Sets the value of the control XPRSconstants.BACKTRACKTIE. Branch and Bound: Specifies how to break ties when selecting the next node to work on when a full backtrack is performed. The options are the same as for the BACKTRACK control. (Values are from the enumeration XPRSenumerations.BacktrackAlg)

      • getBranchDisj

        public int getBranchDisj()
        Retrieves the value of the control XPRSconstants.BRANCHDISJ. Branch and Bound: Determines whether the optimizer should attempt to branch on general split disjunctions during the branch and bound search.

      • setBranchDisj

        public void setBranchDisj​(int newval)
        Sets the value of the control XPRSconstants.BRANCHDISJ. Branch and Bound: Determines whether the optimizer should attempt to branch on general split disjunctions during the branch and bound search.

      • getMipFracReduce

        public int getMipFracReduce()
        Retrieves the value of the control XPRSconstants.MIPFRACREDUCE. Branch and Bound: Specifies how often the optimizer should run a heuristic to reduce the number of fractional integer variables in the node LP solutions.

      • setMipFracReduce

        public void setMipFracReduce​(int newval)
        Sets the value of the control XPRSconstants.MIPFRACREDUCE. Branch and Bound: Specifies how often the optimizer should run a heuristic to reduce the number of fractional integer variables in the node LP solutions.

      • getConcurrentThreads

        public int getConcurrentThreads()
        Retrieves the value of the control XPRSconstants.CONCURRENTTHREADS. Determines the number of threads used by the concurrent solver.

      • setConcurrentThreads

        public void setConcurrentThreads​(int newval)
        Sets the value of the control XPRSconstants.CONCURRENTTHREADS. Determines the number of threads used by the concurrent solver.

      • getMaxScaleFactor

        public int getMaxScaleFactor()
        Retrieves the value of the control XPRSconstants.MAXSCALEFACTOR. This determines the maximum scaling factor that can be applied during scaling. The maximum is provided as an exponent of a power of 2.

      • setMaxScaleFactor

        public void setMaxScaleFactor​(int newval)
        Sets the value of the control XPRSconstants.MAXSCALEFACTOR. This determines the maximum scaling factor that can be applied during scaling. The maximum is provided as an exponent of a power of 2.

      • getHeurThreads

        public int getHeurThreads()
        Retrieves the value of the control XPRSconstants.HEURTHREADS. Branch and Bound: The number of threads to dedicate to running heuristics during the root solve.

      • setHeurThreads

        public void setHeurThreads​(int newval)
        Sets the value of the control XPRSconstants.HEURTHREADS. Branch and Bound: The number of threads to dedicate to running heuristics during the root solve.

      • getThreads

        public int getThreads()
        Retrieves the value of the control XPRSconstants.THREADS. The default number of threads used during optimization.

        This control is used in the following examples:

        • MostViolated

      • setThreads

        public void setThreads​(int newval)
        Sets the value of the control XPRSconstants.THREADS. The default number of threads used during optimization.

        This control is used in the following examples:

        • MostViolated

      • resetThreads

        public void resetThreads()
        Resets to its default the value of control XPRSconstants.THREADS

      • getHeurBeforeLP

        public int getHeurBeforeLP()
        Retrieves the value of the control XPRSconstants.HEURBEFORELP. Branch and Bound: Determines whether primal heuristics should be run before the initial LP relaxation has been solved.

      • setHeurBeforeLP

        public void setHeurBeforeLP​(int newval)
        Sets the value of the control XPRSconstants.HEURBEFORELP. Branch and Bound: Determines whether primal heuristics should be run before the initial LP relaxation has been solved.

      • getPreDomRow

        public int getPreDomRow()
        Retrieves the value of the control XPRSconstants.PREDOMROW. Presolve: Determines the level of dominated row removal reductions to perform when presolving a problem. (Values are from the enumeration XPRSenumerations.PresolveDomRow)

      • setPreDomRow

        public void setPreDomRow​(int newval)
        Sets the value of the control XPRSconstants.PREDOMROW. Presolve: Determines the level of dominated row removal reductions to perform when presolving a problem. (Values are from the enumeration XPRSenumerations.PresolveDomRow)

      • getBranchStructural

        public int getBranchStructural()
        Retrieves the value of the control XPRSconstants.BRANCHSTRUCTURAL. Branch and Bound: Determines whether the optimizer should search for special structure in the problem to branch on during the branch and bound search. (Values are from the enumeration XPRSenumerations.AlwaysNeverAutomatic)

      • setBranchStructural

        public void setBranchStructural​(int newval)
        Sets the value of the control XPRSconstants.BRANCHSTRUCTURAL. Branch and Bound: Determines whether the optimizer should search for special structure in the problem to branch on during the branch and bound search. (Values are from the enumeration XPRSenumerations.AlwaysNeverAutomatic)

      • setQuadraticUnshift

        public void setQuadraticUnshift​(int newval)
        Sets the value of the control XPRSconstants.QUADRATICUNSHIFT. Determines whether an extra solution purification step is called after a solution found by the quadratic simplex (either primal or dual). (Values are from the enumeration XPRSenumerations.AlwaysNeverAutomatic)

      • getQSimplexOps

        public int getQSimplexOps()
        Retrieves the value of the control XPRSconstants.QSIMPLEXOPS. Controls the behavior of the quadratic simplex solvers.

      • setQSimplexOps

        public void setQSimplexOps​(int newval)
        Sets the value of the control XPRSconstants.QSIMPLEXOPS. Controls the behavior of the quadratic simplex solvers.

      • getMipRestart

        public int getMipRestart()
        Retrieves the value of the control XPRSconstants.MIPRESTART. Branch and Bound: controls strategy for in-tree restarts. (Values are from the enumeration XPRSenumerations.MipRestart)

        This control is used in the following examples:

        • MostViolated

      • setMipRestart

        public void setMipRestart​(int newval)
        Sets the value of the control XPRSconstants.MIPRESTART. Branch and Bound: controls strategy for in-tree restarts. (Values are from the enumeration XPRSenumerations.MipRestart)

        This control is used in the following examples:

        • MostViolated

      • getConflictCuts

        public int getConflictCuts()
        Retrieves the value of the control XPRSconstants.CONFLICTCUTS. Branch and Bound: Specifies how cautious or aggressive the optimizer should be when searching for and applying conflict cuts. Conflict cuts are in-tree cuts derived from nodes found to be infeasible or cut off, which can be used to cut off other branches of the search tree.

      • setConflictCuts

        public void setConflictCuts​(int newval)
        Sets the value of the control XPRSconstants.CONFLICTCUTS. Branch and Bound: Specifies how cautious or aggressive the optimizer should be when searching for and applying conflict cuts. Conflict cuts are in-tree cuts derived from nodes found to be infeasible or cut off, which can be used to cut off other branches of the search tree.

      • getPreProtectDual

        public int getPreProtectDual()
        Retrieves the value of the control XPRSconstants.PREPROTECTDUAL. Presolve: specifies whether the presolver should protect a given dual solution by maintaining the same level of dual feasibility. Enabling this control often results in a worse presolved model. This control only expected to be optionally enabled before calling crossoverLpSol.

      • setPreProtectDual

        public void setPreProtectDual​(int newval)
        Sets the value of the control XPRSconstants.PREPROTECTDUAL. Presolve: specifies whether the presolver should protect a given dual solution by maintaining the same level of dual feasibility. Enabling this control often results in a worse presolved model. This control only expected to be optionally enabled before calling crossoverLpSol.

      • getCoresPerCPU

        public int getCoresPerCPU()
        Retrieves the value of the control XPRSconstants.CORESPERCPU. Used to override the detected value of the number of cores on a CPU. The cache size (either detected or specified via the CACHESIZE control) used in Barrier methods will be divided by this amount, and this scaled-down value will be the amount of cache allocated to each Barrier thread

      • setCoresPerCPU

        public void setCoresPerCPU​(int newval)
        Sets the value of the control XPRSconstants.CORESPERCPU. Used to override the detected value of the number of cores on a CPU. The cache size (either detected or specified via the CACHESIZE control) used in Barrier methods will be divided by this amount, and this scaled-down value will be the amount of cache allocated to each Barrier thread

      • getResourceStrategy

        public int getResourceStrategy()
        Retrieves the value of the control XPRSconstants.RESOURCESTRATEGY. Controls whether the optimizer is allowed to make nondeterministic decisions if memory is running low in an effort to preserve memory and finish the solve. Available memory (or container limits) are automatically detected but can also be changed by MAXMEMORYSOFT and MAXMEMORYHARD

      • setResourceStrategy

        public void setResourceStrategy​(int newval)
        Sets the value of the control XPRSconstants.RESOURCESTRATEGY. Controls whether the optimizer is allowed to make nondeterministic decisions if memory is running low in an effort to preserve memory and finish the solve. Available memory (or container limits) are automatically detected but can also be changed by MAXMEMORYSOFT and MAXMEMORYHARD

      • getClamping

        public int getClamping()
        Retrieves the value of the control XPRSconstants.CLAMPING. This control allows for the adjustment of returned solution values such that they are always within bounds.

      • setClamping

        public void setClamping​(int newval)
        Sets the value of the control XPRSconstants.CLAMPING. This control allows for the adjustment of returned solution values such that they are always within bounds.

      • resetClamping

        public void resetClamping()
        Resets to its default the value of control XPRSconstants.CLAMPING

      • getSleepOnThreadWait

        @Deprecated
public int getSleepOnThreadWait()
        Deprecated.
        since 41.00
        Retrieves the value of the control XPRSconstants.SLEEPONTHREADWAIT. In previous versions this was used to determine if the threads should be put into a wait state when waiting for work.

      • setSleepOnThreadWait

        @Deprecated
public void setSleepOnThreadWait​(int newval)
        Deprecated.
        since 41.00
        Sets the value of the control XPRSconstants.SLEEPONTHREADWAIT. In previous versions this was used to determine if the threads should be put into a wait state when waiting for work.

      • resetSleepOnThreadWait

        @Deprecated
public void resetSleepOnThreadWait()
        Deprecated.
        Resets to its default the value of control XPRSconstants.SLEEPONTHREADWAIT

      • getPreDupRow

        public int getPreDupRow()
        Retrieves the value of the control XPRSconstants.PREDUPROW. Presolve: Determines the type of duplicate rows to look for and eliminate when presolving a problem.

      • setPreDupRow

        public void setPreDupRow​(int newval)
        Sets the value of the control XPRSconstants.PREDUPROW. Presolve: Determines the type of duplicate rows to look for and eliminate when presolving a problem.

      • getCPUPlatform

        public int getCPUPlatform()
        Retrieves the value of the control XPRSconstants.CPUPLATFORM. Newton Barrier: Selects the AMD, Intel x86 or ARM vectorization instruction set that Barrier should run optimized code for. On AMD / Intel x86 platforms the SSE2, AVX and AVX2 instruction sets are supported while on ARM platforms the NEON architecture extension can be activated.

      • setCPUPlatform

        public void setCPUPlatform​(int newval)
        Sets the value of the control XPRSconstants.CPUPLATFORM. Newton Barrier: Selects the AMD, Intel x86 or ARM vectorization instruction set that Barrier should run optimized code for. On AMD / Intel x86 platforms the SSE2, AVX and AVX2 instruction sets are supported while on ARM platforms the NEON architecture extension can be activated.

      • getBarAlg

        public int getBarAlg()
        Retrieves the value of the control XPRSconstants.BARALG. This control determines which barrier algorithm is used to solve the problem.

      • setBarAlg

        public void setBarAlg​(int newval)
        Sets the value of the control XPRSconstants.BARALG. This control determines which barrier algorithm is used to solve the problem.

      • resetBarAlg

        public void resetBarAlg()
        Resets to its default the value of control XPRSconstants.BARALG

      • getSifting

        public int getSifting()
        Retrieves the value of the control XPRSconstants.SIFTING. Determines whether to enable sifting algorithm with the dual simplex method.

      • setSifting

        public void setSifting​(int newval)
        Sets the value of the control XPRSconstants.SIFTING. Determines whether to enable sifting algorithm with the dual simplex method.

      • resetSifting

        public void resetSifting()
        Resets to its default the value of control XPRSconstants.SIFTING

      • getLPLogStyle

        public int getLPLogStyle()
        Retrieves the value of the control XPRSconstants.LPLOGSTYLE. Simplex: The style of the simplex log.

      • setLPLogStyle

        public void setLPLogStyle​(int newval)
        Sets the value of the control XPRSconstants.LPLOGSTYLE. Simplex: The style of the simplex log.

      • getRandomSeed

        public int getRandomSeed()
        Retrieves the value of the control XPRSconstants.RANDOMSEED. Sets the initial seed to use for the pseudo-random number generator in the Optimizer. The sequence of random numbers is always reset using the seed when starting a new optimization run.

      • setRandomSeed

        public void setRandomSeed​(int newval)
        Sets the value of the control XPRSconstants.RANDOMSEED. Sets the initial seed to use for the pseudo-random number generator in the Optimizer. The sequence of random numbers is always reset using the seed when starting a new optimization run.

      • getTreeQCCuts

        public int getTreeQCCuts()
        Retrieves the value of the control XPRSconstants.TREEQCCUTS. Branch and Bound: Limit on the number of rounds of outer approximation cuts generated for nodes other than the root node, when solving a mixed integer quadratic constrained or mixed integer second order conic problem with outer approximation.

      • setTreeQCCuts

        public void setTreeQCCuts​(int newval)
        Sets the value of the control XPRSconstants.TREEQCCUTS. Branch and Bound: Limit on the number of rounds of outer approximation cuts generated for nodes other than the root node, when solving a mixed integer quadratic constrained or mixed integer second order conic problem with outer approximation.

      • getPreLinDep

        public int getPreLinDep()
        Retrieves the value of the control XPRSconstants.PRELINDEP. Presolve: Determines whether to check for and remove linearly dependent equality constraints when presolving a problem.

      • setPreLinDep

        public void setPreLinDep​(int newval)
        Sets the value of the control XPRSconstants.PRELINDEP. Presolve: Determines whether to check for and remove linearly dependent equality constraints when presolving a problem.

      • getDualThreads

        public int getDualThreads()
        Retrieves the value of the control XPRSconstants.DUALTHREADS. Determines the maximum number of threads that dual simplex is allowed to use. If DUALTHREADS is set to the default value ( -1), the THREADS control will determine the number of threads used.

      • setDualThreads

        public void setDualThreads​(int newval)
        Sets the value of the control XPRSconstants.DUALTHREADS. Determines the maximum number of threads that dual simplex is allowed to use. If DUALTHREADS is set to the default value ( -1), the THREADS control will determine the number of threads used.

      • getPreObjCutDetect

        public int getPreObjCutDetect()
        Retrieves the value of the control XPRSconstants.PREOBJCUTDETECT. Presolve: Determines whether to check for constraints that are parallel or near parallel to a linear objective function, and which can safely be removed. This reduction applies to MIPs only.

      • setPreObjCutDetect

        public void setPreObjCutDetect​(int newval)
        Sets the value of the control XPRSconstants.PREOBJCUTDETECT. Presolve: Determines whether to check for constraints that are parallel or near parallel to a linear objective function, and which can safely be removed. This reduction applies to MIPs only.

      • getPreBndRedQuad

        public int getPreBndRedQuad()
        Retrieves the value of the control XPRSconstants.PREBNDREDQUAD. Determines if convex quadratic constraints should be used for inferring bound reductions on variables when solving a MIP.

      • setPreBndRedQuad

        public void setPreBndRedQuad​(int newval)
        Sets the value of the control XPRSconstants.PREBNDREDQUAD. Determines if convex quadratic constraints should be used for inferring bound reductions on variables when solving a MIP.

      • getPreBndRedCone

        public int getPreBndRedCone()
        Retrieves the value of the control XPRSconstants.PREBNDREDCONE. Determines if second order cone constraints should be used for inferring bound reductions on variables when solving a MIP.

      • setPreBndRedCone

        public void setPreBndRedCone​(int newval)
        Sets the value of the control XPRSconstants.PREBNDREDCONE. Determines if second order cone constraints should be used for inferring bound reductions on variables when solving a MIP.

      • getPreComponents

        public int getPreComponents()
        Retrieves the value of the control XPRSconstants.PRECOMPONENTS. Presolve: determines whether small independent components should be detected and solved as individual subproblems during root node processing.

      • setPreComponents

        public void setPreComponents​(int newval)
        Sets the value of the control XPRSconstants.PRECOMPONENTS. Presolve: determines whether small independent components should be detected and solved as individual subproblems during root node processing.

      • getMaxMipTasks

        public int getMaxMipTasks()
        Retrieves the value of the control XPRSconstants.MAXMIPTASKS. Branch-and-Bound: The maximum number of tasks to run in parallel during a MIP solve.

      • setMaxMipTasks

        public void setMaxMipTasks​(int newval)
        Sets the value of the control XPRSconstants.MAXMIPTASKS. Branch-and-Bound: The maximum number of tasks to run in parallel during a MIP solve.

      • getMipTerminationMethod

        public int getMipTerminationMethod()
        Retrieves the value of the control XPRSconstants.MIPTERMINATIONMETHOD. Branch and Bound: How a MIP solve should be stopped on early termination when there are still active tasks in the system. This can happen when, for example, a time or node limit is reached.

      • setMipTerminationMethod

        public void setMipTerminationMethod​(int newval)
        Sets the value of the control XPRSconstants.MIPTERMINATIONMETHOD. Branch and Bound: How a MIP solve should be stopped on early termination when there are still active tasks in the system. This can happen when, for example, a time or node limit is reached.

      • getPreConeDecomp

        public int getPreConeDecomp()
        Retrieves the value of the control XPRSconstants.PRECONEDECOMP. Presolve: decompose regular and rotated cones with more than two elements and apply Outer Approximation on the resulting components.

      • setPreConeDecomp

        public void setPreConeDecomp​(int newval)
        Sets the value of the control XPRSconstants.PRECONEDECOMP. Presolve: decompose regular and rotated cones with more than two elements and apply Outer Approximation on the resulting components.

      • getHeurForceSpecialObj

        public int getHeurForceSpecialObj()
        Retrieves the value of the control XPRSconstants.HEURFORCESPECIALOBJ. Branch and Bound: This specifies whether local search heuristics without objective or with an auxiliary objective should always be used, despite the automatic selection of the Optimiezr. Deactivated by default.

      • setHeurForceSpecialObj

        public void setHeurForceSpecialObj​(int newval)
        Sets the value of the control XPRSconstants.HEURFORCESPECIALOBJ. Branch and Bound: This specifies whether local search heuristics without objective or with an auxiliary objective should always be used, despite the automatic selection of the Optimiezr. Deactivated by default.

      • getHeurSearchRootCutFreq

        public int getHeurSearchRootCutFreq()
        Retrieves the value of the control XPRSconstants.HEURSEARCHROOTCUTFREQ. How frequently to run the local search heuristic during root cutting. This is given as how many cut rounds to perform between runs of the heuristic. Set to zero to avoid applying the heuristic during root cutting. Branch and Bound: This specifies how often the local search heuristic should be run in the tree.

      • setHeurSearchRootCutFreq

        public void setHeurSearchRootCutFreq​(int newval)
        Sets the value of the control XPRSconstants.HEURSEARCHROOTCUTFREQ. How frequently to run the local search heuristic during root cutting. This is given as how many cut rounds to perform between runs of the heuristic. Set to zero to avoid applying the heuristic during root cutting. Branch and Bound: This specifies how often the local search heuristic should be run in the tree.

      • getPreElimQuad

        public int getPreElimQuad()
        Retrieves the value of the control XPRSconstants.PREELIMQUAD. Presolve: Allows for elimination of quadratic variables via doubleton rows.

      • setPreElimQuad

        public void setPreElimQuad​(int newval)
        Sets the value of the control XPRSconstants.PREELIMQUAD. Presolve: Allows for elimination of quadratic variables via doubleton rows.

      • getPreImplications

        public int getPreImplications()
        Retrieves the value of the control XPRSconstants.PREIMPLICATIONS. Presolve: Determines whether to use implication structures to remove redundant rows. If implication sequences are detected, they might also be used in probing.

      • setPreImplications

        public void setPreImplications​(int newval)
        Sets the value of the control XPRSconstants.PREIMPLICATIONS. Presolve: Determines whether to use implication structures to remove redundant rows. If implication sequences are detected, they might also be used in probing.

      • getTunerThreads

        public int getTunerThreads()
        Retrieves the value of the control XPRSconstants.TUNERTHREADS. Tuner: the number of threads used by the tuner.

      • setTunerThreads

        public void setTunerThreads​(int newval)
        Sets the value of the control XPRSconstants.TUNERTHREADS. Tuner: the number of threads used by the tuner.

      • getTunerPermute

        public int getTunerPermute()
        Retrieves the value of the control XPRSconstants.TUNERPERMUTE. Tuner: Defines the number of permutations to solve for each control setting.

      • setTunerPermute

        public void setTunerPermute​(int newval)
        Sets the value of the control XPRSconstants.TUNERPERMUTE. Tuner: Defines the number of permutations to solve for each control setting.

      • getTunerVerbose

        public int getTunerVerbose()
        Retrieves the value of the control XPRSconstants.TUNERVERBOSE. Tuner: whether the tuner should prints detailed information for each run.

      • setTunerVerbose

        public void setTunerVerbose​(int newval)
        Sets the value of the control XPRSconstants.TUNERVERBOSE. Tuner: whether the tuner should prints detailed information for each run.

      • getTunerOutput

        public int getTunerOutput()
        Retrieves the value of the control XPRSconstants.TUNEROUTPUT. Tuner: Whether to output tuner results and logs to the file system.

      • setTunerOutput

        public void setTunerOutput​(int newval)
        Sets the value of the control XPRSconstants.TUNEROUTPUT. Tuner: Whether to output tuner results and logs to the file system.

      • getPreAnalyticcenter

        public int getPreAnalyticcenter()
        Retrieves the value of the control XPRSconstants.PREANALYTICCENTER. Determines if analytic centers should be computed and used for variable fixing and the generation of alternative reduced costs (-1: Auto 0: Off, 1: Fixing, 2: Redcost, 3: Both)

      • setPreAnalyticcenter

        public void setPreAnalyticcenter​(int newval)
        Sets the value of the control XPRSconstants.PREANALYTICCENTER. Determines if analytic centers should be computed and used for variable fixing and the generation of alternative reduced costs (-1: Auto 0: Off, 1: Fixing, 2: Redcost, 3: Both)

      • getNetCuts

        @Deprecated
public int getNetCuts()
        Deprecated.
        since 43.00
        Retrieves the value of the control XPRSconstants.NETCUTS.

      • setNetCuts

        @Deprecated
public void setNetCuts​(int newval)
        Deprecated.
        since 43.00
        Sets the value of the control XPRSconstants.NETCUTS.

      • resetNetCuts

        @Deprecated
public void resetNetCuts()
        Deprecated.
        Resets to its default the value of control XPRSconstants.NETCUTS

      • resetLPFlags

        public void resetLPFlags()
        Resets to its default the value of control XPRSconstants.LPFLAGS

      • getMIPKappaFreq

        public int getMIPKappaFreq()
        Retrieves the value of the control XPRSconstants.MIPKAPPAFREQ. Branch and Bound: Specifies how frequently the basis condition number (also known as kappa) should be calculated during the branch-and-bound search.

      • setMIPKappaFreq

        public void setMIPKappaFreq​(int newval)
        Sets the value of the control XPRSconstants.MIPKAPPAFREQ. Branch and Bound: Specifies how frequently the basis condition number (also known as kappa) should be calculated during the branch-and-bound search.

      • getObjScaleFactor

        public int getObjScaleFactor()
        Retrieves the value of the control XPRSconstants.OBJSCALEFACTOR. Custom objective scaling factor, expressed as a power of 2. When set, it overwrites the automatic objective scaling factor. A value of 0 means no objective scaling. This control is applied for the full solve, and is independent of any extra scaling that may occur specifically for the barrier or simplex solvers. As it is a power of 2, to scale by 16, set the value of the control to 4.

      • setObjScaleFactor

        public void setObjScaleFactor​(int newval)
        Sets the value of the control XPRSconstants.OBJSCALEFACTOR. Custom objective scaling factor, expressed as a power of 2. When set, it overwrites the automatic objective scaling factor. A value of 0 means no objective scaling. This control is applied for the full solve, and is independent of any extra scaling that may occur specifically for the barrier or simplex solvers. As it is a power of 2, to scale by 16, set the value of the control to 4.

      • getTreeFileLogInterval

        public int getTreeFileLogInterval()
        Retrieves the value of the control XPRSconstants.TREEFILELOGINTERVAL. This control sets the interval between progress messages output while writing tree data to the tree file, in seconds. The solve is slowed greatly while data is being written to the tree file and this output allows the user to see how much progress is being made.

      • setTreeFileLogInterval

        public void setTreeFileLogInterval​(int newval)
        Sets the value of the control XPRSconstants.TREEFILELOGINTERVAL. This control sets the interval between progress messages output while writing tree data to the tree file, in seconds. The solve is slowed greatly while data is being written to the tree file and this output allows the user to see how much progress is being made.

      • getIgnoreContainerCpuLimit

        public int getIgnoreContainerCpuLimit()

      • getIgnoreContainerMemoryLimit

        public int getIgnoreContainerMemoryLimit()

      • getMIPDualReductions

        public int getMIPDualReductions()
        Retrieves the value of the control XPRSconstants.MIPDUALREDUCTIONS. Branch and Bound: Limits operations that can reduce the MIP solution space.

        This control is used in the following examples:

        • MipSolEnum
        • MostViolated
        • TSP

      • setMIPDualReductions

        public void setMIPDualReductions​(int newval)
        Sets the value of the control XPRSconstants.MIPDUALREDUCTIONS. Branch and Bound: Limits operations that can reduce the MIP solution space.

        This control is used in the following examples:

        • MipSolEnum
        • MostViolated
        • TSP

      • getGenconsDualReductions

        public int getGenconsDualReductions()
        Retrieves the value of the control XPRSconstants.GENCONSDUALREDUCTIONS. This parameter specifies whether dual reductions should be applied to reduce the number of columns and rows added when transforming general constraints to MIP structs.

      • setGenconsDualReductions

        public void setGenconsDualReductions​(int newval)
        Sets the value of the control XPRSconstants.GENCONSDUALREDUCTIONS. This parameter specifies whether dual reductions should be applied to reduce the number of columns and rows added when transforming general constraints to MIP structs.

      • getPwlDualReductions

        public int getPwlDualReductions()
        Retrieves the value of the control XPRSconstants.PWLDUALREDUCTIONS. This parameter specifies whether dual reductions should be applied to reduce the number of columns, rows and SOS-constraints added when transforming piecewise linear objectives and constraints to MIP structs.

      • setPwlDualReductions

        public void setPwlDualReductions​(int newval)
        Sets the value of the control XPRSconstants.PWLDUALREDUCTIONS. This parameter specifies whether dual reductions should be applied to reduce the number of columns, rows and SOS-constraints added when transforming piecewise linear objectives and constraints to MIP structs.

      • getBarFailIterLimit

        public int getBarFailIterLimit()
        Retrieves the value of the control XPRSconstants.BARFAILITERLIMIT. Newton barrier: The maximum number of consecutive iterations that fail to improve the solution in the barrier algorithm.

      • setBarFailIterLimit

        public void setBarFailIterLimit​(int newval)
        Sets the value of the control XPRSconstants.BARFAILITERLIMIT. Newton barrier: The maximum number of consecutive iterations that fail to improve the solution in the barrier algorithm.

      • getAutoScaling

        public int getAutoScaling()
        Retrieves the value of the control XPRSconstants.AUTOSCALING. Whether the Optimizer should automatically select between different scaling algorithms. If the SCALING control is set, no automatic scaling will be applied.

      • setAutoScaling

        public void setAutoScaling​(int newval)
        Sets the value of the control XPRSconstants.AUTOSCALING. Whether the Optimizer should automatically select between different scaling algorithms. If the SCALING control is set, no automatic scaling will be applied.

      • getGenconsAbsTransformation

        public int getGenconsAbsTransformation()
        Retrieves the value of the control XPRSconstants.GENCONSABSTRANSFORMATION. This control specifies the reformulation method for absolute value general constraints at the beginning of the search.

      • setGenconsAbsTransformation

        public void setGenconsAbsTransformation​(int newval)
        Sets the value of the control XPRSconstants.GENCONSABSTRANSFORMATION. This control specifies the reformulation method for absolute value general constraints at the beginning of the search.

      • getComputeJobPriority

        public int getComputeJobPriority()
        Retrieves the value of the control XPRSconstants.COMPUTEJOBPRIORITY. Selects the priority that will be used for remote optimization jobs.

      • setComputeJobPriority

        public void setComputeJobPriority​(int newval)
        Sets the value of the control XPRSconstants.COMPUTEJOBPRIORITY. Selects the priority that will be used for remote optimization jobs.

      • getPreFolding

        public int getPreFolding()
        Retrieves the value of the control XPRSconstants.PREFOLDING. Presolve: Determines if a folding procedure should be used to aggregate continuous columns in an equitable partition.

      • setPreFolding

        public void setPreFolding​(int newval)
        Sets the value of the control XPRSconstants.PREFOLDING. Presolve: Determines if a folding procedure should be used to aggregate continuous columns in an equitable partition.

      • getCompute

        public int getCompute()
        Retrieves the value of the control XPRSconstants.COMPUTE. Controls whether the next solve is performed directly or on an Insight Compute Interface.

      • setCompute

        public void setCompute​(int newval)
        Sets the value of the control XPRSconstants.COMPUTE. Controls whether the next solve is performed directly or on an Insight Compute Interface.

      • resetCompute

        public void resetCompute()
        Resets to its default the value of control XPRSconstants.COMPUTE

      • getNetStallLimit

        public int getNetStallLimit()
        Retrieves the value of the control XPRSconstants.NETSTALLLIMIT. Limit the number of degenerate pivots of the network simplex algorithm, before switching to either primal or dual simplex, depending on ALGAFTERNETWORK.

      • setNetStallLimit

        public void setNetStallLimit​(int newval)
        Sets the value of the control XPRSconstants.NETSTALLLIMIT. Limit the number of degenerate pivots of the network simplex algorithm, before switching to either primal or dual simplex, depending on ALGAFTERNETWORK.

      • getSerializePreIntSol

        public int getSerializePreIntSol()
        Retrieves the value of the control XPRSconstants.SERIALIZEPREINTSOL. Setting SERIALIZEPREINTSOL to 1 will ensure that the preintsol callback is always fired in a deterministic order during a parallel MIP solve. This applies only when the control DETERMINISTIC is set to 1.

      • setSerializePreIntSol

        public void setSerializePreIntSol​(int newval)
        Sets the value of the control XPRSconstants.SERIALIZEPREINTSOL. Setting SERIALIZEPREINTSOL to 1 will ensure that the preintsol callback is always fired in a deterministic order during a parallel MIP solve. This applies only when the control DETERMINISTIC is set to 1.

      • getNumericalEmphasis

        public int getNumericalEmphasis()
        Retrieves the value of the control XPRSconstants.NUMERICALEMPHASIS. How much emphasis to place on numerical stability instead of solve speed.

      • setNumericalEmphasis

        public void setNumericalEmphasis​(int newval)
        Sets the value of the control XPRSconstants.NUMERICALEMPHASIS. How much emphasis to place on numerical stability instead of solve speed.

      • getPwlNonConvexTransformation

        public int getPwlNonConvexTransformation()
        Retrieves the value of the control XPRSconstants.PWLNONCONVEXTRANSFORMATION. This control specifies the reformulation method for piecewise linear constraints at the beginning of the search. Note that the chosen formulation will only be used if MIP entities are necessary but not if presolve detected that a convex reformulation is possible. Furthermore, the binary formulation will only be applied to piecewise linear constraints with bounded input variable, otherwise the SOS2-formulation will be used.

      • setPwlNonConvexTransformation

        public void setPwlNonConvexTransformation​(int newval)
        Sets the value of the control XPRSconstants.PWLNONCONVEXTRANSFORMATION. This control specifies the reformulation method for piecewise linear constraints at the beginning of the search. Note that the chosen formulation will only be used if MIP entities are necessary but not if presolve detected that a convex reformulation is possible. Furthermore, the binary formulation will only be applied to piecewise linear constraints with bounded input variable, otherwise the SOS2-formulation will be used.

      • getMipComponents

        public int getMipComponents()
        Retrieves the value of the control XPRSconstants.MIPCOMPONENTS. Determines whether disconnected components in a MIP should be solved as separate MIPs. There can be significant performence benefits from solving disconnected components individual instead of being part of the main branch-and-bound search.

      • setMipComponents

        public void setMipComponents​(int newval)
        Sets the value of the control XPRSconstants.MIPCOMPONENTS. Determines whether disconnected components in a MIP should be solved as separate MIPs. There can be significant performence benefits from solving disconnected components individual instead of being part of the main branch-and-bound search.

      • getMipConcurrentNodes

        public int getMipConcurrentNodes()
        Retrieves the value of the control XPRSconstants.MIPCONCURRENTNODES. Sets the node limit for when a winning solve is selected when concurrent MIP solves are enabled. When multiple MIP solves are started, they each run up to the MIPCONCURRENTNODES node limit and only one winning solve is selected for contuinuing the search with.

      • setMipConcurrentNodes

        public void setMipConcurrentNodes​(int newval)
        Sets the value of the control XPRSconstants.MIPCONCURRENTNODES. Sets the node limit for when a winning solve is selected when concurrent MIP solves are enabled. When multiple MIP solves are started, they each run up to the MIPCONCURRENTNODES node limit and only one winning solve is selected for contuinuing the search with.

      • getMipConcurrentSolves

        public int getMipConcurrentSolves()
        Retrieves the value of the control XPRSconstants.MIPCONCURRENTSOLVES. Selects the number of concurrent solves to start for a MIP. Each solve will use a unique random seed for its random number generator, but will otherwise apply the same user controls. The first concurrent solve to complete will have solved the MIP and all the concurrent solves will be terminated at this point. Using concurrent solves can be advantageous when a MIP displays a high level of performance variability.

      • setMipConcurrentSolves

        public void setMipConcurrentSolves​(int newval)
        Sets the value of the control XPRSconstants.MIPCONCURRENTSOLVES. Selects the number of concurrent solves to start for a MIP. Each solve will use a unique random seed for its random number generator, but will otherwise apply the same user controls. The first concurrent solve to complete will have solved the MIP and all the concurrent solves will be terminated at this point. Using concurrent solves can be advantageous when a MIP displays a high level of performance variability.

      • getOutputControls

        public int getOutputControls()
        Retrieves the value of the control XPRSconstants.OUTPUTCONTROLS. This control toggles the printing of all control settings at the beginning of the search. This includes the printing of controls that have been explicitly assigned to their default value. All unset controls are omitted as they keep their default value.

      • setOutputControls

        public void setOutputControls​(int newval)
        Sets the value of the control XPRSconstants.OUTPUTCONTROLS. This control toggles the printing of all control settings at the beginning of the search. This includes the printing of controls that have been explicitly assigned to their default value. All unset controls are omitted as they keep their default value.

      • getSiftSwitch

        public int getSiftSwitch()
        Retrieves the value of the control XPRSconstants.SIFTSWITCH. Determines which algorithm to use for solving the subproblems during sifting.

      • setSiftSwitch

        public void setSiftSwitch​(int newval)
        Sets the value of the control XPRSconstants.SIFTSWITCH. Determines which algorithm to use for solving the subproblems during sifting.

      • getHeurEmphasis

        public int getHeurEmphasis()
        Retrieves the value of the control XPRSconstants.HEUREMPHASIS. Branch and Bound: This control specifies an emphasis for the search w.r.t. primal heuristics and other procedures that affect the speed of convergence of the primal-dual gap. For problems where the goal is to achieve a small gap but not neccessarily solving them to optimality, it is recommended to set HEUREMPHASIS to 1. This setting triggers many additional heuristic calls, aiming for reducing the gap at the beginning of the search, typically at the expense of an increased time for proving optimality.

        This control is used in the following examples:

        • AddMipSol
        • Knapsack
        • MostViolated

      • setHeurEmphasis

        public void setHeurEmphasis​(int newval)
        Sets the value of the control XPRSconstants.HEUREMPHASIS. Branch and Bound: This control specifies an emphasis for the search w.r.t. primal heuristics and other procedures that affect the speed of convergence of the primal-dual gap. For problems where the goal is to achieve a small gap but not neccessarily solving them to optimality, it is recommended to set HEUREMPHASIS to 1. This setting triggers many additional heuristic calls, aiming for reducing the gap at the beginning of the search, typically at the expense of an increased time for proving optimality.

        This control is used in the following examples:

        • AddMipSol
        • Knapsack
        • MostViolated

      • getBarRefIter

        public int getBarRefIter()
        Retrieves the value of the control XPRSconstants.BARREFITER. Newton barrier: After terminating the barrier algorithm, further refinement steps can be performed. Such refinement steps are especially helpful if the solution is near to the optimum and can improve primal feasibility and decrease the complementarity gap. It is also often advantageous for the crossover algorithm. BARREFITER specifies the maximum number of such refinement iterations.

      • setBarRefIter

        public void setBarRefIter​(int newval)
        Sets the value of the control XPRSconstants.BARREFITER. Newton barrier: After terminating the barrier algorithm, further refinement steps can be performed. Such refinement steps are especially helpful if the solution is near to the optimum and can improve primal feasibility and decrease the complementarity gap. It is also often advantageous for the crossover algorithm. BARREFITER specifies the maximum number of such refinement iterations.

      • getSiftPresolveOps

        public int getSiftPresolveOps()
        Retrieves the value of the control XPRSconstants.SIFTPRESOLVEOPS. Determines the presolve operations for solving the subproblems during the sifting algorithm.

      • setSiftPresolveOps

        public void setSiftPresolveOps​(int newval)
        Sets the value of the control XPRSconstants.SIFTPRESOLVEOPS. Determines the presolve operations for solving the subproblems during the sifting algorithm.

      • getCheckInputData

        public int getCheckInputData()
        Retrieves the value of the control XPRSconstants.CHECKINPUTDATA. Check input arrays for bad data.

      • setCheckInputData

        public void setCheckInputData​(int newval)
        Sets the value of the control XPRSconstants.CHECKINPUTDATA. Check input arrays for bad data.

      • getEscapeNames

        public int getEscapeNames()
        Retrieves the value of the control XPRSconstants.ESCAPENAMES. If characters illegal to an mps or lp file should be escaped to guarantee readability, and whether escaped characters should be transformed back when reading such a file.

      • setEscapeNames

        public void setEscapeNames​(int newval)
        Sets the value of the control XPRSconstants.ESCAPENAMES. If characters illegal to an mps or lp file should be escaped to guarantee readability, and whether escaped characters should be transformed back when reading such a file.

      • getIOTimeout

        public int getIOTimeout()
        Retrieves the value of the control XPRSconstants.IOTIMEOUT. The maximum number of seconds to wait for an I/O operation before it is cancelled.

      • setIOTimeout

        public void setIOTimeout​(int newval)
        Sets the value of the control XPRSconstants.IOTIMEOUT. The maximum number of seconds to wait for an I/O operation before it is cancelled.

      • getAutoCutting

        public int getAutoCutting()
        Retrieves the value of the control XPRSconstants.AUTOCUTTING. Should the Optimizer automatically decide whether to generate cutting planes at local nodes in the tree or not? If the CUTFREQ control is set, no automatic selection will be made and local cutting will be enabled.

      • setAutoCutting

        public void setAutoCutting​(int newval)
        Sets the value of the control XPRSconstants.AUTOCUTTING. Should the Optimizer automatically decide whether to generate cutting planes at local nodes in the tree or not? If the CUTFREQ control is set, no automatic selection will be made and local cutting will be enabled.

      • getGlobalNumInitNlpCuts

        public int getGlobalNumInitNlpCuts()
        Retrieves the value of the control XPRSconstants.GLOBALNUMINITNLPCUTS. Specifies the maximum number of tangent cuts when setting up the initial relaxation during a global solve. By default, the algorithm chooses the number of cuts automatically. Adding more cuts tightens the problem, resulting in a smaller branch-and-bound tree, at the cost of slowing down each LP solve.

      • setGlobalNumInitNlpCuts

        public void setGlobalNumInitNlpCuts​(int newval)
        Sets the value of the control XPRSconstants.GLOBALNUMINITNLPCUTS. Specifies the maximum number of tangent cuts when setting up the initial relaxation during a global solve. By default, the algorithm chooses the number of cuts automatically. Adding more cuts tightens the problem, resulting in a smaller branch-and-bound tree, at the cost of slowing down each LP solve.

      • getCallbackCheckTimeDelay

        public int getCallbackCheckTimeDelay()
        Retrieves the value of the control XPRSconstants.CALLBACKCHECKTIMEDELAY. Minimum delay in milliseconds between two consecutive executions of the CHECKTIME callback in the same solution process

      • setCallbackCheckTimeDelay

        public void setCallbackCheckTimeDelay​(int newval)
        Sets the value of the control XPRSconstants.CALLBACKCHECKTIMEDELAY. Minimum delay in milliseconds between two consecutive executions of the CHECKTIME callback in the same solution process

      • getMultiObjLog

        public int getMultiObjLog()
        Retrieves the value of the control XPRSconstants.MULTIOBJLOG. Log level for multi-objective optimization.

      • setMultiObjLog

        public void setMultiObjLog​(int newval)
        Sets the value of the control XPRSconstants.MULTIOBJLOG. Log level for multi-objective optimization.

      • getBackgroundMaxThreads

        public int getBackgroundMaxThreads()
        Retrieves the value of the control XPRSconstants.BACKGROUNDMAXTHREADS. Limit the number of threads to use in background jobs (for example in parallel to the root cut loop).

      • setBackgroundMaxThreads

        public void setBackgroundMaxThreads​(int newval)
        Sets the value of the control XPRSconstants.BACKGROUNDMAXTHREADS. Limit the number of threads to use in background jobs (for example in parallel to the root cut loop).

      • getBackgroundSelect

        public long getBackgroundSelect()
        Retrieves the value of the control XPRSconstants.BACKGROUNDSELECT. Select which tasks to run in background jobs (for example in parallel to the root cut loop).

      • setBackgroundSelect

        public void setBackgroundSelect​(long newval)
        Sets the value of the control XPRSconstants.BACKGROUNDSELECT. Select which tasks to run in background jobs (for example in parallel to the root cut loop).

      • getGlobalLSHeurstrategy

        public int getGlobalLSHeurstrategy()
        Retrieves the value of the control XPRSconstants.GLOBALLSHEURSTRATEGY. When integer-feasible (for MINLP, any solution for NLP) but nonlinear-infeasible solutions are encountered within a global solve, the integer variables can be fixed and a local solver (as defined by the LOCALSOLVER control) can be called on the remaining continuous problem. This control defines the frequency and effort of such local solves.

      • setGlobalLSHeurstrategy

        public void setGlobalLSHeurstrategy​(int newval)
        Sets the value of the control XPRSconstants.GLOBALLSHEURSTRATEGY. When integer-feasible (for MINLP, any solution for NLP) but nonlinear-infeasible solutions are encountered within a global solve, the integer variables can be fixed and a local solver (as defined by the LOCALSOLVER control) can be called on the remaining continuous problem. This control defines the frequency and effort of such local solves.

      • getGlobalSpatialBranchIfPreferOrig

        public int getGlobalSpatialBranchIfPreferOrig()
        Retrieves the value of the control XPRSconstants.GLOBALSPATIALBRANCHIFPREFERORIG. Whether spatial branchings on original variables should be preferred over branching on auxiliary variables that were introduced by the reformulation of the global solver.

      • setGlobalSpatialBranchIfPreferOrig

        public void setGlobalSpatialBranchIfPreferOrig​(int newval)
        Sets the value of the control XPRSconstants.GLOBALSPATIALBRANCHIFPREFERORIG. Whether spatial branchings on original variables should be preferred over branching on auxiliary variables that were introduced by the reformulation of the global solver.

      • getPreConfiguration

        public int getPreConfiguration()
        Retrieves the value of the control XPRSconstants.PRECONFIGURATION. MIP Presolve: determines whether binary rows with only few repeating coefficients should be reformulated. The reformulation enumerates the extremal feasible configurations of a row and introduces new columns and rows to model the choice between these extremal configurations. This presolve operation can be disabled as part of the (advanced) IP reductions PRESOLVEOPS.

      • setPreConfiguration

        public void setPreConfiguration​(int newval)
        Sets the value of the control XPRSconstants.PRECONFIGURATION. MIP Presolve: determines whether binary rows with only few repeating coefficients should be reformulated. The reformulation enumerates the extremal feasible configurations of a row and introduces new columns and rows to model the choice between these extremal configurations. This presolve operation can be disabled as part of the (advanced) IP reductions PRESOLVEOPS.

      • getFeasibilityJump

        public int getFeasibilityJump()
        Retrieves the value of the control XPRSconstants.FEASIBILITYJUMP. MIP: Decides if the Feasibility Jump heuristic should be run. The value for this control is either -1 (let Xpress decide), 0 (off) or a value that indicates for which type of models the heuristic should be run.

      • setFeasibilityJump

        public void setFeasibilityJump​(int newval)
        Sets the value of the control XPRSconstants.FEASIBILITYJUMP. MIP: Decides if the Feasibility Jump heuristic should be run. The value for this control is either -1 (let Xpress decide), 0 (off) or a value that indicates for which type of models the heuristic should be run.

      • getIISOps

        public XPRSenumerations.IISOps getIISOps()
        Retrieves the value of the control XPRSconstants.IISOPS. Selects which part of the restrictions (bounds, constraints, entities) should always be kept in an IIS. This is useful if certain types of restrictions cannot be violated, thus they are known not to be the cause of infeasibility. The IIS obtained this way is irreducible only for the non-protected restrictions. This control has an effect only on the deletion filter of the IIS procedure. (Values are from the enumeration XPRSenumerations.IISOps)

      • setIISOps

        public void setIISOps​(XPRSenumerations.IISOps newval)
        Sets the value of the control XPRSconstants.IISOPS. Selects which part of the restrictions (bounds, constraints, entities) should always be kept in an IIS. This is useful if certain types of restrictions cannot be violated, thus they are known not to be the cause of infeasibility. The IIS obtained this way is irreducible only for the non-protected restrictions. This control has an effect only on the deletion filter of the IIS procedure. (Values are from the enumeration XPRSenumerations.IISOps)

      • resetIISOps

        public void resetIISOps()
        Resets to its default the value of control XPRSconstants.IISOPS

      • getRLTCuts

        public int getRLTCuts()
        Retrieves the value of the control XPRSconstants.RLTCUTS. Determines whether RLT cuts should be separated in the Xpress Global Solver.

      • setRLTCuts

        public void setRLTCuts​(int newval)
        Sets the value of the control XPRSconstants.RLTCUTS. Determines whether RLT cuts should be separated in the Xpress Global Solver.

      • resetRLTCuts

        public void resetRLTCuts()
        Resets to its default the value of control XPRSconstants.RLTCUTS

      • getHeursearchBackgroundSelect

        public long getHeursearchBackgroundSelect()
        Retrieves the value of the control XPRSconstants.HEURSEARCHBACKGROUNDSELECT. Select which large neighborhood searches to run in the background (for example in parallel to the root cut loop).

      • setHeursearchBackgroundSelect

        public void setHeursearchBackgroundSelect​(long newval)
        Sets the value of the control XPRSconstants.HEURSEARCHBACKGROUNDSELECT. Select which large neighborhood searches to run in the background (for example in parallel to the root cut loop).

      • getAlternativeRedCosts

        public int getAlternativeRedCosts()
        Retrieves the value of the control XPRSconstants.ALTERNATIVEREDCOSTS. Controls aggressiveness of searching for alternative reduced cost

      • setAlternativeRedCosts

        public void setAlternativeRedCosts​(int newval)
        Sets the value of the control XPRSconstants.ALTERNATIVEREDCOSTS. Controls aggressiveness of searching for alternative reduced cost

      • getHeurShiftProp

        public int getHeurShiftProp()
        Retrieves the value of the control XPRSconstants.HEURSHIFTPROP. Determines whether the Shift-and-propagate primal heuristic should be executed. If enabled, Shift-and-propagate is an LP-free primal heuristic that is executed immediately after presolve.

      • setHeurShiftProp

        public void setHeurShiftProp​(int newval)
        Sets the value of the control XPRSconstants.HEURSHIFTPROP. Determines whether the Shift-and-propagate primal heuristic should be executed. If enabled, Shift-and-propagate is an LP-free primal heuristic that is executed immediately after presolve.

      • getHeurSearchCopyControls

        public int getHeurSearchCopyControls()
        Retrieves the value of the control XPRSconstants.HEURSEARCHCOPYCONTROLS. Select how user-set controls should affect local search heuristics.

      • setHeurSearchCopyControls

        public void setHeurSearchCopyControls​(int newval)
        Sets the value of the control XPRSconstants.HEURSEARCHCOPYCONTROLS. Select how user-set controls should affect local search heuristics.

      • getGlobalNlpCuts

        public int getGlobalNlpCuts()
        Retrieves the value of the control XPRSconstants.GLOBALNLPCUTS. Limit on the number of rounds of outer approximation and convexification cuts generated for the root node, when solving an (MI)NLP to global optimality.

      • setGlobalNlpCuts

        public void setGlobalNlpCuts​(int newval)
        Sets the value of the control XPRSconstants.GLOBALNLPCUTS. Limit on the number of rounds of outer approximation and convexification cuts generated for the root node, when solving an (MI)NLP to global optimality.

      • getGlobalTreeNlpCuts

        public int getGlobalTreeNlpCuts()
        Retrieves the value of the control XPRSconstants.GLOBALTREENLPCUTS. Limit on the number of rounds of outer approximation and convexification cuts generated for each node in the tree, when solving an (MI)NLP to global optimality.

      • setGlobalTreeNlpCuts

        public void setGlobalTreeNlpCuts​(int newval)
        Sets the value of the control XPRSconstants.GLOBALTREENLPCUTS. Limit on the number of rounds of outer approximation and convexification cuts generated for each node in the tree, when solving an (MI)NLP to global optimality.

      • getBarhgOps

        public XPRSenumerations.BARHGOps getBarhgOps()
        Retrieves the value of the control XPRSconstants.BARHGOPS. Control options for the hybrid gradient algorithm. Bits 1, 2 and 3 control which norms of the coefficient matrix are used for solution normalization. The normalization factor is the maximum of the selected norms. By default, or if all three bits are set to 0, the infinity norm is used. The omega parameter referenced in bits 4, 5 and 6 is a measure of the relative magnitudes of the objective and the right-hand side. (Values are from the enumeration XPRSenumerations.BARHGOps)

      • setBarhgOps

        public void setBarhgOps​(XPRSenumerations.BARHGOps newval)
        Sets the value of the control XPRSconstants.BARHGOPS. Control options for the hybrid gradient algorithm. Bits 1, 2 and 3 control which norms of the coefficient matrix are used for solution normalization. The normalization factor is the maximum of the selected norms. By default, or if all three bits are set to 0, the infinity norm is used. The omega parameter referenced in bits 4, 5 and 6 is a measure of the relative magnitudes of the objective and the right-hand side. (Values are from the enumeration XPRSenumerations.BARHGOps)

      • resetBarhgOps

        public void resetBarhgOps()
        Resets to its default the value of control XPRSconstants.BARHGOPS

      • getBarhgMaxRestarts

        public int getBarhgMaxRestarts()
        Retrieves the value of the control XPRSconstants.BARHGMAXRESTARTS. The maximum number of restarts in the hybrid gradient algorithm. Restarts play the role of iterations in the hybrid gradient algorithm. A log line is printed at every restart, unless BAROUTPUT is set to 0.

      • setBarhgMaxRestarts

        public void setBarhgMaxRestarts​(int newval)
        Sets the value of the control XPRSconstants.BARHGMAXRESTARTS. The maximum number of restarts in the hybrid gradient algorithm. Restarts play the role of iterations in the hybrid gradient algorithm. A log line is printed at every restart, unless BAROUTPUT is set to 0.

      • getMCFCutStrategy

        public int getMCFCutStrategy()
        Retrieves the value of the control XPRSconstants.MCFCUTSTRATEGY. Level of Multi-Commodity Flow (MCF) cutting planes separation: This specifies how much aggresively MCF cuts should be separated. If the separation of MCF cuts is enabled, Xpress will try to detect a MCF network structure in the problem and, if such a structure is identified, it will separate specific cutting planes exploiting the identified network.

      • setMCFCutStrategy

        public void setMCFCutStrategy​(int newval)
        Sets the value of the control XPRSconstants.MCFCUTSTRATEGY. Level of Multi-Commodity Flow (MCF) cutting planes separation: This specifies how much aggresively MCF cuts should be separated. If the separation of MCF cuts is enabled, Xpress will try to detect a MCF network structure in the problem and, if such a structure is identified, it will separate specific cutting planes exploiting the identified network.

      • getMaxCutTime

        public double getMaxCutTime()
        Retrieves the value of the control XPRSconstants.MAXCUTTIME. The maximum amount of time allowed for generation of cutting planes and reoptimization. The limit is checked during generation and no further cuts are added once this limit has been exceeded.

      • setMaxCutTime

        public void setMaxCutTime​(double newval)
        Sets the value of the control XPRSconstants.MAXCUTTIME. The maximum amount of time allowed for generation of cutting planes and reoptimization. The limit is checked during generation and no further cuts are added once this limit has been exceeded.

      • getMaxStallTime

        public double getMaxStallTime()
        Retrieves the value of the control XPRSconstants.MAXSTALLTIME. The maximum time in seconds that the Optimizer will continue to search for improving solution after finding a new incumbent.

      • setMaxStallTime

        public void setMaxStallTime​(double newval)
        Sets the value of the control XPRSconstants.MAXSTALLTIME. The maximum time in seconds that the Optimizer will continue to search for improving solution after finding a new incumbent.

      • getTunerMaxTime

        public double getTunerMaxTime()
        Retrieves the value of the control XPRSconstants.TUNERMAXTIME. Tuner: The maximum time in seconds that the tuner will run before it terminates.

      • setTunerMaxTime

        public void setTunerMaxTime​(double newval)
        Sets the value of the control XPRSconstants.TUNERMAXTIME. Tuner: The maximum time in seconds that the tuner will run before it terminates.

      • getMatrixTol

        public double getMatrixTol()
        Retrieves the value of the control XPRSconstants.MATRIXTOL. The zero tolerance on matrix elements. If the value of a matrix element is less than or equal to MATRIXTOL in absolute value, it is treated as zero. The control applies when solving a problem, for an input tolerance see INPUTTOL.

        This control is used in the following examples:

        • MostViolated

      • setMatrixTol

        public void setMatrixTol​(double newval)
        Sets the value of the control XPRSconstants.MATRIXTOL. The zero tolerance on matrix elements. If the value of a matrix element is less than or equal to MATRIXTOL in absolute value, it is treated as zero. The control applies when solving a problem, for an input tolerance see INPUTTOL.

        This control is used in the following examples:

        • MostViolated

      • getPivotTol

        public double getPivotTol()
        Retrieves the value of the control XPRSconstants.PIVOTTOL. Simplex: The zero tolerance for matrix elements. On each iteration, the simplex method seeks a nonzero matrix element to pivot on. Any element with absolute value less than PIVOTTOL is treated as zero for this purpose.

      • setPivotTol

        public void setPivotTol​(double newval)
        Sets the value of the control XPRSconstants.PIVOTTOL. Simplex: The zero tolerance for matrix elements. On each iteration, the simplex method seeks a nonzero matrix element to pivot on. Any element with absolute value less than PIVOTTOL is treated as zero for this purpose.

      • resetPivotTol

        public void resetPivotTol()
        Resets to its default the value of control XPRSconstants.PIVOTTOL

      • getFeasTol

        public double getFeasTol()
        Retrieves the value of the control XPRSconstants.FEASTOL. This tolerance determines when a solution is treated as feasible. If the amount by which a constraint's activity violates its right-hand side or ranged bound is less in absolute magnitude than FEASTOL, then the constraint is treated as satisfied. Similarly, if the amount by which a column violates its bounds is less in absolute magnitude than FEASTOL, those bounds are also treated as satisfied.

      • setFeasTol

        public void setFeasTol​(double newval)
        Sets the value of the control XPRSconstants.FEASTOL. This tolerance determines when a solution is treated as feasible. If the amount by which a constraint's activity violates its right-hand side or ranged bound is less in absolute magnitude than FEASTOL, then the constraint is treated as satisfied. Similarly, if the amount by which a column violates its bounds is less in absolute magnitude than FEASTOL, those bounds are also treated as satisfied.

      • resetFeasTol

        public void resetFeasTol()
        Resets to its default the value of control XPRSconstants.FEASTOL

      • getOutputTol

        public double getOutputTol()
        Retrieves the value of the control XPRSconstants.OUTPUTTOL. Zero tolerance on print values.

      • setOutputTol

        public void setOutputTol​(double newval)
        Sets the value of the control XPRSconstants.OUTPUTTOL. Zero tolerance on print values.

      • getSOSRefTol

        public double getSOSRefTol()
        Retrieves the value of the control XPRSconstants.SOSREFTOL. The minimum relative gap between the ordering values of elements in a special ordered set. The gap divided by the absolute value of the larger of the two adjacent values must be at least SOSREFTOL.

      • setSOSRefTol

        public void setSOSRefTol​(double newval)
        Sets the value of the control XPRSconstants.SOSREFTOL. The minimum relative gap between the ordering values of elements in a special ordered set. The gap divided by the absolute value of the larger of the two adjacent values must be at least SOSREFTOL.

      • getOptimalityTol

        public double getOptimalityTol()
        Retrieves the value of the control XPRSconstants.OPTIMALITYTOL. Simplex: This is the zero tolerance for reduced costs. On each iteration, the simplex method searches for a variable to enter the basis which has a negative reduced cost. The candidates are only those variables which have reduced costs less than the negative value of OPTIMALITYTOL.

      • setOptimalityTol

        public void setOptimalityTol​(double newval)
        Sets the value of the control XPRSconstants.OPTIMALITYTOL. Simplex: This is the zero tolerance for reduced costs. On each iteration, the simplex method searches for a variable to enter the basis which has a negative reduced cost. The candidates are only those variables which have reduced costs less than the negative value of OPTIMALITYTOL.

      • getEtaTol

        public double getEtaTol()
        Retrieves the value of the control XPRSconstants.ETATOL. Tolerance on eta elements. During each iteration, the basis inverse is premultiplied by an elementary matrix, which is the identity except for one column - the eta vector. Elements of eta vectors whose absolute value is smaller than ETATOL are taken to be zero in this step.

      • setEtaTol

        public void setEtaTol​(double newval)
        Sets the value of the control XPRSconstants.ETATOL. Tolerance on eta elements. During each iteration, the basis inverse is premultiplied by an elementary matrix, which is the identity except for one column - the eta vector. Elements of eta vectors whose absolute value is smaller than ETATOL are taken to be zero in this step.

      • resetEtaTol

        public void resetEtaTol()
        Resets to its default the value of control XPRSconstants.ETATOL

      • getRelPivotTol

        public double getRelPivotTol()
        Retrieves the value of the control XPRSconstants.RELPIVOTTOL. Simplex: At each iteration a pivot element is chosen within a given column of the matrix. The relative pivot tolerance, RELPIVOTTOL, is the size of the element chosen relative to the largest possible pivot element in the same column.

      • setRelPivotTol

        public void setRelPivotTol​(double newval)
        Sets the value of the control XPRSconstants.RELPIVOTTOL. Simplex: At each iteration a pivot element is chosen within a given column of the matrix. The relative pivot tolerance, RELPIVOTTOL, is the size of the element chosen relative to the largest possible pivot element in the same column.

      • getMIPTol

        public double getMIPTol()
        Retrieves the value of the control XPRSconstants.MIPTOL. Branch and Bound: This is the tolerance within which a decision variable's value is considered to be integral.

        This control is used in the following examples:

        • AddMipSol
        • Knapsack
        • RoundInt

      • setMIPTol

        public void setMIPTol​(double newval)
        Sets the value of the control XPRSconstants.MIPTOL. Branch and Bound: This is the tolerance within which a decision variable's value is considered to be integral.

        This control is used in the following examples:

        • AddMipSol
        • Knapsack
        • RoundInt

      • resetMIPTol

        public void resetMIPTol()
        Resets to its default the value of control XPRSconstants.MIPTOL

      • getMipTolTarget

        public double getMipTolTarget()
        Retrieves the value of the control XPRSconstants.MIPTOLTARGET. Target MIPTOL value used by the automatic MIP solution refiner as defined by REFINEOPS. Negative and zero values are ignored.

      • setMipTolTarget

        public void setMipTolTarget​(double newval)
        Sets the value of the control XPRSconstants.MIPTOLTARGET. Target MIPTOL value used by the automatic MIP solution refiner as defined by REFINEOPS. Negative and zero values are ignored.

      • getBarPerturb

        public double getBarPerturb()
        Retrieves the value of the control XPRSconstants.BARPERTURB. Newton barrier: In numerically challenging cases it is often advantageous to apply perturbations on the KKT system to improve its numerical properties. BARPERTURB controlls how much perturbation is allowed during the barrier iterations. By default no perturbation is allowed. Set this parameter with care as larger perturbations may lead to less efficient iterates and the best settings are problem-dependent.

      • setBarPerturb

        public void setBarPerturb​(double newval)
        Sets the value of the control XPRSconstants.BARPERTURB. Newton barrier: In numerically challenging cases it is often advantageous to apply perturbations on the KKT system to improve its numerical properties. BARPERTURB controlls how much perturbation is allowed during the barrier iterations. By default no perturbation is allowed. Set this parameter with care as larger perturbations may lead to less efficient iterates and the best settings are problem-dependent.

      • getMIPAddCutoff

        public double getMIPAddCutoff()
        Retrieves the value of the control XPRSconstants.MIPADDCUTOFF. Branch and Bound: The amount to add to the objective function of the best integer solution found to give the new CURRMIPCUTOFF. Once an integer solution has been found whose objective function is equal to or better than CURRMIPCUTOFF, improvements on this value may not be interesting unless they are better by at least a certain amount. If MIPADDCUTOFF is nonzero, it will be added to CURRMIPCUTOFF each time an integer solution is found which is better than this new value. This cuts off sections of the tree whose solutions would not represent substantial improvements in the objective function, saving processor time. The control MIPABSSTOP provides a similar function but works in a different way.

      • setMIPAddCutoff

        public void setMIPAddCutoff​(double newval)
        Sets the value of the control XPRSconstants.MIPADDCUTOFF. Branch and Bound: The amount to add to the objective function of the best integer solution found to give the new CURRMIPCUTOFF. Once an integer solution has been found whose objective function is equal to or better than CURRMIPCUTOFF, improvements on this value may not be interesting unless they are better by at least a certain amount. If MIPADDCUTOFF is nonzero, it will be added to CURRMIPCUTOFF each time an integer solution is found which is better than this new value. This cuts off sections of the tree whose solutions would not represent substantial improvements in the objective function, saving processor time. The control MIPABSSTOP provides a similar function but works in a different way.

      • getMIPAbsCutoff

        public double getMIPAbsCutoff()
        Retrieves the value of the control XPRSconstants.MIPABSCUTOFF. Branch and Bound: If the user knows that they are interested only in values of the objective function which are better than some value, this can be assigned to MIPABSCUTOFF. This allows the Optimizer to ignore solving any nodes which may yield worse objective values, saving solution time. When a MIP solution is found a new cut off value is calculated and the value can be obtained from the CURRMIPCUTOFF attribute. The value of CURRMIPCUTOFF is calculated using the MIPRELCUTOFF and MIPADDCUTOFF controls.

        This control is used in the following examples:

        • AddMipSol
        • Knapsack

      • setMIPAbsCutoff

        public void setMIPAbsCutoff​(double newval)
        Sets the value of the control XPRSconstants.MIPABSCUTOFF. Branch and Bound: If the user knows that they are interested only in values of the objective function which are better than some value, this can be assigned to MIPABSCUTOFF. This allows the Optimizer to ignore solving any nodes which may yield worse objective values, saving solution time. When a MIP solution is found a new cut off value is calculated and the value can be obtained from the CURRMIPCUTOFF attribute. The value of CURRMIPCUTOFF is calculated using the MIPRELCUTOFF and MIPADDCUTOFF controls.

        This control is used in the following examples:

        • AddMipSol
        • Knapsack

      • getMIPRelCutoff

        public double getMIPRelCutoff()
        Retrieves the value of the control XPRSconstants.MIPRELCUTOFF. Branch and Bound: Percentage of the incumbent value to be added to the value of the objective function when an integer solution is found, to give the new value of CURRMIPCUTOFF. The effect is to cut off the search in parts of the tree whose best possible objective function would not be substantially better than the current solution. The control MIPRELSTOP provides a similar functionality but works in a different way.

      • setMIPRelCutoff

        public void setMIPRelCutoff​(double newval)
        Sets the value of the control XPRSconstants.MIPRELCUTOFF. Branch and Bound: Percentage of the incumbent value to be added to the value of the objective function when an integer solution is found, to give the new value of CURRMIPCUTOFF. The effect is to cut off the search in parts of the tree whose best possible objective function would not be substantially better than the current solution. The control MIPRELSTOP provides a similar functionality but works in a different way.

      • getPseudoCost

        public double getPseudoCost()
        Retrieves the value of the control XPRSconstants.PSEUDOCOST. Branch and Bound: The default pseudo cost used in estimation of the degradation associated with an unexplored node in the tree search. A pseudo cost is associated with each integer decision variable and is an estimate of the amount by which the objective function will be worse if that variable is forced to an integral value.

      • setPseudoCost

        public void setPseudoCost​(double newval)
        Sets the value of the control XPRSconstants.PSEUDOCOST. Branch and Bound: The default pseudo cost used in estimation of the degradation associated with an unexplored node in the tree search. A pseudo cost is associated with each integer decision variable and is an estimate of the amount by which the objective function will be worse if that variable is forced to an integral value.

      • getPenalty

        public double getPenalty()
        Retrieves the value of the control XPRSconstants.PENALTY. Minimum absolute penalty variable coefficient. BIGM and PENALTY are set by the input routine ( readProb ( READPROB)) but may be reset by the user prior to lpOptimize ( LPOPTIMIZE).

      • setPenalty

        public void setPenalty​(double newval)
        Sets the value of the control XPRSconstants.PENALTY. Minimum absolute penalty variable coefficient. BIGM and PENALTY are set by the input routine ( readProb ( READPROB)) but may be reset by the user prior to lpOptimize ( LPOPTIMIZE).

      • resetPenalty

        public void resetPenalty()
        Resets to its default the value of control XPRSconstants.PENALTY

      • getBigM

        public double getBigM()
        Retrieves the value of the control XPRSconstants.BIGM. The infeasibility penalty used if the "Big M" method is implemented.

      • setBigM

        public void setBigM​(double newval)
        Sets the value of the control XPRSconstants.BIGM. The infeasibility penalty used if the "Big M" method is implemented.

      • resetBigM

        public void resetBigM()
        Resets to its default the value of control XPRSconstants.BIGM

      • getMIPAbsStop

        public double getMIPAbsStop()
        Retrieves the value of the control XPRSconstants.MIPABSSTOP. Branch and Bound: The absolute tolerance determining whether the tree search will continue or not. It will terminate if
           | MIPOBJVAL - BESTBOUND| <= MIPABSSTOP
        where MIPOBJVAL is the value of the best solution's objective function, and BESTBOUND is the current best solution bound. For example, to stop the tree search when a MIP solution has been found and the Optimizer can guarantee it is within 100 of the optimal solution, set MIPABSSTOP to 100.

      • setMIPAbsStop

        public void setMIPAbsStop​(double newval)
        Sets the value of the control XPRSconstants.MIPABSSTOP. Branch and Bound: The absolute tolerance determining whether the tree search will continue or not. It will terminate if
           | MIPOBJVAL - BESTBOUND| <= MIPABSSTOP
        where MIPOBJVAL is the value of the best solution's objective function, and BESTBOUND is the current best solution bound. For example, to stop the tree search when a MIP solution has been found and the Optimizer can guarantee it is within 100 of the optimal solution, set MIPABSSTOP to 100.

      • getMIPRelStop

        public double getMIPRelStop()
        Retrieves the value of the control XPRSconstants.MIPRELSTOP. Branch and Bound: This determines when the branch and bound tree search will terminate. Branch and bound tree search will stop if:
           | MIPOBJVAL - BESTBOUND| <= MIPRELSTOP x max(| BESTBOUND|,| MIPOBJVAL|)
        where MIPOBJVAL is the value of the best solution's objective function and BESTBOUND is the current best solution bound. For example, to stop the tree search when a MIP solution has been found and the Optimizer can guarantee it is within 5% of the optimal solution, set MIPRELSTOP to 0.05.

      • setMIPRelStop

        public void setMIPRelStop​(double newval)
        Sets the value of the control XPRSconstants.MIPRELSTOP. Branch and Bound: This determines when the branch and bound tree search will terminate. Branch and bound tree search will stop if:
           | MIPOBJVAL - BESTBOUND| <= MIPRELSTOP x max(| BESTBOUND|,| MIPOBJVAL|)
        where MIPOBJVAL is the value of the best solution's objective function and BESTBOUND is the current best solution bound. For example, to stop the tree search when a MIP solution has been found and the Optimizer can guarantee it is within 5% of the optimal solution, set MIPRELSTOP to 0.05.

      • getCrossoverAccuracyTol

        public double getCrossoverAccuracyTol()
        Retrieves the value of the control XPRSconstants.CROSSOVERACCURACYTOL. Newton barrier: This control determines how crossover adjusts the default relative pivot tolerance. When re-inversion is necessary, crossover will compare the recalculated working basic solution with the assumed ones just before re-inversion took place. If the error is above this threshold, crossover will adjust the relative pivot tolerance to address the build-up of numerical inaccuracies.

      • setCrossoverAccuracyTol

        public void setCrossoverAccuracyTol​(double newval)
        Sets the value of the control XPRSconstants.CROSSOVERACCURACYTOL. Newton barrier: This control determines how crossover adjusts the default relative pivot tolerance. When re-inversion is necessary, crossover will compare the recalculated working basic solution with the assumed ones just before re-inversion took place. If the error is above this threshold, crossover will adjust the relative pivot tolerance to address the build-up of numerical inaccuracies.

      • getPrimalPerturb

        public double getPrimalPerturb()
        Retrieves the value of the control XPRSconstants.PRIMALPERTURB. The factor by which the problem will be perturbed prior to optimization by primal simplex. A value of 0.0 results in no perturbation prior to optimization. Note the interconnection to the AUTOPERTURB control. If AUTOPERTURB is set to 1, the decision whether to perturb or not is left to the Optimizer. When the problem is automatically perturbed in primal simplex, however, the value of PRIMALPERTURB will be used for perturbation.

      • setPrimalPerturb

        public void setPrimalPerturb​(double newval)
        Sets the value of the control XPRSconstants.PRIMALPERTURB. The factor by which the problem will be perturbed prior to optimization by primal simplex. A value of 0.0 results in no perturbation prior to optimization. Note the interconnection to the AUTOPERTURB control. If AUTOPERTURB is set to 1, the decision whether to perturb or not is left to the Optimizer. When the problem is automatically perturbed in primal simplex, however, the value of PRIMALPERTURB will be used for perturbation.

      • getDualPerturb

        public double getDualPerturb()
        Retrieves the value of the control XPRSconstants.DUALPERTURB. The factor by which the problem will be perturbed prior to optimization by dual simplex. A value of 0.0 results in no perturbation prior to optimization. Note the interconnection to the AUTOPERTURB control. If AUTOPERTURB is set to 1, the decision whether to perturb or not is left to the Optimizer. When the problem is automatically perturbed in dual simplex, however, the value of DUALPERTURB will be used for perturbation.

      • setDualPerturb

        public void setDualPerturb​(double newval)
        Sets the value of the control XPRSconstants.DUALPERTURB. The factor by which the problem will be perturbed prior to optimization by dual simplex. A value of 0.0 results in no perturbation prior to optimization. Note the interconnection to the AUTOPERTURB control. If AUTOPERTURB is set to 1, the decision whether to perturb or not is left to the Optimizer. When the problem is automatically perturbed in dual simplex, however, the value of DUALPERTURB will be used for perturbation.

      • getBarObjScale

        public double getBarObjScale()
        Retrieves the value of the control XPRSconstants.BAROBJSCALE. Defines how the barrier scales the objective.

      • setBarObjScale

        public void setBarObjScale​(double newval)
        Sets the value of the control XPRSconstants.BAROBJSCALE. Defines how the barrier scales the objective.

      • getBarRhsScale

        public double getBarRhsScale()
        Retrieves the value of the control XPRSconstants.BARRHSSCALE. Defines how the barrier scales the right hand side.

      • setBarRhsScale

        public void setBarRhsScale​(double newval)
        Sets the value of the control XPRSconstants.BARRHSSCALE. Defines how the barrier scales the right hand side.

      • getCholeskyTol

        public double getCholeskyTol()
        Retrieves the value of the control XPRSconstants.CHOLESKYTOL. Newton barrier: The tolerance for pivot elements in the Cholesky decomposition of the normal equations coefficient matrix, computed at each iteration of the barrier algorithm. If the absolute value of the pivot element is less than or equal to CHOLESKYTOL, it merits special treatment in the Cholesky decomposition process.

      • setCholeskyTol

        public void setCholeskyTol​(double newval)
        Sets the value of the control XPRSconstants.CHOLESKYTOL. Newton barrier: The tolerance for pivot elements in the Cholesky decomposition of the normal equations coefficient matrix, computed at each iteration of the barrier algorithm. If the absolute value of the pivot element is less than or equal to CHOLESKYTOL, it merits special treatment in the Cholesky decomposition process.

      • getBarGapStop

        public double getBarGapStop()
        Retrieves the value of the control XPRSconstants.BARGAPSTOP. Newton barrier and hybrid gradient: This is a convergence parameter, representing the tolerance for the relative duality gap. When the difference between the primal and dual objective function values falls below this tolerance, the Optimizer determines that the optimal solution has been found.

      • setBarGapStop

        public void setBarGapStop​(double newval)
        Sets the value of the control XPRSconstants.BARGAPSTOP. Newton barrier and hybrid gradient: This is a convergence parameter, representing the tolerance for the relative duality gap. When the difference between the primal and dual objective function values falls below this tolerance, the Optimizer determines that the optimal solution has been found.

      • getBarDualStop

        public double getBarDualStop()
        Retrieves the value of the control XPRSconstants.BARDUALSTOP. Newton barrier and hybrid gradient: This is a convergence parameter, representing the tolerance for dual infeasibilities. If the difference between the constraints and their bounds in the dual problem falls below this tolerance in absolute value, optimization will stop and the current solution will be returned.

      • setBarDualStop

        public void setBarDualStop​(double newval)
        Sets the value of the control XPRSconstants.BARDUALSTOP. Newton barrier and hybrid gradient: This is a convergence parameter, representing the tolerance for dual infeasibilities. If the difference between the constraints and their bounds in the dual problem falls below this tolerance in absolute value, optimization will stop and the current solution will be returned.

      • getBarPrimalStop

        public double getBarPrimalStop()
        Retrieves the value of the control XPRSconstants.BARPRIMALSTOP. Newton barrier and hybrid gradient: This is a convergence parameter, indicating the tolerance for primal infeasibilities. If the difference between the constraints and their bounds in the primal problem falls below this tolerance in absolute value, the Optimizer will terminate and return the current solution.

      • setBarPrimalStop

        public void setBarPrimalStop​(double newval)
        Sets the value of the control XPRSconstants.BARPRIMALSTOP. Newton barrier and hybrid gradient: This is a convergence parameter, indicating the tolerance for primal infeasibilities. If the difference between the constraints and their bounds in the primal problem falls below this tolerance in absolute value, the Optimizer will terminate and return the current solution.

      • getBarStepStop

        public double getBarStepStop()
        Retrieves the value of the control XPRSconstants.BARSTEPSTOP. Newton barrier: A convergence parameter, representing the minimal step size. On each iteration of the barrier algorithm, a step is taken along a computed search direction. If that step size is smaller than BARSTEPSTOP, the Optimizer will terminate and return the current solution.

      • setBarStepStop

        public void setBarStepStop​(double newval)
        Sets the value of the control XPRSconstants.BARSTEPSTOP. Newton barrier: A convergence parameter, representing the minimal step size. On each iteration of the barrier algorithm, a step is taken along a computed search direction. If that step size is smaller than BARSTEPSTOP, the Optimizer will terminate and return the current solution.

      • getElimTol

        public double getElimTol()
        Retrieves the value of the control XPRSconstants.ELIMTOL. The Markowitz tolerance for the elimination phase of the presolve.

      • setElimTol

        public void setElimTol​(double newval)
        Sets the value of the control XPRSconstants.ELIMTOL. The Markowitz tolerance for the elimination phase of the presolve.

      • resetElimTol

        public void resetElimTol()
        Resets to its default the value of control XPRSconstants.ELIMTOL

      • getMarkowitzTol

        public double getMarkowitzTol()
        Retrieves the value of the control XPRSconstants.MARKOWITZTOL. The Markowitz tolerance used for the factorization of the basis matrix.

      • setMarkowitzTol

        public void setMarkowitzTol​(double newval)
        Sets the value of the control XPRSconstants.MARKOWITZTOL. The Markowitz tolerance used for the factorization of the basis matrix.

      • getMIPAbsGapNotify

        public double getMIPAbsGapNotify()
        Retrieves the value of the control XPRSconstants.MIPABSGAPNOTIFY. Branch and bound: if the gapnotify callback has been set using addCbGapNotify, then this callback will be triggered during the tree search when the absolute gap reaches or passes the value you set of the MIPRELGAPNOTIFY control.

      • setMIPAbsGapNotify

        public void setMIPAbsGapNotify​(double newval)
        Sets the value of the control XPRSconstants.MIPABSGAPNOTIFY. Branch and bound: if the gapnotify callback has been set using addCbGapNotify, then this callback will be triggered during the tree search when the absolute gap reaches or passes the value you set of the MIPRELGAPNOTIFY control.

      • getMIPRelGapNotify

        public double getMIPRelGapNotify()
        Retrieves the value of the control XPRSconstants.MIPRELGAPNOTIFY. Branch and bound: if the gapnotify callback has been set using addCbGapNotify, then this callback will be triggered during the branch and bound tree search when the relative gap reaches or passes the value you set of the MIPRELGAPNOTIFY control.

      • setMIPRelGapNotify

        public void setMIPRelGapNotify​(double newval)
        Sets the value of the control XPRSconstants.MIPRELGAPNOTIFY. Branch and bound: if the gapnotify callback has been set using addCbGapNotify, then this callback will be triggered during the branch and bound tree search when the relative gap reaches or passes the value you set of the MIPRELGAPNOTIFY control.

      • getBarLargeBound

        public double getBarLargeBound()
        Retrieves the value of the control XPRSconstants.BARLARGEBOUND. Threshold for the barrier to handle large bounds.

      • setBarLargeBound

        public void setBarLargeBound​(double newval)
        Sets the value of the control XPRSconstants.BARLARGEBOUND. Threshold for the barrier to handle large bounds.

      • getPPFactor

        public double getPPFactor()
        Retrieves the value of the control XPRSconstants.PPFACTOR. The partial pricing candidate list sizing parameter.

      • setPPFactor

        public void setPPFactor​(double newval)
        Sets the value of the control XPRSconstants.PPFACTOR. The partial pricing candidate list sizing parameter.

      • resetPPFactor

        public void resetPPFactor()
        Resets to its default the value of control XPRSconstants.PPFACTOR

      • getRepairIndefiniteQMax

        public double getRepairIndefiniteQMax()

      • getBarGapTarget

        public double getBarGapTarget()
        Retrieves the value of the control XPRSconstants.BARGAPTARGET. Newton barrier: The target tolerance for the relative duality gap. The barrier algorithm will keep iterating until either BARGAPTARGET is satisfied or until no further improvements are possible. In the latter case, if BARGAPSTOP is satisfied, it will declare the problem optimal.

      • setBarGapTarget

        public void setBarGapTarget​(double newval)
        Sets the value of the control XPRSconstants.BARGAPTARGET. Newton barrier: The target tolerance for the relative duality gap. The barrier algorithm will keep iterating until either BARGAPTARGET is satisfied or until no further improvements are possible. In the latter case, if BARGAPSTOP is satisfied, it will declare the problem optimal.

      • getDummyControl

        public double getDummyControl()

      • getBarStartWeight

        public double getBarStartWeight()
        Retrieves the value of the control XPRSconstants.BARSTARTWEIGHT. Newton barrier: This sets a weight for the warm-start point when warm-start is set for the barrier algorithm. Using larger weight gives more emphasis for the supplied starting point.

      • setBarStartWeight

        public void setBarStartWeight​(double newval)
        Sets the value of the control XPRSconstants.BARSTARTWEIGHT. Newton barrier: This sets a weight for the warm-start point when warm-start is set for the barrier algorithm. Using larger weight gives more emphasis for the supplied starting point.

      • getBarFreeScale

        public double getBarFreeScale()
        Retrieves the value of the control XPRSconstants.BARFREESCALE. Defines how the barrier algorithm scales free variables.

      • setBarFreeScale

        public void setBarFreeScale​(double newval)
        Sets the value of the control XPRSconstants.BARFREESCALE. Defines how the barrier algorithm scales free variables.

      • getSbEffort

        public double getSbEffort()
        Retrieves the value of the control XPRSconstants.SBEFFORT. Adjusts the overall amount of effort when using strong branching to select an infeasible MIP entity to branch on.

      • setSbEffort

        public void setSbEffort​(double newval)
        Sets the value of the control XPRSconstants.SBEFFORT. Adjusts the overall amount of effort when using strong branching to select an infeasible MIP entity to branch on.

      • resetSbEffort

        public void resetSbEffort()
        Resets to its default the value of control XPRSconstants.SBEFFORT

      • getHeurDiveRandomize

        public double getHeurDiveRandomize()
        Retrieves the value of the control XPRSconstants.HEURDIVERANDOMIZE. The level of randomization to apply in the diving heuristic. The diving heuristic uses priority weights on rows and columns to determine the order in which to e.g. round fractional columns, or the direction in which to round them. This control determines by how large a random factor these weights should be changed.

      • setHeurDiveRandomize

        public void setHeurDiveRandomize​(double newval)
        Sets the value of the control XPRSconstants.HEURDIVERANDOMIZE. The level of randomization to apply in the diving heuristic. The diving heuristic uses priority weights on rows and columns to determine the order in which to e.g. round fractional columns, or the direction in which to round them. This control determines by how large a random factor these weights should be changed.

      • getHeurSearchEffort

        public double getHeurSearchEffort()
        Retrieves the value of the control XPRSconstants.HEURSEARCHEFFORT. Adjusts the overall level of the local search heuristics.

      • setHeurSearchEffort

        public void setHeurSearchEffort​(double newval)
        Sets the value of the control XPRSconstants.HEURSEARCHEFFORT. Adjusts the overall level of the local search heuristics.

      • getCutFactor

        public double getCutFactor()
        Retrieves the value of the control XPRSconstants.CUTFACTOR. Limit on the number of cuts and cut coefficients the optimizer is allowed to add to the matrix during tree search. The cuts and cut coefficients are limited by CUTFACTOR times the number of rows and coefficients in the initial matrix.

      • setCutFactor

        public void setCutFactor​(double newval)
        Sets the value of the control XPRSconstants.CUTFACTOR. Limit on the number of cuts and cut coefficients the optimizer is allowed to add to the matrix during tree search. The cuts and cut coefficients are limited by CUTFACTOR times the number of rows and coefficients in the initial matrix.

      • getEigenValueTol

        public double getEigenValueTol()
        Retrieves the value of the control XPRSconstants.EIGENVALUETOL. A quadratic matrix is considered not to be positive semi-definite, if its smallest eigenvalue is smaller than the negative of this value.

      • setEigenValueTol

        public void setEigenValueTol​(double newval)
        Sets the value of the control XPRSconstants.EIGENVALUETOL. A quadratic matrix is considered not to be positive semi-definite, if its smallest eigenvalue is smaller than the negative of this value.

      • getIndLinBigM

        public double getIndLinBigM()
        Retrieves the value of the control XPRSconstants.INDLINBIGM. During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough. This control defines the largest BigM for which such a linearized version will be added to the problem in addition to the original constraint. If the BigM is even smaller than INDPRELINBIGM, then the original indicator constraint will additionally be dropped from the problem.

      • setIndLinBigM

        public void setIndLinBigM​(double newval)
        Sets the value of the control XPRSconstants.INDLINBIGM. During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough. This control defines the largest BigM for which such a linearized version will be added to the problem in addition to the original constraint. If the BigM is even smaller than INDPRELINBIGM, then the original indicator constraint will additionally be dropped from the problem.

      • getTreeMemorySavingTarget

        public double getTreeMemorySavingTarget()
        Retrieves the value of the control XPRSconstants.TREEMEMORYSAVINGTARGET. When the memory used by the branch-and-bound search tree exceeds the limit specified by the TREEMEMORYLIMIT control, the optimizer will try to save memory by writing lower-rated sections of the tree to the tree file. The target amount of memory to save will be enough to bring memory usage back below the limit, plus enough extra to give the tree room to grow. The TREEMEMORYSAVINGTARGET control specifies the extra proportion of the tree's size to try to save; for example, if the tree memory limit is 1000Mb and TREEMEMORYSAVINGTARGET is 0.1, when the tree size exceeds 1000Mb the optimizer will try to reduce the tree size to 900Mb. Reducing the value of TREEMEMORYSAVINGTARGET will cause less extra nodes of the tree to be written to the tree file, but will result in the memory saving routine being triggered more often (as the tree will have less room in which to grow), which can reduce performance. Increasing the value of TREEMEMORYSAVINGTARGET will cause additional, more highly-rated nodes, of the tree to be written to the tree file, which can cause performance issues if these nodes are required later in the solve.

      • setTreeMemorySavingTarget

        public void setTreeMemorySavingTarget​(double newval)
        Sets the value of the control XPRSconstants.TREEMEMORYSAVINGTARGET. When the memory used by the branch-and-bound search tree exceeds the limit specified by the TREEMEMORYLIMIT control, the optimizer will try to save memory by writing lower-rated sections of the tree to the tree file. The target amount of memory to save will be enough to bring memory usage back below the limit, plus enough extra to give the tree room to grow. The TREEMEMORYSAVINGTARGET control specifies the extra proportion of the tree's size to try to save; for example, if the tree memory limit is 1000Mb and TREEMEMORYSAVINGTARGET is 0.1, when the tree size exceeds 1000Mb the optimizer will try to reduce the tree size to 900Mb. Reducing the value of TREEMEMORYSAVINGTARGET will cause less extra nodes of the tree to be written to the tree file, but will result in the memory saving routine being triggered more often (as the tree will have less room in which to grow), which can reduce performance. Increasing the value of TREEMEMORYSAVINGTARGET will cause additional, more highly-rated nodes, of the tree to be written to the tree file, which can cause performance issues if these nodes are required later in the solve.

      • getIndPreLinBigM

        public double getIndPreLinBigM()
        Retrieves the value of the control XPRSconstants.INDPRELINBIGM. During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough. This control defines the largest BigM for which the original constraint will be replaced by the linearized version. If the BigM is larger than INDPRELINBIGM but smaller than INDLINBIGM, the linearized row will be added but the original indicator constraint is kept as a numerically stable way to check feasibility.

      • setIndPreLinBigM

        public void setIndPreLinBigM​(double newval)
        Sets the value of the control XPRSconstants.INDPRELINBIGM. During presolve, indicator constraints will be linearized using a BigM coefficient whenever that BigM coefficient is small enough. This control defines the largest BigM for which the original constraint will be replaced by the linearized version. If the BigM is larger than INDPRELINBIGM but smaller than INDLINBIGM, the linearized row will be added but the original indicator constraint is kept as a numerically stable way to check feasibility.

      • getRelaxTreeMemoryLimit

        public double getRelaxTreeMemoryLimit()
        Retrieves the value of the control XPRSconstants.RELAXTREEMEMORYLIMIT. When the memory used by the branch and bound search tree exceeds the target specified by the TREEMEMORYLIMIT control, the optimizer will try to reduce this by writing nodes to the tree file. In rare cases, usually where the solve has many millions of very small nodes, the tree structural data (which cannot be written to the tree file) will grow large enough to approach or exceed the tree's memory target. When this happens, optimizer performance can degrade greatly as the solver makes heavy use of the tree file in preference to memory. To prevent this, the solver will automatically relax the tree memory limit when it detects this case; the RELAXTREEMEMORYLIMIT control specifies the proportion of the previous memory limit by which to relax it. Set RELAXTREEMEMORYLIMIT to 0.0 to force the Xpress Optimizer to never relax the tree memory limit in this way.

      • setRelaxTreeMemoryLimit

        public void setRelaxTreeMemoryLimit​(double newval)
        Sets the value of the control XPRSconstants.RELAXTREEMEMORYLIMIT. When the memory used by the branch and bound search tree exceeds the target specified by the TREEMEMORYLIMIT control, the optimizer will try to reduce this by writing nodes to the tree file. In rare cases, usually where the solve has many millions of very small nodes, the tree structural data (which cannot be written to the tree file) will grow large enough to approach or exceed the tree's memory target. When this happens, optimizer performance can degrade greatly as the solver makes heavy use of the tree file in preference to memory. To prevent this, the solver will automatically relax the tree memory limit when it detects this case; the RELAXTREEMEMORYLIMIT control specifies the proportion of the previous memory limit by which to relax it. Set RELAXTREEMEMORYLIMIT to 0.0 to force the Xpress Optimizer to never relax the tree memory limit in this way.

      • getMIPAbsGapNotifyObj

        public double getMIPAbsGapNotifyObj()
        Retrieves the value of the control XPRSconstants.MIPABSGAPNOTIFYOBJ. Branch and bound: if the gapnotify callback has been set using addCbGapNotify, then this callback will be triggered during the tree search when the best solution value reaches or passes the value you set of the MIPRELGAPNOTIFYOBJ control.

      • setMIPAbsGapNotifyObj

        public void setMIPAbsGapNotifyObj​(double newval)
        Sets the value of the control XPRSconstants.MIPABSGAPNOTIFYOBJ. Branch and bound: if the gapnotify callback has been set using addCbGapNotify, then this callback will be triggered during the tree search when the best solution value reaches or passes the value you set of the MIPRELGAPNOTIFYOBJ control.

      • getMIPAbsGapNotifyBound

        public double getMIPAbsGapNotifyBound()
        Retrieves the value of the control XPRSconstants.MIPABSGAPNOTIFYBOUND. Branch and bound: if the gapnotify callback has been set using addCbGapNotify, then this callback will be triggered during the tree search when the best bound reaches or passes the value you set of the MIPRELGAPNOTIFYBOUND control.

      • setMIPAbsGapNotifyBound

        public void setMIPAbsGapNotifyBound​(double newval)
        Sets the value of the control XPRSconstants.MIPABSGAPNOTIFYBOUND. Branch and bound: if the gapnotify callback has been set using addCbGapNotify, then this callback will be triggered during the tree search when the best bound reaches or passes the value you set of the MIPRELGAPNOTIFYBOUND control.

      • getPresolveMaxGrow

        public double getPresolveMaxGrow()
        Retrieves the value of the control XPRSconstants.PRESOLVEMAXGROW. Limit on how much the number of non-zero coefficients is allowed to grow during presolve, specified as a ratio of the number of non-zero coefficients in the original problem.

      • setPresolveMaxGrow

        public void setPresolveMaxGrow​(double newval)
        Sets the value of the control XPRSconstants.PRESOLVEMAXGROW. Limit on how much the number of non-zero coefficients is allowed to grow during presolve, specified as a ratio of the number of non-zero coefficients in the original problem.

      • getHeurSearchTargetSize

        public double getHeurSearchTargetSize()

      • getCrossOverRelPivotTol

        public double getCrossOverRelPivotTol()

      • getCrossOverRelPivotTolSafe

        public double getCrossOverRelPivotTolSafe()

      • getDetLogFreq

        public double getDetLogFreq()

      • getMaxImpliedBound

        public double getMaxImpliedBound()
        Retrieves the value of the control XPRSconstants.MAXIMPLIEDBOUND. Presolve: When tighter bounds are calculated during MIP preprocessing, only bounds whose absolute value are smaller than MAXIMPLIEDBOUND will be applied to the problem.

      • setMaxImpliedBound

        public void setMaxImpliedBound​(double newval)
        Sets the value of the control XPRSconstants.MAXIMPLIEDBOUND. Presolve: When tighter bounds are calculated during MIP preprocessing, only bounds whose absolute value are smaller than MAXIMPLIEDBOUND will be applied to the problem.

      • getFeasTolTarget

        public double getFeasTolTarget()
        Retrieves the value of the control XPRSconstants.FEASTOLTARGET. This specifies the target feasibility tolerance for the solution refiner.

      • setFeasTolTarget

        public void setFeasTolTarget​(double newval)
        Sets the value of the control XPRSconstants.FEASTOLTARGET. This specifies the target feasibility tolerance for the solution refiner.

      • getOptimalityTolTarget

        public double getOptimalityTolTarget()
        Retrieves the value of the control XPRSconstants.OPTIMALITYTOLTARGET. This specifies the target optimality tolerance for the solution refiner.

      • setOptimalityTolTarget

        public void setOptimalityTolTarget​(double newval)
        Sets the value of the control XPRSconstants.OPTIMALITYTOLTARGET. This specifies the target optimality tolerance for the solution refiner.

      • getPreComponentsEffort

        public double getPreComponentsEffort()
        Retrieves the value of the control XPRSconstants.PRECOMPONENTSEFFORT. Presolve: adjusts the overall effort for the independent component presolver. This control affects working limits for the subproblem solving as well as thresholds when it is called. Increase to put more emphasis on component presolving.

      • setPreComponentsEffort

        public void setPreComponentsEffort​(double newval)
        Sets the value of the control XPRSconstants.PRECOMPONENTSEFFORT. Presolve: adjusts the overall effort for the independent component presolver. This control affects working limits for the subproblem solving as well as thresholds when it is called. Increase to put more emphasis on component presolving.

      • getLPLogDelay

        public double getLPLogDelay()
        Retrieves the value of the control XPRSconstants.LPLOGDELAY. Time interval between two LP log lines.

      • setLPLogDelay

        public void setLPLogDelay​(double newval)
        Sets the value of the control XPRSconstants.LPLOGDELAY. Time interval between two LP log lines.

      • getHeurDiveIterLimit

        public double getHeurDiveIterLimit()
        Retrieves the value of the control XPRSconstants.HEURDIVEITERLIMIT. Branch and Bound: Simplex iteration limit for reoptimizing during the diving heuristic.

      • setHeurDiveIterLimit

        public void setHeurDiveIterLimit​(double newval)
        Sets the value of the control XPRSconstants.HEURDIVEITERLIMIT. Branch and Bound: Simplex iteration limit for reoptimizing during the diving heuristic.

      • getBarKernel

        public double getBarKernel()
        Retrieves the value of the control XPRSconstants.BARKERNEL. Newton barrier: Defines how centrality is weighted in the barrier algorithm.

      • setBarKernel

        public void setBarKernel​(double newval)
        Sets the value of the control XPRSconstants.BARKERNEL. Newton barrier: Defines how centrality is weighted in the barrier algorithm.

      • getFeasTolPerturb

        public double getFeasTolPerturb()
        Retrieves the value of the control XPRSconstants.FEASTOLPERTURB. This tolerance determines how much a feasible primal basic solution is allowed to be perturbed when performing basis changes. The tolerance FEASTOL is always considered as an upper limit for the perturbations, but in some cases smaller value can be more desirable.

      • setFeasTolPerturb

        public void setFeasTolPerturb​(double newval)
        Sets the value of the control XPRSconstants.FEASTOLPERTURB. This tolerance determines how much a feasible primal basic solution is allowed to be perturbed when performing basis changes. The tolerance FEASTOL is always considered as an upper limit for the perturbations, but in some cases smaller value can be more desirable.

      • getCrossOverFeasWeight

        public double getCrossOverFeasWeight()

      • getLUPivotTol

        public double getLUPivotTol()

      • getMIPRestartGapThreshold

        public double getMIPRestartGapThreshold()

      • setMIPRestartGapThreshold

        public void setMIPRestartGapThreshold​(double newval)
        Sets the value of the control XPRSconstants.MIPRESTARTGAPTHRESHOLD. Branch and Bound: Initial gap threshold to delay in-tree restart. The restart is delayed initially if the gap, given as a fraction between 0 and 1, is below this threshold. The optimizer adjusts the threshold every time a restart is delayed. Note that there are other criteria that can delay or prevent a restart.

      • getNodeProbingEffort

        public double getNodeProbingEffort()
        Retrieves the value of the control XPRSconstants.NODEPROBINGEFFORT. Adjusts the overall level of node probing.

      • setNodeProbingEffort

        public void setNodeProbingEffort​(double newval)
        Sets the value of the control XPRSconstants.NODEPROBINGEFFORT. Adjusts the overall level of node probing.

      • getInputtol

        public double getInputtol()
        Retrieves the value of the control XPRSconstants.INPUTTOL. The tolerance on input values elements. If any value is less than or equal to INPUTTOL in absolute value, it is treated as zero. For the internal zero tolerance see MATRIXTOL.

      • setInputtol

        public void setInputtol​(double newval)
        Sets the value of the control XPRSconstants.INPUTTOL. The tolerance on input values elements. If any value is less than or equal to INPUTTOL in absolute value, it is treated as zero. For the internal zero tolerance see MATRIXTOL.

      • resetInputtol

        public void resetInputtol()
        Resets to its default the value of control XPRSconstants.INPUTTOL

      • getMIPRestartFactor

        public double getMIPRestartFactor()
        Retrieves the value of the control XPRSconstants.MIPRESTARTFACTOR. Branch and Bound: Fine tune initial conditions to trigger an in-tree restart. Use a value > 1 to increase the aggressiveness with which the Optimizer restarts. Use a value < 1 to relax the aggressiveness with which the Optimizer restarts. Note that this control does not affect the initial condition on the gap, which must be set separately.

      • setMIPRestartFactor

        public void setMIPRestartFactor​(double newval)
        Sets the value of the control XPRSconstants.MIPRESTARTFACTOR. Branch and Bound: Fine tune initial conditions to trigger an in-tree restart. Use a value > 1 to increase the aggressiveness with which the Optimizer restarts. Use a value < 1 to relax the aggressiveness with which the Optimizer restarts. Note that this control does not affect the initial condition on the gap, which must be set separately.

      • getBarObjPerturb

        public double getBarObjPerturb()
        Retrieves the value of the control XPRSconstants.BAROBJPERTURB. Defines how the barrier perturbs the objective.

      • setBarObjPerturb

        public void setBarObjPerturb​(double newval)
        Sets the value of the control XPRSconstants.BAROBJPERTURB. Defines how the barrier perturbs the objective.

      • getCpiAlpha

        public double getCpiAlpha()
        Retrieves the value of the control XPRSconstants.CPIALPHA. decay term for confined primal integral computation.

      • setCpiAlpha

        public void setCpiAlpha​(double newval)
        Sets the value of the control XPRSconstants.CPIALPHA. decay term for confined primal integral computation.

      • resetCpiAlpha

        public void resetCpiAlpha()
        Resets to its default the value of control XPRSconstants.CPIALPHA

      • getGlobalSpatialBranchPropagationEffort

        public double getGlobalSpatialBranchPropagationEffort()
        Retrieves the value of the control XPRSconstants.GLOBALSPATIALBRANCHPROPAGATIONEFFORT. Limits the effort that is spent on propagation during spatial branching.

      • setGlobalSpatialBranchPropagationEffort

        public void setGlobalSpatialBranchPropagationEffort​(double newval)
        Sets the value of the control XPRSconstants.GLOBALSPATIALBRANCHPROPAGATIONEFFORT. Limits the effort that is spent on propagation during spatial branching.

      • getGlobalSpatialBranchCuttingEffort

        public double getGlobalSpatialBranchCuttingEffort()
        Retrieves the value of the control XPRSconstants.GLOBALSPATIALBRANCHCUTTINGEFFORT. Limits the effort that is spent on creating cuts during spatial branching.

      • setGlobalSpatialBranchCuttingEffort

        public void setGlobalSpatialBranchCuttingEffort​(double newval)
        Sets the value of the control XPRSconstants.GLOBALSPATIALBRANCHCUTTINGEFFORT. Limits the effort that is spent on creating cuts during spatial branching.

      • getGlobalBoundingBox

        public double getGlobalBoundingBox()
        Retrieves the value of the control XPRSconstants.GLOBALBOUNDINGBOX. If a nonlinear problem cannot be solved due to appearing unbounded, it can automatically be regularized by the application of a bounding box on the variables. If this control is set to a negative value, in a second solving attempt all original variables will be bounded by the absolute value of this control. If set to a positive value, there will be a third solving attempt afterwards, if necessary, in which also all auxiliary variables are bounded by this value.

      • setGlobalBoundingBox

        public void setGlobalBoundingBox​(double newval)
        Sets the value of the control XPRSconstants.GLOBALBOUNDINGBOX. If a nonlinear problem cannot be solved due to appearing unbounded, it can automatically be regularized by the application of a bounding box on the variables. If this control is set to a negative value, in a second solving attempt all original variables will be bounded by the absolute value of this control. If set to a positive value, there will be a third solving attempt afterwards, if necessary, in which also all auxiliary variables are bounded by this value.

      • getTimeLimit

        public double getTimeLimit()
        Retrieves the value of the control XPRSconstants.TIMELIMIT. The maximum time in seconds that the Optimizer will run before it terminates, including the problem setup time and solution time. For MIP problems, this is the total time taken to solve all nodes.

      • setTimeLimit

        public void setTimeLimit​(double newval)
        Sets the value of the control XPRSconstants.TIMELIMIT. The maximum time in seconds that the Optimizer will run before it terminates, including the problem setup time and solution time. For MIP problems, this is the total time taken to solve all nodes.

      • getSolTimeLimit

        public double getSolTimeLimit()
        Retrieves the value of the control XPRSconstants.SOLTIMELIMIT. The maximum time in seconds that the Optimizer will run a MIP solve before it terminates, given that a solution has been found. As long as no solution has been found, this control will have no effect.

      • setSolTimeLimit

        public void setSolTimeLimit​(double newval)
        Sets the value of the control XPRSconstants.SOLTIMELIMIT. The maximum time in seconds that the Optimizer will run a MIP solve before it terminates, given that a solution has been found. As long as no solution has been found, this control will have no effect.

      • getRepairInfeasTimeLimit

        public double getRepairInfeasTimeLimit()
        Retrieves the value of the control XPRSconstants.REPAIRINFEASTIMELIMIT. Overall time limit for the repairinfeas tool

      • setRepairInfeasTimeLimit

        public void setRepairInfeasTimeLimit​(double newval)
        Sets the value of the control XPRSconstants.REPAIRINFEASTIMELIMIT. Overall time limit for the repairinfeas tool

      • getBarhgExtrapolate

        public double getBarhgExtrapolate()
        Retrieves the value of the control XPRSconstants.BARHGEXTRAPOLATE. Extrapolation parameter for the hybrid gradient algorithm. Although theory suggests that a value of 1 is best, slightly smaller values perform better in general.

      • setBarhgExtrapolate

        public void setBarhgExtrapolate​(double newval)
        Sets the value of the control XPRSconstants.BARHGEXTRAPOLATE. Extrapolation parameter for the hybrid gradient algorithm. Although theory suggests that a value of 1 is best, slightly smaller values perform better in general.

      • getMPSRHSName

        public java.lang.String getMPSRHSName()
        Retrieves the value of the control XPRSconstants.MPSRHSNAME. When reading an MPS file, this control determines which entries from the RHS section will be read. As with all string controls, this is of length 64 characters plus a null terminator, \0.

      • setMPSRHSName

        public void setMPSRHSName​(java.lang.String newval)
        Sets the value of the control XPRSconstants.MPSRHSNAME. When reading an MPS file, this control determines which entries from the RHS section will be read. As with all string controls, this is of length 64 characters plus a null terminator, \0.

      • getMPSObjName

        public java.lang.String getMPSObjName()
        Retrieves the value of the control XPRSconstants.MPSOBJNAME. When reading an MPS file, this control determines which neutral row will be read as the objective function. If this control is set when reading a multi-objective MPS file, only the named objective will be read; all other objectives will be ignored. As with all string controls, this is of length 64 characters plus a null terminator, \0.

      • setMPSObjName

        public void setMPSObjName​(java.lang.String newval)
        Sets the value of the control XPRSconstants.MPSOBJNAME. When reading an MPS file, this control determines which neutral row will be read as the objective function. If this control is set when reading a multi-objective MPS file, only the named objective will be read; all other objectives will be ignored. As with all string controls, this is of length 64 characters plus a null terminator, \0.

      • getMPSRangeName

        public java.lang.String getMPSRangeName()
        Retrieves the value of the control XPRSconstants.MPSRANGENAME. When reading an MPS file, this control determines which entries from the RANGES section will be read. As with all string controls, this is of length 64 characters plus a null terminator, \0.

      • setMPSRangeName

        public void setMPSRangeName​(java.lang.String newval)
        Sets the value of the control XPRSconstants.MPSRANGENAME. When reading an MPS file, this control determines which entries from the RANGES section will be read. As with all string controls, this is of length 64 characters plus a null terminator, \0.

      • getMPSBoundName

        public java.lang.String getMPSBoundName()
        Retrieves the value of the control XPRSconstants.MPSBOUNDNAME. When reading an MPS file, this control determines which entries from the BOUNDS section will be read. As with all string controls, this is of length 64 characters plus a null terminator, \0.

      • setMPSBoundName

        public void setMPSBoundName​(java.lang.String newval)
        Sets the value of the control XPRSconstants.MPSBOUNDNAME. When reading an MPS file, this control determines which entries from the BOUNDS section will be read. As with all string controls, this is of length 64 characters plus a null terminator, \0.

      • getOutputMask

        public java.lang.String getOutputMask()
        Retrieves the value of the control XPRSconstants.OUTPUTMASK. Mask to restrict the row and column names written to file. As with all string controls, this is of length 64 characters plus a null terminator, \0.

      • setOutputMask

        public void setOutputMask​(java.lang.String newval)
        Sets the value of the control XPRSconstants.OUTPUTMASK. Mask to restrict the row and column names written to file. As with all string controls, this is of length 64 characters plus a null terminator, \0.

      • getTunerMethodFile

        public java.lang.String getTunerMethodFile()
        Retrieves the value of the control XPRSconstants.TUNERMETHODFILE. Tuner: Defines a file from which the tuner can read user-defined tuner method.

      • setTunerMethodFile

        public void setTunerMethodFile​(java.lang.String newval)
        Sets the value of the control XPRSconstants.TUNERMETHODFILE. Tuner: Defines a file from which the tuner can read user-defined tuner method.

      • getTunerOutputPath

        public java.lang.String getTunerOutputPath()
        Retrieves the value of the control XPRSconstants.TUNEROUTPUTPATH. Tuner: Defines a root path to which the tuner writes the result file and logs.

      • setTunerOutputPath

        public void setTunerOutputPath​(java.lang.String newval)
        Sets the value of the control XPRSconstants.TUNEROUTPUTPATH. Tuner: Defines a root path to which the tuner writes the result file and logs.

      • getTunerSessionName

        public java.lang.String getTunerSessionName()
        Retrieves the value of the control XPRSconstants.TUNERSESSIONNAME. Tuner: Defines a session name for the tuner.

      • setTunerSessionName

        public void setTunerSessionName​(java.lang.String newval)
        Sets the value of the control XPRSconstants.TUNERSESSIONNAME. Tuner: Defines a session name for the tuner.

      • getComputeExecService

        public java.lang.String getComputeExecService()
        Retrieves the value of the control XPRSconstants.COMPUTEEXECSERVICE. Selects the Insight execution service that will be used for solving remote optimizations.

      • setComputeExecService

        public void setComputeExecService​(java.lang.String newval)
        Sets the value of the control XPRSconstants.COMPUTEEXECSERVICE. Selects the Insight execution service that will be used for solving remote optimizations.

      • getNlpFuncEval

        public int getNlpFuncEval()
        Retrieves the value of the control XPRSconstants.NLPFUNCEVAL. Bit map for determining the method of evaluating user functions and their derivatives

      • setNlpFuncEval

        public void setNlpFuncEval​(int newval)
        Sets the value of the control XPRSconstants.NLPFUNCEVAL. Bit map for determining the method of evaluating user functions and their derivatives

      • getNlpLog

        public int getNlpLog()
        Retrieves the value of the control XPRSconstants.NLPLOG. Level of printing during SLP iterations

      • setNlpLog

        public void setNlpLog​(int newval)
        Sets the value of the control XPRSconstants.NLPLOG. Level of printing during SLP iterations

      • resetNlpLog

        public void resetNlpLog()
        Resets to its default the value of control XPRSconstants.NLPLOG

      • getNlpEvaluate

        public int getNlpEvaluate()
        Retrieves the value of the control XPRSconstants.NLPEVALUATE. Evaluation strategy for user functions

      • setNlpEvaluate

        public void setNlpEvaluate​(int newval)
        Sets the value of the control XPRSconstants.NLPEVALUATE. Evaluation strategy for user functions

      • getNlpPresolve

        public int getNlpPresolve()
        Retrieves the value of the control XPRSconstants.NLPPRESOLVE. This control determines whether presolving should be performed prior to starting the main algorithm

      • setNlpPresolve

        public void setNlpPresolve​(int newval)
        Sets the value of the control XPRSconstants.NLPPRESOLVE. This control determines whether presolving should be performed prior to starting the main algorithm

      • getNlpStopOutOfRange

        public int getNlpStopOutOfRange()
        Retrieves the value of the control XPRSconstants.NLPSTOPOUTOFRANGE. Stop optimization and return error code if internal function argument is out of range

      • setNlpStopOutOfRange

        public void setNlpStopOutOfRange​(int newval)
        Sets the value of the control XPRSconstants.NLPSTOPOUTOFRANGE. Stop optimization and return error code if internal function argument is out of range

      • getNlpThreadSafeUserFunc

        public int getNlpThreadSafeUserFunc()
        Retrieves the value of the control XPRSconstants.NLPTHREADSAFEUSERFUNC. Defines if user functions are allowed to be called in parallel

      • setNlpThreadSafeUserFunc

        public void setNlpThreadSafeUserFunc​(int newval)
        Sets the value of the control XPRSconstants.NLPTHREADSAFEUSERFUNC. Defines if user functions are allowed to be called in parallel

      • getNlpJacobian

        public int getNlpJacobian()
        Retrieves the value of the control XPRSconstants.NLPJACOBIAN. First order differentiation mode when using analytical derivatives

      • setNlpJacobian

        public void setNlpJacobian​(int newval)
        Sets the value of the control XPRSconstants.NLPJACOBIAN. First order differentiation mode when using analytical derivatives

      • getNlpHessian

        public int getNlpHessian()
        Retrieves the value of the control XPRSconstants.NLPHESSIAN. Second order differentiation mode when using analytical derivatives

      • setNlpHessian

        public void setNlpHessian​(int newval)
        Sets the value of the control XPRSconstants.NLPHESSIAN. Second order differentiation mode when using analytical derivatives

      • getMultiStart

        public int getMultiStart()
        Retrieves the value of the control XPRSconstants.MULTISTART. The multistart master control. Defines if the multistart search is to be initiated, or if only the baseline model is to be solved.

      • setMultiStart

        public void setMultiStart​(int newval)
        Sets the value of the control XPRSconstants.MULTISTART. The multistart master control. Defines if the multistart search is to be initiated, or if only the baseline model is to be solved.

      • getMultiStart_Threads

        public int getMultiStart_Threads()
        Retrieves the value of the control XPRSconstants.MULTISTART_THREADS. The maximum number of threads to be used in multistart

      • setMultiStart_Threads

        public void setMultiStart_Threads​(int newval)
        Sets the value of the control XPRSconstants.MULTISTART_THREADS. The maximum number of threads to be used in multistart

      • getMultiStart_MaxSolves

        public int getMultiStart_MaxSolves()
        Retrieves the value of the control XPRSconstants.MULTISTART_MAXSOLVES. The maximum number of jobs to create during the multistart search.

      • setMultiStart_MaxSolves

        public void setMultiStart_MaxSolves​(int newval)
        Sets the value of the control XPRSconstants.MULTISTART_MAXSOLVES. The maximum number of jobs to create during the multistart search.

      • getMultiStart_MaxTime

        public int getMultiStart_MaxTime()
        Retrieves the value of the control XPRSconstants.MULTISTART_MAXTIME. The maximum total time to be spent in the mutlistart search.

      • setMultiStart_MaxTime

        public void setMultiStart_MaxTime​(int newval)
        Sets the value of the control XPRSconstants.MULTISTART_MAXTIME. The maximum total time to be spent in the mutlistart search.

      • getNlpMaxTime

        public int getNlpMaxTime()
        Retrieves the value of the control XPRSconstants.NLPMAXTIME. The maximum time in seconds that the SLP optimization will run before it terminates

      • setNlpMaxTime

        public void setNlpMaxTime​(int newval)
        Sets the value of the control XPRSconstants.NLPMAXTIME. The maximum time in seconds that the SLP optimization will run before it terminates

      • getNlpDerivatives

        public int getNlpDerivatives()
        Retrieves the value of the control XPRSconstants.NLPDERIVATIVES. Bitmap describing the method of calculating derivatives

      • setNlpDerivatives

        public void setNlpDerivatives​(int newval)
        Sets the value of the control XPRSconstants.NLPDERIVATIVES. Bitmap describing the method of calculating derivatives

      • getNlpReformulate

        public int getNlpReformulate()
        Retrieves the value of the control XPRSconstants.NLPREFORMULATE. Controls the problem reformulations carried out before augmentation. This allows SLP to take advantage of dedicated algorithms for special problem classes.

      • setNlpReformulate

        public void setNlpReformulate​(int newval)
        Sets the value of the control XPRSconstants.NLPREFORMULATE. Controls the problem reformulations carried out before augmentation. This allows SLP to take advantage of dedicated algorithms for special problem classes.

      • getNlpPresolveOps

        public int getNlpPresolveOps()
        Retrieves the value of the control XPRSconstants.NLPPRESOLVEOPS. Bitmap indicating the SLP presolve actions to be taken

      • setNlpPresolveOps

        public void setNlpPresolveOps​(int newval)
        Sets the value of the control XPRSconstants.NLPPRESOLVEOPS. Bitmap indicating the SLP presolve actions to be taken

      • getMultiStart_Log

        public int getMultiStart_Log()
        Retrieves the value of the control XPRSconstants.MULTISTART_LOG. The level of logging during the multistart run.

      • setMultiStart_Log

        public void setMultiStart_Log​(int newval)
        Sets the value of the control XPRSconstants.MULTISTART_LOG. The level of logging during the multistart run.

      • getMultiStart_Seed

        public int getMultiStart_Seed()
        Retrieves the value of the control XPRSconstants.MULTISTART_SEED. Random seed used for the automatic generation of initial point when loading multistart presets

      • setMultiStart_Seed

        public void setMultiStart_Seed​(int newval)
        Sets the value of the control XPRSconstants.MULTISTART_SEED. Random seed used for the automatic generation of initial point when loading multistart presets

      • getMultiStart_PoolSize

        public int getMultiStart_PoolSize()
        Retrieves the value of the control XPRSconstants.MULTISTART_POOLSIZE. The maximum number of problem objects allowed to pool up before synchronization in the deterministic multistart.

      • setMultiStart_PoolSize

        public void setMultiStart_PoolSize​(int newval)
        Sets the value of the control XPRSconstants.MULTISTART_POOLSIZE. The maximum number of problem objects allowed to pool up before synchronization in the deterministic multistart.

      • getNlpPostsolve

        public int getNlpPostsolve()
        Retrieves the value of the control XPRSconstants.NLPPOSTSOLVE. This control determines whether postsolving should be performed automatically

      • setNlpPostsolve

        public void setNlpPostsolve​(int newval)
        Sets the value of the control XPRSconstants.NLPPOSTSOLVE. This control determines whether postsolving should be performed automatically

      • getNlpDeterministic

        public int getNlpDeterministic()
        Retrieves the value of the control XPRSconstants.NLPDETERMINISTIC. Determines if the parallel features of SLP should be guaranteed to be deterministic

      • setNlpDeterministic

        public void setNlpDeterministic​(int newval)
        Sets the value of the control XPRSconstants.NLPDETERMINISTIC. Determines if the parallel features of SLP should be guaranteed to be deterministic

      • getNlpPresolveLevel

        public int getNlpPresolveLevel()
        Retrieves the value of the control XPRSconstants.NLPPRESOLVELEVEL. This control determines the level of changes presolve may carry out on the problem and whether column/row indices may change

      • setNlpPresolveLevel

        public void setNlpPresolveLevel​(int newval)
        Sets the value of the control XPRSconstants.NLPPRESOLVELEVEL. This control determines the level of changes presolve may carry out on the problem and whether column/row indices may change

      • getNlpProbing

        public int getNlpProbing()
        Retrieves the value of the control XPRSconstants.NLPPROBING. This control determines whether probing on a subset of variables should be performed prior to starting the main algorithm. Probing runs multiple times bound reduction in order to further tighten the bounding box.

      • setNlpProbing

        public void setNlpProbing​(int newval)
        Sets the value of the control XPRSconstants.NLPPROBING. This control determines whether probing on a subset of variables should be performed prior to starting the main algorithm. Probing runs multiple times bound reduction in order to further tighten the bounding box.

      • getNlpCalcThreads

        public int getNlpCalcThreads()
        Retrieves the value of the control XPRSconstants.NLPCALCTHREADS. Number of threads used for formula and derivatives evaluations

      • setNlpCalcThreads

        public void setNlpCalcThreads​(int newval)
        Sets the value of the control XPRSconstants.NLPCALCTHREADS. Number of threads used for formula and derivatives evaluations

      • getNlpThreads

        public int getNlpThreads()
        Retrieves the value of the control XPRSconstants.NLPTHREADS. Default number of threads to be used

      • setNlpThreads

        public void setNlpThreads​(int newval)
        Sets the value of the control XPRSconstants.NLPTHREADS. Default number of threads to be used

      • getNlpFindIV

        public int getNlpFindIV()
        Retrieves the value of the control XPRSconstants.NLPFINDIV. Option for running a heuristic to find a feasible initial point

      • setNlpFindIV

        public void setNlpFindIV​(int newval)
        Sets the value of the control XPRSconstants.NLPFINDIV. Option for running a heuristic to find a feasible initial point

      • getNlpLinQuadBR

        public int getNlpLinQuadBR()
        Retrieves the value of the control XPRSconstants.NLPLINQUADBR. Use linear and quadratic constraints and objective function to further reduce bounds on all variables

      • setNlpLinQuadBR

        public void setNlpLinQuadBR​(int newval)
        Sets the value of the control XPRSconstants.NLPLINQUADBR. Use linear and quadratic constraints and objective function to further reduce bounds on all variables

      • getNLPSolver

        public int getNLPSolver()
        Retrieves the value of the control XPRSconstants.NLPSOLVER. Selects the library to use for local solves

        This control is used in the following examples:

        • PolygonMap
        • PolygonMapDelta
        • PolygonVecMap
        • PolygonVecMapDelta

      • setNLPSolver

        public void setNLPSolver​(int newval)
        Sets the value of the control XPRSconstants.NLPSOLVER. Selects the library to use for local solves

        This control is used in the following examples:

        • PolygonMap
        • PolygonMapDelta
        • PolygonVecMap
        • PolygonVecMapDelta

      • getSlpAlgorithm

        public int getSlpAlgorithm()
        Retrieves the value of the control XPRSconstants.SLPALGORITHM. Bit map describing the SLP algorithm(s) to be used

      • setSlpAlgorithm

        public void setSlpAlgorithm​(int newval)
        Sets the value of the control XPRSconstants.SLPALGORITHM. Bit map describing the SLP algorithm(s) to be used

      • getSlpAugmentation

        public int getSlpAugmentation()
        Retrieves the value of the control XPRSconstants.SLPAUGMENTATION. Bit map describing the SLP augmentation method(s) to be used

      • setSlpAugmentation

        public void setSlpAugmentation​(int newval)
        Sets the value of the control XPRSconstants.SLPAUGMENTATION. Bit map describing the SLP augmentation method(s) to be used

      • getSlpBarLimit

        public int getSlpBarLimit()
        Retrieves the value of the control XPRSconstants.SLPBARLIMIT. Number of initial SLP iterations using the barrier method

      • setSlpBarLimit

        public void setSlpBarLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPBARLIMIT. Number of initial SLP iterations using the barrier method

      • getSlpCascade

        public int getSlpCascade()
        Retrieves the value of the control XPRSconstants.SLPCASCADE. Bit map describing the cascading to be used

      • setSlpCascade

        public void setSlpCascade​(int newval)
        Sets the value of the control XPRSconstants.SLPCASCADE. Bit map describing the cascading to be used

      • getSlpCascadeNLimit

        public int getSlpCascadeNLimit()
        Retrieves the value of the control XPRSconstants.SLPCASCADENLIMIT. Maximum number of iterations for cascading with non-linear determining rows

      • setSlpCascadeNLimit

        public void setSlpCascadeNLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPCASCADENLIMIT. Maximum number of iterations for cascading with non-linear determining rows

      • getSlpDampStart

        public int getSlpDampStart()
        Retrieves the value of the control XPRSconstants.SLPDAMPSTART. SLP iteration at which damping is activated

      • setSlpDampStart

        public void setSlpDampStart​(int newval)
        Sets the value of the control XPRSconstants.SLPDAMPSTART. SLP iteration at which damping is activated

      • getSlpCutStrategy

        public int getSlpCutStrategy()
        Retrieves the value of the control XPRSconstants.SLPCUTSTRATEGY. Determines whihc cuts to apply in the MISLP search when the default SLP-in-MIP strategy is used.

      • setSlpCutStrategy

        public void setSlpCutStrategy​(int newval)
        Sets the value of the control XPRSconstants.SLPCUTSTRATEGY. Determines whihc cuts to apply in the MISLP search when the default SLP-in-MIP strategy is used.

      • getSlpDeltaZLimit

        public int getSlpDeltaZLimit()
        Retrieves the value of the control XPRSconstants.SLPDELTAZLIMIT. Number of SLP iterations during which to apply XSLP_DELTA_Z

      • setSlpDeltaZLimit

        public void setSlpDeltaZLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPDELTAZLIMIT. Number of SLP iterations during which to apply XSLP_DELTA_Z

      • getSlpInfeasLimit

        public int getSlpInfeasLimit()
        Retrieves the value of the control XPRSconstants.SLPINFEASLIMIT. The maximum number of consecutive infeasible SLP iterations which can occur before Xpress-SLP terminates

      • setSlpInfeasLimit

        public void setSlpInfeasLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPINFEASLIMIT. The maximum number of consecutive infeasible SLP iterations which can occur before Xpress-SLP terminates

      • getSlpIterLimit

        public int getSlpIterLimit()
        Retrieves the value of the control XPRSconstants.SLPITERLIMIT. The maximum number of SLP iterations

      • setSlpIterLimit

        public void setSlpIterLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPITERLIMIT. The maximum number of SLP iterations

      • getSlpSameCount

        public int getSlpSameCount()
        Retrieves the value of the control XPRSconstants.SLPSAMECOUNT. Number of steps reaching the step bound in the same direction before step bounds are increased

      • setSlpSameCount

        public void setSlpSameCount​(int newval)
        Sets the value of the control XPRSconstants.SLPSAMECOUNT. Number of steps reaching the step bound in the same direction before step bounds are increased

      • getSlpSameDamp

        public int getSlpSameDamp()
        Retrieves the value of the control XPRSconstants.SLPSAMEDAMP. Number of steps in same direction before damping factor is increased

      • setSlpSameDamp

        public void setSlpSameDamp​(int newval)
        Sets the value of the control XPRSconstants.SLPSAMEDAMP. Number of steps in same direction before damping factor is increased

      • getSlpSBStart

        public int getSlpSBStart()
        Retrieves the value of the control XPRSconstants.SLPSBSTART. SLP iteration after which step bounds are first applied

      • setSlpSBStart

        public void setSlpSBStart​(int newval)
        Sets the value of the control XPRSconstants.SLPSBSTART. SLP iteration after which step bounds are first applied

      • getSlpXCount

        public int getSlpXCount()
        Retrieves the value of the control XPRSconstants.SLPXCOUNT. Number of SLP iterations over which to measure static objective (1) convergence

      • setSlpXCount

        public void setSlpXCount​(int newval)
        Sets the value of the control XPRSconstants.SLPXCOUNT. Number of SLP iterations over which to measure static objective (1) convergence

      • getSlpXLimit

        public int getSlpXLimit()
        Retrieves the value of the control XPRSconstants.SLPXLIMIT. Number of SLP iterations up to which static objective (1) convergence testing starts

      • setSlpXLimit

        public void setSlpXLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPXLIMIT. Number of SLP iterations up to which static objective (1) convergence testing starts

      • getSlpDelayUpdateRows

        public int getSlpDelayUpdateRows()
        Retrieves the value of the control XPRSconstants.SLPDELAYUPDATEROWS. Number of SLP iterations before update rows are fully activated

      • setSlpDelayUpdateRows

        public void setSlpDelayUpdateRows​(int newval)
        Sets the value of the control XPRSconstants.SLPDELAYUPDATEROWS. Number of SLP iterations before update rows are fully activated

      • getSlpAutoSave

        public int getSlpAutoSave()
        Retrieves the value of the control XPRSconstants.SLPAUTOSAVE. Frequency with which to save the model

      • setSlpAutoSave

        public void setSlpAutoSave​(int newval)
        Sets the value of the control XPRSconstants.SLPAUTOSAVE. Frequency with which to save the model

      • getSlpAnalyze

        public int getSlpAnalyze()
        Retrieves the value of the control XPRSconstants.SLPANALYZE. Bit map activating additional options supporting model / solution path analyzis

      • setSlpAnalyze

        public void setSlpAnalyze​(int newval)
        Sets the value of the control XPRSconstants.SLPANALYZE. Bit map activating additional options supporting model / solution path analyzis

      • getSlpOCount

        public int getSlpOCount()
        Retrieves the value of the control XPRSconstants.SLPOCOUNT. Number of SLP iterations over which to measure objective function variation for static objective (2) convergence criterion

      • setSlpOCount

        public void setSlpOCount​(int newval)
        Sets the value of the control XPRSconstants.SLPOCOUNT. Number of SLP iterations over which to measure objective function variation for static objective (2) convergence criterion

      • getSlpMipAlgorithm

        public int getSlpMipAlgorithm()
        Retrieves the value of the control XPRSconstants.SLPMIPALGORITHM. Bitmap describing the MISLP algorithms to be used

      • setSlpMipAlgorithm

        public void setSlpMipAlgorithm​(int newval)
        Sets the value of the control XPRSconstants.SLPMIPALGORITHM. Bitmap describing the MISLP algorithms to be used

      • getSlpMipRelaxStepBounds

        public int getSlpMipRelaxStepBounds()
        Retrieves the value of the control XPRSconstants.SLPMIPRELAXSTEPBOUNDS. Bitmap describing the step-bound relaxation strategy during MISLP

      • setSlpMipRelaxStepBounds

        public void setSlpMipRelaxStepBounds​(int newval)
        Sets the value of the control XPRSconstants.SLPMIPRELAXSTEPBOUNDS. Bitmap describing the step-bound relaxation strategy during MISLP

      • getSlpMipFixStepBounds

        public int getSlpMipFixStepBounds()
        Retrieves the value of the control XPRSconstants.SLPMIPFIXSTEPBOUNDS. Bitmap describing the step-bound fixing strategy during MISLP

      • setSlpMipFixStepBounds

        public void setSlpMipFixStepBounds​(int newval)
        Sets the value of the control XPRSconstants.SLPMIPFIXSTEPBOUNDS. Bitmap describing the step-bound fixing strategy during MISLP

      • getSlpMipIterLimit

        public int getSlpMipIterLimit()
        Retrieves the value of the control XPRSconstants.SLPMIPITERLIMIT. Maximum number of SLP iterations at each node

      • setSlpMipIterLimit

        public void setSlpMipIterLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPMIPITERLIMIT. Maximum number of SLP iterations at each node

      • getSlpMipCutoffLimit

        public int getSlpMipCutoffLimit()
        Retrieves the value of the control XPRSconstants.SLPMIPCUTOFFLIMIT. Number of SLP iterations to check when considering a node for cutting off

      • setSlpMipCutoffLimit

        public void setSlpMipCutoffLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPMIPCUTOFFLIMIT. Number of SLP iterations to check when considering a node for cutting off

      • getSlpMipOCount

        public int getSlpMipOCount()
        Retrieves the value of the control XPRSconstants.SLPMIPOCOUNT. Number of SLP iterations at each node over which to measure objective function variation

      • setSlpMipOCount

        public void setSlpMipOCount​(int newval)
        Sets the value of the control XPRSconstants.SLPMIPOCOUNT. Number of SLP iterations at each node over which to measure objective function variation

      • getSlpMipDefaultAlgorithm

        public int getSlpMipDefaultAlgorithm()
        Retrieves the value of the control XPRSconstants.SLPMIPDEFAULTALGORITHM. Default algorithm to be used during the tree search in MISLP

      • setSlpMipDefaultAlgorithm

        public void setSlpMipDefaultAlgorithm​(int newval)
        Sets the value of the control XPRSconstants.SLPMIPDEFAULTALGORITHM. Default algorithm to be used during the tree search in MISLP

      • getSlpMipLog

        public int getSlpMipLog()
        Retrieves the value of the control XPRSconstants.SLPMIPLOG. Frequency with which MIP status is printed

      • setSlpMipLog

        public void setSlpMipLog​(int newval)
        Sets the value of the control XPRSconstants.SLPMIPLOG. Frequency with which MIP status is printed

      • getSlpDeltaOffset

        public int getSlpDeltaOffset()
        Retrieves the value of the control XPRSconstants.SLPDELTAOFFSET. Position of first character of SLP variable name used to create name of delta vector

      • setSlpDeltaOffset

        public void setSlpDeltaOffset​(int newval)
        Sets the value of the control XPRSconstants.SLPDELTAOFFSET. Position of first character of SLP variable name used to create name of delta vector

      • getSlpUpdateOffset

        public int getSlpUpdateOffset()
        Retrieves the value of the control XPRSconstants.SLPUPDATEOFFSET. Position of first character of SLP variable name used to create name of SLP update row

      • setSlpUpdateOffset

        public void setSlpUpdateOffset​(int newval)
        Sets the value of the control XPRSconstants.SLPUPDATEOFFSET. Position of first character of SLP variable name used to create name of SLP update row

      • getSlpErrorOffset

        public int getSlpErrorOffset()
        Retrieves the value of the control XPRSconstants.SLPERROROFFSET. Position of first character of constraint name used to create name of penalty error vectors

      • setSlpErrorOffset

        public void setSlpErrorOffset​(int newval)
        Sets the value of the control XPRSconstants.SLPERROROFFSET. Position of first character of constraint name used to create name of penalty error vectors

      • getSlpSBRowOffset

        public int getSlpSBRowOffset()
        Retrieves the value of the control XPRSconstants.SLPSBROWOFFSET. Position of first character of SLP variable name used to create name of SLP lower and upper step bound rows

      • setSlpSBRowOffset

        public void setSlpSBRowOffset​(int newval)
        Sets the value of the control XPRSconstants.SLPSBROWOFFSET. Position of first character of SLP variable name used to create name of SLP lower and upper step bound rows

      • getSlpVCount

        public int getSlpVCount()
        Retrieves the value of the control XPRSconstants.SLPVCOUNT. Number of SLP iterations over which to measure static objective (3) convergence

      • setSlpVCount

        public void setSlpVCount​(int newval)
        Sets the value of the control XPRSconstants.SLPVCOUNT. Number of SLP iterations over which to measure static objective (3) convergence

      • getSlpVLimit

        public int getSlpVLimit()
        Retrieves the value of the control XPRSconstants.SLPVLIMIT. Number of SLP iterations after which static objective (3) convergence testing starts

      • setSlpVLimit

        public void setSlpVLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPVLIMIT. Number of SLP iterations after which static objective (3) convergence testing starts

      • getSlpECFCheck

        public int getSlpECFCheck()
        Retrieves the value of the control XPRSconstants.SLPECFCHECK. Check feasibility at the point of linearization for extended convergence criteria

      • setSlpECFCheck

        public void setSlpECFCheck​(int newval)
        Sets the value of the control XPRSconstants.SLPECFCHECK. Check feasibility at the point of linearization for extended convergence criteria

      • getSlpMipCutOffCount

        public int getSlpMipCutOffCount()
        Retrieves the value of the control XPRSconstants.SLPMIPCUTOFFCOUNT. Number of SLP iterations to check when considering a node for cutting off

      • setSlpMipCutOffCount

        public void setSlpMipCutOffCount​(int newval)
        Sets the value of the control XPRSconstants.SLPMIPCUTOFFCOUNT. Number of SLP iterations to check when considering a node for cutting off

      • getSlpWCount

        public int getSlpWCount()
        Retrieves the value of the control XPRSconstants.SLPWCOUNT. Number of SLP iterations over which to measure the objective for the extended convergence continuation criterion

      • setSlpWCount

        public void setSlpWCount​(int newval)
        Sets the value of the control XPRSconstants.SLPWCOUNT. Number of SLP iterations over which to measure the objective for the extended convergence continuation criterion

      • getSlpUnFinishedLimit

        public int getSlpUnFinishedLimit()
        Retrieves the value of the control XPRSconstants.SLPUNFINISHEDLIMIT. The number of consecutive SLP iterations that may have an unfinished status before the solve is terminated.

      • setSlpUnFinishedLimit

        public void setSlpUnFinishedLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPUNFINISHEDLIMIT. The number of consecutive SLP iterations that may have an unfinished status before the solve is terminated.

      • getSlpConvergenceOps

        public int getSlpConvergenceOps()
        Retrieves the value of the control XPRSconstants.SLPCONVERGENCEOPS. Bit map describing which convergence tests should be carried out

      • setSlpConvergenceOps

        public void setSlpConvergenceOps​(int newval)
        Sets the value of the control XPRSconstants.SLPCONVERGENCEOPS. Bit map describing which convergence tests should be carried out

      • getSlpZeroCriterion

        public int getSlpZeroCriterion()
        Retrieves the value of the control XPRSconstants.SLPZEROCRITERION. Bitmap determining the behavior of the placeholder deletion procedure

      • setSlpZeroCriterion

        public void setSlpZeroCriterion​(int newval)
        Sets the value of the control XPRSconstants.SLPZEROCRITERION. Bitmap determining the behavior of the placeholder deletion procedure

      • getSlpZeroCriterionStart

        public int getSlpZeroCriterionStart()
        Retrieves the value of the control XPRSconstants.SLPZEROCRITERIONSTART. SLP iteration at which criteria for deletion of placeholder entries are first activated.

      • setSlpZeroCriterionStart

        public void setSlpZeroCriterionStart​(int newval)
        Sets the value of the control XPRSconstants.SLPZEROCRITERIONSTART. SLP iteration at which criteria for deletion of placeholder entries are first activated.

      • getSlpZeroCriterionCount

        public int getSlpZeroCriterionCount()
        Retrieves the value of the control XPRSconstants.SLPZEROCRITERIONCOUNT. Number of consecutive times a placeholder entry is zero before being considered for deletion

      • setSlpZeroCriterionCount

        public void setSlpZeroCriterionCount​(int newval)
        Sets the value of the control XPRSconstants.SLPZEROCRITERIONCOUNT. Number of consecutive times a placeholder entry is zero before being considered for deletion

      • getSlpLSPatternLimit

        public int getSlpLSPatternLimit()
        Retrieves the value of the control XPRSconstants.SLPLSPATTERNLIMIT. Number of iterations in the pattern search preceding the line search

      • setSlpLSPatternLimit

        public void setSlpLSPatternLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPLSPATTERNLIMIT. Number of iterations in the pattern search preceding the line search

      • getSlpLSIterLimit

        public int getSlpLSIterLimit()
        Retrieves the value of the control XPRSconstants.SLPLSITERLIMIT. Number of iterations in the line search

      • setSlpLSIterLimit

        public void setSlpLSIterLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPLSITERLIMIT. Number of iterations in the line search

      • getSlpLSStart

        public int getSlpLSStart()
        Retrieves the value of the control XPRSconstants.SLPLSSTART. Iteration in which to active the line search

      • setSlpLSStart

        public void setSlpLSStart​(int newval)
        Sets the value of the control XPRSconstants.SLPLSSTART. Iteration in which to active the line search

      • getSlpPenaltyInfoStart

        public int getSlpPenaltyInfoStart()
        Retrieves the value of the control XPRSconstants.SLPPENALTYINFOSTART. Iteration from which to record row penalty information

      • setSlpPenaltyInfoStart

        public void setSlpPenaltyInfoStart​(int newval)
        Sets the value of the control XPRSconstants.SLPPENALTYINFOSTART. Iteration from which to record row penalty information

      • getSlpFilter

        public int getSlpFilter()
        Retrieves the value of the control XPRSconstants.SLPFILTER. Bit map for controlling solution updates

      • setSlpFilter

        public void setSlpFilter​(int newval)
        Sets the value of the control XPRSconstants.SLPFILTER. Bit map for controlling solution updates

      • getSlpTraceMaskOps

        public int getSlpTraceMaskOps()
        Retrieves the value of the control XPRSconstants.SLPTRACEMASKOPS. Controls the information printed for XSLP_TRACEMASK. The order in which the information is printed is determined by the order of bits in XSLP_TRACEMASKOPS.

      • setSlpTraceMaskOps

        public void setSlpTraceMaskOps​(int newval)
        Sets the value of the control XPRSconstants.SLPTRACEMASKOPS. Controls the information printed for XSLP_TRACEMASK. The order in which the information is printed is determined by the order of bits in XSLP_TRACEMASKOPS.

      • getSlpLSZeroLimit

        public int getSlpLSZeroLimit()
        Retrieves the value of the control XPRSconstants.SLPLSZEROLIMIT. Maximum number of zero length line search steps before line search is deactivated

      • setSlpLSZeroLimit

        public void setSlpLSZeroLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPLSZEROLIMIT. Maximum number of zero length line search steps before line search is deactivated

      • getSlpHeurStrategy

        public int getSlpHeurStrategy()
        Retrieves the value of the control XPRSconstants.SLPHEURSTRATEGY. Branch and Bound: This specifies the MINLP heuristic strategy. On some problems it is worth trying more comprehensive heuristic strategies by setting HEURSTRATEGY to 2 or 3.

      • setSlpHeurStrategy

        public void setSlpHeurStrategy​(int newval)
        Sets the value of the control XPRSconstants.SLPHEURSTRATEGY. Branch and Bound: This specifies the MINLP heuristic strategy. On some problems it is worth trying more comprehensive heuristic strategies by setting HEURSTRATEGY to 2 or 3.

      • getSlpBarCrossoverStart

        public int getSlpBarCrossoverStart()
        Retrieves the value of the control XPRSconstants.SLPBARCROSSOVERSTART. Default crossover activation behaviour for barrier start

      • setSlpBarCrossoverStart

        public void setSlpBarCrossoverStart​(int newval)
        Sets the value of the control XPRSconstants.SLPBARCROSSOVERSTART. Default crossover activation behaviour for barrier start

      • getSlpBarStallingLimit

        public int getSlpBarStallingLimit()
        Retrieves the value of the control XPRSconstants.SLPBARSTALLINGLIMIT. Number of iterations to allow numerical failures in barrier before switching to dual

      • setSlpBarStallingLimit

        public void setSlpBarStallingLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPBARSTALLINGLIMIT. Number of iterations to allow numerical failures in barrier before switching to dual

      • getSlpBarStallingObjLimit

        public int getSlpBarStallingObjLimit()
        Retrieves the value of the control XPRSconstants.SLPBARSTALLINGOBJLIMIT. Number of iterations over which to measure the objective change for barrier iterations with no crossover

      • setSlpBarStallingObjLimit

        public void setSlpBarStallingObjLimit​(int newval)
        Sets the value of the control XPRSconstants.SLPBARSTALLINGOBJLIMIT. Number of iterations over which to measure the objective change for barrier iterations with no crossover

      • getSlpBarStartOps

        public int getSlpBarStartOps()
        Retrieves the value of the control XPRSconstants.SLPBARSTARTOPS. Controls behaviour when the barrier is used to solve the linearizations

      • setSlpBarStartOps

        public void setSlpBarStartOps​(int newval)
        Sets the value of the control XPRSconstants.SLPBARSTARTOPS. Controls behaviour when the barrier is used to solve the linearizations

      • getSlpGridHeurSelect

        public int getSlpGridHeurSelect()
        Retrieves the value of the control XPRSconstants.SLPGRIDHEURSELECT. Bit map selectin which heuristics to run if the problem has variable with an integer delta

      • setSlpGridHeurSelect

        public void setSlpGridHeurSelect​(int newval)
        Sets the value of the control XPRSconstants.SLPGRIDHEURSELECT. Bit map selectin which heuristics to run if the problem has variable with an integer delta

      • getNlpInfinity

        public double getNlpInfinity()
        Retrieves the value of the control XPRSconstants.NLPINFINITY. Value returned by a divide-by-zero in a formula

      • setNlpInfinity

        public void setNlpInfinity​(double newval)
        Sets the value of the control XPRSconstants.NLPINFINITY. Value returned by a divide-by-zero in a formula

      • getNlpZero

        public double getNlpZero()
        Retrieves the value of the control XPRSconstants.NLPZERO. Absolute tolerance

      • setNlpZero

        public void setNlpZero​(double newval)
        Sets the value of the control XPRSconstants.NLPZERO. Absolute tolerance

      • resetNlpZero

        public void resetNlpZero()
        Resets to its default the value of control XPRSconstants.NLPZERO

      • getNlpDefaultIV

        public double getNlpDefaultIV()
        Retrieves the value of the control XPRSconstants.NLPDEFAULTIV. Default initial value for an SLP variable if none is explicitly given

      • setNlpDefaultIV

        public void setNlpDefaultIV​(double newval)
        Sets the value of the control XPRSconstants.NLPDEFAULTIV. Default initial value for an SLP variable if none is explicitly given

      • getNlpValidationTol_A

        public double getNlpValidationTol_A()
        Retrieves the value of the control XPRSconstants.NLPVALIDATIONTOL_A. Absolute tolerance for the XSLPvalidate procedure

      • setNlpValidationTol_A

        public void setNlpValidationTol_A​(double newval)
        Sets the value of the control XPRSconstants.NLPVALIDATIONTOL_A. Absolute tolerance for the XSLPvalidate procedure

      • getNlpValidationTol_R

        public double getNlpValidationTol_R()
        Retrieves the value of the control XPRSconstants.NLPVALIDATIONTOL_R. Relative tolerance for the XSLPvalidate procedure

      • setNlpValidationTol_R

        public void setNlpValidationTol_R​(double newval)
        Sets the value of the control XPRSconstants.NLPVALIDATIONTOL_R. Relative tolerance for the XSLPvalidate procedure

      • getNlpPrimalIntegralRef

        public double getNlpPrimalIntegralRef()
        Retrieves the value of the control XPRSconstants.NLPPRIMALINTEGRALREF. Reference solution value to take into account when calculating the primal integral

      • setNlpPrimalIntegralRef

        public void setNlpPrimalIntegralRef​(double newval)
        Sets the value of the control XPRSconstants.NLPPRIMALINTEGRALREF. Reference solution value to take into account when calculating the primal integral

      • getNlpPrimalIntegralAlpha

        public double getNlpPrimalIntegralAlpha()
        Retrieves the value of the control XPRSconstants.NLPPRIMALINTEGRALALPHA. Decay term for primal integral computation

      • setNlpPrimalIntegralAlpha

        public void setNlpPrimalIntegralAlpha​(double newval)
        Sets the value of the control XPRSconstants.NLPPRIMALINTEGRALALPHA. Decay term for primal integral computation

      • getNlpPresolveZero

        public double getNlpPresolveZero()
        Retrieves the value of the control XPRSconstants.NLPPRESOLVEZERO. Minimum absolute value for a variable which is identified as nonzero during SLP presolve

      • setNlpPresolveZero

        public void setNlpPresolveZero​(double newval)
        Sets the value of the control XPRSconstants.NLPPRESOLVEZERO. Minimum absolute value for a variable which is identified as nonzero during SLP presolve

      • getNlpMeritLambda

        public double getNlpMeritLambda()
        Retrieves the value of the control XPRSconstants.NLPMERITLAMBDA. Factor by which the net objective is taken into account in the merit function

      • setNlpMeritLambda

        public void setNlpMeritLambda​(double newval)
        Sets the value of the control XPRSconstants.NLPMERITLAMBDA. Factor by which the net objective is taken into account in the merit function

      • getMsMaxBoundRange

        public double getMsMaxBoundRange()
        Retrieves the value of the control XPRSconstants.MSMAXBOUNDRANGE. Defines the maximum range inside which initial points are generated by multistart presets

      • setMsMaxBoundRange

        public void setMsMaxBoundRange​(double newval)
        Sets the value of the control XPRSconstants.MSMAXBOUNDRANGE. Defines the maximum range inside which initial points are generated by multistart presets

      • getNlpValidationTol_K

        public double getNlpValidationTol_K()
        Retrieves the value of the control XPRSconstants.NLPVALIDATIONTOL_K. Relative tolerance for the XSLPvalidatekkt procedure

      • setNlpValidationTol_K

        public void setNlpValidationTol_K​(double newval)
        Sets the value of the control XPRSconstants.NLPVALIDATIONTOL_K. Relative tolerance for the XSLPvalidatekkt procedure

      • getNlpPresolve_ElimTol

        public double getNlpPresolve_ElimTol()
        Retrieves the value of the control XPRSconstants.NLPPRESOLVE_ELIMTOL. Tolerance for nonlinear eliminations during SLP presolve

      • setNlpPresolve_ElimTol

        public void setNlpPresolve_ElimTol​(double newval)
        Sets the value of the control XPRSconstants.NLPPRESOLVE_ELIMTOL. Tolerance for nonlinear eliminations during SLP presolve

      • setNlpValidationTarget_R

        public void setNlpValidationTarget_R​(double newval)
        Sets the value of the control XPRSconstants.NLPVALIDATIONTARGET_R. Feasiblity target tolerance

      • setNlpValidationTarget_K

        public void setNlpValidationTarget_K​(double newval)
        Sets the value of the control XPRSconstants.NLPVALIDATIONTARGET_K. Optimality target tolerance

      • getNlpValidationFactor

        public double getNlpValidationFactor()
        Retrieves the value of the control XPRSconstants.NLPVALIDATIONFACTOR. Minimum improvement in validation targets to continue iterating

      • setNlpValidationFactor

        public void setNlpValidationFactor​(double newval)
        Sets the value of the control XPRSconstants.NLPVALIDATIONFACTOR. Minimum improvement in validation targets to continue iterating

      • getSlpDamp

        public double getSlpDamp()
        Retrieves the value of the control XPRSconstants.SLPDAMP. Damping factor for updating values of variables

      • setSlpDamp

        public void setSlpDamp​(double newval)
        Sets the value of the control XPRSconstants.SLPDAMP. Damping factor for updating values of variables

      • resetSlpDamp

        public void resetSlpDamp()
        Resets to its default the value of control XPRSconstants.SLPDAMP

      • getSlpDampExpand

        public double getSlpDampExpand()
        Retrieves the value of the control XPRSconstants.SLPDAMPEXPAND. Multiplier to increase damping factor during dynamic damping

      • setSlpDampExpand

        public void setSlpDampExpand​(double newval)
        Sets the value of the control XPRSconstants.SLPDAMPEXPAND. Multiplier to increase damping factor during dynamic damping

      • getSlpDampShrink

        public double getSlpDampShrink()
        Retrieves the value of the control XPRSconstants.SLPDAMPSHRINK. Multiplier to decrease damping factor during dynamic damping

      • setSlpDampShrink

        public void setSlpDampShrink​(double newval)
        Sets the value of the control XPRSconstants.SLPDAMPSHRINK. Multiplier to decrease damping factor during dynamic damping

      • getSlpDelta_A

        public double getSlpDelta_A()
        Retrieves the value of the control XPRSconstants.SLPDELTA_A. Absolute perturbation of values for calculating numerical derivatives

      • setSlpDelta_A

        public void setSlpDelta_A​(double newval)
        Sets the value of the control XPRSconstants.SLPDELTA_A. Absolute perturbation of values for calculating numerical derivatives

      • getSlpDelta_R

        public double getSlpDelta_R()
        Retrieves the value of the control XPRSconstants.SLPDELTA_R. Relative perturbation of values for calculating numerical derivatives

      • setSlpDelta_R

        public void setSlpDelta_R​(double newval)
        Sets the value of the control XPRSconstants.SLPDELTA_R. Relative perturbation of values for calculating numerical derivatives

      • getSlpDelta_Z

        public double getSlpDelta_Z()
        Retrieves the value of the control XPRSconstants.SLPDELTA_Z. Tolerance used when calculating derivatives

      • setSlpDelta_Z

        public void setSlpDelta_Z​(double newval)
        Sets the value of the control XPRSconstants.SLPDELTA_Z. Tolerance used when calculating derivatives

      • getSlpDeltaCost

        public double getSlpDeltaCost()
        Retrieves the value of the control XPRSconstants.SLPDELTACOST. Initial penalty cost multiplier for penalty delta vectors

      • setSlpDeltaCost

        public void setSlpDeltaCost​(double newval)
        Sets the value of the control XPRSconstants.SLPDELTACOST. Initial penalty cost multiplier for penalty delta vectors

      • getSlpDeltaMaxCost

        public double getSlpDeltaMaxCost()
        Retrieves the value of the control XPRSconstants.SLPDELTAMAXCOST. Maximum penalty cost multiplier for penalty delta vectors

      • setSlpDeltaMaxCost

        public void setSlpDeltaMaxCost​(double newval)
        Sets the value of the control XPRSconstants.SLPDELTAMAXCOST. Maximum penalty cost multiplier for penalty delta vectors

      • getSlpDJTol

        public double getSlpDJTol()
        Retrieves the value of the control XPRSconstants.SLPDJTOL. Tolerance on DJ value for determining if a variable is at its step bound

      • setSlpDJTol

        public void setSlpDJTol​(double newval)
        Sets the value of the control XPRSconstants.SLPDJTOL. Tolerance on DJ value for determining if a variable is at its step bound

      • resetSlpDJTol

        public void resetSlpDJTol()
        Resets to its default the value of control XPRSconstants.SLPDJTOL

      • getSlpErrorCost

        public double getSlpErrorCost()
        Retrieves the value of the control XPRSconstants.SLPERRORCOST. Initial penalty cost multiplier for penalty error vectors

      • setSlpErrorCost

        public void setSlpErrorCost​(double newval)
        Sets the value of the control XPRSconstants.SLPERRORCOST. Initial penalty cost multiplier for penalty error vectors

      • getSlpErrorMaxCost

        public double getSlpErrorMaxCost()
        Retrieves the value of the control XPRSconstants.SLPERRORMAXCOST. Maximum penalty cost multiplier for penalty error vectors

      • setSlpErrorMaxCost

        public void setSlpErrorMaxCost​(double newval)
        Sets the value of the control XPRSconstants.SLPERRORMAXCOST. Maximum penalty cost multiplier for penalty error vectors

      • getSlpErrorTol_A

        public double getSlpErrorTol_A()
        Retrieves the value of the control XPRSconstants.SLPERRORTOL_A. Absolute tolerance for error vectors

      • setSlpErrorTol_A

        public void setSlpErrorTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPERRORTOL_A. Absolute tolerance for error vectors

      • getSlpExpand

        public double getSlpExpand()
        Retrieves the value of the control XPRSconstants.SLPEXPAND. Multiplier to increase a step bound

      • setSlpExpand

        public void setSlpExpand​(double newval)
        Sets the value of the control XPRSconstants.SLPEXPAND. Multiplier to increase a step bound

      • getSlpMaxWeight

        public double getSlpMaxWeight()
        Retrieves the value of the control XPRSconstants.SLPMAXWEIGHT. Maximum penalty weight for delta or error vectors

      • setSlpMaxWeight

        public void setSlpMaxWeight​(double newval)
        Sets the value of the control XPRSconstants.SLPMAXWEIGHT. Maximum penalty weight for delta or error vectors

      • getSlpMinWeight

        public double getSlpMinWeight()
        Retrieves the value of the control XPRSconstants.SLPMINWEIGHT. Minimum penalty weight for delta or error vectors

      • setSlpMinWeight

        public void setSlpMinWeight​(double newval)
        Sets the value of the control XPRSconstants.SLPMINWEIGHT. Minimum penalty weight for delta or error vectors

      • getSlpShrink

        public double getSlpShrink()
        Retrieves the value of the control XPRSconstants.SLPSHRINK. Multiplier to reduce a step bound

      • setSlpShrink

        public void setSlpShrink​(double newval)
        Sets the value of the control XPRSconstants.SLPSHRINK. Multiplier to reduce a step bound

      • getSlpCTol

        public double getSlpCTol()
        Retrieves the value of the control XPRSconstants.SLPCTOL. Closure convergence tolerance

      • setSlpCTol

        public void setSlpCTol​(double newval)
        Sets the value of the control XPRSconstants.SLPCTOL. Closure convergence tolerance

      • resetSlpCTol

        public void resetSlpCTol()
        Resets to its default the value of control XPRSconstants.SLPCTOL

      • getSlpATol_A

        public double getSlpATol_A()
        Retrieves the value of the control XPRSconstants.SLPATOL_A. Absolute delta convergence tolerance

      • setSlpATol_A

        public void setSlpATol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPATOL_A. Absolute delta convergence tolerance

      • getSlpATol_R

        public double getSlpATol_R()
        Retrieves the value of the control XPRSconstants.SLPATOL_R. Relative delta convergence tolerance

      • setSlpATol_R

        public void setSlpATol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPATOL_R. Relative delta convergence tolerance

      • getSlpMTol_A

        public double getSlpMTol_A()
        Retrieves the value of the control XPRSconstants.SLPMTOL_A. Absolute effective matrix element convergence tolerance

      • setSlpMTol_A

        public void setSlpMTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPMTOL_A. Absolute effective matrix element convergence tolerance

      • getSlpMTol_R

        public double getSlpMTol_R()
        Retrieves the value of the control XPRSconstants.SLPMTOL_R. Relative effective matrix element convergence tolerance

      • setSlpMTol_R

        public void setSlpMTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPMTOL_R. Relative effective matrix element convergence tolerance

      • getSlpItol_A

        public double getSlpItol_A()
        Retrieves the value of the control XPRSconstants.SLPITOL_A. Absolute impact convergence tolerance

      • setSlpItol_A

        public void setSlpItol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPITOL_A. Absolute impact convergence tolerance

      • getSlpITol_R

        public double getSlpITol_R()
        Retrieves the value of the control XPRSconstants.SLPITOL_R. Relative impact convergence tolerance

      • setSlpITol_R

        public void setSlpITol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPITOL_R. Relative impact convergence tolerance

      • getSlpSTol_A

        public double getSlpSTol_A()
        Retrieves the value of the control XPRSconstants.SLPSTOL_A. Absolute slack convergence tolerance

      • setSlpSTol_A

        public void setSlpSTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPSTOL_A. Absolute slack convergence tolerance

      • getSlpSTol_R

        public double getSlpSTol_R()
        Retrieves the value of the control XPRSconstants.SLPSTOL_R. Relative slack convergence tolerance

      • setSlpSTol_R

        public void setSlpSTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPSTOL_R. Relative slack convergence tolerance

      • getSlpMVTol

        public double getSlpMVTol()
        Retrieves the value of the control XPRSconstants.SLPMVTOL. Marginal value tolerance for determining if a constraint is slack

      • setSlpMVTol

        public void setSlpMVTol​(double newval)
        Sets the value of the control XPRSconstants.SLPMVTOL. Marginal value tolerance for determining if a constraint is slack

      • resetSlpMVTol

        public void resetSlpMVTol()
        Resets to its default the value of control XPRSconstants.SLPMVTOL

      • getSlpXTol_A

        public double getSlpXTol_A()
        Retrieves the value of the control XPRSconstants.SLPXTOL_A. Absolute static objective function (1) tolerance

      • setSlpXTol_A

        public void setSlpXTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPXTOL_A. Absolute static objective function (1) tolerance

      • getSlpXTol_R

        public double getSlpXTol_R()
        Retrieves the value of the control XPRSconstants.SLPXTOL_R. Relative static objective function (1) tolerance

      • setSlpXTol_R

        public void setSlpXTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPXTOL_R. Relative static objective function (1) tolerance

      • getSlpDefaultStepBound

        public double getSlpDefaultStepBound()
        Retrieves the value of the control XPRSconstants.SLPDEFAULTSTEPBOUND. Minimum initial value for the step bound of an SLP variable if none is explicitly given

      • setSlpDefaultStepBound

        public void setSlpDefaultStepBound​(double newval)
        Sets the value of the control XPRSconstants.SLPDEFAULTSTEPBOUND. Minimum initial value for the step bound of an SLP variable if none is explicitly given

      • getSlpDampMax

        public double getSlpDampMax()
        Retrieves the value of the control XPRSconstants.SLPDAMPMAX. Maximum value for the damping factor of a variable during dynamic damping

      • setSlpDampMax

        public void setSlpDampMax​(double newval)
        Sets the value of the control XPRSconstants.SLPDAMPMAX. Maximum value for the damping factor of a variable during dynamic damping

      • getSlpDampMin

        public double getSlpDampMin()
        Retrieves the value of the control XPRSconstants.SLPDAMPMIN. Minimum value for the damping factor of a variable during dynamic damping

      • setSlpDampMin

        public void setSlpDampMin​(double newval)
        Sets the value of the control XPRSconstants.SLPDAMPMIN. Minimum value for the damping factor of a variable during dynamic damping

      • getSlpDeltaCostFactor

        public double getSlpDeltaCostFactor()
        Retrieves the value of the control XPRSconstants.SLPDELTACOSTFACTOR. Factor for increasing cost multiplier on total penalty delta vectors

      • setSlpDeltaCostFactor

        public void setSlpDeltaCostFactor​(double newval)
        Sets the value of the control XPRSconstants.SLPDELTACOSTFACTOR. Factor for increasing cost multiplier on total penalty delta vectors

      • getSlpErrorCostFactor

        public double getSlpErrorCostFactor()
        Retrieves the value of the control XPRSconstants.SLPERRORCOSTFACTOR. Factor for increasing cost multiplier on total penalty error vectors

      • setSlpErrorCostFactor

        public void setSlpErrorCostFactor​(double newval)
        Sets the value of the control XPRSconstants.SLPERRORCOSTFACTOR. Factor for increasing cost multiplier on total penalty error vectors

      • getSlpErrorTol_P

        public double getSlpErrorTol_P()
        Retrieves the value of the control XPRSconstants.SLPERRORTOL_P. Absolute tolerance for printing error vectors

      • setSlpErrorTol_P

        public void setSlpErrorTol_P​(double newval)
        Sets the value of the control XPRSconstants.SLPERRORTOL_P. Absolute tolerance for printing error vectors

      • getSlpCascadeTol_PA

        public double getSlpCascadeTol_PA()
        Retrieves the value of the control XPRSconstants.SLPCASCADETOL_PA. Absolute cascading print tolerance

      • setSlpCascadeTol_PA

        public void setSlpCascadeTol_PA​(double newval)
        Sets the value of the control XPRSconstants.SLPCASCADETOL_PA. Absolute cascading print tolerance

      • getSlpCascadeTol_PR

        public double getSlpCascadeTol_PR()
        Retrieves the value of the control XPRSconstants.SLPCASCADETOL_PR. Relative cascading print tolerance

      • setSlpCascadeTol_PR

        public void setSlpCascadeTol_PR​(double newval)
        Sets the value of the control XPRSconstants.SLPCASCADETOL_PR. Relative cascading print tolerance

      • getSlpOTol_A

        public double getSlpOTol_A()
        Retrieves the value of the control XPRSconstants.SLPOTOL_A. Absolute static objective (2) convergence tolerance

      • setSlpOTol_A

        public void setSlpOTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPOTOL_A. Absolute static objective (2) convergence tolerance

      • getSlpOTol_R

        public double getSlpOTol_R()
        Retrieves the value of the control XPRSconstants.SLPOTOL_R. Relative static objective (2) convergence tolerance

      • setSlpOTol_R

        public void setSlpOTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPOTOL_R. Relative static objective (2) convergence tolerance

      • getSlpDelta_X

        public double getSlpDelta_X()
        Retrieves the value of the control XPRSconstants.SLPDELTA_X. Minimum absolute value of delta coefficients to be retained

      • setSlpDelta_X

        public void setSlpDelta_X​(double newval)
        Sets the value of the control XPRSconstants.SLPDELTA_X. Minimum absolute value of delta coefficients to be retained

      • getSlpGranularity

        public double getSlpGranularity()
        Retrieves the value of the control XPRSconstants.SLPGRANULARITY. Base for calculating penalty costs

      • setSlpGranularity

        public void setSlpGranularity​(double newval)
        Sets the value of the control XPRSconstants.SLPGRANULARITY. Base for calculating penalty costs

      • getSlpMipCutoff_A

        public double getSlpMipCutoff_A()
        Retrieves the value of the control XPRSconstants.SLPMIPCUTOFF_A. Absolute objective function cutoff for MIP termination

      • setSlpMipCutoff_A

        public void setSlpMipCutoff_A​(double newval)
        Sets the value of the control XPRSconstants.SLPMIPCUTOFF_A. Absolute objective function cutoff for MIP termination

      • getSlpMipCutoff_R

        public double getSlpMipCutoff_R()
        Retrieves the value of the control XPRSconstants.SLPMIPCUTOFF_R. Absolute objective function cutoff for MIP termination

      • setSlpMipCutoff_R

        public void setSlpMipCutoff_R​(double newval)
        Sets the value of the control XPRSconstants.SLPMIPCUTOFF_R. Absolute objective function cutoff for MIP termination

      • getSlpMipOtol_A

        public double getSlpMipOtol_A()
        Retrieves the value of the control XPRSconstants.SLPMIPOTOL_A. Absolute objective function tolerance for MIP termination

      • setSlpMipOtol_A

        public void setSlpMipOtol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPMIPOTOL_A. Absolute objective function tolerance for MIP termination

      • getSlpMipOtol_R

        public double getSlpMipOtol_R()
        Retrieves the value of the control XPRSconstants.SLPMIPOTOL_R. Relative objective function tolerance for MIP termination

      • setSlpMipOtol_R

        public void setSlpMipOtol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPMIPOTOL_R. Relative objective function tolerance for MIP termination

      • getSlpEscalation

        public double getSlpEscalation()
        Retrieves the value of the control XPRSconstants.SLPESCALATION. Factor for increasing cost multiplier on individual penalty error vectors

      • setSlpEscalation

        public void setSlpEscalation​(double newval)
        Sets the value of the control XPRSconstants.SLPESCALATION. Factor for increasing cost multiplier on individual penalty error vectors

      • getSlpObjToPenaltyCost

        public double getSlpObjToPenaltyCost()
        Retrieves the value of the control XPRSconstants.SLPOBJTOPENALTYCOST. Factor to estimate initial penalty costs from objective function

      • setSlpObjToPenaltyCost

        public void setSlpObjToPenaltyCost​(double newval)
        Sets the value of the control XPRSconstants.SLPOBJTOPENALTYCOST. Factor to estimate initial penalty costs from objective function

      • getSlpShrinkBias

        public double getSlpShrinkBias()
        Retrieves the value of the control XPRSconstants.SLPSHRINKBIAS. Defines an overwrite / adjustment of step bounds for improving iterations

      • setSlpShrinkBias

        public void setSlpShrinkBias​(double newval)
        Sets the value of the control XPRSconstants.SLPSHRINKBIAS. Defines an overwrite / adjustment of step bounds for improving iterations

      • getSlpFeastolTarget

        public double getSlpFeastolTarget()
        Retrieves the value of the control XPRSconstants.SLPFEASTOLTARGET. When set, this defines a target feasibility tolerance to which the linearizations are solved to

      • setSlpFeastolTarget

        public void setSlpFeastolTarget​(double newval)
        Sets the value of the control XPRSconstants.SLPFEASTOLTARGET. When set, this defines a target feasibility tolerance to which the linearizations are solved to

      • getSlpOptimalityTolTarget

        public double getSlpOptimalityTolTarget()
        Retrieves the value of the control XPRSconstants.SLPOPTIMALITYTOLTARGET. When set, this defines a target optimality tolerance to which the linearizations are solved to

      • setSlpOptimalityTolTarget

        public void setSlpOptimalityTolTarget​(double newval)
        Sets the value of the control XPRSconstants.SLPOPTIMALITYTOLTARGET. When set, this defines a target optimality tolerance to which the linearizations are solved to

      • getSlpDelta_Infinity

        public double getSlpDelta_Infinity()
        Retrieves the value of the control XPRSconstants.SLPDELTA_INFINITY. Maximum value for partial derivatives

      • setSlpDelta_Infinity

        public void setSlpDelta_Infinity​(double newval)
        Sets the value of the control XPRSconstants.SLPDELTA_INFINITY. Maximum value for partial derivatives

      • getSlpVTol_A

        public double getSlpVTol_A()
        Retrieves the value of the control XPRSconstants.SLPVTOL_A. Absolute static objective (3) convergence tolerance

      • setSlpVTol_A

        public void setSlpVTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPVTOL_A. Absolute static objective (3) convergence tolerance

      • getSlpVTol_R

        public double getSlpVTol_R()
        Retrieves the value of the control XPRSconstants.SLPVTOL_R. Relative static objective (3) convergence tolerance

      • setSlpVTol_R

        public void setSlpVTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPVTOL_R. Relative static objective (3) convergence tolerance

      • getSlpETol_A

        public double getSlpETol_A()
        Retrieves the value of the control XPRSconstants.SLPETOL_A. Absolute tolerance on penalty vectors

      • setSlpETol_A

        public void setSlpETol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPETOL_A. Absolute tolerance on penalty vectors

      • getSlpETol_R

        public double getSlpETol_R()
        Retrieves the value of the control XPRSconstants.SLPETOL_R. Relative tolerance on penalty vectors

      • setSlpETol_R

        public void setSlpETol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPETOL_R. Relative tolerance on penalty vectors

      • getSlpEVTol_A

        public double getSlpEVTol_A()
        Retrieves the value of the control XPRSconstants.SLPEVTOL_A. Absolute tolerance on total penalty costs

      • setSlpEVTol_A

        public void setSlpEVTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPEVTOL_A. Absolute tolerance on total penalty costs

      • getSlpEVTol_R

        public double getSlpEVTol_R()
        Retrieves the value of the control XPRSconstants.SLPEVTOL_R. Relative tolerance on total penalty costs

      • setSlpEVTol_R

        public void setSlpEVTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPEVTOL_R. Relative tolerance on total penalty costs

      • getSlpDelta_Zero

        public double getSlpDelta_Zero()
        Retrieves the value of the control XPRSconstants.SLPDELTA_ZERO. Absolute zero acceptance tolerance used when calculating derivatives

      • setSlpDelta_Zero

        public void setSlpDelta_Zero​(double newval)
        Sets the value of the control XPRSconstants.SLPDELTA_ZERO. Absolute zero acceptance tolerance used when calculating derivatives

      • getSlpMinSBFactor

        public double getSlpMinSBFactor()
        Retrieves the value of the control XPRSconstants.SLPMINSBFACTOR. Factor by which step bounds can be decreased beneath XSLP_ATOL_A

      • setSlpMinSBFactor

        public void setSlpMinSBFactor​(double newval)
        Sets the value of the control XPRSconstants.SLPMINSBFACTOR. Factor by which step bounds can be decreased beneath XSLP_ATOL_A

      • getSlpClampValidationTol_A

        public double getSlpClampValidationTol_A()
        Retrieves the value of the control XPRSconstants.SLPCLAMPVALIDATIONTOL_A. Absolute validation tolerance for applying XSLP_CLAMPSHRINK

      • setSlpClampValidationTol_A

        public void setSlpClampValidationTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPCLAMPVALIDATIONTOL_A. Absolute validation tolerance for applying XSLP_CLAMPSHRINK

      • getSlpClampValidationTol_R

        public double getSlpClampValidationTol_R()
        Retrieves the value of the control XPRSconstants.SLPCLAMPVALIDATIONTOL_R. Relative validation tolerance for applying XSLP_CLAMPSHRINK

      • setSlpClampValidationTol_R

        public void setSlpClampValidationTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPCLAMPVALIDATIONTOL_R. Relative validation tolerance for applying XSLP_CLAMPSHRINK

      • getSlpClampShrink

        public double getSlpClampShrink()
        Retrieves the value of the control XPRSconstants.SLPCLAMPSHRINK. Shrink ratio used to impose strict convergence on variables converged in extended criteria only

      • setSlpClampShrink

        public void setSlpClampShrink​(double newval)
        Sets the value of the control XPRSconstants.SLPCLAMPSHRINK. Shrink ratio used to impose strict convergence on variables converged in extended criteria only

      • getSlpEcfTol_A

        public double getSlpEcfTol_A()
        Retrieves the value of the control XPRSconstants.SLPECFTOL_A. Absolute tolerance on testing feasibility at the point of linearization

      • setSlpEcfTol_A

        public void setSlpEcfTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPECFTOL_A. Absolute tolerance on testing feasibility at the point of linearization

      • getSlpEcfTol_R

        public double getSlpEcfTol_R()
        Retrieves the value of the control XPRSconstants.SLPECFTOL_R. Relative tolerance on testing feasibility at the point of linearization

      • setSlpEcfTol_R

        public void setSlpEcfTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPECFTOL_R. Relative tolerance on testing feasibility at the point of linearization

      • getSlpWTol_A

        public double getSlpWTol_A()
        Retrieves the value of the control XPRSconstants.SLPWTOL_A. Absolute extended convergence continuation tolerance

      • setSlpWTol_A

        public void setSlpWTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPWTOL_A. Absolute extended convergence continuation tolerance

      • getSlpWTol_R

        public double getSlpWTol_R()
        Retrieves the value of the control XPRSconstants.SLPWTOL_R. Relative extended convergence continuation tolerance

      • setSlpWTol_R

        public void setSlpWTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPWTOL_R. Relative extended convergence continuation tolerance

      • getSlpMatrixTol

        public double getSlpMatrixTol()
        Retrieves the value of the control XPRSconstants.SLPMATRIXTOL. Nonzero tolerance for dropping coefficients from the linearization.

      • setSlpMatrixTol

        public void setSlpMatrixTol​(double newval)
        Sets the value of the control XPRSconstants.SLPMATRIXTOL. Nonzero tolerance for dropping coefficients from the linearization.

      • getSlpDRFixRange

        public double getSlpDRFixRange()
        Retrieves the value of the control XPRSconstants.SLPDRFIXRANGE. The range around the previous value where variables are fixed in cascading if the determining column is below XSLP_DRCOLTOL.

      • setSlpDRFixRange

        public void setSlpDRFixRange​(double newval)
        Sets the value of the control XPRSconstants.SLPDRFIXRANGE. The range around the previous value where variables are fixed in cascading if the determining column is below XSLP_DRCOLTOL.

      • getSlpDRColTol

        public double getSlpDRColTol()
        Retrieves the value of the control XPRSconstants.SLPDRCOLTOL. The minimum absolute magnitude of a determining column, for which the determined variable is still regarded as well defined

      • setSlpDRColTol

        public void setSlpDRColTol​(double newval)
        Sets the value of the control XPRSconstants.SLPDRCOLTOL. The minimum absolute magnitude of a determining column, for which the determined variable is still regarded as well defined

      • getSlpMipErrorTol_A

        public double getSlpMipErrorTol_A()
        Retrieves the value of the control XPRSconstants.SLPMIPERRORTOL_A. Absolute penalty error cost tolerance for MIP cut-off

      • setSlpMipErrorTol_A

        public void setSlpMipErrorTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPMIPERRORTOL_A. Absolute penalty error cost tolerance for MIP cut-off

      • getSlpMipErrorTol_R

        public double getSlpMipErrorTol_R()
        Retrieves the value of the control XPRSconstants.SLPMIPERRORTOL_R. Relative penalty error cost tolerance for MIP cut-off

      • setSlpMipErrorTol_R

        public void setSlpMipErrorTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPMIPERRORTOL_R. Relative penalty error cost tolerance for MIP cut-off

      • getSlpCDTol_A

        public double getSlpCDTol_A()
        Retrieves the value of the control XPRSconstants.SLPCDTOL_A. Absolute tolerance for deducing constant derivatives

      • setSlpCDTol_A

        public void setSlpCDTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPCDTOL_A. Absolute tolerance for deducing constant derivatives

      • getSlpCDTol_R

        public double getSlpCDTol_R()
        Retrieves the value of the control XPRSconstants.SLPCDTOL_R. Relative tolerance for deducing constant derivatives

      • setSlpCDTol_R

        public void setSlpCDTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPCDTOL_R. Relative tolerance for deducing constant derivatives

      • getSlpEnforceMaxCost

        public double getSlpEnforceMaxCost()
        Retrieves the value of the control XPRSconstants.SLPENFORCEMAXCOST. Maximum penalty cost in the objective before enforcing most violating rows

      • setSlpEnforceMaxCost

        public void setSlpEnforceMaxCost​(double newval)
        Sets the value of the control XPRSconstants.SLPENFORCEMAXCOST. Maximum penalty cost in the objective before enforcing most violating rows

      • getSlpEnforceCostShrink

        public double getSlpEnforceCostShrink()
        Retrieves the value of the control XPRSconstants.SLPENFORCECOSTSHRINK. Factor by which to decrease the current penalty multiplier when enforcing rows.

      • setSlpEnforceCostShrink

        public void setSlpEnforceCostShrink​(double newval)
        Sets the value of the control XPRSconstants.SLPENFORCECOSTSHRINK. Factor by which to decrease the current penalty multiplier when enforcing rows.

      • getSlpDRColDjTol

        public double getSlpDRColDjTol()
        Retrieves the value of the control XPRSconstants.SLPDRCOLDJTOL. Reduced cost tolerance on the delta variable when fixing due to the determining column being below XSLP_DRCOLTOL.

      • setSlpDRColDjTol

        public void setSlpDRColDjTol​(double newval)
        Sets the value of the control XPRSconstants.SLPDRCOLDJTOL. Reduced cost tolerance on the delta variable when fixing due to the determining column being below XSLP_DRCOLTOL.

      • getSlpBarStallingTol

        public double getSlpBarStallingTol()
        Retrieves the value of the control XPRSconstants.SLPBARSTALLINGTOL. Required change in the objective when progress is measured in barrier iterations without crossover

      • setSlpBarStallingTol

        public void setSlpBarStallingTol​(double newval)
        Sets the value of the control XPRSconstants.SLPBARSTALLINGTOL. Required change in the objective when progress is measured in barrier iterations without crossover

      • getSlpObjThreshold

        public double getSlpObjThreshold()
        Retrieves the value of the control XPRSconstants.SLPOBJTHRESHOLD. Assumed maximum value of the objective function in absolute value.

      • setSlpObjThreshold

        public void setSlpObjThreshold​(double newval)
        Sets the value of the control XPRSconstants.SLPOBJTHRESHOLD. Assumed maximum value of the objective function in absolute value.

      • getSlpBoundThreshold

        public double getSlpBoundThreshold()
        Retrieves the value of the control XPRSconstants.SLPBOUNDTHRESHOLD. The maximum size of a bound that can be introduced by nonlinear presolve.

      • setSlpBoundThreshold

        public void setSlpBoundThreshold​(double newval)
        Sets the value of the control XPRSconstants.SLPBOUNDTHRESHOLD. The maximum size of a bound that can be introduced by nonlinear presolve.

      • getKnitroParamHonorBbnds

        public int getKnitroParamHonorBbnds()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_HONORBNDS. Indicates whether or not to enforce satisfaction of simple variable bounds throughout the optimization.

      • setKnitroParamHonorBbnds

        public void setKnitroParamHonorBbnds​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_HONORBNDS. Indicates whether or not to enforce satisfaction of simple variable bounds throughout the optimization.

      • getKnitroParamAlgorithm

        public int getKnitroParamAlgorithm()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_ALGORITHM. Indicates which algorithm to use to solve the problem

      • setKnitroParamAlgorithm

        public void setKnitroParamAlgorithm​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_ALGORITHM. Indicates which algorithm to use to solve the problem

      • getKnitroParamBarMuRule

        public int getKnitroParamBarMuRule()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_MURULE. Indicates which strategy to use for modifying the barrier parameter mu in the barrier algorithms.

      • setKnitroParamBarMuRule

        public void setKnitroParamBarMuRule​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_MURULE. Indicates which strategy to use for modifying the barrier parameter mu in the barrier algorithms.

      • getKnitroParamBarFeasible

        public int getKnitroParamBarFeasible()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_FEASIBLE. Specifies whether special emphasis is placed on getting and staying feasible in the interior-point algorithms.

      • setKnitroParamBarFeasible

        public void setKnitroParamBarFeasible​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_FEASIBLE. Specifies whether special emphasis is placed on getting and staying feasible in the interior-point algorithms.

      • getKnitroParamGradOpt

        public int getKnitroParamGradOpt()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_GRADOPT. Specifies how to compute the gradients of the objective and constraint functions.

      • setKnitroParamGradOpt

        public void setKnitroParamGradOpt​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_GRADOPT. Specifies how to compute the gradients of the objective and constraint functions.

      • getKnitroParamHessOpt

        public int getKnitroParamHessOpt()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_HESSOPT. Specifies how to compute the (approximate) Hessian of the Lagrangian.

      • setKnitroParamHessOpt

        public void setKnitroParamHessOpt​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_HESSOPT. Specifies how to compute the (approximate) Hessian of the Lagrangian.

      • getKnitroParamBarInitPt

        public int getKnitroParamBarInitPt()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_INITPT. Indicates whether an initial point strategy is used with barrier algorithms.

      • setKnitroParamBarInitPt

        public void setKnitroParamBarInitPt​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_INITPT. Indicates whether an initial point strategy is used with barrier algorithms.

      • getKnitroParamMaxCGIt

        public int getKnitroParamMaxCGIt()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MAXCGIT. Specifies the number of limited memory pairs stored when approximating the Hessian using the limited-memory quasi-Newton BFGS option.

      • setKnitroParamMaxCGIt

        public void setKnitroParamMaxCGIt​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MAXCGIT. Specifies the number of limited memory pairs stored when approximating the Hessian using the limited-memory quasi-Newton BFGS option.

      • getKnitroParamMaxIt

        public int getKnitroParamMaxIt()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MAXIT. Specifies the maximum number of iterations before termination.

      • setKnitroParamMaxIt

        public void setKnitroParamMaxIt​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MAXIT. Specifies the maximum number of iterations before termination.

      • getKnitroParamOutLev

        public int getKnitroParamOutLev()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_OUTLEV. Controls the level of output produced by Knitro.

      • setKnitroParamOutLev

        public void setKnitroParamOutLev​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_OUTLEV. Controls the level of output produced by Knitro.

      • getKnitroParamScale

        public int getKnitroParamScale()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_SCALE. Performs a scaling of the objective and constraint functions based on their values at the initial point.

      • setKnitroParamScale

        public void setKnitroParamScale​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_SCALE. Performs a scaling of the objective and constraint functions based on their values at the initial point.

      • getKnitroParamSOC

        public int getKnitroParamSOC()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_SOC. Specifies whether or not to try second order corrections (SOC).

      • setKnitroParamSOC

        public void setKnitroParamSOC​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_SOC. Specifies whether or not to try second order corrections (SOC).

      • getKnitroParamDelta

        public double getKnitroParamDelta()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_DELTA. Specifies the initial trust region radius scaling factor used to determine the initial trust region size.

      • setKnitroParamDelta

        public void setKnitroParamDelta​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_DELTA. Specifies the initial trust region radius scaling factor used to determine the initial trust region size.

      • getKnitroParamBarFeasModeTol

        public double getKnitroParamBarFeasModeTol()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_FEASMODETOL. Specifies the tolerance in equation that determines whether Knitro will force subsequent iterates to remain feasible.

      • setKnitroParamBarFeasModeTol

        public void setKnitroParamBarFeasModeTol​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_FEASMODETOL. Specifies the tolerance in equation that determines whether Knitro will force subsequent iterates to remain feasible.

      • getKnitroParamFeastol

        public double getKnitroParamFeastol()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_FEASTOL. Specifies the final relative stopping tolerance for the feasibility error.

      • setKnitroParamFeastol

        public void setKnitroParamFeastol​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_FEASTOL. Specifies the final relative stopping tolerance for the feasibility error.

      • getKnitroParamFeasTolAbs

        public double getKnitroParamFeasTolAbs()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_FEASTOLABS. Specifies the final absolute stopping tolerance for the feasibility error.

      • setKnitroParamFeasTolAbs

        public void setKnitroParamFeasTolAbs​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_FEASTOLABS. Specifies the final absolute stopping tolerance for the feasibility error.

      • getKnitroParamBarInitMu

        public double getKnitroParamBarInitMu()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_INITMU. Specifies the initial value for the barrier parameter : mu used with the barrier algorithms. This option has no effect on the Active Set algorithm.

      • setKnitroParamBarInitMu

        public void setKnitroParamBarInitMu​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_INITMU. Specifies the initial value for the barrier parameter : mu used with the barrier algorithms. This option has no effect on the Active Set algorithm.

      • getKnitroParamObjRange

        public double getKnitroParamObjRange()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_OBJRANGE. Specifies the extreme limits of the objective function for purposes of determining unboundedness.

      • setKnitroParamObjRange

        public void setKnitroParamObjRange​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_OBJRANGE. Specifies the extreme limits of the objective function for purposes of determining unboundedness.

      • getKnitroParamOptTol

        public double getKnitroParamOptTol()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_OPTTOL. Specifies the final relative stopping tolerance for the KKT (optimality) error.

      • setKnitroParamOptTol

        public void setKnitroParamOptTol​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_OPTTOL. Specifies the final relative stopping tolerance for the KKT (optimality) error.

      • getKnitroParamOptTolAbs

        public double getKnitroParamOptTolAbs()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_OPTTOLABS. Specifies the final absolute stopping tolerance for the KKT (optimality) error.

      • setKnitroParamOptTolAbs

        public void setKnitroParamOptTolAbs​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_OPTTOLABS. Specifies the final absolute stopping tolerance for the KKT (optimality) error.

      • getKnitroParamXTol

        public double getKnitroParamXTol()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_XTOL. The optimization process will terminate if the relative change in all components of the solution point estimate is less than xtol.

      • setKnitroParamXTol

        public void setKnitroParamXTol​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_XTOL. The optimization process will terminate if the relative change in all components of the solution point estimate is less than xtol.

      • getKnitroParamLMSize

        public int getKnitroParamLMSize()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_LMSIZE. Specifies the number of limited memory pairs stored when approximating the Hessian using the limited-memory quasi-Newton BFGS option.

      • setKnitroParamLMSize

        public void setKnitroParamLMSize​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_LMSIZE. Specifies the number of limited memory pairs stored when approximating the Hessian using the limited-memory quasi-Newton BFGS option.

      • getKnitroParamMaxCrossIt

        public int getKnitroParamMaxCrossIt()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_MAXCROSSIT. Specifies the maximum number of crossover iterations before termination.

      • setKnitroParamMaxCrossIt

        public void setKnitroParamMaxCrossIt​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_MAXCROSSIT. Specifies the maximum number of crossover iterations before termination.

      • getKnitroParamBarMaxRefactor

        public int getKnitroParamBarMaxRefactor()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_MAXREFACTOR. Indicates the maximum number of refactorizations of the KKT system per iteration of the Interior/Direct algorithm before reverting to a CG step.

      • setKnitroParamBarMaxRefactor

        public void setKnitroParamBarMaxRefactor​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_MAXREFACTOR. Indicates the maximum number of refactorizations of the KKT system per iteration of the Interior/Direct algorithm before reverting to a CG step.

      • getKnitroParamBarMaxBacktrack

        public int getKnitroParamBarMaxBacktrack()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_MAXBACKTRACK. Indicates the maximum allowable number of backtracks during the linesearch of the Interior/Direct algorithm before reverting to a CG step.

      • setKnitroParamBarMaxBacktrack

        public void setKnitroParamBarMaxBacktrack​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_MAXBACKTRACK. Indicates the maximum allowable number of backtracks during the linesearch of the Interior/Direct algorithm before reverting to a CG step.

      • getKnitroParamBarPenRule

        public int getKnitroParamBarPenRule()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_PENRULE. Indicates which penalty parameter strategy to use for determining whether or not to accept a trial iterate.

      • setKnitroParamBarPenRule

        public void setKnitroParamBarPenRule​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_PENRULE. Indicates which penalty parameter strategy to use for determining whether or not to accept a trial iterate.

      • getKnitroParamBarPenCons

        public int getKnitroParamBarPenCons()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_PENCONS. Indicates whether a penalty approach is applied to the constraints.

      • setKnitroParamBarPenCons

        public void setKnitroParamBarPenCons​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_PENCONS. Indicates whether a penalty approach is applied to the constraints.

      • getKnitroParamInfeasTol

        public double getKnitroParamInfeasTol()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_INFEASTOL. Specifies the (relative) tolerance used for declaring infeasibility of a model.

      • setKnitroParamInfeasTol

        public void setKnitroParamInfeasTol​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_INFEASTOL. Specifies the (relative) tolerance used for declaring infeasibility of a model.

      • getKnitroParamBarDirectInterval

        public int getKnitroParamBarDirectInterval()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_DIRECTINTERVAL. Controls the maximum number of consecutive conjugate gradient (CG) steps before Knitro will try to enforce that a step is taken using direct linear algebra.

      • setKnitroParamBarDirectInterval

        public void setKnitroParamBarDirectInterval​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_DIRECTINTERVAL. Controls the maximum number of consecutive conjugate gradient (CG) steps before Knitro will try to enforce that a step is taken using direct linear algebra.

      • getKnitroParamPresolve

        public int getKnitroParamPresolve()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_PRESOLVE. Determine whether or not to use the Knitro presolver to try to simplify the model by removing variables or constraints. Specifies conditions for terminating the MIP algorithm.

      • setKnitroParamPresolve

        public void setKnitroParamPresolve​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_PRESOLVE. Determine whether or not to use the Knitro presolver to try to simplify the model by removing variables or constraints. Specifies conditions for terminating the MIP algorithm.

      • getKnitroParamPresolveTol

        public double getKnitroParamPresolveTol()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_PRESOLVE_TOL. Determines the tolerance used by the Knitro presolver to remove variables and constraints from the model.

      • setKnitroParamPresolveTol

        public void setKnitroParamPresolveTol​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_PRESOLVE_TOL. Determines the tolerance used by the Knitro presolver to remove variables and constraints from the model.

      • getKnitroParamBarSwitchRule

        public int getKnitroParamBarSwitchRule()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_BAR_SWITCHRULE. Indicates whether or not the barrier algorithms will allow switching from an optimality phase to a pure feasibility phase.

      • setKnitroParamBarSwitchRule

        public void setKnitroParamBarSwitchRule​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_BAR_SWITCHRULE. Indicates whether or not the barrier algorithms will allow switching from an optimality phase to a pure feasibility phase.

      • getKnitroParamMIPBranchRule

        public int getKnitroParamMIPBranchRule()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_BRANCHRULE. Specifies which branching rule to use for MIP branch and bound procedure.

      • setKnitroParamMIPBranchRule

        public void setKnitroParamMIPBranchRule​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_BRANCHRULE. Specifies which branching rule to use for MIP branch and bound procedure.

      • getKnitroParamMIPSelectRule

        public int getKnitroParamMIPSelectRule()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_SELECTRULE. Specifies the MIP select rule for choosing the next node in the branch and bound tree.

      • setKnitroParamMIPSelectRule

        public void setKnitroParamMIPSelectRule​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_SELECTRULE. Specifies the MIP select rule for choosing the next node in the branch and bound tree.

      • getKnitroParamMIPIntGapAbs

        public double getKnitroParamMIPIntGapAbs()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_INTGAPABS. The absolute integrality gap stop tolerance for MIP.

      • setKnitroParamMIPIntGapAbs

        public void setKnitroParamMIPIntGapAbs​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_INTGAPABS. The absolute integrality gap stop tolerance for MIP.

      • getKnitroParamMIPIntGapRel

        public double getKnitroParamMIPIntGapRel()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_INTGAPREL. The relative integrality gap stop tolerance for MIP.

      • setKnitroParamMIPIntGapRel

        public void setKnitroParamMIPIntGapRel​(double newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_INTGAPREL. The relative integrality gap stop tolerance for MIP.

      • setKnitroParamMIPOutLevel

        public void setKnitroParamMIPOutLevel​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_OUTLEVEL. Specifies how much MIP information to print.

      • getKnitroParamMIPOutInterval

        public int getKnitroParamMIPOutInterval()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_OUTINTERVAL. Specifies node printing interval for XKTR_PARAM_MIP_OUTLEVEL when XKTR_PARAM_MIP_OUTLEVEL > 0.

      • setKnitroParamMIPOutInterval

        public void setKnitroParamMIPOutInterval​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_OUTINTERVAL. Specifies node printing interval for XKTR_PARAM_MIP_OUTLEVEL when XKTR_PARAM_MIP_OUTLEVEL > 0.

      • getKnitroParamMIPImplicatns

        public int getKnitroParamMIPImplicatns()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_IMPLICATNS. Specifies whether or not to add constraints to the MIP derived from logical implications.

      • setKnitroParamMIPImplicatns

        public void setKnitroParamMIPImplicatns​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_IMPLICATNS. Specifies whether or not to add constraints to the MIP derived from logical implications.

      • getKnitroParamMIPGUBBranch

        public int getKnitroParamMIPGUBBranch()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_GUB_BRANCH. Specifies whether or not to branch on generalized upper bounds (GUBs).

      • setKnitroParamMIPGUBBranch

        public void setKnitroParamMIPGUBBranch​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_GUB_BRANCH. Specifies whether or not to branch on generalized upper bounds (GUBs).

      • setKnitroParamMIPKnapsack

        public void setKnitroParamMIPKnapsack​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_KNAPSACK. Specifies rules for adding MIP knapsack cuts.

      • setKnitroParamMIPRounding

        public void setKnitroParamMIPRounding​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_ROUNDING. Specifies the MIP rounding rule to apply.

      • getKnitroParamMIPRootAlg

        public int getKnitroParamMIPRootAlg()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_ROOTALG. Specifies which algorithm to use for the root node solve in MIP (same options as XKTR_PARAM_ALGORITHM user option).

      • setKnitroParamMIPRootAlg

        public void setKnitroParamMIPRootAlg​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_ROOTALG. Specifies which algorithm to use for the root node solve in MIP (same options as XKTR_PARAM_ALGORITHM user option).

      • getKnitroParamMIPLPAlg

        public int getKnitroParamMIPLPAlg()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_LPALG. Specifies which algorithm to use for any linear programming (LP) subproblem solves that may occur in the MIP branch and bound procedure.

      • setKnitroParamMIPLPAlg

        public void setKnitroParamMIPLPAlg​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_LPALG. Specifies which algorithm to use for any linear programming (LP) subproblem solves that may occur in the MIP branch and bound procedure.

      • setKnitroParamMIPMaxNodes

        public void setKnitroParamMIPMaxNodes​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_MAXNODES. Specifies the maximum number of nodes explored.

      • getKnitroParamMIPHeuristic

        public int getKnitroParamMIPHeuristic()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_HEURISTIC. Specifies which MIP heuristic search approach to apply to try to find an initial integer feasible point.

      • setKnitroParamMIPHeuristic

        public void setKnitroParamMIPHeuristic​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_HEURISTIC. Specifies which MIP heuristic search approach to apply to try to find an initial integer feasible point.

      • getKnitroParamMIPPseudoint

        public int getKnitroParamMIPPseudoint()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_PSEUDOINIT. Specifies the method used to initialize pseudo-costs corresponding to variables that have not yet been branched on in the MIP method.

      • setKnitroParamMIPPseudoint

        public void setKnitroParamMIPPseudoint​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_PSEUDOINIT. Specifies the method used to initialize pseudo-costs corresponding to variables that have not yet been branched on in the MIP method.

      • getKnitroParamMIPStringMaxIt

        public int getKnitroParamMIPStringMaxIt()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_STRONG_MAXIT. Specifies the maximum number of iterations to allow for MIP strong branching solves.

      • setKnitroParamMIPStringMaxIt

        public void setKnitroParamMIPStringMaxIt​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_STRONG_MAXIT. Specifies the maximum number of iterations to allow for MIP strong branching solves.

      • getKnitroParamMIPStrongCandLim

        public int getKnitroParamMIPStrongCandLim()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_STRONG_CANDLIM. Specifies the maximum number of candidates to explore for MIP strong branching.

      • setKnitroParamMIPStrongCandLim

        public void setKnitroParamMIPStrongCandLim​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_STRONG_CANDLIM. Specifies the maximum number of candidates to explore for MIP strong branching.

      • getKnitroParamMIPStrongLevel

        public int getKnitroParamMIPStrongLevel()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_MIP_STRONG_LEVEL. Specifies the maximum number of tree levels on which to perform MIP strong branching.

      • setKnitroParamMIPStrongLevel

        public void setKnitroParamMIPStrongLevel​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_MIP_STRONG_LEVEL. Specifies the maximum number of tree levels on which to perform MIP strong branching.
Parent Topic XPRSprob

© 2001-2024 Fair Isaac Corporation. All rights reserved. This documentation is the property of Fair Isaac Corporation (“FICO”). Receipt or possession of this documentation does not convey rights to disclose, reproduce, make derivative works, use, or allow others to use it except solely for internal evaluation purposes to determine whether to purchase a license to the software described in this documentation, or as otherwise set forth in a written software license agreement between you and FICO (or a FICO affiliate). Use of this documentation and the software described in it must conform strictly to the foregoing permitted uses, and no other use is permitted.