--

_couenne.opt

@@ -0,0 +1,327 @@
+
+#
+# Couenne options
+#
+# Couenne is an open-source solver for nonconvex Mixed-Integer 
+# Nonlinear Programming (MINLP) problems. See more at 
+# 
+# https://projects.coin-or.org/Couenne
+#
+# The following is a list of option to tweak the performance of
+# Couenne.  Each option has a brief description and is set to a
+# default value that we believe works well in most cases.
+#
+#
+# Some of the notation used here is close to that of the paper that
+# describes Couenne:
+#
+# P. Belotti, J. Lee, L. Liberti, F. Margot, A. Waechter, "Branching
+#   and bounds tightening techniques for non-convex MINLP," 2008.
+# Available on Optimization Online at
+#
+# http://www.optimization-online.org/DB_HTML/2008/08/2059.html
+#
+# We refer the curious user of Couenne to this paper for more insight
+# on how the options are used.
+
+lp_solver cplex
+
+#
+# Verbosity/output level options
+#
+
+# display statistics at the end of the run [yes/no]. Set to yes for a
+# line of output at the end with some brief data on the problem
+
+display_stats no
+
+
+# The following are verbosity levels for the main components of Couenne. 
+# Values: 0 for quiet, 11 for excessive output [0..11]
+
+branching_print_level       0 # Output level for branching code in Couenne.
+boundtightening_print_level 0 # Output level for bound tightening code in Couenne
+convexifying_print_level    0 # Output level for convexifying code in Couenne
+problem_print_level         0 # Output level for problem manipulation code in Couenne 
+                              # (4 prints out original problem)
+nlpheur_print_level         0 # Output level for NLP heuristic in Couenne
+#disjcuts_print_level       0 # Output level for disjunctive cuts in Couenne - disabled for now
+
+#
+# Option for branching rules
+#
+
+# Multipliers of pseudocosts for estimating and update estimation of bound
+#
+# When using pseudocosts, the lower bound of a node is estimated by multiplying 
+# the pseudocost by a measure of the "infeasibility" of that variable.
+#
+# Valid Settings:
+#   infeasibility (infeasibility returned by object)
+#   projectDist (distance between current LP point and resulting branches' LP points)
+#   interval_lp (width of the interval between bound and current lp point)
+#   interval_lp_rev (similar to interval_lp, reversed)
+#   interval_br (width of the interval between bound and branching point)
+#   interval_br_rev (similar to interval_br, reversed)
+
+pseudocost_mult interval_br_rev
+
+
+# Use distance between LP points to update multipliers of
+# pseudocosts. Can give a better estimate of the change in the node as
+# a result of the branching rule.
+
+pseudocost_mult_lp yes
+
+
+# Use Special Ordered Sets (SOS) as indicated in the MINLP
+# model. Couenne recognizes constraints of the form 
+# 
+# f_1(x) + f_2(x) ... + f_n (x) = 1,
+#
+# where f_i (x) are binary expressions, as SOS constraints, and adds
+# them to the Branch&Bound solver (disabled now -- still testing)
+
+enable_sos no
+
+
+# Apply bound tightening before branching
+#
+# Upon branching, it may be useful to apply a bound reduction
+# technique as a preprocessing step for the node, even to check if the
+# node is feasible
+
+branch_fbbt yes
+
+
+# Apply convexification cuts before branching (for now only within
+# strong branching)
+#
+# This is useful to get a more precise lower bound within strong
+# branching (note: does not work when performing the real branching
+# rule)
+
+branch_conv_cuts yes
+
+
+# Chooses branching point selection strategy
+#
+#
+# When branching on a continuous variable x that has a bound interval
+# [l,u], the branching point is also important. Couenne implements
+# several ways of computing the branching point, that may depend on
+# the current solution of the LP relaxation or on the characteristics
+# of the linearization that would result from the branching.
+#
+# The default value of this option is a convex combination 
+#
+#     alpha xp + (1-alpha) xm
+#
+#
+# where xm is the middle point (l+u)/2, xp is the value of x in the
+# current LP relaxation, and 0 <= alpha <= 1. Alpha is defined in the
+# next option.
+#
+# Valid Settings:
+#   lp-clamped (LP point clamped in [k,1-k] of the bound intervals (k defined by lp_clamp))
+#   lp-central (LP point if within [k,1-k] of the bound intervals, 
+#               middle point otherwise(k defined by branch_lp_clamp))
+#   balanced (minimizes max distance from curve to convexification)
+#   min-area (minimizes total area of the two convexifications)
+#   mid-point (convex combination of current point and mid point)
+#   no-branch (do not branch, return null infeasibility; for testing purposes only)
+
+branch_pt_select mid-point
+
+
+# Defines convex combination of mid point and current LP point. See
+# comments on option "branch_pt_select" above.
+
+#branch_midpoint_alpha 0.25
+
+
+# Priority of continuous variable branching
+#
+# In Cbc, the Branch&Bound solver on which Couenne is based, integer
+# variables have a priority of 1000. This parameter is the branching
+# priority of continuous variables. Setting it to more than 1000 gives
+# precedence to integer variables, i.e., as long as one integer
+# variable is currently "infeasible" (i.e. fractional) it will be
+# branched on.  A value below 1000 will give precedence to continuous
+# variables. 
+
+#cont_var_priority 2000
+
+
+# Apply Reduced Cost Branching (instead of the Violation Transfer) --
+# MUST have vt_obj enabled
+#
+#
+# Violation Transfer and reduced cost branching are similar techniques
+# for selecting a branching variable. Couenne implements both and lets
+# you choose which one to use. Set this to yes to use reduced cost
+# branching. Experimentally, Violation Transfer appears slightly
+# better, hence it is preferred by default.
+
+red_cost_branching yes
+
+
+# Type of branching object for variable selection
+#
+#
+# This parameter determines the branching variable selection
+# technique. With "vt_obj", the Violation Transfer branching technique
+# is used. "var_obj" chooses a variable based on the set of nonlinear
+# expressions that depends on it, while "expr_obj" selects the most
+# violated nonlinear expression and branches on one of the variables
+# on which the expression depends. The default is var_obj
+#
+#
+# Valid Settings:
+#   vt_obj    use Violation Transfer from Tawarmalani and Sahinidis
+#   var_obj   use one object for each variable
+#   expr_obj  use one object for each nonlinear expression
+
+#branching_object var_obj
+branching_object expr_obj
+#branching_object vt_obj
+
+
+
+
+#
+# Options for bound tightening
+#
+
+
+# Feasibility-based (cheap) bound tightening (FBBT)
+#
+# A fast bound reduction technique. Not very efficient in eliminating
+# vast portions of the solution set, but recommended.
+
+feasibility_bt yes
+
+
+# Optimality-based (expensive) bound tightening (OBBT)
+#
+# A slower bound reduction technique that relies on solving 2n LP
+# problems (n is the number of variables). Probably more efficient
+# that FBBT, but much more computationally intensive. Recommended 
+# for small problems. See also the next option.
+
+optimality_bt yes
+
+
+# Specify the frequency (in terms of nodes) for optimality-based bound
+# tightening
+#
+# As OBBT is expensive, the user may choose to run it only until the
+# depth k of the branch&bound tree, and with probability exponentially
+# decreasing with the depth of the branch&bound node at any other node
+# below depth k.
+
+log_num_obbt_per_level 1
+
+
+# Aggressive feasibility-based bound tightening (to use with NLP points)
+#
+#
+# See the paper for a detailed explanation. This is also an expensive
+# but efficient way to reduce the solution set
+
+aggressive_fbbt yes
+
+
+# Specify the frequency (in terms of nodes) for aggressive bound tightening.
+#
+# A parameter analogous to what log_num_obbt_per_level is for OBBT.
+
+#log_num_abt_per_level 2
+log_num_abt_per_level 2000
+
+
+#
+# Options for reformulation and linearization
+#
+
+
+# Specify the frequency (in terms of nodes) at which couenne ecp cuts
+# are generated.
+#
+# A default value of 1 has linearization inequalities generated at
+# every node.
+
+convexification_cuts 1
+
+
+# Specify the number of points at which to convexify when
+# convexification type.
+
+convexification_points 4
+
+
+# Yes if only violated convexification cuts should be added 
+
+violated_cuts_only yes
+
+
+
+#
+# Options for debugging
+#
+# Some of these options usually slow down Couenne, and are hence only suggested for debugging purposes.
+#
+
+# Check all LPs through an independent call to
+#  OsiClpSolverInterface::initialSolve() (very expensive)
+#check_lp no
+
+# Artificial cutoff. Used when you know a feasible solution and want
+# to use it to restrict the solution space
+
+art_cutoff 1e100
+#art_cutoff 903
+
+# Window around known optimum
+#opt_window 
+
+# Artificial lower bound
+#art_lower -1e100
+
+
+#
+# Other options
+#
+
+
+# Do we search for local solutions of NLP's?
+local_optimization_heuristic yes
+
+
+# Specify the logarithm of the number of local optimizations to
+# perform.
+#
+#
+# Analogous to log_num_abt_per_level and log_num_obbt_per_level, this
+# option determines until which depth of the branch&bound tree the
+# call to a nonlinear solver is done at every node. Below this depth,
+# calls to the nonlinear solver happen with probability inversely
+# proportional to the depth of the node.
+
+log_num_local_optimization_per_level 2
+
+
+# Tolerance for constraints/auxiliary variables
+#
+#
+# A solution is feasible for the original problem if the maximum
+# violation of a constraint is below this number
+
+feas_tolerance 1e-6
+
+
+# Use quadratic expressions and related exprQuad class
+#
+# Allows to use a single operator for quadratic forms (not yet enabled)
+
+use_quadratic no

