# source:trunk/SYMPHONY/Doc/man-param.tex@1747

Last change on this file since 1747 was 1747, checked in by asm4, 4 years ago

Documented parameters for reliability branching and feasibility pump.

• Property svn:eol-style set to native
• Property svn:keywords set to Author Date Id Revision
File size: 53.3 KB
Line
1%===========================================================================%
2%                                                                           %
3% This file is part of the documentation for the SYMPHONY MILP Solver.      %
4%                                                                           %
5% SYMPHONY was jointly developed by Ted Ralphs (ted@lehigh.edu) and         %
7%                                                                           %
9%                                                                           %
11% accompanying file for terms.                                              %
12%                                                                           %
13%===========================================================================%
14
15\label{parameter_file}
16Parameters can be set in one of two ways. Some commonly-used parameters can be
17set on the command line. To see a list of these, run \BB\ with no command-line
18arguments. Other parameters must be set in a parameter file. The name of this
19file is specified on the command line with \texttt{-f}''.  Each line of the
20parameter file contains either a comment or two words -- a keyword and a
21value, separated by white space. If the first word (sequence of
22non-white-space characters) on a line is not a keyword, then the line is
23considered a comment line. Otherwise the parameter corresponding to the
24keyword is set to the listed value. Usually the keyword is the same as the
25parameter name in the source code. Here we list the keywords, the type of
26value that should be given with the keywords and the default value. A
27parameter corresponding to keyword K'' in module P'' can also be set by
28using the keyword P\_K''.
29
30To make this list shorter, occasionally a comma separated list of parameters
31is given if the meanings of those parameters are strongly
32connected. For clarity, the constant name is sometimes given instead
33of the numerical value for default settings and options. The
34corresponding value is given in curly braces for convenience.
35
36\subsection{Global parameters}
37\begin{description}
38\item[\ptt{verbosity} -- integer (0).]
39\sindex[p]{\GP!verbosity}
40Sets the verbosity of all modules to the given value. In general,
41the greater this number the more verbose each module is. Experiment
42to find out what this means.
43
44\item[\ptt{random\_seed} -- integer (17).]
45\sindex[p]{\GP!random\_seed}
46A random seed.
47
48\item[\ptt{granularity} -- double (1e-6).]
49\sindex[p]{\GP!granularity}
50Should be set to the minimum difference between two distinct
51objective function values'' less the epsilon tolerance. E.g., if every
52variable is integral and the objective coefficients are integral then
53for any feasible solution the objective value is integer, so {\tt
54granularity} could be correctly set to .99999.
55
56\item[\ptt{upper\_bound} -- double (none)].
57\sindex[p]{\GP!upper\_bound}
58The value of the best known upper bound.
59
60\item[\ptt{probname} -- string (empty string).]
61\sindex[p]{\GP!probname}
62The name of the problem name.
63
64\item[\ptt{infile\_name} -- string (empty string).]
65\sindex[p]{\GP!infile\_name}
66The name of the input file that was read by -F'' or the -L'' flag.
67
68\end{description}
69
70\subsection{Master module parameters}
71\begin{description}
72
73\item[\ptt{M\_verbosity} -- integer (0).]
74\sindex[p]{\MP!M\_verbosity}
75
76\item[\ptt{M\_random\_seed} -- integer (17).]
77\sindex[p]{\MP!M\_random\_seed}
78A random seed just for the Master module.
79
80\item[\ptt{upper\_bound} -- double (no upper bound).]
81\sindex[p]{\MP!upper\_bound}
82This parameter is used if the user wants to artificially impose an
83upper bound (for instance if a solution of that value is already
84known).
85
86\item[\ptt{lower\_bound} -- double (no lower bound).]
87\sindex[p]{\MP!lower\_bound}
88This parameter is used if the user wants to artificially impose a
89lower bound.
90
91\label{upper_bound_estimate}
92\item[\ptt{upper\_bound\_estimate} -- double (no estimate).]
93\sindex[p]{\MP!upper\_bound\_estimate}
94This parameter is used if the user wants to provide an estimate of the
95optimal value which will help guide the search. This is used in
96conjunction with the diving strategy \htmlref{\tt
97BEST\_ESTIMATE}{diving_strategy}.
98
99\item[\ptt{tm\_exe, dg\_exe} -- strings (tm'', dg'').]
100\sindex[p]{\MP!tm\_exe}
101\sindex[p]{\MP!dg\_exe}
102The name of the executable files of the TM and DG modules. Note that
103the TM executable name may have extensions that depend on the
104configuration of the modules, but the default is always set to the
105file name produced by the makefile. If you change the name of the
106treemanager executable from the default, you must set this parameter
107to the new name.
108
109\item[\ptt{tm\_debug, dg\_debug} -- boolean (both {\tt FALSE}).]
110\sindex[p]{\MP!tm\_debug}
111\sindex[p]{\MP!dg\_debug}
112Whether these modules should be started under a debugger or not (see
113\ref{debugging-PVM} for more details on this).
114
115\item[\ptt{tm\_machine} -- string (empty string).]
116\sindex[p]{\MP!tm\_machine}
117On which processor of the virtual machine the TM should be run. Leaving this
118parameter as an empty string means arbitrary selection.
119
120\item[\ptt{do\_draw\_graph} -- boolean ({\tt FALSE}).]
121\sindex[p]{\MP!do\_draw\_graph}
122Whether to start up the DG module or not (see Section \ref{IGD} for
123an introduction to this).
124
125\item[\ptt{do\_branch\_and\_cut} -- boolean ({\tt TRUE}).]
126\sindex[p]{\MP!do\_branch\_and\_cut}
127Whether to run the branch and cut algorithm or not. (Set this to {\tt
128FALSE} to run the user's heuristics only.)
129
130\item[\ptt{mc\_search\_order} -- integer ({\tt MC\_FIFO}).]
131\sindex[p]{\MP!mc\_search\_order}
132Use the fifo (MC\_FIFO) or lifo (MC\_LIFO) searh order during the multi
133criteria solution procedure.
134
135\item[\ptt{mc\_warm\_start} -- boolean({\tt FALSE}).]
136\sindex[p]{\MP!mc\_warm\_start}
137Whether to solve the corresponding problem of each iteration from a warm
138start loaded from a base iteration (which is the first iteration where
139gamma = 1.0 and tau = 0.0) or from scratch. Currently, this option is
140supported if only the supported solutions are desired to be found.
141
142\item[\ptt{trim\_warm\_tree} -- boolean({\tt FALSE}).]
143\sindex[p]{\MP!trim\_warm\_tree}
144Whether to trim the warm start tree before re-solving. This consists of
145locating nodes whose descendants are all likely to be pruned in the resolve
146and eliminating those descendants in favor of processing the parent node
147itself.
148
149\item[\ptt{mc\_compare\_solution\_tolerance} -- double({\tt 0.001}).]
150\sindex[p]{\MP!mc\_compare\_solution\_tolerance}
151If the difference between the objective values of two solutions to be compared,
152during the bicriteria solution procedure, are less than this tolerance, then
153assume them to be equal.
154
155\item[\ptt{mc\_binary\_search\_tolerance} -- double({\tt 0}).]
156\sindex[p]{\MP!mc\_binary\_search\_tolerance}
157The tolerance to be used to differentiate the gamma values if binary search
158is used during the bicriteria solution procedure. A value greater than zero
159will cause the binary search to be activated.
160
161\end{description}
162
163\subsection{Draw Graph parameters}
164\begin{description}
165
166\item[\ptt{source\_path} -- string (.'').]
167\sindex[p]{\DP!source\_path}
168The directory where the DG tcl/tk scripts reside.
169
170\item[\ptt{echo\_commands} -- boolean ({\tt FALSE}).]
171\sindex[p]{\DP!echo\_commands}
172Whether to echo the tcl/tk commands on the screen or not.
173
174\item[\ptt{canvas\_width, canvas\_height} -- integers (1000, 700).]
175\sindex[p]{\DP!canvas\_width}
176\sindex[p]{\DP!canvas\_height}
177The default width and height of the drawing canvas in pixels.
178
179\item[\ptt{viewable\_width, viewable\_height} -- integers (600, 400).]
180\sindex[p]{\DP!viewable\_width}
181\sindex[p]{\DP!viewable\_height}
182The default viewable width and height of the drawing canvas in pixels.
183
184\item[\ptt{interactive\_mode} -- integer ({\tt TRUE}).]
185\sindex[p]{\DP!interactive\_mode}
186Whether it is allowable to change things interactively on the canvas or not.
187
188\item[\ptt{node\_radius} -- integer (8).]
190The default radius of a displayed graph node.
191
192\item[\ptt{disp\_nodelabels, disp\_nodeweights, disp\_edgeweights} -- integers
193(all {\tt TRUE}).]
194\sindex[p]{\DP!disp\_nodelabels}
195\sindex[p]{\DP!disp\_nodeweights}
196\sindex[p]{\DP!disp\_edgeweights}
197Whether to display node labels, node weights, and edge weights or not.
198
199\item[\ptt{nodelabel\_font, nodeweight\_font, edgeweight\_font} -- strings
200(all -adobe-helvetica-...'').]
201\sindex[p]{\DP!nodelabel\_font}
202\sindex[p]{\DP!nodeweight\_font}
203\sindex[p]{\DP!edgeweight\_font}
204The default character font for displaying node labels, node weights and edge
205weights.
206
207\item[\ptt{node\_dash, edge\_dash} -- strings (both empty string).]
208\sindex[p]{\DP!node\_dash}
209\sindex[p]{\DP!edge\_dash}
210The dash pattern of the circles drawn around dashed nodes and that of
211dashed edges.
212
213\end{description}
214
215\subsection{Tree Manager parameters}
216\label{tm_params}
217\begin{description}
218
219\item[\ptt{TM\_verbosity} -- integer (0).]
220\sindex[p]{\TP!TM\_verbosity}
221The verbosity of the TM module.
222
223\item[\ptt{lp\_exe, cg\_exe, cp\_exe} -- strings (lp'', cg'',
224cp'').]
225\sindex[p]{\TP!lp\_exe}
226\sindex[p]{\TP!cg\_exe}
227\sindex[p]{\TP!cp\_exe}
228The name of the LP, CG, and CP module binaries. Note: when running in
229parallel using PVM, these executables (or links to them) must reside
230in the \ptt{PVM\_ROOT/bin/PVM\_ARCH/} directory. Also, be sure to note
231that the executable names may have extensions that depend on the
232configuration of the modules, but the defaults will always be set to
233the name that the makefile produces.
234
235\item[\ptt{lp\_debug, cg\_debug, cp\_debug} -- boolean (all {\tt
236FALSE}).]
237\sindex[p]{\TP!lp\_debug}
238\sindex[p]{\TP!cg\_debug}
239\sindex[p]{\TP!cp\_debug}
240Whether the modules should be started under a debugger or not.
241
242\item[\ptt{max\_active\_nodes} -- integer (1).]
243\sindex[p]{\TP!max\_active\_nodes}
244The maximum number of active search tree nodes---equal to the number of
245LP and CG tandems to be started up.
246
247\item[\ptt{max\_cp\_num} -- integer (0).]
248\sindex[p]{\TP!max\_cp\_num}
249The maximum number of cut pools to be used.
250
251\item[\ptt{lp\_mach\_num, cg\_mach\_num, cp\_mach\_num} -- integers
252(all 0).]
253\sindex[p]{\TP!lp\_mach\_num}
254\sindex[p]{\TP!cg\_mach\_num}
255\sindex[p]{\TP!cp\_mach\_num}
256The number of processors in the virtual machine to run LP (CG, CP)
257processes. If this value is 0 then the processes will be assigned to
258processors in round-robin order. Otherwise the next \ptt{xx\_mach\_num} lines
259describe the processors where the LP (CG, CP) modules must run. The
260keyword -- value pairs on these lines must be {\bf TM\_xx\_machine} and the
261name or IP address of a processor (the processor names need not be distinct).
262In this case the actual processes are assigned in a round robin fashion to the
263processors on this list.\\
264\\
265This feature is useful if a specific software package is needed for
266some module, but that software is not licensed for every node of the
267virtual machine or if a certain process must run on a certain type of
268machine due to resource requirements.
269
270\item[\ptt{use\_cg} -- boolean ({\tt FALSE}).]
271\sindex[p]{\TP!use\_cg}
272Whether to use a cut generator or not.
273
274\item[\ptt{TM\_random\_seed} -- integer (17).]
275\sindex[p]{\TP!TM\_random\_seed}
276The random seed used in the TM.
277
278\item[\ptt{unconditional\_dive\_frac} -- double (0.0).]
279\sindex[p]{\TP!unconditional\_dive\_frac}
280The fraction of the nodes on which \BB\ randomly dives
281unconditionally into one of the children.
282
283\label{diving_strategy}
284\item[\ptt{diving\_strategy} -- integer ({\tt BEST\_ESTIMATE}\{0\}).]
285\sindex[p]{\TP!diving\_strategy}
286The strategy employed when deciding whether to dive or not. \\
287\\
288The {\tt BEST\_ESTIMATE}\{0\} strategy continues to dive until the
289lower bound in the child to be dived into exceeds the parameter
290\htmlref{\texttt{upper\_bound\_estimate}}{upper_bound_estimate}, which is
291given by the user. \\
292\\
293The {\tt COMP\_BEST\_K}\{1\} strategy computes the average lower bound
294on the best \htmlref{\texttt{diving\_k}}{diving} search tree nodes and
295decides to dive if
296the lower bound of the child to be dived into does not exceed this
297average by more than the fraction \htmlref{\texttt{diving\_threshold}}{diving}.
298\\
299\\
300The {\tt COMP\_BEST\_K\_GAP}\{2\} strategy takes the size of the gap
301into account when deciding whether to dive. After the average lower
302bound of the best \htmlref{\texttt{diving\_k}}{diving} nodes is computed,
303the gap between
304this average lower bound and the current upper bound is computed.
305Diving only occurs if the difference between the computed average
306lower bound and the lower bound of the child to be dived into is at
307most the fraction \htmlref{\texttt{diving\_threshold}}{diving} of the gap.\\
308\\
309Note that fractional diving settings can override these strategies.
310See \htmlref{below}{fractional_diving}.
311
312\label{diving}
313\item[\ptt{diving\_k, diving\_threshold} -- integer, double (1, 0.05).]
314\sindex[p]{\TP!diving\_k}
315\sindex[p]{\TP!diving\_threshold}
316See above.
317
318\label{fractional_diving}
319\item[\ptt{fractional\_diving\_ratio, fractional\_diving\_num} --
320integer (0.02, 0).]
321\sindex[p]{\TP!fractional\_diving\_ratio}
322\sindex[p]{\TP!fractional\_diving\_num}
323
324Diving occurs automatically if the number of fractional variables in
325the child to be dived into is less than \ptt{fractional\_diving\_num}
326or the fraction of total variables that are fractional is less than {\tt
327fractional\_diving\_ratio}. This overrides the other diving rules.
328Note that in order for this option to work, the code must be compiled
329with {\tt FRACTIONAL\_BRANCHING} defined. This is the default. See the
330makefile for more details.
331
332\item[\ptt{node\_selection\_rule} -- integer ({\tt LOWEST\_LP\_FIRST}\{0\}).]
333\sindex[p]{\TP!node\_selection\_rule}
334The rule for selecting the next search tree node to be processed. This rule
335selects the one with lowest lower bound. Other possible values are: {\tt
336HIGHEST\_LP\_FIRST}\{1\}, {\tt BREADTH\_FIRST\_SEARCH}\{2\} and {\tt
337DEPTH\_FIRST\_SEARCH}\{3\}.
338
339\item[\ptt{load\_balance\_level}] -- integer (-1).]
341A naive attempt at load balancing on problems where significant time
342is spent in the root node, contributing to a lack of parallel
343speed-up. Only a prescribed number of iterations ({\tt
344load\_balance\_iter}) are performed in the root node (and in each
345subsequent node on
346a level less than or equal to \ptt{load\_balance\_level}) before
347branching is forced in order to provide additional subproblems for the
348idle processors to work on. This doesn't work well in general.
349
350\item[\ptt{load\_balance\_iter}] -- integer (-1).]
352Works in tandem with the \ptt{load\_balance\_level} to attempt some
353simple load balancing. See the above description.
354
355\item[\ptt{keep\_description\_of\_pruned} -- integer ({\tt DISCARD}\{0\}).]
356\sindex[p]{\TP!keep\_description\_of\_pruned}
357Whether to keep the description of pruned search tree nodes or not.
358The reasons to do this are (1) if the user wants to write out a proof
359of optimality using the logging function, (2) for debugging, or (3) to
360get a visual picture of the tree using the software VBCTOOL.
361Otherwise, keeping the pruned nodes around just takes up memory.
362
363There are three options if it is desired to keep some description of
364the pruned nodes around. First, their full description can be written
365out to disk and freed from memory ({\tt KEEP\_ON\_DISK\_FULL}\{1\}). There
366is not really too much you can do with this kind of file, but
367theoretically, it contains a full record of the solution process and
368could be used to provide a certificate of optimality (if we were using
369exact arithmetic) using an independent verifier. In this case, the
370line following \ptt{keep\_description\_of\_pruned} should be a line
371containing the keyword \ptt{pruned\_node\_file\_name} with its
372corresponding value being the name of a file to which a description of
373the pruned nodes can be written. The file does not need to exist and
374will be over-written if it does exist.
375
376If you have the software VBCTOOL, then
377you can alternatively just write out the information VBCTOOL needs to
378display the tree ({\tt KEEP\_ON\_DISK\_VBC\_TOOL}\{2\}).
379
380Finally, the user can set the value to of this parameter to {\tt
381KEEP\_IN\_MEMORY}\{2\}, in which case all pruned nodes will be kept in
382memory and written out to the regular log file if that option is
383chosen. This is really only useful for debugging. Otherwise, pruned
384nodes should be flushed.
385
386\item[\ptt{keep\_warm\_start} -- boolean ({\tt FALSE}).]
387\sindex[p]{\TP!keep\_warm\_start}
388Turning this parameter on will have exactly the same impact with
389setting the \ptt{keep\_description\_of\_pruned} to
390{\tt KEEP\_IN\_MEMORY}\{2\}. This will allow SYMPHONY to keep all the
391necessary information obtained from the branching tree of the original
392problem to be able to warm start after a parameter or problem data
393modification. Thus, if it is intended to warm start later, the user
394should set this parameter before solving the original problem.
395
396\item[\ptt{warm\_start\_node\_limit} -- integer ({\tt SYM\_INFINITY}).]
397\sindex[p]{\TP!warm\_start\_node\_limit}
398Setting this parameter will start the warm start routine using only the
399first \ptt{warm\_start\_node\_limit} nodes generated during the
400previous solve procedure. The rest of the tree will be trimmed.
401
402\item[\ptt{warm\_start\_node\_ratio} -- double ({\tt 0.0}).]
403\sindex[p]{\TP!warm\_start\_node\_ratio}
404Setting this parameter will start the warm start routine using only the
405first \ptt{warm\_start\_node\_ratio}\% of the nodes generated during the
406previous solve procedure.
407
408\item[\ptt{warm\_start\_node\_level} -- integer ({\tt SYM\_INFINITY}).]
409\sindex[p]{\TP!warm\_start\_node\_level}
410Setting this parameter will start the warm start routine using all the
411nodes above the level \ptt{warm\_start\_node\_level} of the
412tree generated during the previous solve procedure. The rest of the tree
413will be trimmed.
414
415\item[\ptt{warm\_start\_node\_level\_ratio} -- double ({\tt 0.0}).]
416\sindex[p]{\TP!warm\_start\_node\_level\_ratio}
417Setting this parameter will start the warm start routine using all the
418nodes above the level \ptt{warm\_start\_node\_level}\% of the
419warm start tree depth. The rest of the tree will be trimmed
420
421\item[\ptt{logging} -- integer ({\tt NO\_LOGGING}\{0\}).]
422\sindex[p]{\TP!logging}
423Whether or not to write out the state of the search tree and all other
424necessary data to disk periodically in order to allow a warm start in
425the case of a system crash or to allow periodic viewing with VBCTOOL.
426
427If the value of this parameter is set to {\tt FULL\_LOGGING}\{1\},
428then all information needed to warm start the calculation will written
429out periodically. The next two lines of the parameter file following
430should contain the keywords \ptt{tree\_log\_file\_name} and {\tt
431cut\_log\_file\_name} along with corresponding file names as values.
432These will be the files used to record the search tree and related
433data and the list of cuts needed to reconstruct the tree.
434
435If the value of the parameter is set to {\tt VBC\_TOOL}\{2\}, then
436only the information VBCTOOL needs to display the tree will be
437logged. This is not really a very useful option since a live'' picture
438of the tree can be obtained using the \ptt{vbc\_emulation} parameter
439described below.
440
441\item[\ptt{logging\_interval} -- integer (1800).]
442\sindex[p]{\TP!logging\_interval}
443Interval (in seconds) between writing out the above log files.
444
445\item[\ptt{warm\_start} -- boolean (0).]
446\sindex[p]{\TP!warm\_start}
447Used to allow the tree manager to make a warm start by reading in
448previously written log files. If this option is set, then the two line
449following must start with the keywords {\tt
450warm\_start\_tree\_file\_name} and \ptt{warm\_start\_cut\_file\_name}
451and include the appropriate file names as the corresponding values.
452
453\item[\ptt{vbc\_emulation}] -- integer ({\tt
454NO\_VBC\_EMULATION}\{0\}).]
455\sindex[p]{\TP!vbc\_emulation}
456Determines whether or not to employ the VBCTOOL emulation mode. If
457one of these modes is chosen, then the tree will be displayed in
458real time'' using the VBCTOOL Software. When using the option {\tt
459VBC\_EMULATION\_LIVE}\{2\} and piping the output directly to VBCTOOL, the
460tree will be displayed as it is constructed, with color coding
461indicating the status of each node. With {\tt
462VBC\_EMULATION\_FILE}\{1\} selected, a log file will be produced which
463can later be read into VBCTOOL to produce an emulation of the
464solution process at any desired speed. If {\tt VBC\_EMULATION\_FILE}
465is selected, the the following line should contain the keyword {\tt
466vbc\_emulation\_file\_name} along with the corresponding file name
467for a value.
468
469\item[\ptt{price\_in\_root} -- boolean ({\tt FALSE}).]
470\sindex[p]{\TP!price\_in\_root}
471Whether to price out variables in the root node before the second
472phase starts (called {\em repricing the root}).
473
474\item[\ptt{trim\_search\_tree} -- boolean ({\tt FALSE}).]
475\sindex[p]{\TP!trim\_search\_tree}
476Whether to trim the search tree before the second phase starts or not. Useful
477only if there are two phases. (It is very useful then.)
478
479\item[\ptt{colgen\_in\_first\_phase, colgen\_in\_second\_phase} --
480integers (both 4).]
481\sindex[p]{\TP!colgen\_in\_first\_phase}
482\sindex[p]{\TP!colgen\_in\_second\_phase}
483These parameters determine if and when to do
484column generation in the first and second phase of the algorithm. The
485value of each parameter is obtained by setting the last four bits.
486The last two bits refer to what to do when attempting to prune a node.
487If neither of the last two bits are set, then we don't do
488anything---we just prune it. If only the last bit is set, then we
489simply save the node for the second phase without doing any column
490generation (yet). If only the second to last bit is set, then we do
491column generation immediately and resolve if any new columns are
492found. The next two higher bits determine whether or not to do column
493generation before branching. If only the third lowest bit is set, then no
494column generation occurs before branching. If only the fourth lowest bit is
495set, then column generation is attempted before branching. The default
496is not to generate columns before branching or fathoming, which
497corresponds to only the third lowest bit being set, resulting in a
498default value of 4.
499
500\item[\ptt{time\_limit} -- double (-1.0).]
501\sindex[p]{\TP!time\_limit}
502Number of seconds of wall-clock time allowed for solution. When this
503time limit is reached, the solution process will stop and the best
504solution found to that point, along with other relevant data, will be
505output. A time limit less than 0.0 means there is no limit.
506
507\item[\ptt{node\_limit} -- integer (-1).]
508\sindex[p]{\TP!node\_limit}
509Number of nodes allowed to be analyzed during the solution. When this
510node limit is reached, the solution process will stop and the best
511solution found to that point, along with other relevant data, will be
512output. A node limit less than 0 means there is no limit.
513
514\item[\ptt{gap\_limit} -- double (-1.0).]
515\sindex[p]{\TP!gap\_limit}
516Target gap limit allowed for solution. When the gap between the lower and
517the upper bound reaches this point, the solution process will stop and the
518best solution found to that point, along with other relevant data, will be
519output. A gap limit less than 0 means there is no limit.
520
521\item[\ptt{find\_first\_feasible} -- boolean (FALSE).]
522\sindex[p]{\TP!find\_first\_feasible}
523Whether to stop after finding the first feasible solution or not.
524
525\item[\ptt{sensitivity\_analysis} -- boolean (FALSE).]
526\sindex[p]{\TP!sensitivity\_analysis}
527If the user wants to do the rudimentary sensitivity analysis, which will
528give a lower bound for the problem modified by the right hand side, then,
529this parameter has to be set before solving the original problem. If it
530is set, SYMPHONY will keep the necessary information from the solution
531processes of the original problem to be able to do the sensitivity analysis
532later.
533
534\end{description}
535
536\subsection{LP parameters}
537
538\begin{description}
539
540\item[\ptt{LP\_verbosity} -- integer (0).]
541\sindex[p]{\LPP!LP\_verbosity}
542Verbosity level of the LP module.
543
544\item[\ptt{set\_obj\_upper\_lim} -- boolean ({\tt FALSE}).]
545\sindex[p]{\LPP!set\_obj\_upper\_lim}
546Whether to stop solving the LP relaxation when it's optimal value is
547provably higher than the global upper bound. There are some advantages
548to continuing the solution process anyway. For instance, this results
549in the highest possible lower bound. On the other hand, if the matrix
550is full, this node will be pruned anyway and the rest of the
551computation is pointless. This option should be set at {\tt FALSE} for
552column generation since the LP dual values may not be reliable otherwise.
553
554\item[\ptt{try\_to\_recover\_from\_error} -- boolean ({\tt TRUE}).]
555\sindex[p]{\LPP!try\_to\_recover\_from\_error}
556Indicates what should be done in case the LP solver is unable to solve
557a particular LP relaxation because of numerical problems. It is
558possible to recover from this situation but further results may be
559suspect. On the other hand, the entire solution process can be
560abandoned.
561
562\item[\ptt{problem\_type} -- integer ({\tt ZERO\_ONE\_PROBLEM}\{0\}).]
563\sindex[p]{\LPP!problem\_type}
564The type of problem being solved. Other values are {\tt
565INTEGER\_PROBLEM}\{1\} or {\tt MIXED\_INTEGER\_PROBLEM}\{2\}.
566(Caution: The mixed-integer option is not well tested.)
567
568\item[\ptt{cut\_pool\_check\_frequency} -- integer (10).]
569\sindex[p]{\LPP!cut\_pool\_check\_frequency}
570The number of iterations between sending LP solutions to the cut pool
571to find violated cuts. It is not advisable to check the cut pool too
572frequently as the cut pool module can get bogged down and the LP
573solution generally do not change that drastically from one iteration
574to the next anyway.
575
576\item[\ptt{not\_fixed\_storage\_size} -- integer (2048).]
577\sindex[p]{\LPP!not\_fixed\_storage\_size}
578The {\em not fixed list} is a partial list of indices of variables not
579in the matrix that have not been fixed by reduced cost. Keeping this
580list allows \BB\ to avoid repricing variables (an expensive operation)
581that are not in the matrix because they have already been permanently
582fixed. When this array reaches its maximum size, no more variable
583indices can be stored. It is therefore advisable to keep the maximum
584size of this array as large as possible, given memory limitations.
585
589-- integer, integer, double (20, 200, .05).]
592These three parameters determine the maximum number of
593non-dual-feasible columns that can be added in any one iteration
594after pricing. This maximum is set to the indicated
595fraction of the current number of active columns unless this numbers
596exceeds the given maximum or is less than the given minimum, in which
597case, it is set to the max or min, respectively.
598
601\item[\ptt{max\_not\_fixable\_to\_add\_frac} -- integer, integer, double (100,
602500, .1) ]
605As above, these three parameters determine the maximum number of new
606columns to be added to the problem because they cannot be priced out.
607These variables are only added when trying to restore infeasibility
608and usually, this does not require many variables anyway.
609
610\item[\ptt{mat\_col\_compress\_num, mat\_col\_compress\_ratio} -- integer,
611double (50, .05).]
612\sindex[p]{\LPP!mat\_col\_compress\_num}
613\sindex[p]{\LPP!mat\_col\_compress\_ratio}
614Determines when the matrix should be physically compressed. This only
615happens when the number of columns is high enough to make it
616worthwhile.'' The matrix is physically compressed when the number of
617deleted columns exceeds either an absolute number {\em and} a specified
618fraction of the current number of active columns.
619
620\item[\ptt{mat\_row\_compress\_num, mat\_row\_compress\_ratio} -- integer,
621double (20, .05).]
622\sindex[p]{\LPP!mat\_row\_compress\_num}
623\sindex[p]{\LPP!mat\_row\_compress\_ratio}
624Same as above except for rows.
625
626\item[\ptt{tailoff\_gap\_backsteps, tailoff\_gap\_frac} -- integer, double
627(2, .99).]
628\sindex[p]{\LPP!tailoff\_gap\_backsteps}
629\sindex[p]{\LPP!tailoff\_gap\_frac}
630Determines when tailoff is detected in the LP module.
631Tailoff is reported if the average ratio of the current gap to the
632previous iteration's gap over the last \ptt{tailoff\_gap\_backsteps}
633iterations wasn't at least \ptt{tailoff\_gap\_frac}.
634
635\item[\ptt{tailoff\_obj\_backsteps, tailoff\_obj\_frac} -- integer, double
636(2, .99).]
637\sindex[p]{\LPP!tailoff\_obj\_backsteps}
638\sindex[p]{\LPP!tailoff\_obj\_frac}
639Same as above, only the ratio is taken with respect to the change in
640objective function values instead of the change in the gap.
641
642\item[\ptt{ineff\_cnt\_to\_delete} -- integer (0).]
643\sindex[p]{\LPP!ineff\_cnt\_to\_delete}
644Determines after how many iterations of being deemed ineffective a
645constraint is removed from the current relaxation.
646
647\item[\ptt{eff\_cnt\_before\_cutpool} -- integer (3).]
648\sindex[p]{\LPP!eff\_cnt\_before\_cutpool}
649Determines after how many iterations of being deemed effective each
650cut will be sent to the global pool.
651
652\item[\ptt{ineffective\_constraints} -- integer
653({\tt BASIC\_SLACKS\_ARE\_INEFFECTIVE}\{2\}).]
654\sindex[p]{\LPP!ineffective\_constraints}
655Determines under what condition a constraint is deemed ineffective in
656the current relaxation. Other possible values are {\tt
657NO\_CONSTRAINT\_IS\_INEFFECTIVE}\{0\}{\tt
658NONZERO\_SLACKS\_ARE\_INEFFECTIVE}\{1\}, and \\
659{\tt ZERO\_DUAL\_VALUES\_ARE\_INEFFECTIVE}\{3\}.
660
661\item[\ptt{base\_constraints\_always\_effective} -- boolean ({\tt TRUE}).]
662\sindex[p]{\LPP!base\_constraints\_always\_effective}
663Determines whether the base constraints can ever be removed from the
664relaxation. In some case, removing the base constraints from the
665problem can be disastrous depending on the assumptions made by the cut
666generator.
667
668\item[\ptt{branch\_on\_cuts} -- boolean ({\tt FALSE}).]
669\sindex[p]{\LPP!branch\_on\_cuts}
670This informs the framework whether the user plans on branching on cuts
671or not. If so, there is additional bookkeeping to be done, such as
672maintaining a pool of slack cuts to be used for branching. Therefore,
673the user should not set this flag unless he actually plans on using
674this feature.
675
676\item[\ptt{discard\_slack\_cuts} -- integer ({\tt
679Determines when the pool of slack cuts is discarded. The other option
681
682
683\item[\ptt{first\_lp\_first\_cut\_time\_out},]
684\item[\ptt{first\_lp\_all\_cuts\_time\_out},]
685\item[\ptt{later\_lp\_first\_cut\_time\_out},]
686\item[\ptt{later\_lp\_all\_cuts\_time\_out} --
687double (0, 0, 5, 1).]
688\sindex[p]{\LPP!first\_lp\_first\_cut\_time\_out}
689\sindex[p]{\LPP!first\_lp\_all\_cuts\_time\_out}
690\sindex[p]{\LPP!later\_lp\_first\_cut\_time\_out}
691\sindex[p]{\LPP!later\_lp\_all\_cuts\_time\_out}
692The next group of parameters determines when the LP should give up
693waiting for cuts from the cut generator and start to solve the
694relaxation in its current form or possibly branch if necessary. There
695are two factors that contribute to determining this timeout. First
696is whether this is the first LP in the search node of whether it is a
697later LP. Second is whether any cuts have been added already in this
698iteration. The four timeout parameters correspond to the four possible
699combinations of these two variables.
700
701\item[\ptt{no\_cut\_timeout} -- ]
702\sindex[p]{\LPP!no\_cut\_timeout}
703This keyword does not have an associated value. If this keyword
704appears on a line by itself or with a value, this tells the framework
705not to time out while waiting for cuts. This is useful for debugging
706since it enables runs with a single LP module to be duplicated.
707
708\item[\ptt{all\_cut\_timeout} -- double (no default).]
709\sindex[p]{\LPP!all\_cut\_timeout}
710This keyword tells the framework to set all of the above timeout
711parameters to the value indicated.
712
713\item[\ptt{max\_cut\_num\_per\_iter} -- integer (20).]
714\sindex[p]{\LPP!max\_cut\_num\_per\_iter}
715The maximum number of cuts that can be added to the LP in an
716iteration. The remaining cuts stay in the local pool to be added in
717subsequent iterations, if they are strong enough.
718
719\item[\ptt{do\_reduced\_cost\_fixing} -- boolean ({\tt FALSE}).]
720\sindex[p]{\LPP!do\_reduced\_cost\_fixing}
721Whether or not to attempt to fix variables by reduced cost. This
722option is highly recommended
723
724\item[\ptt{gap\_as\_ub\_frac, gap\_as\_last\_gap\_frac} -- double (.1, .7).]
725\sindex[p]{\LPP!gap\_as\_ub\_frac}
726\sindex[p]{\LPP!gap\_as\_last\_gap\_frac}
727Determines when reduced cost fixing should be attempted. It is only
728done when the gap is within the fraction \ptt{gap\_as\_ub\_frac} of the upper
729bound or when the gap has decreased by the fraction
730\ptt{gap\_as\_last\_gap\_frac} since the last time variables were fixed.
731
732\item[\ptt{do\_logical\_fixing} -- boolean ({\tt FALSE}).]
733\sindex[p]{\LPP!do\_logical\_fixing}
734Determines whether the user's logical fixing routine should be used.
735
736\item[\ptt{fixed\_to\_ub\_before\_logical\_fixing},]
737\item[\ptt{fixed\_to\_ub\_frac\_before\_logical\_fixing} --
738{\bf integer, double (1, .01)}.]
739\sindex[p]{\LPP!fixed\_to\_ub\_before\_logical\_fixing}
740\sindex[p]{\LPP!fixed\_to\_ub\_frac\_before\_logical\_fixing}
741Determines when logical fixing should be attempted. It will be called
742only when a certain absolute number {\em and} a certain number of variables
743have been fixed to their upper bounds by reduced cost. This is because
744it is typically only after fixing variables to their upper bound that
745other variables can be logically fixed.
746
747\label{strong_branching}
748\item[\ptt{max\_presolve\_iter} -- integer (10).]
749\sindex[p]{\LPP!max\_presolve\_iter}
750Number of simplex iterations to be performed in the pre-solve for
751strong branching.
752
753\item[\ptt{strong\_branching\_cand\_num\_max},]
754\item[\ptt{strong\_branching\_cand\_num\_min},]
755\item[\ptt{strong\_branching\_red\_ratio} --
756{\bf integer (10, 5, 1)}.]
757\sindex[p]{\LPP!strong\_branching\_cand\_num\_max}
758\sindex[p]{\LPP!strong\_branching\_cand\_num\_min}
759\sindex[p]{\LPP!strong\_branching\_red\_ratio}
760These three parameters together determine the number of strong
761branching candidates to be used by default. In the root node,
762\ptt{strong\_branching\_cand\_num\_max} candidates are used. On each
763succeeding level, this number is reduced by the number
764\ptt{strong\_branching\_red\_ratio} multiplied by the square of the level.
765This continues until the number of candidates is reduced to
766\ptt{strong\_branching\_cand\_num\_min} and then that number of candidates
767is used in all lower levels of the tree.
768
769\item [\ptt{strong\_branching\_high\_low\_weight} -- double (0.8).]
770\sindex[p]{strong\_branching\_high\_low\_weight}
771This parameter is used to calculate the score of each branching candidate. The
772candidate with the highest score is then selected for branching. Let $z_i^+, 773z_i^-$ be the estimated change in objective function value when we branch on
774the candidate $i$. Then the score of candidate $i$ is $s_i = 775\alpha\times\min\{z_i^+, z_i^-\} + (1-\alpha)\times\max\{z_i^+,z_i^-\}$, where
776$\alpha$ is the value of \ptt{strong\_branching\_high\_low\_weight}. This
777value should always lie in the interval $[0,1]$.
778
779\item [\ptt{use\_hot\_starts} -- boolean ({\tt TRUE}).]
780Determines if the LP solver is asked to make special arrangements for doing
781dual-simplex iterations when bounds on a variable are changed for strong
782branching. Some LP solvers provide such options so that strong branching can
783be performed much faster than the regular dual-simplex procedure.
784
785\item[\ptt{should\_use\_rel\_br} -- boolean ({\tt TRUE}).]
786\sindex[p]{should\_use\_rel\_br}
787Determines if reliability braching is used to determine branching candidates
788or not. This parameter is set to {\tt FALSE} if OPENMP is used. When this
789branching rule is disabled, strong branching is used to select a candidate.
790
791%   lp_par->rel_br_override_max_solves = 200;
792%   lp_par->rel_br_chain_backtrack = 5;
793%   lp_par->rel_br_min_imp = 0.0133;
794%   lp_par->rel_br_max_imp = 0.30;
795
796\item[\ptt{rel\_br\_override\_default} -- boolean ({\tt TRUE}).]
797\sindex[p]{\LPP!rel\_br\_override\_default}
798If reliability branching is enabled and this paramter is set to {\tt TRUE} then the
799policy of selecting branching candidates is automatically adjusted on the
800basis of bounds on solution value and the time elapsed. If this parameter is
801set to {\tt FALSE}, the policy is based on the values of the following three
802parameters.
803
804\item[\ptt{rel\_br\_threshold} -- integer (8).]
805\sindex[p]{\LPP!rel\_br\_threshold}
806It is assumed that the score obtained by branching on a given variable these many
807times is reliable for estimating the pseudocosts of this variable in the rest
808of the branch-and-bound algorithm. In other words, if reliability branching is
809enabled, strong branching is used on a variable at most
810\ptt{rel\_br\_threshold} many times.
811
812\item[\ptt{rel\_br\_max\_solves} -- integer (20).]
813\sindex[p]{\LPP!rel\_br\_max\_solves}
814If reliability branching is enabled, this parameter determines the maximum
815number of strong branching LPs that are solved in each node. If some branching
816candidates have reliable estimates, the number of LPs can be less than
817the value of this parameter.
818
819\item[\ptt{rel\_br\_cand\_threshold} -- integer (10).]
820\sindex[p]{\LPP!rel\_br\_cand\_threshold}
821If reliability branching is enabled, then strong branching is stopped if the
822last \ptt{rel\_br\_cand\_threshold} LPs did not give a better improvement in
823the lower bound.
824
825
826\item[\ptt{is\_feasible\_default} -- integer ({\tt TEST\_INTEGRALITY}\{1\}).]
827\sindex[p]{\LPP!is\_feasible\_default}
828Determines the default test to be used to determine feasibility. This
829parameter is provided so that the user can change the default behavior
830without recompiling. The only other option is {\tt TEST\_ZERO\_ONE}\{0\}.
831
832\item[\ptt{send\_feasible\_solution\_default} -- integer
833({\tt SEND\_NONZEROS}\{0\}).]
834\sindex[p]{\LPP!send\_feasible\_solution\_default}
835Determines the form in which to send the feasible solution. This
836parameter is provided so that the user can change the default behavior
837without recompiling. This is currently the only option.
838
839\item[\ptt{send\_lp\_solution\_default} -- integer ({\tt SEND\_NONZEROS}\{0\}).] \sindex[p]{\LPP!send\_lp\_solution\_default}
840Determines the default form in which to send the LP solution to the
841cut generator and cut pool. This
842parameter is provided so that the user can change the default behavior
843without recompiling. The other option is {\tt SEND\_FRACTIONS}\{1\}.
844
845\item[\ptt{display\_solution\_default} -- integer ({\tt DISP\_NOTHING}\{0\}).] \sindex[p]{\LPP!display\_solution\_default}
846Determines how to display the current LP solution if desired.
847See the description of \htmlref{\texttt{user\_display\_solution()}}
848{user_display_solution} for other
849possible values. This parameter is provided so that
850the user can change the default behavior without recompiling.
851
852\item[\ptt{shall\_we\_branch\_default} -- integer
853({\tt USER\_\_BRANCH\_IF\_MUST}\{2\}).]
854\sindex[p]{\LPP!shall\_we\_branch\_default}
855Determines the default branching behavior. Other values are {\tt
856USER\_\_DO\_NOT\_BRANCH}\{0\} (not recommended as a default), {\tt
857USER\_\_DO\_BRANCH}\{1\} (also not recommended as a default), and {\tt
858USER\_\_BRANCH\_IF\_TAILOFF}\{3\}. This
859parameter is provided so that the user can change the default behavior
860without recompiling.
861
862\item[\ptt{select\_candidates\_default} -- integer ({\tt
863USER\_\_CLOSE\_TO\_HALF\_AND\_EXPENSIVE}\{10\}).]
864\sindex[p]{\LPP!select\_candidates\_default}
865Determines the default rule for selecting strong branching candidates.
866Other values are {\tt USER\_\_CLOSE\_TO\_HALF}\{10\} and
867{\tt USER\_\_CLOSE\_TO\_ONE\_AND\_CHEAP}\{12\}. This
868parameter is provided so that the user can change the default behavior
869without recompiling.
870
871\item[\ptt{compare\_candidates\_default} -- integer
872({\tt HIGHEST\_LOW\_OBJ}\{2\}).]
873\sindex[p]{\LPP!compare\_candidates\_default}
874Determines the default rule for comparing candidates. See the
875description of \htmlref{\texttt{user\_compare\_candidates()}}
876{user_compare_candidates} for other values. This
877parameter is provided so that the user can change the default behavior
878without recompiling.
879
880\item[\ptt{select\_child\_default} -- integer
881({\tt PREFER\_LOWER\_OBJ\_VALUE}\{0\}).]
882\sindex[p]{\LPP!select\_child\_default}
883Determines the default rule for selecting the child to be processed
884next. For other possible values, see the description \htmlref{
885\texttt{user\_select\_child()}}{user_select_child}. This
886parameter is provided so that the user can change the default behavior
887without recompiling.
888
889\item[\ptt{mc\_find\_supported\_solutions} -- boolean ({\tt FALSE}).]
890\sindex[p]{\LPP!mc\_find\_supported\_solutions}
891By default, {\tt sym\_mc\_solve} routine will find all the non-dominated
892solutions if the problem to be solved is
893a bicriteria problem. However, if the user plans to find only the supported
894solutions, then, this parameter has to be set before
895calling {\tt sym\_mc\_solve} routine.
896
897\item[\ptt{mc\_rho} -- double ({\tt 0.00001}).]
898\sindex[p]{\LPP!mc\_rho}
899The value used in augmented Chebyshev norm during the bicriteria
900solution procedure.
901
902\item[\ptt{generate\_cgl\_cuts} -- boolean ({\tt TRUE}).]
903\sindex[p]{\LPP!generate\_cgl\_cuts}
904Whether or not to generate cuts using COIN's cut generation library.
905Note that, to use CGL cuts, OSI interface has to be used and moreover the
906corresponding flags have to be set during installation. See the makefile for
907more details.
908
909\item[\ptt{generate\_cgl\_gomory\_cuts} -- boolean ({\tt TRUE}).]
910\sindex[p]{\LPP!generate\_cgl\_gomory\_cuts}
911Whether or not to generate Gomory cuts using COIN's cut generation library.
912
913\item[\ptt{generate\_cgl\_knapsack\_cuts} -- boolean ({\tt TRUE}).]
914\sindex[p]{\LPP!generate\_cgl\_knapsack\_cuts}
915Whether or not to generate knapsack cover cuts using COIN's cut generation
916library.
917
918\item[\ptt{generate\_cgl\_oddhole\_cuts} -- boolean ({\tt TRUE}).]
919\sindex[p]{\LPP!generate\_cgl\_oddhole\_cuts}
920Whether or not to generate generalized odd hole cuts using COIN's cut
921generation library.
922
923\item[\ptt{generate\_cgl\_probing\_cuts} -- boolean ({\tt TRUE}).]
924\sindex[p]{\LPP!generate\_cgl\_probing\_cuts}
925Whether or not to generate probing cuts using COIN's cut generation library.
926
927\item[\ptt{generate\_cgl\_clique\_cuts} -- boolean ({\tt TRUE}).]
928\sindex[p]{\LPP!generate\_cgl\_clique\_cuts}
929Whether or not to generate clique cuts using COIN's cut generation library.
930
931\item[\ptt{generate\_cgl\_flow\_and\_cover\_cuts} -- boolean ({\tt FALSE}).]
932\sindex[p]{\LPP!generate\_cgl\_flow\_and\_cover\_cuts}
933Whether or not to generate flow and cover cuts using COIN's cut generation
934library.
935
936\item[\ptt{generate\_cgl\_rounding\_cuts} -- boolean ({\tt FALSE}).]
937\sindex[p]{\LPP!generate\_cgl\_rounding\_cuts}
938Whether or not to generate simple rounding cuts using COIN's cut generation
939library.
940
941\item[\ptt{generate\_cgl\_lift\_and\_project\_cuts} -- boolean ({\tt FALSE}).] \sindex[p]{\LPP!generate\_cgl\_lift\_and\_project\_cuts}
942Whether or not to generate lift-and-project cuts using COIN's cut generation
943library.
944
945\label{fp_enabled}
946\item[\ptt{fp\_enabled} -- integer ({\tt SYM\_FEAS\_PUMP\_DEFAULT}\{1\}).]
947\sindex[p]{\LP!fp\_enabled}
948Determines the overall policy of using the feasibility pump heuristic to find
949feasible solutions. {\tt SYM\_FEAS\_PUMP\_DEFAULT}\{1\} indicates that the
950decision to use the heuristic is determined on the basis of current values of
951lower bound, upper bound, the time used etc., based on some preset rules. {\tt
952SYM\_FEAS\_PUMP\_REPEATED}\{2\} indicates that the heuristic will be used
953every few iterations until the problem is solved. The frequency can be
954adjusted through the \ptt{fp\_frequency} parameter.  {\tt
955SYM\_FEAS\_PUMP\_TILL\_SOL}\{3\} indicates that the heuristic is used only
956until the first feasible solution is found. {\tt
957SYM\_FEAS\_PUMP\_DISABLE}\{-1\} indicates that the heuristic is not used.
958
959\item[\ptt{fp\_frequency} -- integer (10).]
960\sindex[p]{\LP!fp\_frequency}
961Determines the number of LPs that are solved before which the feasibility pump
962heuristic is called again. This parameter is used only if the parameter
963\ptt{fp\_enabled} is set to {\tt SYM\_FEAS\_PUMP\_REPEATED}\{2\}. Otherwise,
964the frequency is determined automatically based on some preset rules.
965
966\item[\ptt{fp\_max\_cycles} -- integer (100).]
967\sindex[p]{\LP!fp\_max\_cycles}
968Determines the maximum number of LPs that can be solved in a call to the
969feasibility pump heuristic. A higher number might be helpful in finding a
970better feasible solution but may result in more time spent in the heuristic.
971
972\item[\ptt{fp\_time\_limit} -- double (50).]
973\sindex[p]{\LP!fp\_time\_limit}
974If a feasible solution has been found, this parameter determines the time in
975seconds that can be spent on the feasibility pump heuristic. If a solution has
976not been found yet, the parameter \ptt{fp\_max\_initial\_time} is used.
977
978\item[\ptt{fp\_max\_initial\_time} -- double (100).]
979\sindex[p]{\LP!fp\_max\_initial\_time}
980If a feasible solution has not been found, this parameter determines the time in
981seconds that can be spent on the feasibility pump heuristic. If a solution has
982been found, the parameter \ptt{fp\_time\_limit} is used.
983
984\item[\ptt{fp\_min\_gap} -- double (0.5).]
985\sindex[p]{\LP!fp\_min\_gap}
986If the relative (\%) gap between the lower and the upper bounds falls below the
987value of this parameter, feasibility pump is not called.
988
989\item[\ptt{fp\_flip\_fraction} -- double (0.1).]
990\sindex[p]{\LP!fp\_flip\_fraction}
991When the feasibility pump gets stuck in a cycle, this fraction of binary
992variables are flipped. The variables are selected randomly. Increasing the
993value of this parameter may result in the pump getting stuck fewer number of
994times, but the time to solve LPs after flipping may increase substantially.
995
996\item[\ptt{fp\_poor\_sol\_lim\_fac} -- integer (10).]
997\sindex[p]{\LP!fp\_poor\_sol\_lim\_fac}
998Sometimes the feasibility pump keeps generating solutions that have high
999objective function values. When the number of such solutions becomes more than
1000\ptt{fp\_poor\_sol\_lim\_fac} times the number of good'' solutions, the pump
1001is disabled.
1002
1003\end{description}
1004\subsection{Cut Generator Parameters}
1005
1006\begin{description}
1007
1008\item[\ptt{CG\_verbosity} -- integer (0).]
1009\sindex[p]{\CGP!CG\_verbosity}
1010Verbosity level for the cut generator module.
1011
1012\end{description}
1013
1014\subsection{Cut Pool Parameters}
1015\label{cut_pool_params}
1016\begin{description}
1017
1018\item[\ptt{CP\_verbosity} -- integer (0).]
1019\sindex[p]{\CP!CP\_verbosity}
1020Verbosity of the cut pool module.
1021
1022\item[\ptt{cp\_logging} -- boolean (0).]
1023\sindex[p]{\CP!cp\_logging}
1024Determines whether the logging option is enabled. In this case, the
1025entire contents of the cut pool are written out periodically to disk
1026(at the same interval as the tree manager log files are written). If
1027this option is set, then the line following must start with the
1028keyword \ptt{cp\_log\_file\_name} and include the appropriate
1029file name as the value.
1030
1031\item[\ptt{cp\_warm\_start} -- boolean (0).]
1032\sindex[p]{\CP!cp\_warm\_start}
1033Used to allow the cut pool to make a warm start by reading in a
1034previously written log file. If
1035this option is set, then the line following must start with the
1036keyword \ptt{cp\_warm\_start\_file\_name} and include the appropriate
1037file name as the value.
1038
1039\item[\ptt{block\_size} -- integer (5000).]
1040\sindex[p]{\CP!block\_size}
1041Indicates the size of the blocks to allocate when more space is needed
1042in the cut list.
1043
1044\item[\ptt{max\_size} -- integer (2000000).]
1045\sindex[p]{\CP!max\_size}
1046Indicates the maximum size of the cut pool in bytes. This is the total
1047memory taken up by the cut list, including all data structures and the
1048array of pointers itself.
1049
1050\item[\ptt{max\_number\_of\_cuts} -- integer (10000).]
1051\sindex[p]{\CP!max\_number\_of\_cuts}
1052Indicates the maximum number of cuts allowed to be stored. When this
1053max is reached, cuts are forcibly purged, starting with duplicates
1054and then those indicated by the parameter \htmlref{\texttt{delete\_which}}
1055{delete_which} (see below), until the list is below the allowable size.
1056
1057\item[\ptt{min\_to\_delete} -- integer (1000).]
1058\sindex[p]{\CP!min\_to\_delete}
1059Indicates the number of cuts required to be deleted when the pool reaches
1060it's maximum size.
1061
1062\item[\ptt{touches\_until\_deletion} -- integer (10).]
1063\sindex[p]{\CP!touches\_until\_deletion}
1064When using the number of touches a cut has as a measure of its
1065quality, this parameter indicates the number of touches a cut can have
1066before being deleted from the pool. The number of touches is the
1067number of times in a row that a cut has been checked without being
1068found to be violated. It is a measure of a cut's relevance or
1069effectiveness.
1070
1071\label{delete_which}
1072\item[\ptt{delete\_which} -- integer
1073({\tt DELETE\_BY\_TOUCHES}\{2\}).]
1074\sindex[p]{\CP!delete\_which}
1075Indicates which cuts to delete when
1076purging the pool. {\tt DELETE\_BY\_TOUCHES} indicates that cuts whose
1077number of touches is above the threshold (see {\tt
1078touches\_until\_deletion} above) should be purged if the pool gets too
1079large. {\tt DELETE\_BY\_QUALITY}\{1\} indicates that a user-defined
1080measure of quality should be used (see the function \hyperref{\tt
1081user\_check\_cuts()} {{\tt user\_check\_cuts} in Section}{}
1082{user_check_cuts}).
1083
1084\item[\ptt{check\_which} -- integer ({\tt CHECK\_ALL\_CUTS}\{0\}).]
1085\sindex[p]{\CP!check\_which}
1086Indicates which cuts should be checked for violation. The choices are
1087to check all cuts ({\tt CHECK\_ALL\_CUTS}\{0\}); only those that have
1088number of touches below the threshold ({\tt CHECK\_TOUCHES}\{2\}); only
1089those that were generated at a level higher in the tree than the
1090current one ({\tt CHECK\_LEVEL}\{1\}); or both ({\tt
1091CHECK\_LEVEL\_AND\_TOUCHES}\{3\}). Note that with {\tt
1092CHECK\_ALL\_CUTS} set, SYMPHONY will still only check the first
1093\htmlref{\texttt{cuts\_to\_check}}{cuts_to_check} cuts in the list ordered
1094by quality (see the function \htmlref{\texttt{user\_check\_cut}}
1095{user_check_cuts}).
1096
1097\label{cuts_to_check}
1098\item[\ptt{cuts\_to\_check} -- integer (1000).]
1099\sindex[p]{\CP!cuts\_to\_check}
1100Indicates how many cuts in the pool to actually check. The list is
1101ordered by quality and the first \ptt{cuts\_to\_check} cuts are
1102checked for violation.
1103
1104\end{description}
1105
1106\subsection{C++ Interface/OSI Parameters}
1107\label{OSI Parameters}
1108
1109As the implementation of the whole interface, there exists a matching
1110C interface parameter to each of the C++ Interface/OSI parameter and
1111the parameter setting functions are designed to set the
1112corresponding C interface parameter. Thus, we will just give a table of the
1113parameter names, their C interface complements and the values they can be set
1114to, rather than their detailed descriptions. For each parameter, the user
1115can see the C interface complement for further explanation. \\
1116
1117\resizebox{16cm}{7cm}{
1118\begin{tabular}{|l||l||l|} \hline
1119{\bf C++ Interface} & {\bf C Interface} & {\bf Value}\\ \hline \hline
1120OsiSymVerbosity & verbosity & -user defined- \\
1121\hline \hline
1122OsiSymWarmStart & warm\_start & -boolean- \\
1123\hline \hline
1124OsiSymNodeLimit &  & \\
1125OsiMaxNumIteration & node\_limit & -user defined-\\
1126OsiMaxNumIterationHotStart & & \\
1127\hline \hline
1128OsiSymFindFirstFeasible & find\_first\_feasible & -boolean- \\
1129\hline \hline
1130OsiSymSearchStrategy & node\_selection\_rule & LOWEST\_LP\_FIRST \\
1131& & HIGHEST\_LP\_FIRST \\
1132& & BREADTH\_FIRST\_SEARCH \\
1133& & DEPTH\_FIRST\_SEARCH \\
1134\hline \hline
1135OsiSymUsePermanentCutPools & use\_permanent\_cut\_pools & -boolean- \\
1136\hline \hline
1137OsiSymGenerateCglGomoryCuts & generate\_cgl\_gomory\_cuts & -boolean- \\
1138\hline \hline
1139OsiSymGenerateCglKnapsackCuts & generate\_cgl\_knapsack\_cuts & -boolean- \\
1140\hline \hline
1141OsiSymGenerateCglOddHoleCuts & generate\_cgl\_oddhole\_cuts & -boolean- \\
1142\hline \hline
1143OsiSymGenerateCglProbingCuts & generate\_cgl\_probing\_cuts & -boolean- \\
1144\hline \hline
1145OsiSymGenerateCglCliqueCuts & generate\_cgl\_clique\_cuts & -boolean- \\
1146\hline \hline
1147OsiSymGenerateCglFlowAndCoverCuts & generate\_cgl\_flow\_and\_cover\_cuts & -boolean- \\
1148\hline \hline
1149OsiSymGenerateCglRoundingCuts & generate\_cgl\_rounding\_cuts & -boolean- \\
1150\hline \hline
1151OsiSymGenerateCglLiftAndProjectCuts & generate\_cgl\_lift\_and\_project\_cuts & -boolean- \\
1152\hline \hline
1153OsiSymKeepWarmStart & keep\_warm\_start & -boolean- \\
1154\hline \hline
1155OsiSymTrimWarmTree & trim\_warm\_tree * -boolean- \\
1156\hline \hline
1157OsiSymDoReducedCostFixing & do\_reduced\_cost\_fixing & -boolean- \\
1158\hline \hline
1159OsiSymMCFindSupportedSolutions &
1160mc\_find\_supported\_solutions & -boolean- \\
1161\hline \hline
1162OsiSymSensitivityAnalysis & sensitivity\_analysis & -boolean- \\
1163\hline \hline
1164OsiSymRandomSeed & random\_seed & -user defined-\\
1165\hline \hline
1166OsiSymDivingStrategy & diving\_strategy & BEST\_ESTIMATE \\
1167& & COMP\_BEST\_K \\
1168& & COMP\_BEST\_K\_GAP \\
1169\hline \hline
1170OsiSymDivingK & diving\_k & -user defined- \\
1171\hline \hline
1172OsiSymDivingThreshold & diving\_threshold & -user defined- \\
1173\hline \hline
1174OsiSymGranularity & granularity & -user defined- \\
1175\hline \hline
1176OsiSymTimeLimit & time\_limit & -user defined- \\
1177\hline \hline
1178OsiSymGapLimit & gap\_limit & -user defined- \\
1179\hline \hline
1180OsiObjOffset & - & -user defined- \\
1181\hline \hline
1182OsiProbName & problem\_name & -user defined- \\
1183\hline
1184\end{tabular}
1185} \\
1186
1187However, as it is seen, only some of the C interface parameters have their
1188matches. If the other parameters are required to be modified, the user
1189can always set them directly by their C interface names,
1190using the overlapping functions: {\tt setSymParam(string, int),
1191setSymParam(string, double) and setSymParam(string,string)}. For instance,
1192the \ptt{verbosity} parameter can be set, let's say, to 2 either by
1193setSymParam(OsiSymVerbosity, 2) or by setSymParam(verbosity'', 2).
1194Note that, this flexibility is also supported for parameter querying
1195functions.
1196
Note: See TracBrowser for help on using the repository browser.