Optimizer control settings

Analytica Optimizer GuideOptimizer control settings

This chapter shows you how to:

Specify Optimizer engine settings in DefineOptimization()
Determine what setting are available for each engine, defaults, and possible range
Determine size capacities for installed engines
Control termination criteria during optimization
Select search algorithms
Specify numeric precision

Controlling the search

The optimization engine exposes several settings that you can change to influence how the search for the optimum proceeds and when it terminates. The specific collection of available settings is a function of which engine is used to solve the optimization, so that if you install and use an add-on engine, other than the engine that comes standard with Analytica Optimizer, the possible settings might be different. The OptInfo() function can be used to view current values for a problem.

To see this, define a variable as:

   OptInfo(Opt, "Settings")

Where Opt identifies the variable containing the DefineOptimization() function.

Settings can be changed for a particular problem by specifying values for the SettingName and SettingValue parameters to DefineOptimization(). The first subsection below describes how you specify and view settings, while the subsequent sub-sections detail particular settings used by engines the come standard with Analytica Optimizer.

Selecting the optimization engine

Four optimization engines come standard with Analytica Optimizer:

LP/Quadratic - uses a dual simplex method combined with branch-and bound for mixed-integer constraints, with a variety of integer cut-set procedures. This is generally the engine of choice for LPs and mixed-integer LPs. For hard mixed-integer LPs, however, the Evolutionary engine uses a very different approach and might be worth trying.

SOCP Barrier - uses interior point methods designed specifically for quadratically constrained convex problems. The GRG Nonlinear engine is often a good alternative for thi type of problem, especially if the constraints end up being non-convex.

GRG Nonlinear - The Generalized Reduced Gradient solver is suitable for smooth non-linear problems. If gradients and Jacobians can be analytically determined, the speed of this method will be dramatically faster.

Evolutionary - Best suited for non-smooth problems the evolutionary engine creates a population of potential solutions and keeps the best ones.. By default, the Evolutionary engine does not use gradient information. However, if the LocalSearch setting is on, then it optimizes sample points before adding them to the population using various techniques including gradient-based search.

The following matrix shows engine compatibility for each problem type:

		LP/Quadratic	SOCP Barrier	GRG Nonlinear	Evolutionary
LP	Linear Program	*	*	*	*
QP	Quadratic Program (linearly constrained)	*	*	*	*
QCP	Quadratically Constrained Program		*^[1]	*	*
CQCP	Convex QCP		*	*	*
NCQCP	Non-Convex QCP			*	*
NLP	Non-Linear Program (smooth)			*	*
NSP	Non-Smooth Program			*	*

If you have purchased other add-on engines, other options might also be available to you. You can obtain a full list of installed engines and the problem types supported by each by evaluating the following Analytica expression.

   OptEngineInfo("All","ProblemTypes")

To explicitly select the engine to be used, include the Engine parameter to DefineOptimization().

   Engine : Optional Text

For example:

   DefineOptimization( ..., Engine: "Evolutionary" )

If you do not specify the engine, Analytica selects an appropriate engine based on the properties of the problem that you specified. However, if the engine does not perform satisfactorily on that problem, you might obtain better results with a different engine.

To determine what engine is actually used on a problem, evaluate this Analytica expression.

   OptInfo(Opt, "Engine")

Where Opt is the object returned by DefineOptimization().

Examining engine capabilities

Information about the limits on the maximum number of variables or constraints allowed by each installed engine can be accessed using this expression:

 OptEngineInfo( "All",["MaxVars","MaxIntVars","MaxConstraints"])

This returns a table indexed by .ProblemType, .Engine and the limit type, e.g.:

The problem types displayed include are:

Element	Description
LP	linear program
QP	quadratic objective, linear constraints
QCP	quadratic with convex quadratic constraints (solvers designed specifically for quadratics treat this as if the problem is convex)
NLP	smooth nonlinear
NSP	non-smooth nonlinear

Specifying settings

If you want to change the value for a single control setting, you can specify values for two optional parameters, settingName and settingValue, to DefineOptimization(), providing the text name of the setting to settingName, and the numeric value to settingValue. For example, if you want to set the Scaling parameter to 1, you would modify your call to DefineOptimization() as follows.

DefineOptimization( .., settingName: "Scaling", settingValue: 1 )

To alter more than one control setting, you need to supply arrays to these parameters. The arrays passed to settingName and settingValue should have a single common index. If the index of the array passed to settingValue is a list of labels, where the index labels contain the name of each control setting, then you only need to include the settingValue parameter.

It is often convenient to specify control settings in a self-indexed edit table. The following steps illustrate this:

Drag a variable node to your diagram, title it Opt Settings.
In the definition pane, set the definition type to Table.
In the Index Chooser dialog, select Opt Settings (Self) as the table index.
Click the row heading cell, and change Item 1 to Scaling.
With the row header still selected, press down-arrow to add a row.
Change the second row header cell to MaxTime.
Enter 1 into the first table body cell.
Enter 30 into the second body table cell.

In your call to DefineOptimization(), insert a settng parameter as follows.

     DefineOptimization( ..., settingValue: Opt_Settings )

The Optimizer scales parameters and terminates after 30 seconds if the optimum has not been found. A self-indexed table set up in this fashion makes it easy to adjust multiple control settings if the need arises.

↑ You may not know whether your QCP is convex when you formulate it, and DefineOptimization’s quadratic analysis does not determine convexity. Testing for convexity can be more computationally intensive than solving the problem, so if you think SOCP Barrier is the preferred engine, you can attempt to solve it using SOCP Barrier. During the solution, it may succeed, or it may detect the non-convexity and terminate without a feasible solution. Always check OptStatusText().

[1] You may not know whether your QCP is convex when you formulate it, and DefineOptimization’s quadratic analysis does not determine convexity. Testing for convexity can be more computationally intensive than solving the problem, so if you think SOCP Barrier is the preferred engine, you can attempt to solve it using SOCP Barrier. During the solution, it may succeed, or it may detect the non-convexity and terminate without a feasible solution. Always check OptStatusText().

[1]