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

Last change on this file since 1733 was 1733, checked in by tkr, 4 years ago

• Property svn:eol-style set to native
• Property svn:keywords set to Author Date Id Revision
File size: 47.5 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
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
337DEPTH\_FIRST\_SEARCH}\{3\}.
338
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
352Works in tandem with the \ptt{load\_balance\_level} to attempt some
353simple load balancing. See the above description.
354
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
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
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{is\_feasible\_default} -- integer ({\tt TEST\_INTEGRALITY}\{1\}).]
770\sindex[p]{\LPP!is\_feasible\_default}
771Determines the default test to be used to determine feasibility. This
772parameter is provided so that the user can change the default behavior
773without recompiling. The only other option is {\tt TEST\_ZERO\_ONE}\{0\}.
774
775\item[\ptt{send\_feasible\_solution\_default} -- integer
776({\tt SEND\_NONZEROS}\{0\}).]
777\sindex[p]{\LPP!send\_feasible\_solution\_default}
778Determines the form in which to send the feasible solution. This
779parameter is provided so that the user can change the default behavior
780without recompiling. This is currently the only option.
781
782\item[\ptt{send\_lp\_solution\_default} -- integer ({\tt SEND\_NONZEROS}\{0\}).] \sindex[p]{\LPP!send\_lp\_solution\_default}
783Determines the default form in which to send the LP solution to the
784cut generator and cut pool. This
785parameter is provided so that the user can change the default behavior
786without recompiling. The other option is {\tt SEND\_FRACTIONS}\{1\}.
787
788\item[\ptt{display\_solution\_default} -- integer ({\tt DISP\_NOTHING}\{0\}).] \sindex[p]{\LPP!display\_solution\_default}
789Determines how to display the current LP solution if desired.
790See the description of \htmlref{\texttt{user\_display\_solution()}}
791{user_display_solution} for other
792possible values. This parameter is provided so that
793the user can change the default behavior without recompiling.
794
795\item[\ptt{shall\_we\_branch\_default} -- integer
796({\tt USER\_\_BRANCH\_IF\_MUST}\{2\}).]
797\sindex[p]{\LPP!shall\_we\_branch\_default}
798Determines the default branching behavior. Other values are {\tt
799USER\_\_DO\_NOT\_BRANCH}\{0\} (not recommended as a default), {\tt
800USER\_\_DO\_BRANCH}\{1\} (also not recommended as a default), and {\tt
801USER\_\_BRANCH\_IF\_TAILOFF}\{3\}. This
802parameter is provided so that the user can change the default behavior
803without recompiling.
804
805\item[\ptt{select\_candidates\_default} -- integer ({\tt
806USER\_\_CLOSE\_TO\_HALF\_AND\_EXPENSIVE}\{10\}).]
807\sindex[p]{\LPP!select\_candidates\_default}
808Determines the default rule for selecting strong branching candidates.
809Other values are {\tt USER\_\_CLOSE\_TO\_HALF}\{10\} and
810{\tt USER\_\_CLOSE\_TO\_ONE\_AND\_CHEAP}\{12\}. This
811parameter is provided so that the user can change the default behavior
812without recompiling.
813
814\item[\ptt{compare\_candidates\_default} -- integer
815({\tt HIGHEST\_LOW\_OBJ}\{2\}).]
816\sindex[p]{\LPP!compare\_candidates\_default}
817Determines the default rule for comparing candidates. See the
818description of \htmlref{\texttt{user\_compare\_candidates()}}
819{user_compare_candidates} for other values. This
820parameter is provided so that the user can change the default behavior
821without recompiling.
822
823\item[\ptt{select\_child\_default} -- integer
824({\tt PREFER\_LOWER\_OBJ\_VALUE}\{0\}).]
825\sindex[p]{\LPP!select\_child\_default}
826Determines the default rule for selecting the child to be processed
827next. For other possible values, see the description \htmlref{
828\texttt{user\_select\_child()}}{user_select_child}. This
829parameter is provided so that the user can change the default behavior
830without recompiling.
831
832\item[\ptt{mc\_find\_supported\_solutions} -- boolean ({\tt FALSE}).]
833\sindex[p]{\LPP!mc\_find\_supported\_solutions}
834By default, {\tt sym\_mc\_solve} routine will find all the non-dominated
835solutions if the problem to be solved is
836a bicriteria problem. However, if the user plans to find only the supported
837solutions, then, this parameter has to be set before
838calling {\tt sym\_mc\_solve} routine.
839
840\item[\ptt{mc\_rho} -- double ({\tt 0.00001}).]
841\sindex[p]{\LPP!mc\_rho}
842The value used in augmented Chebyshev norm during the bicriteria
843solution procedure.
844
845\item[\ptt{generate\_cgl\_cuts} -- boolean ({\tt TRUE}).]
846\sindex[p]{\LPP!generate\_cgl\_cuts}
847Whether or not to generate cuts using COIN's cut generation library.
848Note that, to use CGL cuts, OSI interface has to be used and moreover the
849corresponding flags have to be set during installation. See the makefile for
850more details.
851
852\item[\ptt{generate\_cgl\_gomory\_cuts} -- boolean ({\tt TRUE}).]
853\sindex[p]{\LPP!generate\_cgl\_gomory\_cuts}
854Whether or not to generate Gomory cuts using COIN's cut generation library.
855
856\item[\ptt{generate\_cgl\_knapsack\_cuts} -- boolean ({\tt TRUE}).]
857\sindex[p]{\LPP!generate\_cgl\_knapsack\_cuts}
858Whether or not to generate knapsack cover cuts using COIN's cut generation
859library.
860
861\item[\ptt{generate\_cgl\_oddhole\_cuts} -- boolean ({\tt TRUE}).]
862\sindex[p]{\LPP!generate\_cgl\_oddhole\_cuts}
863Whether or not to generate generalized odd hole cuts using COIN's cut
864generation library.
865
866\item[\ptt{generate\_cgl\_probing\_cuts} -- boolean ({\tt TRUE}).]
867\sindex[p]{\LPP!generate\_cgl\_probing\_cuts}
868Whether or not to generate probing cuts using COIN's cut generation library.
869
870\item[\ptt{generate\_cgl\_clique\_cuts} -- boolean ({\tt TRUE}).]
871\sindex[p]{\LPP!generate\_cgl\_clique\_cuts}
872Whether or not to generate clique cuts using COIN's cut generation library.
873
874\item[\ptt{generate\_cgl\_flow\_and\_cover\_cuts} -- boolean ({\tt FALSE}).]
875\sindex[p]{\LPP!generate\_cgl\_flow\_and\_cover\_cuts}
876Whether or not to generate flow and cover cuts using COIN's cut generation
877library.
878
879\item[\ptt{generate\_cgl\_rounding\_cuts} -- boolean ({\tt FALSE}).]
880\sindex[p]{\LPP!generate\_cgl\_rounding\_cuts}
881Whether or not to generate simple rounding cuts using COIN's cut generation
882library.
883
884\item[\ptt{generate\_cgl\_lift\_and\_project\_cuts} -- boolean ({\tt FALSE}).] \sindex[p]{\LPP!generate\_cgl\_lift\_and\_project\_cuts}
885Whether or not to generate lift-and-project cuts using COIN's cut generation
886library.
887
888\end{description}
889\subsection{Cut Generator Parameters}
890
891\begin{description}
892
893\item[\ptt{CG\_verbosity} -- integer (0).]
894\sindex[p]{\CGP!CG\_verbosity}
895Verbosity level for the cut generator module.
896
897\end{description}
898
899\subsection{Cut Pool Parameters}
900\label{cut_pool_params}
901\begin{description}
902
903\item[\ptt{CP\_verbosity} -- integer (0).]
904\sindex[p]{\CP!CP\_verbosity}
905Verbosity of the cut pool module.
906
907\item[\ptt{cp\_logging} -- boolean (0).]
908\sindex[p]{\CP!cp\_logging}
909Determines whether the logging option is enabled. In this case, the
910entire contents of the cut pool are written out periodically to disk
911(at the same interval as the tree manager log files are written). If
912this option is set, then the line following must start with the
913keyword \ptt{cp\_log\_file\_name} and include the appropriate
914file name as the value.
915
916\item[\ptt{cp\_warm\_start} -- boolean (0).]
917\sindex[p]{\CP!cp\_warm\_start}
918Used to allow the cut pool to make a warm start by reading in a
919previously written log file. If
920this option is set, then the line following must start with the
921keyword \ptt{cp\_warm\_start\_file\_name} and include the appropriate
922file name as the value.
923
924\item[\ptt{block\_size} -- integer (5000).]
925\sindex[p]{\CP!block\_size}
926Indicates the size of the blocks to allocate when more space is needed
927in the cut list.
928
929\item[\ptt{max\_size} -- integer (2000000).]
930\sindex[p]{\CP!max\_size}
931Indicates the maximum size of the cut pool in bytes. This is the total
932memory taken up by the cut list, including all data structures and the
933array of pointers itself.
934
935\item[\ptt{max\_number\_of\_cuts} -- integer (10000).]
936\sindex[p]{\CP!max\_number\_of\_cuts}
937Indicates the maximum number of cuts allowed to be stored. When this
938max is reached, cuts are forcibly purged, starting with duplicates
939and then those indicated by the parameter \htmlref{\texttt{delete\_which}}
940{delete_which} (see below), until the list is below the allowable size.
941
942\item[\ptt{min\_to\_delete} -- integer (1000).]
943\sindex[p]{\CP!min\_to\_delete}
944Indicates the number of cuts required to be deleted when the pool reaches
945it's maximum size.
946
947\item[\ptt{touches\_until\_deletion} -- integer (10).]
948\sindex[p]{\CP!touches\_until\_deletion}
949When using the number of touches a cut has as a measure of its
950quality, this parameter indicates the number of touches a cut can have
951before being deleted from the pool. The number of touches is the
952number of times in a row that a cut has been checked without being
953found to be violated. It is a measure of a cut's relevance or
954effectiveness.
955
956\label{delete_which}
957\item[\ptt{delete\_which} -- integer
958({\tt DELETE\_BY\_TOUCHES}\{2\}).]
959\sindex[p]{\CP!delete\_which}
960Indicates which cuts to delete when
961purging the pool. {\tt DELETE\_BY\_TOUCHES} indicates that cuts whose
962number of touches is above the threshold (see {\tt
963touches\_until\_deletion} above) should be purged if the pool gets too
964large. {\tt DELETE\_BY\_QUALITY}\{1\} indicates that a user-defined
965measure of quality should be used (see the function \hyperref{\tt
966user\_check\_cuts()} {{\tt user\_check\_cuts} in Section}{}
967{user_check_cuts}).
968
969\item[\ptt{check\_which} -- integer ({\tt CHECK\_ALL\_CUTS}\{0\}).]
970\sindex[p]{\CP!check\_which}
971Indicates which cuts should be checked for violation. The choices are
972to check all cuts ({\tt CHECK\_ALL\_CUTS}\{0\}); only those that have
973number of touches below the threshold ({\tt CHECK\_TOUCHES}\{2\}); only
974those that were generated at a level higher in the tree than the
975current one ({\tt CHECK\_LEVEL}\{1\}); or both ({\tt
976CHECK\_LEVEL\_AND\_TOUCHES}\{3\}). Note that with {\tt
977CHECK\_ALL\_CUTS} set, SYMPHONY will still only check the first
978\htmlref{\texttt{cuts\_to\_check}}{cuts_to_check} cuts in the list ordered
979by quality (see the function \htmlref{\texttt{user\_check\_cut}}
980{user_check_cuts}).
981
982\label{cuts_to_check}
983\item[\ptt{cuts\_to\_check} -- integer (1000).]
984\sindex[p]{\CP!cuts\_to\_check}
985Indicates how many cuts in the pool to actually check. The list is
986ordered by quality and the first \ptt{cuts\_to\_check} cuts are
987checked for violation.
988
989\end{description}
990
991\subsection{C++ Interface/OSI Parameters}
992\label{OSI Parameters}
993
994As the implementation of the whole interface, there exists a matching
995C interface parameter to each of the C++ Interface/OSI parameter and
996the parameter setting functions are designed to set the
997corresponding C interface parameter. Thus, we will just give a table of the
998parameter names, their C interface complements and the values they can be set
999to, rather than their detailed descriptions. For each parameter, the user
1000can see the C interface complement for further explanation. \\
1001
1002\resizebox{16cm}{7cm}{
1003\begin{tabular}{|l||l||l|} \hline
1004{\bf C++ Interface} & {\bf C Interface} & {\bf Value}\\ \hline \hline
1005OsiSymVerbosity & verbosity & -user defined- \\
1006\hline \hline
1007OsiSymWarmStart & warm\_start & -boolean- \\
1008\hline \hline
1009OsiSymNodeLimit &  & \\
1010OsiMaxNumIteration & node\_limit & -user defined-\\
1011OsiMaxNumIterationHotStart & & \\
1012\hline \hline
1013OsiSymFindFirstFeasible & find\_first\_feasible & -boolean- \\
1014\hline \hline
1015OsiSymSearchStrategy & node\_selection\_rule & LOWEST\_LP\_FIRST \\
1016& & HIGHEST\_LP\_FIRST \\
1018& & DEPTH\_FIRST\_SEARCH \\
1019\hline \hline
1020OsiSymUsePermanentCutPools & use\_permanent\_cut\_pools & -boolean- \\
1021\hline \hline
1022OsiSymGenerateCglGomoryCuts & generate\_cgl\_gomory\_cuts & -boolean- \\
1023\hline \hline
1024OsiSymGenerateCglKnapsackCuts & generate\_cgl\_knapsack\_cuts & -boolean- \\
1025\hline \hline
1026OsiSymGenerateCglOddHoleCuts & generate\_cgl\_oddhole\_cuts & -boolean- \\
1027\hline \hline
1028OsiSymGenerateCglProbingCuts & generate\_cgl\_probing\_cuts & -boolean- \\
1029\hline \hline
1030OsiSymGenerateCglCliqueCuts & generate\_cgl\_clique\_cuts & -boolean- \\
1031\hline \hline
1032OsiSymGenerateCglFlowAndCoverCuts & generate\_cgl\_flow\_and\_cover\_cuts & -boolean- \\
1033\hline \hline
1034OsiSymGenerateCglRoundingCuts & generate\_cgl\_rounding\_cuts & -boolean- \\
1035\hline \hline
1036OsiSymGenerateCglLiftAndProjectCuts & generate\_cgl\_lift\_and\_project\_cuts & -boolean- \\
1037\hline \hline
1038OsiSymKeepWarmStart & keep\_warm\_start & -boolean- \\
1039\hline \hline
1040OsiSymTrimWarmTree & trim\_warm\_tree * -boolean- \\
1041\hline \hline
1042OsiSymDoReducedCostFixing & do\_reduced\_cost\_fixing & -boolean- \\
1043\hline \hline
1044OsiSymMCFindSupportedSolutions &
1045mc\_find\_supported\_solutions & -boolean- \\
1046\hline \hline
1047OsiSymSensitivityAnalysis & sensitivity\_analysis & -boolean- \\
1048\hline \hline
1049OsiSymRandomSeed & random\_seed & -user defined-\\
1050\hline \hline
1051OsiSymDivingStrategy & diving\_strategy & BEST\_ESTIMATE \\
1052& & COMP\_BEST\_K \\
1053& & COMP\_BEST\_K\_GAP \\
1054\hline \hline
1055OsiSymDivingK & diving\_k & -user defined- \\
1056\hline \hline
1057OsiSymDivingThreshold & diving\_threshold & -user defined- \\
1058\hline \hline
1059OsiSymGranularity & granularity & -user defined- \\
1060\hline \hline
1061OsiSymTimeLimit & time\_limit & -user defined- \\
1062\hline \hline
1063OsiSymGapLimit & gap\_limit & -user defined- \\
1064\hline \hline
1065OsiObjOffset & - & -user defined- \\
1066\hline \hline
1067OsiProbName & problem\_name & -user defined- \\
1068\hline
1069\end{tabular}
1070} \\
1071
1072However, as it is seen, only some of the C interface parameters have their
1073matches. If the other parameters are required to be modified, the user
1074can always set them directly by their C interface names,
1075using the overlapping functions: {\tt setSymParam(string, int),
1076setSymParam(string, double) and setSymParam(string,string)}. For instance,
1077the \ptt{verbosity} parameter can be set, let's say, to 2 either by
1078setSymParam(OsiSymVerbosity, 2) or by setSymParam(verbosity'', 2).
1079Note that, this flexibility is also supported for parameter querying
1080functions.
1081
Note: See TracBrowser for help on using the repository browser.