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

Last change on this file since 604 was 369, checked in by tkr, 9 years ago

* empty log message *

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