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.
        Returns:
        Value of control XPRSconstants.EXTRAROWS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.EXTRAROWS.

      • 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.
        Returns:
        Value of control XPRSconstants.EXTRACOLS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.EXTRACOLS.

      • 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.
        Returns:
        Value of control XPRSconstants.EXTRAELEMS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.EXTRAELEMS.

      • 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.

        Examples using controls().setLPIterLimit:

        Returns:
        Value of control XPRSconstants.LPITERLIMIT.

      • 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.

        Examples using controls().setLPIterLimit:

        Parameters:
        newval - New value for control XPRSconstants.LPITERLIMIT.

      • getLPLog

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

        Examples using controls().setLPLog:

        Returns:
        Value of control XPRSconstants.LPLOG.

      • setLPLog

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

        Examples using controls().setLPLog:

        Parameters:
        newval - New value for control XPRSconstants.LPLOG.

      • 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 (see Section ) 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)
        Returns:
        Value of control XPRSconstants.SCALING.

      • setScaling

        public void setScaling​(int newval)
        Sets the value of the control XPRSconstants.SCALING. This bit-vector control (see Section ) 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)
        Parameters:
        newval - New value for control XPRSconstants.SCALING.

      • resetScaling

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

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.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.
        Returns:
        Value of control XPRSconstants.CRASH.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.CRASH.

      • 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)
        Returns:
        Value of control XPRSconstants.PRICINGALG.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.PRICINGALG.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.PRICINGALG.

      • 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.
        Returns:
        Value of control XPRSconstants.INVERTFREQ.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.INVERTFREQ.

      • 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.
        Returns:
        Value of control XPRSconstants.INVERTMIN.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.INVERTMIN.

      • 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.

        Examples using controls().setMaxNode:

        Parameters:
        newval - New value for control XPRSconstants.MAXNODE.

      • 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.
        Returns:
        Value of control XPRSconstants.MAXTIME.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXTIME.

      • 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.

        Examples using controls().setMaxMIPSol:

        Returns:
        Value of control XPRSconstants.MAXMIPSOL.

      • 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.

        Examples using controls().setMaxMIPSol:

        Parameters:
        newval - New value for control XPRSconstants.MAXMIPSOL.

      • 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.
        Returns:
        Value of control XPRSconstants.SIFTPASSES.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SIFTPASSES.

      • 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)
        Returns:
        Value of control XPRSconstants.VARSELECTION.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.VARSELECTION.

      • resetMIPLog

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

      • setKeepNRows

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

      • 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.
        Returns:
        Value of control XPRSconstants.MPSECHO.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MPSECHO.

      • resetMPSEcho

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

      • 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)

        Examples using controls().setOutputLog:

        Returns:
        Value of control XPRSconstants.OUTPUTLOG.

      • 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)

        Examples using controls().setOutputLog:

        Parameters:
        newval - New value for control XPRSconstants.OUTPUTLOG.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.OUTPUTLOG.

      • 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.
        Returns:
        Value of control XPRSconstants.BARSOLUTION.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARSOLUTION.

      • 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.
        Returns:
        Value of control XPRSconstants.CACHESIZE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.CACHESIZE.

      • 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)
        Returns:
        Value of control XPRSconstants.CROSSOVER.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.CROSSOVER.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.CROSSOVER.

      • 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.
        Returns:
        Value of control XPRSconstants.BARITERLIMIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARITERLIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.BAROUTPUT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BAROUTPUT.

      • 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.
        Returns:
        Value of control XPRSconstants.REFACTOR.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.REFACTOR.

      • 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.
        Returns:
        Value of control XPRSconstants.BARTHREADS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARTHREADS.

      • 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.
        Returns:
        Value of control XPRSconstants.KEEPBASIS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.KEEPBASIS.

      • getCrossoverOps

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

      • setCrossoverOps

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

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.VERSION.

      • 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.
        Returns:
        Value of control XPRSconstants.CROSSOVERTHREADS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.CROSSOVERTHREADS.

      • 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.
        Returns:
        Value of control XPRSconstants.BIGMMETHOD.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BIGMMETHOD.

      • getMPSNameLength

        public int getMPSNameLength()

      • 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 .
        Parameters:
        newval - New value for control XPRSconstants.ELIMFILLIN.

      • 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.

        Examples using controls().getMIPThreads/controls().setMIPThreads:

        Returns:
        Value of control XPRSconstants.MIPTHREADS.

      • 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.

        Examples using controls().getMIPThreads/controls().setMIPThreads:

        Parameters:
        newval - New value for control XPRSconstants.MIPTHREADS.

      • 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).
        Returns:
        Value of control XPRSconstants.BREADTHFIRST.

      • 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).
        Parameters:
        newval - New value for control XPRSconstants.BREADTHFIRST.

      • 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)
        Returns:
        Value of control XPRSconstants.AUTOPERTURB.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.AUTOPERTURB.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.AUTOPERTURB.

      • 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.
        Returns:
        Value of control XPRSconstants.DENSECOLLIMIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.DENSECOLLIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.MAXMCOEFFBUFFERELEMS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXMCOEFFBUFFERELEMS.

      • 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.
        Returns:
        Value of control XPRSconstants.REFINEOPS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.REFINEOPS.

      • 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.
        Returns:
        Value of control XPRSconstants.LPREFINEITERLIMIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.LPREFINEITERLIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPREFINEITERLIMIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPREFINEITERLIMIT.

      • getDualizeOps

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

      • setDualizeOps

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

      • 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.
        Returns:
        Value of control XPRSconstants.CROSSOVERITERLIMIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.CROSSOVERITERLIMIT.

      • 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
        Returns:
        Value of control XPRSconstants.PREBASISRED.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.PREBASISRED.

      • getPreSort

        public int getPreSort()
        Retrieves the value of the control XPRSconstants.PRESORT. This bit-vector control (see Section ) 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.
        Returns:
        Value of control XPRSconstants.PRESORT.

      • setPreSort

        public void setPreSort​(int newval)
        Sets the value of the control XPRSconstants.PRESORT. This bit-vector control (see Section ) 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.
        Parameters:
        newval - New value for control XPRSconstants.PRESORT.

      • 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 (see Section ) specifies whether to randomly permute rows, columns and MIP entities when starting the presolve. With the default value 0, no permutation will take place.
        Returns:
        Value of control XPRSconstants.PREPERMUTE.

      • setPrePermute

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

      • 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.
        Returns:
        Value of control XPRSconstants.PREPERMUTESEED.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PREPERMUTESEED.

      • 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.
        Returns:
        Value of control XPRSconstants.MAXMEMORYSOFT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXMEMORYSOFT.

      • 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.
        Returns:
        Value of control XPRSconstants.CUTFREQ.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.CUTFREQ.

      • resetCutFreq

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

      • setSymSelect

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

      • setSymmetry

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

      • 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.
        Returns:
        Value of control XPRSconstants.MAXMEMORYHARD.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXMEMORYHARD.

      • 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.
        Returns:
        Value of control XPRSconstants.MIQCPALG.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIQCPALG.

      • 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.
        Returns:
        Value of control XPRSconstants.QCCUTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.QCCUTS.

      • 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.
        Returns:
        Value of control XPRSconstants.QCROOTALG.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.QCROOTALG.

      • 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.
        Returns:
        Value of control XPRSconstants.PRECONVERTSEPARABLE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PRECONVERTSEPARABLE.

      • 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.
        Returns:
        Value of control XPRSconstants.TRACE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TRACE.

      • 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).
        Returns:
        Value of control XPRSconstants.MAXIIS.

      • 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).
        Parameters:
        newval - New value for control XPRSconstants.MAXIIS.

      • 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
        Returns:
        Value of control XPRSconstants.CPUTIME.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.CPUTIME.

      • 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 root 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 root node, since these inequalities then apply to every subsequent node in the tree search.
        Returns:
        Value of control XPRSconstants.COVERCUTS.

      • 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 root 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 root node, since these inequalities then apply to every subsequent node in the tree search.
        Parameters:
        newval - New value for control XPRSconstants.COVERCUTS.

      • 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 root node.
        Returns:
        Value of control XPRSconstants.GOMCUTS.

      • 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 root node.
        Parameters:
        newval - New value for control XPRSconstants.GOMCUTS.

      • resetGomCuts

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

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.LPFOLDING.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.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.
        Returns:
        Value of control XPRSconstants.CUTDEPTH.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.CUTDEPTH.

      • 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 root node in the tree. Compare with the description for COVERCUTS. A value of -1 indicates the number of rounds is determined automatically.
        Returns:
        Value of control XPRSconstants.TREECOVERCUTS.

      • 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 root node in the tree. Compare with the description for COVERCUTS. A value of -1 indicates the number of rounds is determined automatically.
        Parameters:
        newval - New value for control XPRSconstants.TREECOVERCUTS.

      • 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.
        Returns:
        Value of control XPRSconstants.TREEGOMCUTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TREEGOMCUTS.

      • getCutSelect

        public int getCutSelect()
        Retrieves the value of the control XPRSconstants.CUTSELECT. A bit-vector (see Section ) 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)
        Returns:
        Value of control XPRSconstants.CUTSELECT.

      • setCutSelect

        public void setCutSelect​(int newval)
        Sets the value of the control XPRSconstants.CUTSELECT. A bit-vector (see Section ) 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)
        Parameters:
        newval - New value for control XPRSconstants.CUTSELECT.

      • getTreeCutSelect

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

      • setTreeCutSelect

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

      • resetDualize

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

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SBITERLIMIT.

      • 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.

        Examples using controls().setSBBest:

        Returns:
        Value of control XPRSconstants.SBBEST.

      • 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.

        Examples using controls().setSBBest:

        Parameters:
        newval - New value for control XPRSconstants.SBBEST.

      • 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.
        Returns:
        Value of control XPRSconstants.BARINDEFLIMIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARINDEFLIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.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.
        Parameters:
        newval - New value for control XPRSconstants.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.
        Returns:
        Value of control XPRSconstants.HEURDEPTH.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURDEPTH.

      • 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.
        Returns:
        Value of control XPRSconstants.HEURMAXSOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURMAXSOL.

      • 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.
        Returns:
        Value of control XPRSconstants.HEURNODES.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURNODES.

      • 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 root node (see GOMCUTS).
        Returns:
        Value of control XPRSconstants.LNPBEST.

      • 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 root node (see GOMCUTS).
        Parameters:
        newval - New value for control XPRSconstants.LNPBEST.

      • resetLNPBest

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

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.LNPITERLIMIT.

      • getBarRegularize

        public int getBarRegularize()
        Retrieves the value of the control XPRSconstants.BARREGULARIZE. This bit-vector control (see Section ) determines how the barrier algorithm applies regularization on the KKT system.
        Returns:
        Value of control XPRSconstants.BARREGULARIZE.

      • setBarRegularize

        public void setBarRegularize​(int newval)
        Sets the value of the control XPRSconstants.BARREGULARIZE. This bit-vector control (see Section ) determines how the barrier algorithm applies regularization on the KKT system.
        Parameters:
        newval - New value for control XPRSconstants.BARREGULARIZE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SBSELECT.

      • 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.
        Returns:
        Value of control XPRSconstants.IISLOG.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.IISLOG.

      • 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.
        Returns:
        Value of control XPRSconstants.LOCALCHOICE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.LOCALCHOICE.

      • 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.
        Returns:
        Value of control XPRSconstants.L1CACHE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.L1CACHE.

      • resetL1Cache

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

      • 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.
        Returns:
        Value of control XPRSconstants.BARSTART.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARSTART.

      • resetBarStart

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

      • getBarNumStability

        @Deprecated
