- 1 SolverInfo(item, lp, LpType, engine, ref)
- 2 Obtaining Information about a Problem Instance
- 3 Obtaining Information about a Solver Engine
- 4 General Information
- 5 Obtaining Multiple Items in a Single Call
- 6 Testing for the presence of an Engine
- 7 Diagnostics
- 8 History
- 9 See Also
SolverInfo(item, lp, LpType, engine, ref)
The SolverInfo function provides information about a specific optimizer engine, or about a previously-defined LP, QP or NLP. Its declaration is:
- SolverInfo(item: atomic text; lp: optional atomic LpType; engine: optional atomic text; ref: optional boolean = False )
- A problem instance previously defined by LpDefine, QpDefine or NlpDefine, LpRead, or returned by LpFindIIS.
- A description of the desired item(s). Case insensitive. See below for possible values.
- The name of a Solver engine.
- A flag indicating whether a reference to the result should be returned.
Obtaining Information about a Problem Instance
You can obtain information about a previously-defined optimization problem using the two-parameter form of SolverInfo:
For example, to get the variable lower bounds use:
Possible values for «Item» are
«Item» Valid For Dimensionality Type Description
LP, QP Vars numeric
QP Vars, Vars2 numeric
LP, QP Vars, Constraints numeric
QP Vars, Vars2, Constraints numeric
LP, QP, NLP Constraints numeric
LP, QP, NLP Constraints numeric Upper bound for each constraint
LP, QP, NLP Constraints numeric Lower bound for each constraint
LP, QP, NLP Constraints '>=', '<=', '=', 'R' inequality for each constraint. 'R' for range (lb & ub)
LP, QP, NLP Vars numeric lower bound for each variable
LP, QP, NLP Vars numeric upper bound for each variable
LP, QP, NLP Vars 'C', 'I', or 'B'
LP, QP, NLP Vars numeric
LP, QP, NLP atomic True, False
LP, QP, NLP atomic text
LP, QP, NLP local .Parameter numeric
LP, QP, NLP atomic "LP", "QP", "QCP" or "NLP"
LP, QP, NLP Vars elements of the Vars index
LP, QP, NLP Constraints the constraint names
If any of these «item»s are specified, but the «lp» parameter is not provided, an error results.
Obtaining Information about a Solver Engine
SolverInfo(item, Engine: engineName)
returns information about a solver engine. The possible values for «item» in this usage are:
«Item» Dimensionality Type Description
List numeric Array of control setting names.
Local .Parameter numeric upper bounds for setting
Local .Parameter numeric lower bounds for setting
Local .Parameter numeric default value for setting
atomic text The engine name (null without error if engine not installed)
atomic text File path to solver engine's DLL, "" for bulit-in engines.
atomic numeric number of days until Frontline solver trial license expires
Local .ProblemType boolean A list of the problem types handled by each engine
Local .ProblemType numeric Maximum number of decision variables supported by engine
Local .ProblemType numeric Maximum number of integer variables supported by engine
Local .ProblemType numeric Maximum number of constraints supported by engine
Local .ProblemType numeric Maximum number of variable bounds supported by engine
atomic numeric Time spent in computation.
atomic numeric # of iterations engine has performed
atomic numeric # of function evaluations that have occurred
atomic numeric # of jacobians evaluations that have occurred
atomic numeric # of hessians evaluations that have occurred
If the «Engine» parameter is omitted, but the «Lp» parameter is present, then the setting for the engine used by «Lp» is returned. If both the «LP» and «Engine» parameters are specified, then these settings will be returned for the specified «Engine» (in the case that these differ).
Some information can be obtained without specifying any problem instance or engine using the syntax, e.g.:
The possible Items not pertaining to any engine or problem instance are:
«Item» Dimensionality Type Description
List Text The names the Solver engines available for use.
Obtaining Multiple Items in a Single Call
Multiple items can be obtained from SolverInfo in a single call by array abstracting over the Item parameter. For example:
Index SettingInfo := ["Name", "Max", "Min", "Value"]
Variable TheSettings := SolverInfo(Lp: the_lp, Item: SettingInfo)
This example would return two dimensional arrays indexed by
SettingInfo and by a local index named
Since many of the possible Item values return results with different dimensionality, using the function in this way would cause the dimensionalities to be combined undesirably. Thus, when obtaining items having different dimensionality in a single call, the ref parameter can be set to true, and a reference to each setting is returned. For example, the following would compute slack:
Var info := SolverInfo(lp: lp, Item: ["lhs","rhs"], Ref: true);
Var x := LpSolution(lp);
#info[.Parameter="rhs"] - sum(#info[.Parameter = 'lhs']*x, Vars)
Testing for the presence of an Engine
Suppose you have an external solver engine, such as Knitro, which you use. However, your colleague who also uses the model has Analyica Optimizer but not the Knitro add-in. Your model may need to test whether Knitro is present on the machine and then fall back to the default solver if it is not present.
The preferred method for testing whether an external solver engine (Knitro in this example) is installed is:
SolverInfo( "EngineName", Engine: "Knitro" ) <> Null
SolverInfo("Name",Engine:eng) returns the engine name (e.g.,
"Knitro") if the engine is fully installed. If it is installed, the engine DLL is loaded into the processes memory. If the engine is not present, or not correctly installed, Null is returned. All other items that require an engine issue an error if the engine is not present.
"EngineName" does not issue an error.
This section details some problems you might encounter while using SolverInfo, why they occur, and what to do about them.
Result has multiple .Parameter dimensions
If you array abstract across multiple solver engines with an Item returning a
.Parameter-indexed result (such as "Defaults", "MinSettings", etc), the result of SolverInfo may contain multiple local
.Parameter indexes. This occurs because different solver engines have different sets of possible parameters, so a separate local index is created for each one. This can also occur if you abstract over multiple problem instances, if each problem instance uses a different engine.
If you do not specify the
Ref: True parameter to SolverInfo in this case, you'll end up with a very large array, indexes by all the
.Parameter indexes. For example, if
engine1 has 70 parameters,
engine2 has 75 parameters, and
engine3 has 65 parameters, you'll have an array with 70*75*65 = 341K elements after abstracting over the three engines. So, if you are abstracting a settings parameter over multiple problems, or over multiple engines, you probably want to use
Takes excessively long time
If SolverInfo is taking a very long time to compute, possibly giving the impression that it is hanging (although it should abort with Ctrl+break), a likely cause is that you may be inadvertently combining many multi-dimensional results into a very large high-dimensional result array. This situation can occur if you are array abstracting over multiple items, LPs or engines, and if some or all of the atomic cases are returning array-valued results. In such a case, you will want to use
Ref: True so that these results are not combined.
If SolverInfo unexpectedly consumes all available memory, it is likely that you are array abstracting over many array-valued results with different dimensionalities. These dimensionalities get combined, and may result in an excessively large array. The remedy is to specify
Ref: True so that individual results are returned as references and dimensionalities are not combined.
Error: "Engine library could not be found"
This error may result if an external add-on engine is not correctly installed. You may find that the name of an external engine appears in the result returned by
SolverInfo("AvailEngines"), but when you try to use this same value for the Engine parameter, the error message appears.
To fix, use regedit to modify the value
HKLM/Software/Lumina Decision Systems/Analytica/4.0/SolverEngines/engName
engName is the engine name. The value of this key should be a string value with a fully qualified path to the DLL containing the engine. For example, it should not contain just
"Knitro.DLL", but rather it should contain
"C:\Program Files\Frontline Systems\Knitro\Knitro.DLL", for example. The quotations marks should not be in the value. To test whether this fixes the problem, it is not necessary to exit and restart Analytica - you can simply attempt to re-evaluate the SolverInfo call.
Introduced in Analytica 4.0.