couenne.opt

@@ -22,7 +22,7 @@
 #
 # We refer the curious user of Couenne to this paper for more insight
 # on how the options are used.
-
+lp_solver clp
 
 
 #
@@ -70,7 +70,7 @@ pseudocost_mult interval_br_rev
 # pseudocosts. Can give a better estimate of the change in the node as
 # a result of the branching rule.
 
-pseudocost_mult_lp yes
+pseudocost_mult_lp no
 
 
 # Use Special Ordered Sets (SOS) as indicated in the MINLP
@@ -162,7 +162,7 @@ branch_pt_select mid-point
 # branching. Experimentally, Violation Transfer appears slightly
 # better, hence it is preferred by default.
 
-red_cost_branching yes
+red_cost_branching no
 
 
 # Type of branching object for variable selection
@@ -181,9 +181,7 @@ red_cost_branching yes
 #   var_obj   use one object for each variable
 #   expr_obj  use one object for each nonlinear expression
 
-#branching_object var_obj
 branching_object expr_obj
-#branching_object vt_obj
 
 
 
@@ -235,7 +233,6 @@ aggressive_fbbt yes
 #
 # A parameter analogous to what log_num_obbt_per_level is for OBBT.
 
-#log_num_abt_per_level 2
 log_num_abt_per_level 2
 
 
@@ -278,8 +275,7 @@ violated_cuts_only yes
 # Artificial cutoff. Used when you know a feasible solution and want
 # to use it to restrict the solution space
 
-art_cutoff 1e100
-#art_cutoff 903
+#art_cutoff 1e100
 
 # Window around known optimum
 #opt_window 
@@ -316,7 +312,7 @@ log_num_local_optimization_per_level 2
 # A solution is feasible for the original problem if the maximum
 # violation of a constraint is below this number
 
-feas_tolerance 1e-6
+feas_tolerance 1e-4
 
 
 # Use quadratic expressions and related exprQuad class