public int getBarNumStability()
        Deprecated.

      • resetBarNumStability

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

      • 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.
        Returns:
        Value of control XPRSconstants.BARORDERTHREADS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARORDERTHREADS.

      • 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.
        Returns:
        Value of control XPRSconstants.EXTRASETS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.EXTRASETS.

      • 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.
        Returns:
        Value of control XPRSconstants.EXTRASETELEMS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.EXTRASETELEMS.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.PRECOEFELIM.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.PREDOMCOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURSEARCHFREQ.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURDIVESPEEDUP.

      • 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.
        Returns:
        Value of control XPRSconstants.SBESTIMATE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SBESTIMATE.

      • 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.
        Returns:
        Value of control XPRSconstants.BARCORES.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARCORES.

      • 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.
        Returns:
        Value of control XPRSconstants.MAXCHECKSONMAXTIME.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXCHECKSONMAXTIME.

      • 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.
        Returns:
        Value of control XPRSconstants.MAXCHECKSONMAXCUTTIME.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXCHECKSONMAXCUTTIME.

      • 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.
        Returns:
        Value of control XPRSconstants.HISTORYCOSTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HISTORYCOSTS.

      • 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.

        Examples using controls().getMutexCallBacks/controls().setMutexCallBacks:

        Returns:
        Value of control XPRSconstants.MUTEXCALLBACKS.

      • 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.

        Examples using controls().getMutexCallBacks/controls().setMutexCallBacks:

        Parameters:
        newval - New value for control XPRSconstants.MUTEXCALLBACKS.

      • 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.
        Returns:
        Value of control XPRSconstants.BARCRASH.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARCRASH.

      • 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.
        Returns:
        Value of control XPRSconstants.HEURDIVESOFTROUNDING.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURDIVESOFTROUNDING.

      • 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.
        Returns:
        Value of control XPRSconstants.FORCEOUTPUT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.FORCEOUTPUT.

      • 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.
        Returns:
        Value of control XPRSconstants.PRIMALOPS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PRIMALOPS.

      • 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.
        Returns:
        Value of control XPRSconstants.DETERMINISTIC.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.DETERMINISTIC.

      • 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)
        Returns:
        Value of control XPRSconstants.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)
        Parameters:
        newval - New value for control XPRSconstants.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.
        Returns:
        Value of control XPRSconstants.TREEMEMORYLIMIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TREEMEMORYLIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.TREECOMPRESSION.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TREECOMPRESSION.

      • 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.
        Returns:
        Value of control XPRSconstants.MAXTREEFILESIZE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXTREEFILESIZE.

      • 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)
        Returns:
        Value of control XPRSconstants.IFCHECKCONVEXITY.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.IFCHECKCONVEXITY.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.IFCHECKCONVEXITY.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPRAMPUP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPRAMPUP.

      • 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.
        Returns:
        Value of control XPRSconstants.MAXLOCALBACKTRACK.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXLOCALBACKTRACK.

      • 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.
        Returns:
        Value of control XPRSconstants.USERSOLHEURISTIC.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.USERSOLHEURISTIC.

      • 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.
        Returns:
        Value of control XPRSconstants.FORCEPARALLELDUAL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.FORCEPARALLELDUAL.

      • 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)
        Returns:
        Value of control XPRSconstants.BACKTRACKTIE.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.BACKTRACKTIE.

      • 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.
        Returns:
        Value of control XPRSconstants.BRANCHDISJ.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BRANCHDISJ.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPFRACREDUCE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPFRACREDUCE.

      • 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.
        Returns:
        Value of control XPRSconstants.MAXSCALEFACTOR.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXSCALEFACTOR.

      • 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.
        Returns:
        Value of control XPRSconstants.HEURTHREADS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURTHREADS.

      • 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.
        Returns:
        Value of control XPRSconstants.HEURBEFORELP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURBEFORELP.

      • setQSimplexOps

        public void setQSimplexOps​(int newval)
        Sets the value of the control XPRSconstants.QSIMPLEXOPS. Controls the behavior of the quadratic simplex solvers via a bit-vector (see Section ).
        Parameters:
        newval - New value for control XPRSconstants.QSIMPLEXOPS.

      • 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.
        Returns:
        Value of control XPRSconstants.CONFLICTCUTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.CONFLICTCUTS.

      • 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.
        Returns:
        Value of control XPRSconstants.PREPROTECTDUAL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PREPROTECTDUAL.

      • 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
        Returns:
        Value of control XPRSconstants.CORESPERCPU.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.CORESPERCPU.

      • 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
        Returns:
        Value of control XPRSconstants.RESOURCESTRATEGY.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.RESOURCESTRATEGY.

      • getClamping

        public int getClamping()
        Retrieves the value of the control XPRSconstants.CLAMPING. This bit-vector control (see Section ) allows for the adjustment of returned solution values such that they are always within bounds.
        Returns:
        Value of control XPRSconstants.CLAMPING.

      • setClamping

        public void setClamping​(int newval)
        Sets the value of the control XPRSconstants.CLAMPING. This bit-vector control (see Section ) allows for the adjustment of returned solution values such that they are always within bounds.
        Parameters:
        newval - New value for control XPRSconstants.CLAMPING.

      • 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.
        Returns:
        Value of control XPRSconstants.SLEEPONTHREADWAIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SLEEPONTHREADWAIT.

      • 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.
        Returns:
        Value of control XPRSconstants.PREDUPROW.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PREDUPROW.

      • 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.
        Returns:
        Value of control XPRSconstants.CPUPLATFORM.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.CPUPLATFORM.

      • getBarAlg

        public int getBarAlg()
        Retrieves the value of the control XPRSconstants.BARALG. This control determines which barrier algorithm is used to solve the problem. Notably, this is also the control to enable the primal-dual hybrid gradient algorithm.
        Returns:
        Value of control XPRSconstants.BARALG.

      • 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. Notably, this is also the control to enable the primal-dual hybrid gradient algorithm.
        Parameters:
        newval - New value for control XPRSconstants.BARALG.

      • 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.
        Returns:
        Value of control XPRSconstants.SIFTING.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SIFTING.

      • resetSifting

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

      • getBarKeepLastSol

        public int getBarKeepLastSol()

      • 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.
        Returns:
        Value of control XPRSconstants.RANDOMSEED.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.RANDOMSEED.

      • 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.
        Returns:
        Value of control XPRSconstants.TREEQCCUTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TREEQCCUTS.

      • 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.
        Returns:
        Value of control XPRSconstants.PRELINDEP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PRELINDEP.

      • 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.
        Returns:
        Value of control XPRSconstants.DUALTHREADS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.DUALTHREADS.

      • 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.
        Returns:
        Value of control XPRSconstants.PREOBJCUTDETECT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PREOBJCUTDETECT.

      • 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.
        Returns:
        Value of control XPRSconstants.PREBNDREDQUAD.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PREBNDREDQUAD.

      • 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.
        Returns:
        Value of control XPRSconstants.PREBNDREDCONE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PREBNDREDCONE.

      • 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.
        Returns:
        Value of control XPRSconstants.PRECOMPONENTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PRECOMPONENTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXMIPTASKS.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPTERMINATIONMETHOD.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPTERMINATIONMETHOD.

      • 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.
        Returns:
        Value of control XPRSconstants.PRECONEDECOMP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PRECONEDECOMP.

      • 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.
        Returns:
        Value of control XPRSconstants.HEURFORCESPECIALOBJ.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURFORCESPECIALOBJ.

      • 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.
        Returns:
        Value of control XPRSconstants.HEURSEARCHROOTCUTFREQ.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURSEARCHROOTCUTFREQ.

      • setPreElimQuad

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

      • 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.
        Returns:
        Value of control XPRSconstants.PREIMPLICATIONS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PREIMPLICATIONS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TUNERPERMUTE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TUNERVERBOSE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TUNEROUTPUT.

      • 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)
        Returns:
        Value of control XPRSconstants.PREANALYTICCENTER.

      • 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)
        Parameters:
        newval - New value for control XPRSconstants.PREANALYTICCENTER.

      • getNetCuts

        @Deprecated
public int getNetCuts()
        Deprecated.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPKAPPAFREQ.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPKAPPAFREQ.

      • 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.
        Returns:
        Value of control XPRSconstants.OBJSCALEFACTOR.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.OBJSCALEFACTOR.

      • 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.
        Returns:
        Value of control XPRSconstants.TREEFILELOGINTERVAL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TREEFILELOGINTERVAL.

      • getIgnoreContainerCpuLimit

        public int getIgnoreContainerCpuLimit()

      • getIgnoreContainerMemoryLimit

        public int getIgnoreContainerMemoryLimit()

      • 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.
        Returns:
        Value of control XPRSconstants.GENCONSDUALREDUCTIONS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.GENCONSDUALREDUCTIONS.

      • 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.
        Returns:
        Value of control XPRSconstants.PWLDUALREDUCTIONS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PWLDUALREDUCTIONS.

      • 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.
        Returns:
        Value of control XPRSconstants.BARFAILITERLIMIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARFAILITERLIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.AUTOSCALING.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.AUTOSCALING.

      • 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.
        Returns:
        Value of control XPRSconstants.PREFOLDING.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PREFOLDING.

      • 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.
        Returns:
        Value of control XPRSconstants.COMPUTE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.COMPUTE.

      • 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.
        Returns:
        Value of control XPRSconstants.NETSTALLLIMIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.NETSTALLLIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.SERIALIZEPREINTSOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SERIALIZEPREINTSOL.

      • 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.
        Returns:
        Value of control XPRSconstants.PWLNONCONVEXTRANSFORMATION.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PWLNONCONVEXTRANSFORMATION.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPCOMPONENTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPCOMPONENTS.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPCONCURRENTNODES.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPCONCURRENTNODES.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPCONCURRENTSOLVES.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPCONCURRENTSOLVES.

      • 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.
        Returns:
        Value of control XPRSconstants.OUTPUTCONTROLS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.OUTPUTCONTROLS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SIFTSWITCH.

      • 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.

        Examples using controls().setHeurEmphasis:

        Returns:
        Value of control XPRSconstants.HEUREMPHASIS.

      • 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.

        Examples using controls().setHeurEmphasis:

        Parameters:
        newval - New value for control XPRSconstants.HEUREMPHASIS.

      • 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.
        Returns:
        Value of control XPRSconstants.BARREFITER.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARREFITER.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SIFTPRESOLVEOPS.

      • 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.
        Returns:
        Value of control XPRSconstants.ESCAPENAMES.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.ESCAPENAMES.

      • 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.
        Returns:
        Value of control XPRSconstants.IOTIMEOUT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.IOTIMEOUT.

      • 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.
        Returns:
        Value of control XPRSconstants.AUTOCUTTING.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.AUTOCUTTING.

      • 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.
        Returns:
        Value of control XPRSconstants.GLOBALNUMINITNLPCUTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.GLOBALNUMINITNLPCUTS.

      • getBackgroundSelect

        public long getBackgroundSelect()
        Retrieves the value of the control XPRSconstants.BACKGROUNDSELECT. Bit-vector control (see Section ) to select which tasks to run in background jobs (for example in parallel to the root cut loop).
        Returns:
        Value of control XPRSconstants.BACKGROUNDSELECT.

      • setBackgroundSelect

        public void setBackgroundSelect​(long newval)
        Sets the value of the control XPRSconstants.BACKGROUNDSELECT. Bit-vector control (see Section ) to select which tasks to run in background jobs (for example in parallel to the root cut loop).
        Parameters:
        newval - New value for control XPRSconstants.BACKGROUNDSELECT.

      • 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.
        Returns:
        Value of control XPRSconstants.GLOBALLSHEURSTRATEGY.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.GLOBALLSHEURSTRATEGY.

      • 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.
        Returns:
        Value of control XPRSconstants.PRECONFIGURATION.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PRECONFIGURATION.

      • 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.
        Returns:
        Value of control XPRSconstants.FEASIBILITYJUMP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.FEASIBILITYJUMP.

      • 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 bit-vector control (see Section ) has an effect only on the deletion filter of the IIS procedure. (Values are from the enumeration XPRSenumerations.IISOps)
        Returns:
        Value of control XPRSconstants.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 bit-vector control (see Section ) has an effect only on the deletion filter of the IIS procedure. (Values are from the enumeration XPRSenumerations.IISOps)
        Parameters:
        newval - New value for control XPRSconstants.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.
        Returns:
        Value of control XPRSconstants.RLTCUTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.RLTCUTS.

      • resetRLTCuts

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

      • setHeursearchBackgroundSelect

        public void setHeursearchBackgroundSelect​(long newval)
        Sets the value of the control XPRSconstants.HEURSEARCHBACKGROUNDSELECT. Bit-vector control (see Section ) to select which large neighborhood searches to run in the background (for example in parallel to the root cut loop).
        Parameters:
        newval - New value for control XPRSconstants.HEURSEARCHBACKGROUNDSELECT.

      • 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.
        Returns:
        Value of control XPRSconstants.HEURSHIFTPROP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURSHIFTPROP.

      • 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.
        Returns:
        Value of control XPRSconstants.GLOBALNLPCUTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.GLOBALNLPCUTS.

      • 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.
        Returns:
        Value of control XPRSconstants.GLOBALTREENLPCUTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.GLOBALTREENLPCUTS.

      • getBarhgOps

        public XPRSenumerations.BARHGOps getBarhgOps()
        Retrieves the value of the control XPRSconstants.BARHGOPS. Bit-vector control (see Section ) 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)
        Returns:
        Value of control XPRSconstants.BARHGOPS.

      • setBarhgOps

        public void setBarhgOps​(XPRSenumerations.BARHGOps newval)
        Sets the value of the control XPRSconstants.BARHGOPS. Bit-vector control (see Section ) 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)
        Parameters:
        newval - New value for control XPRSconstants.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.
        Returns:
        Value of control XPRSconstants.BARHGMAXRESTARTS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARHGMAXRESTARTS.

      • getMCFCutStrategy

        public int getMCFCutStrategy()
        Retrieves the value of the control XPRSconstants.MCFCUTSTRATEGY. Level of Multi-Commodity Flow (MCF) cutting planes separation: This specifies how aggressively 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.
        Returns:
        Value of control XPRSconstants.MCFCUTSTRATEGY.

      • 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 aggressively 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.
        Parameters:
        newval - New value for control XPRSconstants.MCFCUTSTRATEGY.

      • getPreRootThreads

        public int getPreRootThreads()
        Retrieves the value of the control XPRSconstants.PREROOTTHREADS. Specifies an explicit number of threads that should be used for the Pre-root parallel heuristic phase. By default, this phase will use all threads available to the solver (as governed by the control THREADS).
        Returns:
        Value of control XPRSconstants.PREROOTTHREADS.

      • setPreRootThreads

        public void setPreRootThreads​(int newval)
        Sets the value of the control XPRSconstants.PREROOTTHREADS. Specifies an explicit number of threads that should be used for the Pre-root parallel heuristic phase. By default, this phase will use all threads available to the solver (as governed by the control THREADS).
        Parameters:
        newval - New value for control XPRSconstants.PREROOTTHREADS.

      • getBarIterative

        public int getBarIterative()
        Retrieves the value of the control XPRSconstants.BARITERATIVE. The maximum number of barrier iterations in which an iterative solver is used instead of the Cholesky decomposition.
        Returns:
        Value of control XPRSconstants.BARITERATIVE.

      • setBarIterative

        public void setBarIterative​(int newval)
        Sets the value of the control XPRSconstants.BARITERATIVE. The maximum number of barrier iterations in which an iterative solver is used instead of the Cholesky decomposition.
        Parameters:
        newval - New value for control XPRSconstants.BARITERATIVE.

      • getDeterministicLog

        public int getDeterministicLog()
        Retrieves the value of the control XPRSconstants.DETERMINISTICLOG. Suppress non-deterministic log information in the standard MIP log. In particular, wall clock time stamps are replaced by (deterministic) work units.
        Returns:
        Value of control XPRSconstants.DETERMINISTICLOG.

      • setDeterministicLog

        public void setDeterministicLog​(int newval)
        Sets the value of the control XPRSconstants.DETERMINISTICLOG. Suppress non-deterministic log information in the standard MIP log. In particular, wall clock time stamps are replaced by (deterministic) work units.
        Parameters:
        newval - New value for control XPRSconstants.DETERMINISTICLOG.

      • getBarhgGPU

        public int getBarhgGPU()
        Retrieves the value of the control XPRSconstants.BARHGGPU. Whether to use a GPU for the hybrid gradient algorithm. Even though the GPU implementation of the hybrid gradient algorithm is identical in operation and functionality to the CPU implementation, the returned solutions can differ between the two versions due to the different architecture of the GPU. GPU support is not available in the deterministic concurrent LP algorithm.
        Returns:
        Value of control XPRSconstants.BARHGGPU.

      • setBarhgGPU

        public void setBarhgGPU​(int newval)
        Sets the value of the control XPRSconstants.BARHGGPU. Whether to use a GPU for the hybrid gradient algorithm. Even though the GPU implementation of the hybrid gradient algorithm is identical in operation and functionality to the CPU implementation, the returned solutions can differ between the two versions due to the different architecture of the GPU. GPU support is not available in the deterministic concurrent LP algorithm.
        Parameters:
        newval - New value for control XPRSconstants.BARHGGPU.

      • resetBarhgGPU

        public void resetBarhgGPU()
        Resets to its default the value of control XPRSconstants.BARHGGPU

      • getBarhgPrecision

        public XPRSenumerations.BarHGPrecision getBarhgPrecision()
        Retrieves the value of the control XPRSconstants.BARHGPRECISION. Whether to use single or double precision floating-point arithmetic in the hybrid gardient algorithm. The single precision implementation uses less memory and is, in general, faster than the double precision implementation. This control applies to both the CPU and the GPU implementation of the algorithm. The performance difference is greater for the GPU version. (Values are from the enumeration XPRSenumerations.BarHGPrecision)
        Returns:
        Value of control XPRSconstants.BARHGPRECISION.

      • setBarhgPrecision

        public void setBarhgPrecision​(XPRSenumerations.BarHGPrecision newval)
        Sets the value of the control XPRSconstants.BARHGPRECISION. Whether to use single or double precision floating-point arithmetic in the hybrid gardient algorithm. The single precision implementation uses less memory and is, in general, faster than the double precision implementation. This control applies to both the CPU and the GPU implementation of the algorithm. The performance difference is greater for the GPU version. (Values are from the enumeration XPRSenumerations.BarHGPrecision)
        Parameters:
        newval - New value for control XPRSconstants.BARHGPRECISION.

      • getGPUPlatform

        public int getGPUPlatform()
        Retrieves the value of the control XPRSconstants.GPUPLATFORM. Controls what kind of GPU support is enabled overall in Xpress. Individual solver components may disable GPU support.
        Returns:
        Value of control XPRSconstants.GPUPLATFORM.

      • setGPUPlatform

        public void setGPUPlatform​(int newval)
        Sets the value of the control XPRSconstants.GPUPLATFORM. Controls what kind of GPU support is enabled overall in Xpress. Individual solver components may disable GPU support.
        Parameters:
        newval - New value for control XPRSconstants.GPUPLATFORM.

      • 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.
        Returns:
        Value of control XPRSconstants.MAXCUTTIME.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXCUTTIME.

      • 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.
        Returns:
        Value of control XPRSconstants.MAXSTALLTIME.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXSTALLTIME.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TUNERMAXTIME.

      • 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.

        Examples using controls().getMatrixTol:

        Returns:
        Value of control XPRSconstants.MATRIXTOL.

      • 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.

        Examples using controls().getMatrixTol:

        Parameters:
        newval - New value for control XPRSconstants.MATRIXTOL.

      • 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.
        Returns:
        Value of control XPRSconstants.PIVOTTOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PIVOTTOL.

      • 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.

        Examples using controls().getFeasTol:

        Returns:
        Value of control XPRSconstants.FEASTOL.

      • 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.

        Examples using controls().getFeasTol:

        Parameters:
        newval - New value for control XPRSconstants.FEASTOL.

      • resetFeasTol

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

      • 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.
        Returns:
        Value of control XPRSconstants.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.
        Parameters:
        newval - New value for control XPRSconstants.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.
        Returns:
        Value of control XPRSconstants.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.
        Parameters:
        newval - New value for control XPRSconstants.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.
        Returns:
        Value of control XPRSconstants.ETATOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.ETATOL.

      • 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.
        Returns:
        Value of control XPRSconstants.RELPIVOTTOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.RELPIVOTTOL.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPTOLTARGET.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPTOLTARGET.

      • 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.
        Returns:
        Value of control XPRSconstants.BARPERTURB.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARPERTURB.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPADDCUTOFF.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPADDCUTOFF.

      • 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.

        Examples using controls().getMIPAbsCutoff/controls().setMIPAbsCutoff:

        Returns:
        Value of control XPRSconstants.MIPABSCUTOFF.

      • 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.

        Examples using controls().getMIPAbsCutoff/controls().setMIPAbsCutoff:

        Parameters:
        newval - New value for control XPRSconstants.MIPABSCUTOFF.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPRELCUTOFF.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPRELCUTOFF.

      • 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.
        Returns:
        Value of control XPRSconstants.PSEUDOCOST.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PSEUDOCOST.

      • 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).
        Returns:
        Value of control XPRSconstants.PENALTY.

      • 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).
        Parameters:
        newval - New value for control XPRSconstants.PENALTY.

      • 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.
        Returns:
        Value of control XPRSconstants.BIGM.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BIGM.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPABSSTOP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPABSSTOP.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPRELSTOP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPRELSTOP.

      • 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.
        Returns:
        Value of control XPRSconstants.CROSSOVERACCURACYTOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.CROSSOVERACCURACYTOL.

      • 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.
        Returns:
        Value of control XPRSconstants.PRIMALPERTURB.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PRIMALPERTURB.

      • 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.
        Returns:
        Value of control XPRSconstants.DUALPERTURB.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.DUALPERTURB.

      • 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.
        Returns:
        Value of control XPRSconstants.CHOLESKYTOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.CHOLESKYTOL.

      • 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.
        Returns:
        Value of control XPRSconstants.BARGAPSTOP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARGAPSTOP.

      • 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.
        Returns:
        Value of control XPRSconstants.BARDUALSTOP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARDUALSTOP.

      • 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.
        Returns:
        Value of control XPRSconstants.BARPRIMALSTOP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARPRIMALSTOP.

      • 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.
        Returns:
        Value of control XPRSconstants.BARSTEPSTOP.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARSTEPSTOP.

      • getElimTol

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

      • setElimTol

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

      • resetElimTol

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

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MARKOWITZTOL.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPABSGAPNOTIFY.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPABSGAPNOTIFY.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPRELGAPNOTIFY.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPRELGAPNOTIFY.

      • setPPFactor

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

      • 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.
        Returns:
        Value of control XPRSconstants.BARGAPTARGET.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARGAPTARGET.

      • 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.
        Returns:
        Value of control XPRSconstants.BARSTARTWEIGHT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARSTARTWEIGHT.

      • 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.
        Returns:
        Value of control XPRSconstants.SBEFFORT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SBEFFORT.

      • 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.
        Returns:
        Value of control XPRSconstants.HEURDIVERANDOMIZE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.HEURDIVERANDOMIZE.

      • 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.
        Returns:
        Value of control XPRSconstants.CUTFACTOR.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.CUTFACTOR.

      • 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.
        Returns:
        Value of control XPRSconstants.EIGENVALUETOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.EIGENVALUETOL.

      • 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.
        Returns:
        Value of control XPRSconstants.INDLINBIGM.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.INDLINBIGM.

      • 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.
        Returns:
        Value of control XPRSconstants.TREEMEMORYSAVINGTARGET.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TREEMEMORYSAVINGTARGET.

      • 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.
        Returns:
        Value of control XPRSconstants.INDPRELINBIGM.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.INDPRELINBIGM.

      • 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.
        Returns:
        Value of control XPRSconstants.RELAXTREEMEMORYLIMIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.RELAXTREEMEMORYLIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPABSGAPNOTIFYOBJ.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPABSGAPNOTIFYOBJ.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPABSGAPNOTIFYBOUND.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPABSGAPNOTIFYBOUND.

      • 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.
        Returns:
        Value of control XPRSconstants.PRESOLVEMAXGROW.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PRESOLVEMAXGROW.

      • 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.
        Returns:
        Value of control XPRSconstants.MAXIMPLIEDBOUND.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MAXIMPLIEDBOUND.

      • setFeasTolTarget

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

      • 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.
        Returns:
        Value of control XPRSconstants.PRECOMPONENTSEFFORT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.PRECOMPONENTSEFFORT.

      • getBarKernel

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

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARKERNEL.

      • 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.
        Returns:
        Value of control XPRSconstants.FEASTOLPERTURB.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.FEASTOLPERTURB.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPRESTARTGAPTHRESHOLD.

      • 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.
        Returns:
        Value of control XPRSconstants.INPUTTOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.INPUTTOL.

      • 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.
        Returns:
        Value of control XPRSconstants.MIPRESTARTFACTOR.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MIPRESTARTFACTOR.

      • setCpiAlpha

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

      • resetCpiAlpha

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

      • 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.
        Returns:
        Value of control XPRSconstants.GLOBALBOUNDINGBOX.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.GLOBALBOUNDINGBOX.

      • 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.

        Examples using controls().setTimeLimit:

        Returns:
        Value of control XPRSconstants.TIMELIMIT.

      • 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.

        Examples using controls().setTimeLimit:

        Parameters:
        newval - New value for control XPRSconstants.TIMELIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.SOLTIMELIMIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SOLTIMELIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.BARHGEXTRAPOLATE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.BARHGEXTRAPOLATE.

      • getWorkLimit

        public double getWorkLimit()
        Retrieves the value of the control XPRSconstants.WORKLIMIT. The maximum work (measured in work units) that the Optimizer will run before it terminates. WORK is accumulated during the search and ever increasing. In contrast to TIME, WORK is independent of the hardware and platform on which the search is conducted. The WORKLIMIT serves as a deterministic stopping criterion. When it is reached, it leaves the optimizer in a reproducible state.
        Returns:
        Value of control XPRSconstants.WORKLIMIT.

      • setWorkLimit

        public void setWorkLimit​(double newval)
        Sets the value of the control XPRSconstants.WORKLIMIT. The maximum work (measured in work units) that the Optimizer will run before it terminates. WORK is accumulated during the search and ever increasing. In contrast to TIME, WORK is independent of the hardware and platform on which the search is conducted. The WORKLIMIT serves as a deterministic stopping criterion. When it is reached, it leaves the optimizer in a reproducible state.
        Parameters:
        newval - New value for control XPRSconstants.WORKLIMIT.

      • getPreRootWorkLimit

        public double getPreRootWorkLimit()
        Retrieves the value of the control XPRSconstants.PREROOTWORKLIMIT. Set an explicit work limit in work units for the Pre-root parallel heuristic phase. Any positive value also enables this phase and runs it until the PREROOTWORKLIMIT units of work are hit.
        Returns:
        Value of control XPRSconstants.PREROOTWORKLIMIT.

      • setPreRootWorkLimit

        public void setPreRootWorkLimit​(double newval)
        Sets the value of the control XPRSconstants.PREROOTWORKLIMIT. Set an explicit work limit in work units for the Pre-root parallel heuristic phase. Any positive value also enables this phase and runs it until the PREROOTWORKLIMIT units of work are hit.
        Parameters:
        newval - New value for control XPRSconstants.PREROOTWORKLIMIT.

      • getPreRootEffort

        public double getPreRootEffort()
        Retrieves the value of the control XPRSconstants.PREROOTEFFORT. Dial for the work spent during the Pre-root parallel heuristic phase. A positive value sets a suitable work limit that is dependent on problem-characteristics. Changing the value up/or down dials the work spent in this phase up or down. This control also enables/disables Pre-root parallel heuristics.
        Returns:
        Value of control XPRSconstants.PREROOTEFFORT.

      • setPreRootEffort

        public void setPreRootEffort​(double newval)
        Sets the value of the control XPRSconstants.PREROOTEFFORT. Dial for the work spent during the Pre-root parallel heuristic phase. A positive value sets a suitable work limit that is dependent on problem-characteristics. Changing the value up/or down dials the work spent in this phase up or down. This control also enables/disables Pre-root parallel heuristics.
        Parameters:
        newval - New value for control XPRSconstants.PREROOTEFFORT.

      • setBarhgRelTol

        public void setBarhgRelTol​(double newval)
        Sets the value of the control XPRSconstants.BARHGRELTOL. Relative feasibility tolerance for the hybrid gradient algorithm.
        Parameters:
        newval - New value for control XPRSconstants.BARHGRELTOL.

      • 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.
        Returns:
        Value of control XPRSconstants.MPSRHSNAME.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MPSRHSNAME.

      • 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.
        Returns:
        Value of control XPRSconstants.MPSOBJNAME.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MPSOBJNAME.

      • 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.
        Returns:
        Value of control XPRSconstants.MPSRANGENAME.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MPSRANGENAME.

      • 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.
        Returns:
        Value of control XPRSconstants.MPSBOUNDNAME.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MPSBOUNDNAME.

      • 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.
        Returns:
        Value of control XPRSconstants.OUTPUTMASK.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.OUTPUTMASK.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TUNERMETHODFILE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.TUNEROUTPUTPATH.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.NLPFUNCEVAL.

      • setNlpLog

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

      • resetNlpLog

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

      • getNlpPresolve

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

      • setNlpPresolve

        public void setNlpPresolve​(int newval)
        Sets the value of the control XPRSconstants.NLPPRESOLVE. This control determines whether presolving should be performed on the nonlinear problem prior to starting the main algorithm
        Parameters:
        newval - New value for control XPRSconstants.NLPPRESOLVE.

      • setSlpLog

        public void setSlpLog​(int newval)
        Sets the value of the control XPRSconstants.SLPLOG. Frequency with which SLP status is printed
        Parameters:
        newval - New value for control XPRSconstants.SLPLOG.

      • resetSlpLog

        public void resetSlpLog()
        Resets to its default the value of control XPRSconstants.SLPLOG

      • setNlpJacobian

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

      • setNlpHessian

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

      • getMultiStart

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

      • setMultiStart

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

      • 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
        Returns:
        Value of control XPRSconstants.NLPMAXTIME.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.NLPMAXTIME.

      • 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.
        Returns:
        Value of control XPRSconstants.NLPREFORMULATE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.NLPREFORMULATE.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.MULTISTART_SEED.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.MULTISTART_POOLSIZE.

      • setNlpPostsolve

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

      • 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
        Returns:
        Value of control XPRSconstants.NLPPRESOLVELEVEL.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.NLPPRESOLVELEVEL.

      • 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.
        Returns:
        Value of control XPRSconstants.NLPPROBING.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.NLPPROBING.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.NLPFINDIV.

      • 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
        Returns:
        Value of control XPRSconstants.NLPLINQUADBR.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.NLPLINQUADBR.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SLPCUTSTRATEGY.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPINFEASLIMIT.

      • 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
        Returns:
        Value of control XPRSconstants.SLPSAMECOUNT.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPSAMECOUNT.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPSAMEDAMP.

      • setSlpSBStart

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

      • getSlpXCount

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

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPXCOUNT.

      • getSlpXLimit

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

      • 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 is performed
        Parameters:
        newval - New value for control XPRSconstants.SLPXLIMIT.

      • setSlpAnalyze

        public void setSlpAnalyze​(int newval)
        Sets the value of the control XPRSconstants.SLPANALYZE. Bit map activating additional options supporting model / solution path analysis
        Parameters:
        newval - New value for control XPRSconstants.SLPANALYZE.

      • 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
        Returns:
        Value of control XPRSconstants.SLPOCOUNT.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPOCOUNT.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPMIPOCOUNT.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPDELTAOFFSET.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPUPDATEOFFSET.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPERROROFFSET.

      • 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
        Returns:
        Value of control XPRSconstants.SLPSBROWOFFSET.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPSBROWOFFSET.

      • getSlpVCount

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

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPVCOUNT.

      • getSlpVLimit

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

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPVLIMIT.

      • resetSlpScale

        public void resetSlpScale()
        Resets to its default the value of control XPRSconstants.SLPSCALE

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPECFCHECK.

      • 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
        Returns:
        Value of control XPRSconstants.SLPWCOUNT.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPWCOUNT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SLPUNFINISHEDLIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.SLPTRACEMASKOPS.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SLPTRACEMASKOPS.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPLSZEROLIMIT.

      • 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.
        Returns:
        Value of control XPRSconstants.SLPHEURSTRATEGY.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SLPHEURSTRATEGY.

      • resetNlpZero

        public void resetNlpZero()
        Resets to its default the value of control XPRSconstants.NLPZERO

      • 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
        Parameters:
        newval - New value for control XPRSconstants.NLPDEFAULTIV.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.NLPPRESOLVEZERO.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.NLPMERITLAMBDA.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.MSMAXBOUNDRANGE.

      • setSlpDamp

        public void setSlpDamp​(double newval)
        Sets the value of the control XPRSconstants.SLPDAMP. Damping factor for updating values of variables
        Parameters:
        newval - New value for control XPRSconstants.SLPDAMP.

      • resetSlpDamp

        public void resetSlpDamp()
        Resets to its default the value of control XPRSconstants.SLPDAMP

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPDELTA_A.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPDELTA_R.

      • 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
        Returns:
        Value of control XPRSconstants.SLPDJTOL.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPDJTOL.

      • resetSlpDJTol

        public void resetSlpDJTol()
        Resets to its default the value of control XPRSconstants.SLPDJTOL

      • resetSlpCTol

        public void resetSlpCTol()
        Resets to its default the value of control XPRSconstants.SLPCTOL

      • setSlpMTol_A

        public void setSlpMTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPMTOL_A. Absolute effective matrix element convergence tolerance
        Parameters:
        newval - New value for control XPRSconstants.SLPMTOL_A.

      • setSlpMTol_R

        public void setSlpMTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPMTOL_R. Relative effective matrix element convergence tolerance
        Parameters:
        newval - New value for control XPRSconstants.SLPMTOL_R.

      • setSlpMVTol

        public void setSlpMVTol​(double newval)
        Sets the value of the control XPRSconstants.SLPMVTOL. Marginal value tolerance for determining if a constraint is slack
        Parameters:
        newval - New value for control XPRSconstants.SLPMVTOL.

      • resetSlpMVTol

        public void resetSlpMVTol()
        Resets to its default the value of control XPRSconstants.SLPMVTOL

      • setSlpXTol_A

        public void setSlpXTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPXTOL_A. Absolute static objective function (1) tolerance
        Parameters:
        newval - New value for control XPRSconstants.SLPXTOL_A.

      • setSlpXTol_R

        public void setSlpXTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPXTOL_R. Relative static objective function (1) tolerance
        Parameters:
        newval - New value for control XPRSconstants.SLPXTOL_R.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPDAMPMAX.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPDAMPMIN.

      • setSlpOTol_A

        public void setSlpOTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPOTOL_A. Absolute static objective (2) convergence tolerance
        Parameters:
        newval - New value for control XPRSconstants.SLPOTOL_A.

      • setSlpOTol_R

        public void setSlpOTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPOTOL_R. Relative static objective (2) convergence tolerance
        Parameters:
        newval - New value for control XPRSconstants.SLPOTOL_R.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPDELTA_X.

      • setSlpEscalation

        public void setSlpEscalation​(double newval)
        Sets the value of the control XPRSconstants.SLPESCALATION. Factor for increasing cost multiplier on individual penalty error vectors
        Parameters:
        newval - New value for control XPRSconstants.SLPESCALATION.

      • setSlpShrinkBias

        public void setSlpShrinkBias​(double newval)
        Sets the value of the control XPRSconstants.SLPSHRINKBIAS. Defines an overwrite / adjustment of step bounds for improving iterations
        Parameters:
        newval - New value for control XPRSconstants.SLPSHRINKBIAS.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPFEASTOLTARGET.

      • setSlpVTol_A

        public void setSlpVTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPVTOL_A. Absolute static objective (3) convergence tolerance
        Parameters:
        newval - New value for control XPRSconstants.SLPVTOL_A.

      • setSlpVTol_R

        public void setSlpVTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPVTOL_R. Relative static objective (3) convergence tolerance
        Parameters:
        newval - New value for control XPRSconstants.SLPVTOL_R.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPCLAMPSHRINK.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPECFTOL_A.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPECFTOL_R.

      • setSlpWTol_A

        public void setSlpWTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPWTOL_A. Absolute extended convergence continuation tolerance
        Parameters:
        newval - New value for control XPRSconstants.SLPWTOL_A.

      • setSlpWTol_R

        public void setSlpWTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPWTOL_R. Relative extended convergence continuation tolerance
        Parameters:
        newval - New value for control XPRSconstants.SLPWTOL_R.

      • setSlpMatrixTol

        public void setSlpMatrixTol​(double newval)
        Sets the value of the control XPRSconstants.SLPMATRIXTOL. Nonzero tolerance for dropping coefficients from the linearization.
        Parameters:
        newval - New value for control XPRSconstants.SLPMATRIXTOL.

      • 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.
        Returns:
        Value of control XPRSconstants.SLPDRFIXRANGE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SLPDRFIXRANGE.

      • 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
        Returns:
        Value of control XPRSconstants.SLPDRCOLTOL.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPDRCOLTOL.

      • setSlpCDTol_A

        public void setSlpCDTol_A​(double newval)
        Sets the value of the control XPRSconstants.SLPCDTOL_A. Absolute tolerance for deducing constant derivatives
        Parameters:
        newval - New value for control XPRSconstants.SLPCDTOL_A.

      • setSlpCDTol_R

        public void setSlpCDTol_R​(double newval)
        Sets the value of the control XPRSconstants.SLPCDTOL_R. Relative tolerance for deducing constant derivatives
        Parameters:
        newval - New value for control XPRSconstants.SLPCDTOL_R.

      • 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.
        Returns:
        Value of control XPRSconstants.SLPDRCOLDJTOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.SLPDRCOLDJTOL.

      • 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
        Parameters:
        newval - New value for control XPRSconstants.SLPBARSTALLINGTOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.KNITRO_PARAM_MAXCGIT.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.KNITRO_PARAM_DELTA.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.KNITRO_PARAM_BAR_INITMU.

      • 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.
        Returns:
        Value of control XPRSconstants.KNITRO_PARAM_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.
        Parameters:
        newval - New value for control XPRSconstants.KNITRO_PARAM_XTOL.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.KNITRO_PARAM_LMSIZE.

      • 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.
        Returns:
        Value of control XPRSconstants.KNITRO_PARAM_PRESOLVE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.KNITRO_PARAM_PRESOLVE.

      • getKnitroParamSoltype

        public int getKnitroParamSoltype()
        Retrieves the value of the control XPRSconstants.KNITRO_PARAM_SOLTYPE. This option specifies the solution returned by Knitro. Generally, the solution converged to by Knitro is a locally optimal solution that corresponds to the best feasible solution found. However, on rare occasions, Knitro may enounter a feasible solution during the optimization process that has a better objective value than the final solution converged to by Knitro. Setting soltype = 1 in this case will return this iterate.
        Returns:
        Value of control XPRSconstants.KNITRO_PARAM_SOLTYPE.

      • setKnitroParamSoltype

        public void setKnitroParamSoltype​(int newval)
        Sets the value of the control XPRSconstants.KNITRO_PARAM_SOLTYPE. This option specifies the solution returned by Knitro. Generally, the solution converged to by Knitro is a locally optimal solution that corresponds to the best feasible solution found. However, on rare occasions, Knitro may enounter a feasible solution during the optimization process that has a better objective value than the final solution converged to by Knitro. Setting soltype = 1 in this case will return this iterate.
        Parameters:
        newval - New value for control XPRSconstants.KNITRO_PARAM_SOLTYPE.

      • 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.
        Parameters:
        newval - New value for control XPRSconstants.KNITRO_PARAM_MIP_LPALG.
Parent Topic XPRSprob

© 2001-2025 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.