diff --git a/help/en_US/linprog.xml b/help/en_US/linprog.xml
old mode 100755
new mode 100644
diff --git a/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS b/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS
index e29698f..236a815 100644
Binary files a/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS and b/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS differ
diff --git a/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS.TAB b/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS.TAB
index 0d7319d..2133bb0 100644
Binary files a/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS.TAB and b/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS.TAB differ
diff --git a/help/en_US/scilab_en_US_help/JavaHelpSearch/OFFSETS b/help/en_US/scilab_en_US_help/JavaHelpSearch/OFFSETS
index 3bc2a52..8728452 100644
Binary files a/help/en_US/scilab_en_US_help/JavaHelpSearch/OFFSETS and b/help/en_US/scilab_en_US_help/JavaHelpSearch/OFFSETS differ
diff --git a/help/en_US/scilab_en_US_help/JavaHelpSearch/POSITIONS b/help/en_US/scilab_en_US_help/JavaHelpSearch/POSITIONS
index 5b008c5..bfc07ce 100644
Binary files a/help/en_US/scilab_en_US_help/JavaHelpSearch/POSITIONS and b/help/en_US/scilab_en_US_help/JavaHelpSearch/POSITIONS differ
diff --git a/help/en_US/scilab_en_US_help/JavaHelpSearch/SCHEMA b/help/en_US/scilab_en_US_help/JavaHelpSearch/SCHEMA
index 00ccabf..d34e905 100644
--- a/help/en_US/scilab_en_US_help/JavaHelpSearch/SCHEMA
+++ b/help/en_US/scilab_en_US_help/JavaHelpSearch/SCHEMA
@@ -1,2 +1,2 @@
JavaSearch 1.0
-TMAP bs=2048 rt=1 fl=-1 id1=1516 id2=1
+TMAP bs=2048 rt=1 fl=-1 id1=1523 id2=1
diff --git a/help/en_US/scilab_en_US_help/JavaHelpSearch/TMAP b/help/en_US/scilab_en_US_help/JavaHelpSearch/TMAP
index 6b36ea7..882bad7 100644
Binary files a/help/en_US/scilab_en_US_help/JavaHelpSearch/TMAP and b/help/en_US/scilab_en_US_help/JavaHelpSearch/TMAP differ
diff --git a/help/en_US/scilab_en_US_help/fminbnd.html b/help/en_US/scilab_en_US_help/fminbnd.html
index 46755f8..4ac4a98 100644
--- a/help/en_US/scilab_en_US_help/fminbnd.html
+++ b/help/en_US/scilab_en_US_help/fminbnd.html
@@ -89,7 +89,8 @@ It has type "struct" and contains the following fields.
- output.Iterations: The number of iterations performed during the search
- output.Cpu_Time: The total cpu-time spend during the search
- output.Objective_Evaluation: The number of Objective Evaluations performed during the search
-- output.Dual_Infeasibility: The Dual Infeasiblity of the final soution
+output.Dual_Infeasibility: The Dual Infeasiblity of the final soution
+output.Message: The output message for the problem
The lambda data structure contains the Lagrange multipliers at the end
of optimization. In the current version the values are returned only when the the solution is optimal.
It has type "struct" and contains the following fields.
diff --git a/help/en_US/scilab_en_US_help/fmincon.html b/help/en_US/scilab_en_US_help/fmincon.html
index ea3077f..5d4a558 100644
--- a/help/en_US/scilab_en_US_help/fmincon.html
+++ b/help/en_US/scilab_en_US_help/fmincon.html
@@ -112,7 +112,8 @@ It has type "struct" and contains the following fields.
- output.Iterations: The number of iterations performed during the search
- output.Cpu_Time: The total cpu-time spend during the search
- output.Objective_Evaluation: The number of Objective Evaluations performed during the search
-- output.Dual_Infeasibility: The Dual Infeasiblity of the final soution
+output.Dual_Infeasibility: The Dual Infeasiblity of the final soution
+output.Message: The output message for the problem
The lambda data structure contains the Lagrange multipliers at the end
of optimization. In the current version the values are returned only when the the solution is optimal.
It has type "struct" and contains the following fields.
@@ -276,7 +277,8 @@ It has type "struct" and contains the following fields.
options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", fGrad, "Hessian", lHess,"GradCon", cGrad);
-[x,fval,exitflag,output,lambda,grad,hessian] =fmincon(f, x0,A,b,Aeq,beq,lb,ub,nlc,options)
 |  | |
+[x,fval,exitflag,output,lambda,grad,hessian] =fmincon(f, x0,A,b,Aeq,beq,lb,ub,nlc,options)
+ | | |
Authors
- R.Vidyadhar , Vignesh Kannan
Parameters
- fun:
diff --git a/help/en_US/scilab_en_US_help/fminunc.html b/help/en_US/scilab_en_US_help/fminunc.html
index 636ea68..e6ec051 100644
--- a/help/en_US/scilab_en_US_help/fminunc.html
+++ b/help/en_US/scilab_en_US_help/fminunc.html
@@ -91,7 +91,8 @@ It has type "struct" and contains the following fields.
- output.Iterations: The number of iterations performed during the search
- output.Cpu_Time: The total cpu-time spend during the search
- output.Objective_Evaluation: The number of Objective Evaluations performed during the search
-- output.Dual_Infeasibility: The Dual Infeasiblity of the final soution
+- output.Dual_Infeasibility: The Dual Infeasiblity of the final soution
+- output.Message: The output message for the problem
Examples
diff --git a/help/en_US/scilab_en_US_help/section_24af5d179784a48827745fa0aa9df4dd.html b/help/en_US/scilab_en_US_help/section_24af5d179784a48827745fa0aa9df4dd.html
new file mode 100644
index 0000000..7fd89ea
--- /dev/null
+++ b/help/en_US/scilab_en_US_help/section_24af5d179784a48827745fa0aa9df4dd.html
@@ -0,0 +1,358 @@
+
+
+
+
+
+
+
+
+
+
+
FOSSEE Optimization Toolbox >> FOSSEE Optimization Toolbox
+
+
+
FOSSEE Optimization Toolbox
+
- fgoalattain — Solves a multiobjective goal attainment problem
+
+
+
+
+
+- fminbnd — Solves a multi-variable optimization problem on a bounded interval
+
+
+
+
+
+- fmincon — Solves a multi-variable constrainted optimization problem
+
+
+
+
+
+- fminimax — Solves minimax constraint problem
+
+
+
+
+
+- fminunc — Solves a multi-variable unconstrainted optimization problem
+
+
+
+
+
+- linprog — Solves a linear programming problem.
+
+
+
+
+
+- lsqlin — Solves a linear quadratic problem.
+
+
+
+
+
+- lsqnonlin — Solves a non linear data fitting problems.
+
+
+
+
+
+- lsqnonneg — Solves nonnegative least-squares curve fitting problems.
+
+
+
+
+
+- qpipopt — Solves a linear quadratic problem.
+
+
+
+
+
+- qpipoptmat — Solves a linear quadratic problem.
+
+
+
+
+
+- symphony — Solves a mixed integer linear programming constrained optimization problem.
+
+
+
+
+
+- symphonymat — Solves a mixed integer linear programming constrained optimization problem in intlinprog format.
+
+- Symphony Native Functions
+
- sym_addConstr — Add a new constraint
+
+
+
+- sym_addVar — Add a new variable
+
+
+
+- sym_close — Close the Symphony environment
+
+
+
+- sym_deleteConstrs — This routine is used to delete rows from the original constraint matrix.
+
+
+
+- sym_deleteVars — This routine is used to delete columns from the original problem description.
+
+
+
+- sym_getConstrActivity — Get the activity of the constraints in the solution
+
+
+
+- sym_getConstrLower — To get the lower bounds of the constraints.
+
+
+
+- sym_getConstrRange — To to get the constraint ranges.
+
+
+
+- sym_getConstrSense — To get the row senses.
+
+
+
+- sym_getConstrUpper — To get the upper bounds of the constraints.
+
+
+
+- sym_getDblParam — This routine is used to get the value of a double type parameter.
+
+
+
+- sym_getInfinity — Get Symphony's infinity value
+
+
+
+- sym_getIntParam — This routine is used to get the value of an integer type parameter.
+
+
+
+- sym_getIterCount — To get the number of the analyzed nodes of the branching tree after solving the problem.
+
+
+
+- sym_getMatrix — To get the constraint matrix.
+
+
+
+- sym_getNumConstr — To get the number of the constraints of the current problem.
+
+
+
+- sym_getNumElements — To get the number of non-zero entries of the constraint matrix of the current problem.
+
+
+
+- sym_getNumVar — To get the number of the variables of the current problem.
+
+
+
+- sym_getObjCoeff — To get the objective vector.
+
+
+
+- sym_getObjSense — Get the objective sense
+
+
+
+- sym_getObjVal — Get the optimized objective value
+
+
+
+- sym_getPrimalBound — Get the primal bound of the problem
+
+
+
+- sym_getRhs — To to get the right hand side vector(column vector).
+
+
+
+- sym_getStatus — To get status of the problem solver.
+
+
+
+- sym_getStrParam — This routine is used to get the value of a string type parameter.
+
+
+
+- sym_getVarLower — To get the lower bounds of the variables.
+
+
+
+- sym_getVarSoln — Get the solution for the problem
+
+
+
+- sym_getVarUpper — To get the upper bounds of the variables.
+
+
+
+- sym_isAbandoned — To check whether the problem was abandoned for some reason.
+
+
+
+- sym_isBinary — Check if a variable is constrained to be binary
+
+
+
+- sym_isContinuous — Check if a variable is continuous
+
+
+
+- sym_isEnvActive — Check if Symphony environment is active
+
+
+
+- sym_isInfeasible — To check whether the problem was proven to be infeasible.
+
+
+
+- sym_isInteger — Check if a variable is constrained to be an integer
+
+
+
+- sym_isIterLimitReached — To know whether the iteration limit (node limit) was reached.
+
+
+
+- sym_isOptimal — To check whether the problem was solved to optimality.
+
+
+
+- sym_isTargetGapAchieved — To know whether the target gap was reached.
+
+
+
+- sym_isTimeLimitReached — To know whether the time limit was reached.
+
+
+
+- sym_loadMPS — This routine is used to load an instance from an MPS file.
+
+
+
+- sym_loadProblem — Load a problem into Symphony
+
+
+
+- sym_loadProblemBasic — Load a problem into Symphony (basic version)
+
+
+
+- sym_open — Open the Symphony environment
+
+
+
+- sym_resetParams — This routine sets all the environment variables and parameters to their default values.
+
+
+
+- sym_setConstrLower — Set the lower bound of a constraint
+
+
+
+- sym_setConstrType — Set the type of a constraint
+
+
+
+- sym_setConstrUpper — Set the upper bound of a constraint
+
+
+
+- sym_setContinuous — This routine is used to set the type of a variable to be continuous.
+
+
+
+- sym_setDblParam — This routine is used to set a double type parameter.
+
+
+
+- sym_setIntParam — This routine is used to set an integer type parameter.
+
+
+
+- sym_setInteger — This routine is used to set the type of a variable to be integer.
+
+
+
+- sym_setObjCoeff — Set coefficient of a variable in the objective
+
+
+
+- sym_setObjSense — Set the objective sense
+
+
+
+- sym_setPrimalBound — Set the primal bound of the problem
+
+
+
+- sym_setStrParam — This routine is used to set a string type parameter.
+
+
+
+- sym_setVarLower — Set lower bound of a variable
+
+
+
+- sym_setVarSoln — Set a solution for the problem
+
+
+
+- sym_setVarUpper — Set upper bound of a variable
+
+
+
+- sym_solve — To solve the currently loaded MILP problem from scratch.
+
+
+
+
+
diff --git a/help/en_US/scilab_en_US_help/section_43d915e486cd1a7dde8c0c09d6ab177e.html b/help/en_US/scilab_en_US_help/section_43d915e486cd1a7dde8c0c09d6ab177e.html
new file mode 100644
index 0000000..5ba90ab
--- /dev/null
+++ b/help/en_US/scilab_en_US_help/section_43d915e486cd1a7dde8c0c09d6ab177e.html
@@ -0,0 +1,285 @@
+
+
+
+
+
+
+
+
+
+
+
FOSSEE Optimization Toolbox >> FOSSEE Optimization Toolbox > Symphony Native Functions
+
+
+
Symphony Native Functions
+
- sym_addConstr — Add a new constraint
+
+
+
+- sym_addVar — Add a new variable
+
+
+
+- sym_close — Close the Symphony environment
+
+
+
+- sym_deleteConstrs — This routine is used to delete rows from the original constraint matrix.
+
+
+
+- sym_deleteVars — This routine is used to delete columns from the original problem description.
+
+
+
+- sym_getConstrActivity — Get the activity of the constraints in the solution
+
+
+
+- sym_getConstrLower — To get the lower bounds of the constraints.
+
+
+
+- sym_getConstrRange — To to get the constraint ranges.
+
+
+
+- sym_getConstrSense — To get the row senses.
+
+
+
+- sym_getConstrUpper — To get the upper bounds of the constraints.
+
+
+
+- sym_getDblParam — This routine is used to get the value of a double type parameter.
+
+
+
+- sym_getInfinity — Get Symphony's infinity value
+
+
+
+- sym_getIntParam — This routine is used to get the value of an integer type parameter.
+
+
+
+- sym_getIterCount — To get the number of the analyzed nodes of the branching tree after solving the problem.
+
+
+
+- sym_getMatrix — To get the constraint matrix.
+
+
+
+- sym_getNumConstr — To get the number of the constraints of the current problem.
+
+
+
+- sym_getNumElements — To get the number of non-zero entries of the constraint matrix of the current problem.
+
+
+
+- sym_getNumVar — To get the number of the variables of the current problem.
+
+
+
+- sym_getObjCoeff — To get the objective vector.
+
+
+
+- sym_getObjSense — Get the objective sense
+
+
+
+- sym_getObjVal — Get the optimized objective value
+
+
+
+- sym_getPrimalBound — Get the primal bound of the problem
+
+
+
+- sym_getRhs — To to get the right hand side vector(column vector).
+
+
+
+- sym_getStatus — To get status of the problem solver.
+
+
+
+- sym_getStrParam — This routine is used to get the value of a string type parameter.
+
+
+
+- sym_getVarLower — To get the lower bounds of the variables.
+
+
+
+- sym_getVarSoln — Get the solution for the problem
+
+
+
+- sym_getVarUpper — To get the upper bounds of the variables.
+
+
+
+- sym_isAbandoned — To check whether the problem was abandoned for some reason.
+
+
+
+- sym_isBinary — Check if a variable is constrained to be binary
+
+
+
+- sym_isContinuous — Check if a variable is continuous
+
+
+
+- sym_isEnvActive — Check if Symphony environment is active
+
+
+
+- sym_isInfeasible — To check whether the problem was proven to be infeasible.
+
+
+
+- sym_isInteger — Check if a variable is constrained to be an integer
+
+
+
+- sym_isIterLimitReached — To know whether the iteration limit (node limit) was reached.
+
+
+
+- sym_isOptimal — To check whether the problem was solved to optimality.
+
+
+
+- sym_isTargetGapAchieved — To know whether the target gap was reached.
+
+
+
+- sym_isTimeLimitReached — To know whether the time limit was reached.
+
+
+
+- sym_loadMPS — This routine is used to load an instance from an MPS file.
+
+
+
+- sym_loadProblem — Load a problem into Symphony
+
+
+
+- sym_loadProblemBasic — Load a problem into Symphony (basic version)
+
+
+
+- sym_open — Open the Symphony environment
+
+
+
+- sym_resetParams — This routine sets all the environment variables and parameters to their default values.
+
+
+
+- sym_setConstrLower — Set the lower bound of a constraint
+
+
+
+- sym_setConstrType — Set the type of a constraint
+
+
+
+- sym_setConstrUpper — Set the upper bound of a constraint
+
+
+
+- sym_setContinuous — This routine is used to set the type of a variable to be continuous.
+
+
+
+- sym_setDblParam — This routine is used to set a double type parameter.
+
+
+
+- sym_setIntParam — This routine is used to set an integer type parameter.
+
+
+
+- sym_setInteger — This routine is used to set the type of a variable to be integer.
+
+
+
+- sym_setObjCoeff — Set coefficient of a variable in the objective
+
+
+
+- sym_setObjSense — Set the objective sense
+
+
+
+- sym_setPrimalBound — Set the primal bound of the problem
+
+
+
+- sym_setStrParam — This routine is used to set a string type parameter.
+
+
+
+- sym_setVarLower — Set lower bound of a variable
+
+
+
+- sym_setVarSoln — Set a solution for the problem
+
+
+
+- sym_setVarUpper — Set upper bound of a variable
+
+
+
+- sym_solve — To solve the currently loaded MILP problem from scratch.
+
+
+
+
+
diff --git a/help/en_US/scilab_en_US_help/section_4fff750f952bf1f67f4b2a1869ada898.html b/help/en_US/scilab_en_US_help/section_4fff750f952bf1f67f4b2a1869ada898.html
new file mode 100644
index 0000000..8384736
--- /dev/null
+++ b/help/en_US/scilab_en_US_help/section_4fff750f952bf1f67f4b2a1869ada898.html
@@ -0,0 +1,358 @@
+
+
+
+
+
+
+
+
+
+
+
FOSSEE Optimization Toolbox >> FOSSEE Optimization Toolbox
+
+
+
FOSSEE Optimization Toolbox
+
- fgoalattain — Solves a multiobjective goal attainment problem
+
+
+
+
+
+- fminbnd — Solves a multi-variable optimization problem on a bounded interval
+
+
+
+
+
+- fmincon — Solves a multi-variable constrainted optimization problem
+
+
+
+
+
+- fminimax — Solves minimax constraint problem
+
+
+
+
+
+- fminunc — Solves a multi-variable unconstrainted optimization problem
+
+
+
+
+
+- linprog — Solves a linear programming problem.
+
+
+
+
+
+- lsqlin — Solves a linear quadratic problem.
+
+
+
+
+
+- lsqnonlin — Solves a non linear data fitting problems.
+
+
+
+
+
+- lsqnonneg — Solves nonnegative least-squares curve fitting problems.
+
+
+
+
+
+- qpipopt — Solves a linear quadratic problem.
+
+
+
+
+
+- qpipoptmat — Solves a linear quadratic problem.
+
+
+
+
+
+- symphony — Solves a mixed integer linear programming constrained optimization problem.
+
+
+
+
+
+- symphonymat — Solves a mixed integer linear programming constrained optimization problem in intlinprog format.
+
+- Symphony Native Functions
+
- sym_addConstr — Add a new constraint
+
+
+
+- sym_addVar — Add a new variable
+
+
+
+- sym_close — Close the Symphony environment
+
+
+
+- sym_deleteConstrs — This routine is used to delete rows from the original constraint matrix.
+
+
+
+- sym_deleteVars — This routine is used to delete columns from the original problem description.
+
+
+
+- sym_getConstrActivity — Get the activity of the constraints in the solution
+
+
+
+- sym_getConstrLower — To get the lower bounds of the constraints.
+
+
+
+- sym_getConstrRange — To to get the constraint ranges.
+
+
+
+- sym_getConstrSense — To get the row senses.
+
+
+
+- sym_getConstrUpper — To get the upper bounds of the constraints.
+
+
+
+- sym_getDblParam — This routine is used to get the value of a double type parameter.
+
+
+
+- sym_getInfinity — Get Symphony's infinity value
+
+
+
+- sym_getIntParam — This routine is used to get the value of an integer type parameter.
+
+
+
+- sym_getIterCount — To get the number of the analyzed nodes of the branching tree after solving the problem.
+
+
+
+- sym_getMatrix — To get the constraint matrix.
+
+
+
+- sym_getNumConstr — To get the number of the constraints of the current problem.
+
+
+
+- sym_getNumElements — To get the number of non-zero entries of the constraint matrix of the current problem.
+
+
+
+- sym_getNumVar — To get the number of the variables of the current problem.
+
+
+
+- sym_getObjCoeff — To get the objective vector.
+
+
+
+- sym_getObjSense — Get the objective sense
+
+
+
+- sym_getObjVal — Get the optimized objective value
+
+
+
+- sym_getPrimalBound — Get the primal bound of the problem
+
+
+
+- sym_getRhs — To to get the right hand side vector(column vector).
+
+
+
+- sym_getStatus — To get status of the problem solver.
+
+
+
+- sym_getStrParam — This routine is used to get the value of a string type parameter.
+
+
+
+- sym_getVarLower — To get the lower bounds of the variables.
+
+
+
+- sym_getVarSoln — Get the solution for the problem
+
+
+
+- sym_getVarUpper — To get the upper bounds of the variables.
+
+
+
+- sym_isAbandoned — To check whether the problem was abandoned for some reason.
+
+
+
+- sym_isBinary — Check if a variable is constrained to be binary
+
+
+
+- sym_isContinuous — Check if a variable is continuous
+
+
+
+- sym_isEnvActive — Check if Symphony environment is active
+
+
+
+- sym_isInfeasible — To check whether the problem was proven to be infeasible.
+
+
+
+- sym_isInteger — Check if a variable is constrained to be an integer
+
+
+
+- sym_isIterLimitReached — To know whether the iteration limit (node limit) was reached.
+
+
+
+- sym_isOptimal — To check whether the problem was solved to optimality.
+
+
+
+- sym_isTargetGapAchieved — To know whether the target gap was reached.
+
+
+
+- sym_isTimeLimitReached — To know whether the time limit was reached.
+
+
+
+- sym_loadMPS — This routine is used to load an instance from an MPS file.
+
+
+
+- sym_loadProblem — Load a problem into Symphony
+
+
+
+- sym_loadProblemBasic — Load a problem into Symphony (basic version)
+
+
+
+- sym_open — Open the Symphony environment
+
+
+
+- sym_resetParams — This routine sets all the environment variables and parameters to their default values.
+
+
+
+- sym_setConstrLower — Set the lower bound of a constraint
+
+
+
+- sym_setConstrType — Set the type of a constraint
+
+
+
+- sym_setConstrUpper — Set the upper bound of a constraint
+
+
+
+- sym_setContinuous — This routine is used to set the type of a variable to be continuous.
+
+
+
+- sym_setDblParam — This routine is used to set a double type parameter.
+
+
+
+- sym_setIntParam — This routine is used to set an integer type parameter.
+
+
+
+- sym_setInteger — This routine is used to set the type of a variable to be integer.
+
+
+
+- sym_setObjCoeff — Set coefficient of a variable in the objective
+
+
+
+- sym_setObjSense — Set the objective sense
+
+
+
+- sym_setPrimalBound — Set the primal bound of the problem
+
+
+
+- sym_setStrParam — This routine is used to set a string type parameter.
+
+
+
+- sym_setVarLower — Set lower bound of a variable
+
+
+
+- sym_setVarSoln — Set a solution for the problem
+
+
+
+- sym_setVarUpper — Set upper bound of a variable
+
+
+
+- sym_solve — To solve the currently loaded MILP problem from scratch.
+
+
+
+
+
diff --git a/help/en_US/scilab_en_US_help/section_5e696f2d03a3604c545d1892ce44a062.html b/help/en_US/scilab_en_US_help/section_5e696f2d03a3604c545d1892ce44a062.html
new file mode 100644
index 0000000..2d33b2d
--- /dev/null
+++ b/help/en_US/scilab_en_US_help/section_5e696f2d03a3604c545d1892ce44a062.html
@@ -0,0 +1,285 @@
+
+
+
+
+
+
+
+
+
+
+
FOSSEE Optimization Toolbox >> FOSSEE Optimization Toolbox > Symphony Native Functions
+
+
+
Symphony Native Functions
+
- sym_addConstr — Add a new constraint
+
+
+
+- sym_addVar — Add a new variable
+
+
+
+- sym_close — Close the Symphony environment
+
+
+
+- sym_deleteConstrs — This routine is used to delete rows from the original constraint matrix.
+
+
+
+- sym_deleteVars — This routine is used to delete columns from the original problem description.
+
+
+
+- sym_getConstrActivity — Get the activity of the constraints in the solution
+
+
+
+- sym_getConstrLower — To get the lower bounds of the constraints.
+
+
+
+- sym_getConstrRange — To to get the constraint ranges.
+
+
+
+- sym_getConstrSense — To get the row senses.
+
+
+
+- sym_getConstrUpper — To get the upper bounds of the constraints.
+
+
+
+- sym_getDblParam — This routine is used to get the value of a double type parameter.
+
+
+
+- sym_getInfinity — Get Symphony's infinity value
+
+
+
+- sym_getIntParam — This routine is used to get the value of an integer type parameter.
+
+
+
+- sym_getIterCount — To get the number of the analyzed nodes of the branching tree after solving the problem.
+
+
+
+- sym_getMatrix — To get the constraint matrix.
+
+
+
+- sym_getNumConstr — To get the number of the constraints of the current problem.
+
+
+
+- sym_getNumElements — To get the number of non-zero entries of the constraint matrix of the current problem.
+
+
+
+- sym_getNumVar — To get the number of the variables of the current problem.
+
+
+
+- sym_getObjCoeff — To get the objective vector.
+
+
+
+- sym_getObjSense — Get the objective sense
+
+
+
+- sym_getObjVal — Get the optimized objective value
+
+
+
+- sym_getPrimalBound — Get the primal bound of the problem
+
+
+
+- sym_getRhs — To to get the right hand side vector(column vector).
+
+
+
+- sym_getStatus — To get status of the problem solver.
+
+
+
+- sym_getStrParam — This routine is used to get the value of a string type parameter.
+
+
+
+- sym_getVarLower — To get the lower bounds of the variables.
+
+
+
+- sym_getVarSoln — Get the solution for the problem
+
+
+
+- sym_getVarUpper — To get the upper bounds of the variables.
+
+
+
+- sym_isAbandoned — To check whether the problem was abandoned for some reason.
+
+
+
+- sym_isBinary — Check if a variable is constrained to be binary
+
+
+
+- sym_isContinuous — Check if a variable is continuous
+
+
+
+- sym_isEnvActive — Check if Symphony environment is active
+
+
+
+- sym_isInfeasible — To check whether the problem was proven to be infeasible.
+
+
+
+- sym_isInteger — Check if a variable is constrained to be an integer
+
+
+
+- sym_isIterLimitReached — To know whether the iteration limit (node limit) was reached.
+
+
+
+- sym_isOptimal — To check whether the problem was solved to optimality.
+
+
+
+- sym_isTargetGapAchieved — To know whether the target gap was reached.
+
+
+
+- sym_isTimeLimitReached — To know whether the time limit was reached.
+
+
+
+- sym_loadMPS — This routine is used to load an instance from an MPS file.
+
+
+
+- sym_loadProblem — Load a problem into Symphony
+
+
+
+- sym_loadProblemBasic — Load a problem into Symphony (basic version)
+
+
+
+- sym_open — Open the Symphony environment
+
+
+
+- sym_resetParams — This routine sets all the environment variables and parameters to their default values.
+
+
+
+- sym_setConstrLower — Set the lower bound of a constraint
+
+
+
+- sym_setConstrType — Set the type of a constraint
+
+
+
+- sym_setConstrUpper — Set the upper bound of a constraint
+
+
+
+- sym_setContinuous — This routine is used to set the type of a variable to be continuous.
+
+
+
+- sym_setDblParam — This routine is used to set a double type parameter.
+
+
+
+- sym_setIntParam — This routine is used to set an integer type parameter.
+
+
+
+- sym_setInteger — This routine is used to set the type of a variable to be integer.
+
+
+
+- sym_setObjCoeff — Set coefficient of a variable in the objective
+
+
+
+- sym_setObjSense — Set the objective sense
+
+
+
+- sym_setPrimalBound — Set the primal bound of the problem
+
+
+
+- sym_setStrParam — This routine is used to set a string type parameter.
+
+
+
+- sym_setVarLower — Set lower bound of a variable
+
+
+
+- sym_setVarSoln — Set a solution for the problem
+
+
+
+- sym_setVarUpper — Set upper bound of a variable
+
+
+
+- sym_solve — To solve the currently loaded MILP problem from scratch.
+
+
+
+
+
diff --git a/help/en_US/scilab_en_US_help/section_acc9053f8b9eb28fc8444868aeb726ed.html b/help/en_US/scilab_en_US_help/section_acc9053f8b9eb28fc8444868aeb726ed.html
new file mode 100644
index 0000000..85e5dc9
--- /dev/null
+++ b/help/en_US/scilab_en_US_help/section_acc9053f8b9eb28fc8444868aeb726ed.html
@@ -0,0 +1,285 @@
+
+
+
+
+
+
+
+
+
+
+
FOSSEE Optimization Toolbox >> FOSSEE Optimization Toolbox > Symphony Native Functions
+
+
+
Symphony Native Functions
+
- sym_addConstr — Add a new constraint
+
+
+
+- sym_addVar — Add a new variable
+
+
+
+- sym_close — Close the Symphony environment
+
+
+
+- sym_deleteConstrs — This routine is used to delete rows from the original constraint matrix.
+
+
+
+- sym_deleteVars — This routine is used to delete columns from the original problem description.
+
+
+
+- sym_getConstrActivity — Get the activity of the constraints in the solution
+
+
+
+- sym_getConstrLower — To get the lower bounds of the constraints.
+
+
+
+- sym_getConstrRange — To to get the constraint ranges.
+
+
+
+- sym_getConstrSense — To get the row senses.
+
+
+
+- sym_getConstrUpper — To get the upper bounds of the constraints.
+
+
+
+- sym_getDblParam — This routine is used to get the value of a double type parameter.
+
+
+
+- sym_getInfinity — Get Symphony's infinity value
+
+
+
+- sym_getIntParam — This routine is used to get the value of an integer type parameter.
+
+
+
+- sym_getIterCount — To get the number of the analyzed nodes of the branching tree after solving the problem.
+
+
+
+- sym_getMatrix — To get the constraint matrix.
+
+
+
+- sym_getNumConstr — To get the number of the constraints of the current problem.
+
+
+
+- sym_getNumElements — To get the number of non-zero entries of the constraint matrix of the current problem.
+
+
+
+- sym_getNumVar — To get the number of the variables of the current problem.
+
+
+
+- sym_getObjCoeff — To get the objective vector.
+
+
+
+- sym_getObjSense — Get the objective sense
+
+
+
+- sym_getObjVal — Get the optimized objective value
+
+
+
+- sym_getPrimalBound — Get the primal bound of the problem
+
+
+
+- sym_getRhs — To to get the right hand side vector(column vector).
+
+
+
+- sym_getStatus — To get status of the problem solver.
+
+
+
+- sym_getStrParam — This routine is used to get the value of a string type parameter.
+
+
+
+- sym_getVarLower — To get the lower bounds of the variables.
+
+
+
+- sym_getVarSoln — Get the solution for the problem
+
+
+
+- sym_getVarUpper — To get the upper bounds of the variables.
+
+
+
+- sym_isAbandoned — To check whether the problem was abandoned for some reason.
+
+
+
+- sym_isBinary — Check if a variable is constrained to be binary
+
+
+
+- sym_isContinuous — Check if a variable is continuous
+
+
+
+- sym_isEnvActive — Check if Symphony environment is active
+
+
+
+- sym_isInfeasible — To check whether the problem was proven to be infeasible.
+
+
+
+- sym_isInteger — Check if a variable is constrained to be an integer
+
+
+
+- sym_isIterLimitReached — To know whether the iteration limit (node limit) was reached.
+
+
+
+- sym_isOptimal — To check whether the problem was solved to optimality.
+
+
+
+- sym_isTargetGapAchieved — To know whether the target gap was reached.
+
+
+
+- sym_isTimeLimitReached — To know whether the time limit was reached.
+
+
+
+- sym_loadMPS — This routine is used to load an instance from an MPS file.
+
+
+
+- sym_loadProblem — Load a problem into Symphony
+
+
+
+- sym_loadProblemBasic — Load a problem into Symphony (basic version)
+
+
+
+- sym_open — Open the Symphony environment
+
+
+
+- sym_resetParams — This routine sets all the environment variables and parameters to their default values.
+
+
+
+- sym_setConstrLower — Set the lower bound of a constraint
+
+
+
+- sym_setConstrType — Set the type of a constraint
+
+
+
+- sym_setConstrUpper — Set the upper bound of a constraint
+
+
+
+- sym_setContinuous — This routine is used to set the type of a variable to be continuous.
+
+
+
+- sym_setDblParam — This routine is used to set a double type parameter.
+
+
+
+- sym_setIntParam — This routine is used to set an integer type parameter.
+
+
+
+- sym_setInteger — This routine is used to set the type of a variable to be integer.
+
+
+
+- sym_setObjCoeff — Set coefficient of a variable in the objective
+
+
+
+- sym_setObjSense — Set the objective sense
+
+
+
+- sym_setPrimalBound — Set the primal bound of the problem
+
+
+
+- sym_setStrParam — This routine is used to set a string type parameter.
+
+
+
+- sym_setVarLower — Set lower bound of a variable
+
+
+
+- sym_setVarSoln — Set a solution for the problem
+
+
+
+- sym_setVarUpper — Set upper bound of a variable
+
+
+
+- sym_solve — To solve the currently loaded MILP problem from scratch.
+
+
+
+
+
diff --git a/help/en_US/scilab_en_US_help/section_f892b70a029847ba39043aa5f758cc43.html b/help/en_US/scilab_en_US_help/section_f892b70a029847ba39043aa5f758cc43.html
new file mode 100644
index 0000000..17278da
--- /dev/null
+++ b/help/en_US/scilab_en_US_help/section_f892b70a029847ba39043aa5f758cc43.html
@@ -0,0 +1,358 @@
+
+
+
+
+
+
+
+
+
+
+
FOSSEE Optimization Toolbox >> FOSSEE Optimization Toolbox
+
+
+
FOSSEE Optimization Toolbox
+
- fgoalattain — Solves a multiobjective goal attainment problem
+
+
+
+
+
+- fminbnd — Solves a multi-variable optimization problem on a bounded interval
+
+
+
+
+
+- fmincon — Solves a multi-variable constrainted optimization problem
+
+
+
+
+
+- fminimax — Solves minimax constraint problem
+
+
+
+
+
+- fminunc — Solves a multi-variable unconstrainted optimization problem
+
+
+
+
+
+- linprog — Solves a linear programming problem.
+
+
+
+
+
+- lsqlin — Solves a linear quadratic problem.
+
+
+
+
+
+- lsqnonlin — Solves a non linear data fitting problems.
+
+
+
+
+
+- lsqnonneg — Solves nonnegative least-squares curve fitting problems.
+
+
+
+
+
+- qpipopt — Solves a linear quadratic problem.
+
+
+
+
+
+- qpipoptmat — Solves a linear quadratic problem.
+
+
+
+
+
+- symphony — Solves a mixed integer linear programming constrained optimization problem.
+
+
+
+
+
+- symphonymat — Solves a mixed integer linear programming constrained optimization problem in intlinprog format.
+
+- Symphony Native Functions
+
- sym_addConstr — Add a new constraint
+
+
+
+- sym_addVar — Add a new variable
+
+
+
+- sym_close — Close the Symphony environment
+
+
+
+- sym_deleteConstrs — This routine is used to delete rows from the original constraint matrix.
+
+
+
+- sym_deleteVars — This routine is used to delete columns from the original problem description.
+
+
+
+- sym_getConstrActivity — Get the activity of the constraints in the solution
+
+
+
+- sym_getConstrLower — To get the lower bounds of the constraints.
+
+
+
+- sym_getConstrRange — To to get the constraint ranges.
+
+
+
+- sym_getConstrSense — To get the row senses.
+
+
+
+- sym_getConstrUpper — To get the upper bounds of the constraints.
+
+
+
+- sym_getDblParam — This routine is used to get the value of a double type parameter.
+
+
+
+- sym_getInfinity — Get Symphony's infinity value
+
+
+
+- sym_getIntParam — This routine is used to get the value of an integer type parameter.
+
+
+
+- sym_getIterCount — To get the number of the analyzed nodes of the branching tree after solving the problem.
+
+
+
+- sym_getMatrix — To get the constraint matrix.
+
+
+
+- sym_getNumConstr — To get the number of the constraints of the current problem.
+
+
+
+- sym_getNumElements — To get the number of non-zero entries of the constraint matrix of the current problem.
+
+
+
+- sym_getNumVar — To get the number of the variables of the current problem.
+
+
+
+- sym_getObjCoeff — To get the objective vector.
+
+
+
+- sym_getObjSense — Get the objective sense
+
+
+
+- sym_getObjVal — Get the optimized objective value
+
+
+
+- sym_getPrimalBound — Get the primal bound of the problem
+
+
+
+- sym_getRhs — To to get the right hand side vector(column vector).
+
+
+
+- sym_getStatus — To get status of the problem solver.
+
+
+
+- sym_getStrParam — This routine is used to get the value of a string type parameter.
+
+
+
+- sym_getVarLower — To get the lower bounds of the variables.
+
+
+
+- sym_getVarSoln — Get the solution for the problem
+
+
+
+- sym_getVarUpper — To get the upper bounds of the variables.
+
+
+
+- sym_isAbandoned — To check whether the problem was abandoned for some reason.
+
+
+
+- sym_isBinary — Check if a variable is constrained to be binary
+
+
+
+- sym_isContinuous — Check if a variable is continuous
+
+
+
+- sym_isEnvActive — Check if Symphony environment is active
+
+
+
+- sym_isInfeasible — To check whether the problem was proven to be infeasible.
+
+
+
+- sym_isInteger — Check if a variable is constrained to be an integer
+
+
+
+- sym_isIterLimitReached — To know whether the iteration limit (node limit) was reached.
+
+
+
+- sym_isOptimal — To check whether the problem was solved to optimality.
+
+
+
+- sym_isTargetGapAchieved — To know whether the target gap was reached.
+
+
+
+- sym_isTimeLimitReached — To know whether the time limit was reached.
+
+
+
+- sym_loadMPS — This routine is used to load an instance from an MPS file.
+
+
+
+- sym_loadProblem — Load a problem into Symphony
+
+
+
+- sym_loadProblemBasic — Load a problem into Symphony (basic version)
+
+
+
+- sym_open — Open the Symphony environment
+
+
+
+- sym_resetParams — This routine sets all the environment variables and parameters to their default values.
+
+
+
+- sym_setConstrLower — Set the lower bound of a constraint
+
+
+
+- sym_setConstrType — Set the type of a constraint
+
+
+
+- sym_setConstrUpper — Set the upper bound of a constraint
+
+
+
+- sym_setContinuous — This routine is used to set the type of a variable to be continuous.
+
+
+
+- sym_setDblParam — This routine is used to set a double type parameter.
+
+
+
+- sym_setIntParam — This routine is used to set an integer type parameter.
+
+
+
+- sym_setInteger — This routine is used to set the type of a variable to be integer.
+
+
+
+- sym_setObjCoeff — Set coefficient of a variable in the objective
+
+
+
+- sym_setObjSense — Set the objective sense
+
+
+
+- sym_setPrimalBound — Set the primal bound of the problem
+
+
+
+- sym_setStrParam — This routine is used to set a string type parameter.
+
+
+
+- sym_setVarLower — Set lower bound of a variable
+
+
+
+- sym_setVarSoln — Set a solution for the problem
+
+
+
+- sym_setVarUpper — Set upper bound of a variable
+
+
+
+- sym_solve — To solve the currently loaded MILP problem from scratch.
+
+
+
+
+
diff --git a/help/en_US/scilab_en_US_help/symphony.html b/help/en_US/scilab_en_US_help/symphony.html
index a27f8e8..8b87039 100644
--- a/help/en_US/scilab_en_US_help/symphony.html
+++ b/help/en_US/scilab_en_US_help/symphony.html
@@ -193,7 +193,7 @@ It has type "struct" and contains the following fields.
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 1 0 ..
0 1 0 1 0 0 1 0 0 1 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 1 0 0 1 0]
-
fopt = [ 24381 ]
+
fopt = [ -24381 ]
[x,f,status,output] = symphony(nbVar,nbCon,c,isInt,lb,ub,A,conLB,conUB,-1,options); | | | | | |
diff --git a/help/en_US/symphony.xml b/help/en_US/symphony.xml
index d11fafc..692d4ad 100644
--- a/help/en_US/symphony.xml
+++ b/help/en_US/symphony.xml
@@ -221,7 +221,7 @@ xopt = [0 1 1 0 0 1 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 1 1 0 1 ..
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 1 0 ..
0 1 0 1 0 0 1 0 0 1 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 1 0 0 1 0]
// Optimal value
-fopt = [ 24381 ]
+fopt = [ -24381 ]
// Calling Symphony
[x,f,status,output] = symphony(nbVar,nbCon,c,isInt,lb,ub,A,conLB,conUB,-1,options);
]]>
diff --git a/help/en_US/symphonymat.xml b/help/en_US/symphonymat.xml
index 32059cb..e99d223 100644
--- a/help/en_US/symphonymat.xml
+++ b/help/en_US/symphonymat.xml
@@ -211,7 +211,7 @@ xopt = [0 1 1 0 0 1 0 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 1 0 1 1 0 1 1 0 1 ..
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 1 1 ..
0 0 1 0 0 1 0 1 0 0 1 0 0 1 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 1 0 0 1 0]
// Optimal value
-fopt = [ 24381 ]
+fopt = [ -24381 ]
// Calling Symphony
[x,f,status,output] = symphonymat(c,intcon,A,b,[],[],lb,ub,options);
]]>
diff --git a/hs_err_pid5921.log b/hs_err_pid5921.log
deleted file mode 100644
index 1a8e10f..0000000
--- a/hs_err_pid5921.log
+++ /dev/null
@@ -1,1625 +0,0 @@
-#
-# A fatal error has been detected by the Java Runtime Environment:
-#
-# SIGSEGV (0xb) at pc=0x00007efbf4a7d3b0, pid=5921, tid=139620662339456
-#
-# JRE version: OpenJDK Runtime Environment (7.0_95) (build 1.7.0_95-b00)
-# Java VM: OpenJDK 64-Bit Server VM (24.95-b01 mixed mode linux-amd64 compressed oops)
-# Derivative: IcedTea 2.6.4
-# Distribution: Ubuntu 14.04.3 LTS, package 7u95-2.6.4-0ubuntu0.14.04.1
-# Problematic frame:
-# C [libscilab-cli.so.0+0x17c3b0] sivars_+0x30
-#
-# Failed to write core dump. Core dumps have been disabled. To enable core dumping, try "ulimit -c unlimited" before starting Java again
-#
-# If you would like to submit a bug report, please include
-# instructions on how to reproduce the bug and visit:
-# http://icedtea.classpath.org/bugzilla
-# The crash happened outside the Java Virtual Machine in native code.
-# See problematic frame for where to report the bug.
-#
-
---------------- T H R E A D ---------------
-
-Current thread (0x000000000264e000): JavaThread "Thread-28299" [_thread_in_native, id=5921, stack(0x00007ffbffefe000,0x00007ffbffffe000)]
-
-siginfo:si_signo=SIGSEGV: si_errno=0, si_code=2 (SEGV_ACCERR), si_addr=0x00007efbf6ece008
-
-Registers:
-RAX=0x00000000000052c5, RBX=0x00007efbf4f22020, RCX=0x000000000000a04d, RDX=0x00007efbf6ece008
-RSP=0x00007ffbffffaa38, RBP=0x00007ffbffffaa98, RSI=0x00007ffbffffaa98, RDI=0x00007efbf4f22020
-R8 =0x0000000019171838, R9 =0x00007efbf6e51da0, R10=0x0000000019171838, R11=0x00007ffbffffa7a0
-R12=0x00007efbf6e4f280, R13=0x00007efbf6e4f280, R14=0x00007efbf506c330, R15=0x00007efbf6e0e170
-RIP=0x00007efbf4a7d3b0, EFLAGS=0x0000000000010297, CSGSFS=0x0000000000000033, ERR=0x0000000000000004
- TRAPNO=0x000000000000000e
-
-Top of Stack: (sp=0x00007ffbffffaa38)
-0x00007ffbffffaa38: 00007efbf4a5dd01 0000000000000015
-0x00007ffbffffaa48: 00000000000000aa 00000000029824d0
-0x00007ffbffffaa58: 00007efbf7de6816 00000000029824d0
-0x00007ffbffffaa68: 00007ffbffffaaa0 00007efbf4907c78
-0x00007ffbffffaa78: 00007ffb00000000 00007efbf49184c0
-0x00007ffbffffaa88: 0000000002a91c5b 00007ffbffffaba0
-0x00007ffbffffaa98: 0000000000000000 0000000000000000
-0x00007ffbffffaaa8: 0000000000000000 00007efbf7fe04e8
-0x00007ffbffffaab8: 00007efbf492448c 00007efbf4920aa0
-0x00007ffbffffaac8: 00007efbf49184c0 0000000500000000
-0x00007ffbffffaad8: 0000000100000b03 0000000500000000
-0x00007ffbffffaae8: 00007ffbffffac68 00007ffbffffac40
-0x00007ffbffffaaf8: 0000000000000000 0000000000000001
-0x00007ffbffffab08: 00007efbf6ea80c0 00007efbf4f6892c
-0x00007ffbffffab18: 00007efbf6e4f280 00007efbf6e0e1a0
-0x00007ffbffffab28: 00007efbf506c330 00007efbf6e0e170
-0x00007ffbffffab38: 00007efbf4a750dc 00007efbf6ea80c0
-0x00007ffbffffab48: 00007efbf6ea80a4 00007ffbffffabc8
-0x00007ffbffffab58: 00007efbf4a75c43 00007efb00000000
-0x00007ffbffffab68: 0000000000000000 0000000000000000
-0x00007ffbffffab78: 00007efbf7fe0840 00007ffbffffabb0
-0x00007ffbffffab88: 00007ffbffffaba0 00007ffbffffabcc
-0x00007ffbffffab98: 00007ffbffffac1c 00007efbf6e4f280
-0x00007ffbffffaba8: 00007efbf4924479 00007efbf49184c0
-0x00007ffbffffabb8: 00007efbf7fe04e8 00007efbf490c8e0
-0x00007ffbffffabc8: 00007efbf7fe04e8 0000000000000002
-0x00007ffbffffabd8: 00007efbef6e96b0 0000000002ed8850
-0x00007ffbffffabe8: 0000000000000000 0000000000000000
-0x00007ffbffffabf8: 0000000002fcb030 0000000000000002
-0x00007ffbffffac08: 00007efbef3db62e 00007ffbffffacb0
-0x00007ffbffffac18: 00007efbf4f1e900 0000000000000000
-0x00007ffbffffac28: 0000000000000000 0000000000000000
-
-Instructions: (pc=0x00007efbf4a7d3b0)
-0x00007efbf4a7d390: 41 8b 89 1c e2 04 00 39 c8 7f 25 8d 54 40 fd 44
-0x00007efbf4a7d3a0: 8b 07 01 d2 48 63 d2 49 8d 54 91 08 0f 1f 40 00
-0x00007efbf4a7d3b0: 44 3b 02 74 13 83 c0 01 48 83 c2 18 39 c8 7e f0
-0x00007efbf4a7d3c0: f3 c3 66 0f 1f 44 00 00 44 8b 57 04 44 39 52 04
-
-Register to memory mapping:
-
-RAX=0x00000000000052c5 is an unknown value
-RBX=0x00007efbf4f22020: in /usr/lib/scilab/libscilab-cli.so.0 at 0x00007efbf4901000
-RCX=0x000000000000a04d is an unknown value
-RDX=0x00007efbf6ece008: in /usr/lib/scilab/libsciaction_binding.so.5 at 0x00007efbf6eca000
-RSP=0x00007ffbffffaa38 is pointing into the stack for thread: 0x000000000264e000
-RBP=0x00007ffbffffaa98 is pointing into the stack for thread: 0x000000000264e000
-RSI=0x00007ffbffffaa98 is pointing into the stack for thread: 0x000000000264e000
-RDI=0x00007efbf4f22020: in /usr/lib/scilab/libscilab-cli.so.0 at 0x00007efbf4901000
-R8 =0x0000000019171838 is an unknown value
-R9 =0x00007efbf6e51da0: vstk_+0 in /usr/lib/scilab/libscigraphic_objects.so.5 at 0x00007efbf6b8d000
-R10=0x0000000019171838 is an unknown value
-R11=0x00007ffbffffa7a0 is pointing into the stack for thread: 0x000000000264e000
-R12=0x00007efbf6e4f280: com_+0 in /usr/lib/scilab/libscigraphic_objects.so.5 at 0x00007efbf6b8d000
-R13=0x00007efbf6e4f280: com_+0 in /usr/lib/scilab/libscigraphic_objects.so.5 at 0x00007efbf6b8d000
-R14=0x00007efbf506c330: basbrk_+0 in /usr/lib/scilab/libscilab-cli.so.0 at 0x00007efbf4901000
-R15=0x00007efbf6e0e170: errgst_+0 in /usr/lib/scilab/libscigraphic_objects.so.5 at 0x00007efbf6b8d000
-
-
-Stack: [0x00007ffbffefe000,0x00007ffbffffe000], sp=0x00007ffbffffaa38, free space=1010k
-Native frames: (J=compiled Java code, j=interpreted, Vv=VM code, C=native code)
-C [libscilab-cli.so.0+0x17c3b0] sivars_+0x30
-
-
---------------- P R O C E S S ---------------
-
-Java Threads: ( => current thread )
-=>0x000000000264e000 JavaThread "Thread-28299" [_thread_in_native, id=5921, stack(0x00007ffbffefe000,0x00007ffbffffe000)]
- 0x00007efb9c660800 JavaThread "SwingWorker-pool-1-thread-2" daemon [_thread_blocked, id=5956, stack(0x00007efb8ce32000,0x00007efb8cf33000)]
- 0x00007efb9c532800 JavaThread "SwingWorker-pool-1-thread-1" daemon [_thread_blocked, id=5949, stack(0x00007efb8cc30000,0x00007efb8cd31000)]
- 0x00007efb9c2c0000 JavaThread "TimerQueue" daemon [_thread_blocked, id=5943, stack(0x00007efb8cf6c000,0x00007efb8d06d000)]
- 0x00000000030bf800 JavaThread "AWT-EventQueue-0" [_thread_blocked, id=5941, stack(0x00007efbd8c8f000,0x00007efbd8d90000)]
- 0x000000000311e000 JavaThread "AWT-Shutdown" [_thread_blocked, id=5940, stack(0x00007efbd8b8e000,0x00007efbd8c8f000)]
- 0x0000000002b44000 JavaThread "main-SharedResourceRunner" daemon [_thread_blocked, id=5938, stack(0x00007efbd8077000,0x00007efbd8178000)]
- 0x00000000029f7800 JavaThread "AWT-XAWT" daemon [_thread_in_native, id=5935, stack(0x00007efbd8d90000,0x00007efbd8e91000)]
- 0x00000000029e5000 JavaThread "Java2D Disposer" daemon [_thread_blocked, id=5934, stack(0x00007efbd92a1000,0x00007efbd93a2000)]
- 0x0000000002733800 JavaThread "Service Thread" daemon [_thread_blocked, id=5932, stack(0x00007efbdb3f4000,0x00007efbdb4f5000)]
- 0x0000000002731800 JavaThread "C2 CompilerThread1" daemon [_thread_blocked, id=5931, stack(0x00007efbdb4f5000,0x00007efbdb5f6000)]
- 0x000000000272e800 JavaThread "C2 CompilerThread0" daemon [_thread_blocked, id=5930, stack(0x00007efbdb5f6000,0x00007efbdb6f7000)]
- 0x000000000272c800 JavaThread "Attach Listener" daemon [_thread_blocked, id=5929, stack(0x00007efbdb6f7000,0x00007efbdb7f8000)]
- 0x0000000002702800 JavaThread "Finalizer" daemon [_thread_blocked, id=5928, stack(0x00007efbdb7f8000,0x00007efbdb8f9000)]
- 0x0000000002700800 JavaThread "Reference Handler" daemon [_thread_blocked, id=5927, stack(0x00007efbdb8f9000,0x00007efbdb9fa000)]
-
-Other Threads:
- 0x00000000026fc000 VMThread [stack: 0x00007efbdb9fa000,0x00007efbdbafb000] [id=5926]
- 0x000000000273e800 WatcherThread [stack: 0x00007efbdb2f3000,0x00007efbdb3f4000] [id=5933]
-
-VM state:not at safepoint (normal execution)
-
-VM Mutex/Monitor currently owned by a thread: None
-
-Heap
- PSYoungGen total 87040K, used 71001K [0x00000000faa80000, 0x0000000100000000, 0x0000000100000000)
- eden space 86528K, 82% used [0x00000000faa80000,0x00000000fefce4e0,0x00000000fff00000)
- from space 512K, 6% used [0x00000000fff00000,0x00000000fff08000,0x00000000fff80000)
- to space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
- ParOldGen total 97792K, used 51061K [0x00000000f0000000, 0x00000000f5f80000, 0x00000000faa80000)
- object space 97792K, 52% used [0x00000000f0000000,0x00000000f31dd538,0x00000000f5f80000)
- PSPermGen total 76800K, used 36060K [0x00000000e5a00000, 0x00000000ea500000, 0x00000000f0000000)
- object space 76800K, 46% used [0x00000000e5a00000,0x00000000e7d37340,0x00000000ea500000)
-
-Card table byte_map: [0x00007efbf7e21000,0x00007efbf7ef5000] byte_map_base: 0x00007efbf76f4000
-
-Polling page: 0x00007efbf7ff6000
-
-Code Cache [0x00007efbe208d000, 0x00007efbe24ad000, 0x00007efbe508d000)
- total_blobs=2179 nmethods=1231 adapters=901 free_code_cache=45048Kb largest_free_block=46025792
-
-Compilation events (10 events):
-Event: 1589.899 Thread 0x000000000272e800 nmethod 1405 0x00007efbe24a5190 code [0x00007efbe24a54a0, 0x00007efbe24a6be0]
-Event: 1589.899 Thread 0x000000000272e800 1407 ! sun.awt.AWTAutoShutdown::notifyThreadBusy (86 bytes)
-Event: 1589.910 Thread 0x000000000272e800 nmethod 1407 0x00007efbe245cf90 code [0x00007efbe245d120, 0x00007efbe245da58]
-Event: 1589.910 Thread 0x000000000272e800 1408 java.util.HashMap::removeEntryForKey (159 bytes)
-Event: 1589.925 Thread 0x000000000272e800 nmethod 1408 0x00007efbe24579d0 code [0x00007efbe2457b40, 0x00007efbe2457fb8]
-Event: 1589.952 Thread 0x0000000002731800 nmethod 1406 0x00007efbe23f0f10 code [0x00007efbe23f11c0, 0x00007efbe23f24a0]
-Event: 1590.464 Thread 0x000000000272e800 1409 % ! sun.awt.AWTAutoShutdown::run @ 40 (159 bytes)
-Event: 1590.476 Thread 0x000000000272e800 nmethod 1409% 0x00007efbe2459c10 code [0x00007efbe2459da0, 0x00007efbe245a338]
-Event: 1592.735 Thread 0x0000000002731800 1410 % ! java.lang.ref.Reference$ReferenceHandler::run @ 0 (108 bytes)
-Event: 1592.757 Thread 0x0000000002731800 nmethod 1410% 0x00007efbe248e650 code [0x00007efbe248e800, 0x00007efbe248f4e8]
-
-GC Heap History (10 events):
-Event: 1594.004 GC heap before
-{Heap before GC invocations=555 (full 2):
- PSYoungGen total 87040K, used 86560K [0x00000000faa80000, 0x0000000100000000, 0x0000000100000000)
- eden space 86528K, 100% used [0x00000000faa80000,0x00000000fff00000,0x00000000fff00000)
- from space 512K, 6% used [0x00000000fff80000,0x00000000fff88000,0x0000000100000000)
- to space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
- ParOldGen total 97792K, used 51061K [0x00000000f0000000, 0x00000000f5f80000, 0x00000000faa80000)
- object space 97792K, 52% used [0x00000000f0000000,0x00000000f31dd538,0x00000000f5f80000)
- PSPermGen total 76800K, used 36060K [0x00000000e5a00000, 0x00000000ea500000, 0x00000000f0000000)
- object space 76800K, 46% used [0x00000000e5a00000,0x00000000e7d37340,0x00000000ea500000)
-Event: 1594.009 GC heap after
-Heap after GC invocations=555 (full 2):
- PSYoungGen total 87040K, used 32K [0x00000000faa80000, 0x0000000100000000, 0x0000000100000000)
- eden space 86528K, 0% used [0x00000000faa80000,0x00000000faa80000,0x00000000fff00000)
- from space 512K, 6% used [0x00000000fff00000,0x00000000fff08000,0x00000000fff80000)
- to space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
- ParOldGen total 97792K, used 51061K [0x00000000f0000000, 0x00000000f5f80000, 0x00000000faa80000)
- object space 97792K, 52% used [0x00000000f0000000,0x00000000f31dd538,0x00000000f5f80000)
- PSPermGen total 76800K, used 36060K [0x00000000e5a00000, 0x00000000ea500000, 0x00000000f0000000)
- object space 76800K, 46% used [0x00000000e5a00000,0x00000000e7d37340,0x00000000ea500000)
-}
-Event: 1594.017 GC heap before
-{Heap before GC invocations=556 (full 2):
- PSYoungGen total 87040K, used 86560K [0x00000000faa80000, 0x0000000100000000, 0x0000000100000000)
- eden space 86528K, 100% used [0x00000000faa80000,0x00000000fff00000,0x00000000fff00000)
- from space 512K, 6% used [0x00000000fff00000,0x00000000fff08000,0x00000000fff80000)
- to space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
- ParOldGen total 97792K, used 51061K [0x00000000f0000000, 0x00000000f5f80000, 0x00000000faa80000)
- object space 97792K, 52% used [0x00000000f0000000,0x00000000f31dd538,0x00000000f5f80000)
- PSPermGen total 76800K, used 36060K [0x00000000e5a00000, 0x00000000ea500000, 0x00000000f0000000)
- object space 76800K, 46% used [0x00000000e5a00000,0x00000000e7d37340,0x00000000ea500000)
-Event: 1594.021 GC heap after
-Heap after GC invocations=556 (full 2):
- PSYoungGen total 87040K, used 32K [0x00000000faa80000, 0x0000000100000000, 0x0000000100000000)
- eden space 86528K, 0% used [0x00000000faa80000,0x00000000faa80000,0x00000000fff00000)
- from space 512K, 6% used [0x00000000fff80000,0x00000000fff88000,0x0000000100000000)
- to space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
- ParOldGen total 97792K, used 51061K [0x00000000f0000000, 0x00000000f5f80000, 0x00000000faa80000)
- object space 97792K, 52% used [0x00000000f0000000,0x00000000f31dd538,0x00000000f5f80000)
- PSPermGen total 76800K, used 36060K [0x00000000e5a00000, 0x00000000ea500000, 0x00000000f0000000)
- object space 76800K, 46% used [0x00000000e5a00000,0x00000000e7d37340,0x00000000ea500000)
-}
-Event: 1594.029 GC heap before
-{Heap before GC invocations=557 (full 2):
- PSYoungGen total 87040K, used 86560K [0x00000000faa80000, 0x0000000100000000, 0x0000000100000000)
- eden space 86528K, 100% used [0x00000000faa80000,0x00000000fff00000,0x00000000fff00000)
- from space 512K, 6% used [0x00000000fff80000,0x00000000fff88000,0x0000000100000000)
- to space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
- ParOldGen total 97792K, used 51061K [0x00000000f0000000, 0x00000000f5f80000, 0x00000000faa80000)
- object space 97792K, 52% used [0x00000000f0000000,0x00000000f31dd538,0x00000000f5f80000)
- PSPermGen total 76800K, used 36060K [0x00000000e5a00000, 0x00000000ea500000, 0x00000000f0000000)
- object space 76800K, 46% used [0x00000000e5a00000,0x00000000e7d37340,0x00000000ea500000)
-Event: 1594.033 GC heap after
-Heap after GC invocations=557 (full 2):
- PSYoungGen total 87040K, used 32K [0x00000000faa80000, 0x0000000100000000, 0x0000000100000000)
- eden space 86528K, 0% used [0x00000000faa80000,0x00000000faa80000,0x00000000fff00000)
- from space 512K, 6% used [0x00000000fff00000,0x00000000fff08000,0x00000000fff80000)
- to space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
- ParOldGen total 97792K, used 51061K [0x00000000f0000000, 0x00000000f5f80000, 0x00000000faa80000)
- object space 97792K, 52% used [0x00000000f0000000,0x00000000f31dd538,0x00000000f5f80000)
- PSPermGen total 76800K, used 36060K [0x00000000e5a00000, 0x00000000ea500000, 0x00000000f0000000)
- object space 76800K, 46% used [0x00000000e5a00000,0x00000000e7d37340,0x00000000ea500000)
-}
-Event: 1594.039 GC heap before
-{Heap before GC invocations=558 (full 2):
- PSYoungGen total 87040K, used 86560K [0x00000000faa80000, 0x0000000100000000, 0x0000000100000000)
- eden space 86528K, 100% used [0x00000000faa80000,0x00000000fff00000,0x00000000fff00000)
- from space 512K, 6% used [0x00000000fff00000,0x00000000fff08000,0x00000000fff80000)
- to space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
- ParOldGen total 97792K, used 51061K [0x00000000f0000000, 0x00000000f5f80000, 0x00000000faa80000)
- object space 97792K, 52% used [0x00000000f0000000,0x00000000f31dd538,0x00000000f5f80000)
- PSPermGen total 76800K, used 36060K [0x00000000e5a00000, 0x00000000ea500000, 0x00000000f0000000)
- object space 76800K, 46% used [0x00000000e5a00000,0x00000000e7d37340,0x00000000ea500000)
-Event: 1594.042 GC heap after
-Heap after GC invocations=558 (full 2):
- PSYoungGen total 87040K, used 32K [0x00000000faa80000, 0x0000000100000000, 0x0000000100000000)
- eden space 86528K, 0% used [0x00000000faa80000,0x00000000faa80000,0x00000000fff00000)
- from space 512K, 6% used [0x00000000fff80000,0x00000000fff88000,0x0000000100000000)
- to space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
- ParOldGen total 97792K, used 51061K [0x00000000f0000000, 0x00000000f5f80000, 0x00000000faa80000)
- object space 97792K, 52% used [0x00000000f0000000,0x00000000f31dd538,0x00000000f5f80000)
- PSPermGen total 76800K, used 36060K [0x00000000e5a00000, 0x00000000ea500000, 0x00000000f0000000)
- object space 76800K, 46% used [0x00000000e5a00000,0x00000000e7d37340,0x00000000ea500000)
-}
-Event: 1594.048 GC heap before
-{Heap before GC invocations=559 (full 2):
- PSYoungGen total 87040K, used 86560K [0x00000000faa80000, 0x0000000100000000, 0x0000000100000000)
- eden space 86528K, 100% used [0x00000000faa80000,0x00000000fff00000,0x00000000fff00000)
- from space 512K, 6% used [0x00000000fff80000,0x00000000fff88000,0x0000000100000000)
- to space 512K, 0% used [0x00000000fff00000,0x00000000fff00000,0x00000000fff80000)
- ParOldGen total 97792K, used 51061K [0x00000000f0000000, 0x00000000f5f80000, 0x00000000faa80000)
- object space 97792K, 52% used [0x00000000f0000000,0x00000000f31dd538,0x00000000f5f80000)
- PSPermGen total 76800K, used 36060K [0x00000000e5a00000, 0x00000000ea500000, 0x00000000f0000000)
- object space 76800K, 46% used [0x00000000e5a00000,0x00000000e7d37340,0x00000000ea500000)
-Event: 1594.052 GC heap after
-Heap after GC invocations=559 (full 2):
- PSYoungGen total 87040K, used 32K [0x00000000faa80000, 0x0000000100000000, 0x0000000100000000)
- eden space 86528K, 0% used [0x00000000faa80000,0x00000000faa80000,0x00000000fff00000)
- from space 512K, 6% used [0x00000000fff00000,0x00000000fff08000,0x00000000fff80000)
- to space 512K, 0% used [0x00000000fff80000,0x00000000fff80000,0x0000000100000000)
- ParOldGen total 97792K, used 51061K [0x00000000f0000000, 0x00000000f5f80000, 0x00000000faa80000)
- object space 97792K, 52% used [0x00000000f0000000,0x00000000f31dd538,0x00000000f5f80000)
- PSPermGen total 76800K, used 36060K [0x00000000e5a00000, 0x00000000ea500000, 0x00000000f0000000)
- object space 76800K, 46% used [0x00000000e5a00000,0x00000000e7d37340,0x00000000ea500000)
-}
-
-Deoptimization events (10 events):
-Event: 1586.978 Thread 0x00000000030bf800 Uncommon trap: reason=unstable_if action=reinterpret pc=0x00007efbe24619ac method=javax.swing.JComponent.putClientProperty(Ljava/lang/Object;Ljava/lang/Object;)V @ 57
-Event: 1586.992 Thread 0x00000000030bf800 Uncommon trap: reason=unstable_if action=reinterpret pc=0x00007efbe242a01c method=java.awt.Component.areBoundsValid()Z @ 6
-Event: 1586.999 Thread 0x00000000030bf800 Uncommon trap: reason=unstable_if action=reinterpret pc=0x00007efbe24249ec method=java.awt.Component.areBoundsValid()Z @ 6
-Event: 1587.018 Thread 0x00000000030bf800 Uncommon trap: reason=unstable_if action=reinterpret pc=0x00007efbe2362530 method=sun.awt.X11.XGlobalCursorManager.getCapableCursor(Ljava/awt/Component;)Ljava/awt/Cursor; @ 82
-Event: 1587.030 Thread 0x00000000030bf800 Uncommon trap: reason=unstable_if action=reinterpret pc=0x00007efbe2369458 method=java.awt.Component.getNativeContainer()Ljava/awt/Container; @ 6
-Event: 1587.030 Thread 0x00000000030bf800 Uncommon trap: reason=unstable_if action=reinterpret pc=0x00007efbe23ac94c method=javax.swing.RepaintManager.collectDirtyComponents(Ljava/util/Map;Ljava/awt/Component;Ljava/util/List;)V @ 104
-Event: 1587.030 Thread 0x00000000030bf800 Uncommon trap: reason=unstable_if action=reinterpret pc=0x00007efbe234c948 method=java.awt.Component.isShowing()Z @ 11
-Event: 1587.032 Thread 0x000000000264e000 Uncommon trap: reason=unstable_if action=reinterpret pc=0x00007efbe2433dbc method=sun.awt.AWTAutoShutdown.isReadyToShutdown()Z @ 16
-Event: 1587.089 Thread 0x00007efb9c2c0000 Uncommon trap: reason=unstable_if action=reinterpret pc=0x00007efbe23fafc8 method=java.util.PriorityQueue.peek()Ljava/lang/Object; @ 4
-Event: 1594.096 Thread 0x000000000264e000 Uncommon trap: reason=unstable_if action=reinterpret pc=0x00007efbe2364230 method=javax.swing.text.GapContent.removeUnusedMarks()V @ 21
-
-Internal exceptions (10 events):
-Event: 577.085 Thread 0x00000000030bf800 Implicit null exception at 0x00007efbe2391173 to 0x00007efbe2392d85
-Event: 717.536 Thread 0x00000000030bf800 Implicit null exception at 0x00007efbe2387283 to 0x00007efbe2387a85
-Event: 730.723 Thread 0x00000000030bf800 Threw 0x00000000fb478128 at /build/openjdk-7-2FOwCu/openjdk-7-7u95-2.6.4/build/openjdk/hotspot/src/share/vm/prims/jvm.cpp:1322
-Event: 1527.747 Thread 0x00007efb84001800 Implicit null exception at 0x00007efbe23eb9ab to 0x00007efbe23ed2f5
-Event: 1586.872 Thread 0x000000000264e000 Threw 0x00000000fba66be8 at /build/openjdk-7-2FOwCu/openjdk-7-7u95-2.6.4/build/openjdk/hotspot/src/share/vm/prims/jvm.cpp:1322
-Event: 1586.891 Thread 0x00000000030bf800 Threw 0x00000000fc7a4db8 at /build/openjdk-7-2FOwCu/openjdk-7-7u95-2.6.4/build/openjdk/hotspot/src/share/vm/prims/jvm.cpp:1322
-Event: 1586.908 Thread 0x00000000030bf800 Threw 0x00000000fc8943e0 at /build/openjdk-7-2FOwCu/openjdk-7-7u95-2.6.4/build/openjdk/hotspot/src/share/vm/prims/jvm.cpp:1322
-Event: 1586.992 Thread 0x00000000030bf800 Implicit null exception at 0x00007efbe2429b94 to 0x00007efbe242a009
-Event: 1586.999 Thread 0x00000000030bf800 Implicit null exception at 0x00007efbe242498c to 0x00007efbe24249dc
-Event: 1587.030 Thread 0x00000000030bf800 Implicit null exception at 0x00007efbe23abd40 to 0x00007efbe23ac915
-
-Events (10 events):
-Event: 1594.056 Thread 0x000000000264e000 Thread added: 0x000000000264e000
-Event: 1594.056 Thread 0x000000000264e000 Thread exited: 0x000000000264e000
-Event: 1594.056 Thread 0x000000000264e000 Thread added: 0x000000000264e000
-Event: 1594.056 Thread 0x000000000264e000 Thread exited: 0x000000000264e000
-Event: 1594.056 Thread 0x000000000264e000 Thread added: 0x000000000264e000
-Event: 1594.056 Thread 0x000000000264e000 Thread exited: 0x000000000264e000
-Event: 1594.094 Thread 0x000000000264e000 Thread added: 0x000000000264e000
-Event: 1594.096 Thread 0x000000000264e000 Uncommon trap: trap_request=0xffffff75 fr.pc=0x00007efbe2364230
-Event: 1594.096 Thread 0x000000000264e000 DEOPT PACKING pc=0x00007efbe2364230 sp=0x00007ffbffff6a00
-Event: 1594.096 Thread 0x000000000264e000 DEOPT UNPACKING pc=0x00007efbe20c6045 sp=0x00007ffbffff69b8 mode 2
-
-
-Dynamic libraries:
-00400000-00402000 r-xp 00000000 08:05 4207237 /usr/bin/scilab-bin
-00602000-00603000 r--p 00002000 08:05 4207237 /usr/bin/scilab-bin
-00603000-00604000 rw-p 00003000 08:05 4207237 /usr/bin/scilab-bin
-02604000-0354a000 rw-p 00000000 00:00 0 [heap]
-e5a00000-ea500000 rw-p 00000000 00:00 0
-ea500000-f0000000 rw-p 00000000 00:00 0
-f0000000-f5f80000 rw-p 00000000 00:00 0
-f5f80000-faa80000 rw-p 00000000 00:00 0
-faa80000-100000000 rw-p 00000000 00:00 0
-7efb54000000-7efb54021000 rw-p 00000000 00:00 0
-7efb54021000-7efb58000000 ---p 00000000 00:00 0
-7efb585e7000-7efb5d237000 rw-p 00000000 00:00 0
-7efb5e04b000-7efb5e0a5000 r-xp 00000000 08:05 4206994 /usr/lib/scilab/libscioptimization.so.5.5.0
-7efb5e0a5000-7efb5e2a4000 ---p 0005a000 08:05 4206994 /usr/lib/scilab/libscioptimization.so.5.5.0
-7efb5e2a4000-7efb5e2a5000 r--p 00059000 08:05 4206994 /usr/lib/scilab/libscioptimization.so.5.5.0
-7efb5e2a5000-7efb5e2a6000 rw-p 0005a000 08:05 4206994 /usr/lib/scilab/libscioptimization.so.5.5.0
-7efb5e2a6000-7efb5e360000 rw-p 00000000 00:00 0
-7efb5e360000-7efb5e386000 r-xp 00000000 08:05 4206239 /home/harpreet/symphony_work/symphony/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so
-7efb5e386000-7efb5e585000 ---p 00026000 08:05 4206239 /home/harpreet/symphony_work/symphony/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so
-7efb5e585000-7efb5e586000 r--p 00025000 08:05 4206239 /home/harpreet/symphony_work/symphony/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so
-7efb5e586000-7efb5e587000 rw-p 00026000 08:05 4206239 /home/harpreet/symphony_work/symphony/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so
-7efb5e587000-7efb5e588000 rw-p 00000000 00:00 0
-7efb5e588000-7efb5e7b0000 r-xp 00000000 08:05 4079329 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libipopt.so.1.10.4
-7efb5e7b0000-7efb5e9af000 ---p 00228000 08:05 4079329 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libipopt.so.1.10.4
-7efb5e9af000-7efb5e9b7000 r--p 00227000 08:05 4079329 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libipopt.so.1.10.4
-7efb5e9b7000-7efb5e9ba000 rw-p 0022f000 08:05 4079329 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libipopt.so.1.10.4
-7efb5e9ba000-7efb5eb3a000 r-xp 00000000 08:05 4079326 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4
-7efb5eb3a000-7efb5ed3a000 ---p 00180000 08:05 4079326 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4
-7efb5ed3a000-7efb5ed3b000 r--p 00180000 08:05 4079326 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4
-7efb5ed3b000-7efb5ed3d000 rw-p 00181000 08:05 4079326 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4
-7efb5ed3d000-7efb5ed40000 rw-p 00000000 00:00 0
-7efb5ed40000-7efb5edca000 r-xp 00000000 08:05 4079322 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4
-7efb5edca000-7efb5efc9000 ---p 0008a000 08:05 4079322 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4
-7efb5efc9000-7efb5efca000 r--p 00089000 08:05 4079322 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4
-7efb5efca000-7efb5efcb000 rw-p 0008a000 08:05 4079322 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4
-7efb5efcb000-7efb5efeb000 rw-p 00000000 00:00 0
-7efb5efeb000-7efb5f011000 r-xp 00000000 08:05 4079319 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinblas.so.1.4.4
-7efb5f011000-7efb5f210000 ---p 00026000 08:05 4079319 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinblas.so.1.4.4
-7efb5f210000-7efb5f211000 r--p 00025000 08:05 4079319 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinblas.so.1.4.4
-7efb5f211000-7efb5f212000 rw-p 00026000 08:05 4079319 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libcoinblas.so.1.4.4
-7efb5f212000-7efb5f228000 r-xp 00000000 08:05 4079313 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiSym.so.3.6.10
-7efb5f228000-7efb5f427000 ---p 00016000 08:05 4079313 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiSym.so.3.6.10
-7efb5f427000-7efb5f429000 r--p 00015000 08:05 4079313 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiSym.so.3.6.10
-7efb5f429000-7efb5f42a000 rw-p 00017000 08:05 4079313 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiSym.so.3.6.10
-7efb5f42a000-7efb5f50e000 r-xp 00000000 08:05 4079316 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libSym.so.3.6.10
-7efb5f50e000-7efb5f70d000 ---p 000e4000 08:05 4079316 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libSym.so.3.6.10
-7efb5f70d000-7efb5f70e000 r--p 000e3000 08:05 4079316 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libSym.so.3.6.10
-7efb5f70e000-7efb5f710000 rw-p 000e4000 08:05 4079316 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libSym.so.3.6.10
-7efb5f710000-7efb5f8c9000 r-xp 00000000 08:05 4079292 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libCgl.so.1.9.4
-7efb5f8c9000-7efb5fac8000 ---p 001b9000 08:05 4079292 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libCgl.so.1.9.4
-7efb5fac8000-7efb5faca000 r--p 001b8000 08:05 4079292 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libCgl.so.1.9.4
-7efb5faca000-7efb5facf000 rw-p 001ba000 08:05 4079292 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libCgl.so.1.9.4
-7efb5facf000-7efb5fad0000 rw-p 00000000 00:00 0
-7efb5fad0000-7efb5fb34000 r-xp 00000000 08:05 4079307 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiClp.so.1.13.6
-7efb5fb34000-7efb5fd33000 ---p 00064000 08:05 4079307 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiClp.so.1.13.6
-7efb5fd33000-7efb5fd35000 r--p 00063000 08:05 4079307 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiClp.so.1.13.6
-7efb5fd35000-7efb5fd37000 rw-p 00065000 08:05 4079307 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiClp.so.1.13.6
-7efb5fd37000-7efb5fdfd000 r-xp 00000000 08:05 4079310 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiCommonTests.so.1.12.4
-7efb5fdfd000-7efb5fffc000 ---p 000c6000 08:05 4079310 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiCommonTests.so.1.12.4
-7efb5fffc000-7efb5fffd000 r--p 000c5000 08:05 4079310 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiCommonTests.so.1.12.4
-7efb5fffd000-7efb60000000 rw-p 000c6000 08:05 4079310 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsiCommonTests.so.1.12.4
-7efb60000000-7efb60021000 rw-p 00000000 00:00 0
-7efb60021000-7efb64000000 ---p 00000000 00:00 0
-7efb64043000-7efb640bc000 r-xp 00000000 08:05 4079304 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsi.so.1.12.4
-7efb640bc000-7efb642bb000 ---p 00079000 08:05 4079304 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsi.so.1.12.4
-7efb642bb000-7efb642bd000 r--p 00078000 08:05 4079304 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsi.so.1.12.4
-7efb642bd000-7efb642bf000 rw-p 0007a000 08:05 4079304 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libOsi.so.1.12.4
-7efb642bf000-7efb64513000 r-xp 00000000 08:05 4079295 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libClp.so.1.13.6
-7efb64513000-7efb64713000 ---p 00254000 08:05 4079295 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libClp.so.1.13.6
-7efb64713000-7efb64716000 r--p 00254000 08:05 4079295 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libClp.so.1.13.6
-7efb64716000-7efb6471b000 rw-p 00257000 08:05 4079295 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libClp.so.1.13.6
-7efb6471b000-7efb648c6000 r-xp 00000000 08:05 4079301 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libCoinUtils.so.3.10.6
-7efb648c6000-7efb64ac5000 ---p 001ab000 08:05 4079301 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libCoinUtils.so.3.10.6
-7efb64ac5000-7efb64ac8000 r--p 001aa000 08:05 4079301 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libCoinUtils.so.3.10.6
-7efb64ac8000-7efb64acd000 rw-p 001ad000 08:05 4079301 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libCoinUtils.so.3.10.6
-7efb64acd000-7efb64ace000 ---p 00000000 00:00 0
-7efb64ace000-7efb652ce000 rw-p 00000000 00:00 0 [stack:5955]
-7efb652ce000-7efb652d1000 ---p 00000000 00:00 0
-7efb652d1000-7efb65acf000 rw-p 00000000 00:00 0
-7efb65ef1000-7efb65f87000 r-xp 00000000 08:05 4079298 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libClpSolver.so.1.13.6
-7efb65f87000-7efb66186000 ---p 00096000 08:05 4079298 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libClpSolver.so.1.13.6
-7efb66186000-7efb66187000 r--p 00095000 08:05 4079298 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libClpSolver.so.1.13.6
-7efb66187000-7efb6618a000 rw-p 00096000 08:05 4079298 /home/harpreet/symphony_work/symphony/thirdparty/linux/lib/x64/libClpSolver.so.1.13.6
-7efb66a76000-7efb66c76000 rw-s 00000000 00:05 118325261 /SYSV00000000 (deleted)
-7efb66c76000-7efb66c77000 ---p 00000000 00:00 0
-7efb66c77000-7efb67477000 rw-p 00000000 00:00 0 [stack:5952]
-7efb67477000-7efb674ab000 r-xp 00000000 08:05 4330536 /usr/lib/x86_64-linux-gnu/gvfs/libgvfscommon.so
-7efb674ab000-7efb676ab000 ---p 00034000 08:05 4330536 /usr/lib/x86_64-linux-gnu/gvfs/libgvfscommon.so
-7efb676ab000-7efb676b0000 r--p 00034000 08:05 4330536 /usr/lib/x86_64-linux-gnu/gvfs/libgvfscommon.so
-7efb676b0000-7efb676b1000 rw-p 00039000 08:05 4330536 /usr/lib/x86_64-linux-gnu/gvfs/libgvfscommon.so
-7efb676b1000-7efb676e0000 r-xp 00000000 08:05 4590045 /usr/lib/x86_64-linux-gnu/gio/modules/libgvfsdbus.so
-7efb676e0000-7efb678e0000 ---p 0002f000 08:05 4590045 /usr/lib/x86_64-linux-gnu/gio/modules/libgvfsdbus.so
-7efb678e0000-7efb678e1000 r--p 0002f000 08:05 4590045 /usr/lib/x86_64-linux-gnu/gio/modules/libgvfsdbus.so
-7efb678e1000-7efb678e2000 rw-p 00030000 08:05 4590045 /usr/lib/x86_64-linux-gnu/gio/modules/libgvfsdbus.so
-7efb678e2000-7efb678e3000 rw-p 00000000 00:00 0
-7efb678e3000-7efb6849e000 r--p 00000000 08:05 555994 /usr/share/icons/hicolor/icon-theme.cache
-7efb6849e000-7efb6c24f000 r--p 00000000 08:05 548712 /usr/share/icons/gnome/icon-theme.cache
-7efb6c24f000-7efb70000000 r--p 00000000 08:05 548712 /usr/share/icons/gnome/icon-theme.cache
-7efb70000000-7efb70035000 rw-p 00000000 00:00 0
-7efb70035000-7efb74000000 ---p 00000000 00:00 0
-7efb74151000-7efb74d0c000 r--p 00000000 08:05 555994 /usr/share/icons/hicolor/icon-theme.cache
-7efb74d0c000-7efb76686000 r--p 00000000 08:05 536532 /usr/share/icons/elementary-xfce/icon-theme.cache
-7efb76686000-7efb78000000 r--p 00000000 08:05 536532 /usr/share/icons/elementary-xfce/icon-theme.cache
-7efb78000000-7efb78048000 rw-p 00000000 00:00 0
-7efb78048000-7efb7c000000 ---p 00000000 00:00 0
-7efb7c000000-7efb7c021000 rw-p 00000000 00:00 0
-7efb7c021000-7efb80000000 ---p 00000000 00:00 0
-7efb80000000-7efb80021000 rw-p 00000000 00:00 0
-7efb80021000-7efb84000000 ---p 00000000 00:00 0
-7efb84000000-7efb84023000 rw-p 00000000 00:00 0
-7efb84023000-7efb88000000 ---p 00000000 00:00 0
-7efb88000000-7efb880a9000 rw-p 00000000 00:00 0
-7efb880a9000-7efb8c000000 ---p 00000000 00:00 0
-7efb8c029000-7efb8c089000 rw-s 00000000 00:05 118194179 /SYSV00000000 (deleted)
-7efb8c102000-7efb8c109000 r--s 00000000 08:05 4330193 /usr/lib/x86_64-linux-gnu/gconv/gconv-modules.cache
-7efb8c109000-7efb8c193000 r--p 00000000 08:05 547239 /usr/share/icons/elementary-xfce-dark/icon-theme.cache
-7efb8c193000-7efb8c5e8000 r--p 00000000 08:05 547632 /usr/share/icons/elementary-xfce-darker/icon-theme.cache
-7efb8c5e8000-7efb8ca3d000 r--p 00000000 08:05 547632 /usr/share/icons/elementary-xfce-darker/icon-theme.cache
-7efb8ca3d000-7efb8ca47000 r--s 00064000 08:05 560912 /usr/share/scilab/modules/scinotes/jar/org.scilab.modules.scinotes.jar
-7efb8ca4b000-7efb8ca68000 r--s 00000000 08:05 4729716 /usr/share/mime/mime.cache
-7efb8ca68000-7efb8ca85000 r--s 00000000 08:05 4729716 /usr/share/mime/mime.cache
-7efb8ca85000-7efb8cb0f000 r--p 00000000 08:05 547239 /usr/share/icons/elementary-xfce-dark/icon-theme.cache
-7efb8cb0f000-7efb8cb2f000 r--s 012ac000 08:05 1721173 /usr/share/scilab/modules/helptools/jar/scilab_images.jar
-7efb8cb2f000-7efb8cb32000 ---p 00000000 00:00 0
-7efb8cb32000-7efb8cc30000 rw-p 00000000 00:00 0
-7efb8cc30000-7efb8cc33000 ---p 00000000 00:00 0
-7efb8cc33000-7efb8cd31000 rw-p 00000000 00:00 0 [stack:5949]
-7efb8cd31000-7efb8cd34000 ---p 00000000 00:00 0
-7efb8cd34000-7efb8ce32000 rw-p 00000000 00:00 0
-7efb8ce32000-7efb8ce35000 ---p 00000000 00:00 0
-7efb8ce35000-7efb8cf33000 rw-p 00000000 00:00 0 [stack:5956]
-7efb8cf33000-7efb8cf6c000 r--s 006dd000 08:05 1721219 /usr/share/scilab/modules/helptools/jar/scilab_en_US_help.jar
-7efb8cf6c000-7efb8cf6f000 ---p 00000000 00:00 0
-7efb8cf6f000-7efb8d06d000 rw-p 00000000 00:00 0 [stack:5943]
-7efb8d06d000-7efb8d06e000 r--s 00001000 08:05 415879 /usr/share/scilab/modules/completion/jar/org.scilab.modules.completion.jar
-7efb8d06e000-7efb8d071000 ---p 00000000 00:00 0
-7efb8d071000-7efb8d16f000 rw-p 00000000 00:00 0
-7efb8d16f000-7efb8d1c1000 r--p 00000000 08:05 264916 /usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf
-7efb8d1c1000-7efb8d1f0000 r--p 00000000 08:05 264922 /usr/share/fonts/truetype/droid/DroidSans.ttf
-7efb8d3c1000-7efb8d3d1000 r-xp 00000000 08:05 4599212 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libnio.so
-7efb8d3d1000-7efb8d5d1000 ---p 00010000 08:05 4599212 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libnio.so
-7efb8d5d1000-7efb8d5d2000 r--p 00010000 08:05 4599212 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libnio.so
-7efb8d5d2000-7efb8d5d3000 rw-p 00011000 08:05 4599212 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libnio.so
-7efb8d5d3000-7efb8d5ea000 r-xp 00000000 08:05 4599231 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libnet.so
-7efb8d5ea000-7efb8d7e9000 ---p 00017000 08:05 4599231 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libnet.so
-7efb8d7e9000-7efb8d7ea000 r--p 00016000 08:05 4599231 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libnet.so
-7efb8d7ea000-7efb8d7eb000 rw-p 00017000 08:05 4599231 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libnet.so
-7efb8d7eb000-7efb8d83d000 r-xp 00000000 08:05 4599220 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libfontmanager.so
-7efb8d83d000-7efb8da3c000 ---p 00052000 08:05 4599220 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libfontmanager.so
-7efb8da3c000-7efb8da3f000 r--p 00051000 08:05 4599220 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libfontmanager.so
-7efb8da3f000-7efb8da40000 rw-p 00054000 08:05 4599220 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libfontmanager.so
-7efb8da40000-7efb8da49000 r-xp 00000000 08:05 4590057 /usr/lib/x86_64-linux-gnu/gtk-2.0/2.10.0/engines/libpixmap.so
-7efb8da49000-7efb8dc49000 ---p 00009000 08:05 4590057 /usr/lib/x86_64-linux-gnu/gtk-2.0/2.10.0/engines/libpixmap.so
-7efb8dc49000-7efb8dc4a000 r--p 00009000 08:05 4590057 /usr/lib/x86_64-linux-gnu/gtk-2.0/2.10.0/engines/libpixmap.so
-7efb8dc4a000-7efb8dc4b000 rw-p 0000a000 08:05 4590057 /usr/lib/x86_64-linux-gnu/gtk-2.0/2.10.0/engines/libpixmap.so
-7efb8dc4b000-7efb8dc7a000 r-xp 00000000 08:05 4590056 /usr/lib/x86_64-linux-gnu/gtk-2.0/2.10.0/engines/libmurrine.so
-7efb8dc7a000-7efb8de7a000 ---p 0002f000 08:05 4590056 /usr/lib/x86_64-linux-gnu/gtk-2.0/2.10.0/engines/libmurrine.so
-7efb8de7a000-7efb8de7b000 r--p 0002f000 08:05 4590056 /usr/lib/x86_64-linux-gnu/gtk-2.0/2.10.0/engines/libmurrine.so
-7efb8de7b000-7efb8de7c000 rw-p 00030000 08:05 4590056 /usr/lib/x86_64-linux-gnu/gtk-2.0/2.10.0/engines/libmurrine.so
-7efb8de7c000-7efb8de96000 r-xp 00000000 08:05 4201359 /usr/lib/x86_64-linux-gnu/libgraphite2.so.3.0.1
-7efb8de96000-7efb8e095000 ---p 0001a000 08:05 4201359 /usr/lib/x86_64-linux-gnu/libgraphite2.so.3.0.1
-7efb8e095000-7efb8e097000 r--p 00019000 08:05 4201359 /usr/lib/x86_64-linux-gnu/libgraphite2.so.3.0.1
-7efb8e097000-7efb8e098000 rw-p 0001b000 08:05 4201359 /usr/lib/x86_64-linux-gnu/libgraphite2.so.3.0.1
-7efb8e098000-7efb8e09e000 r-xp 00000000 08:05 4201177 /usr/lib/x86_64-linux-gnu/libdatrie.so.1.3.1
-7efb8e09e000-7efb8e29d000 ---p 00006000 08:05 4201177 /usr/lib/x86_64-linux-gnu/libdatrie.so.1.3.1
-7efb8e29d000-7efb8e29e000 r--p 00005000 08:05 4201177 /usr/lib/x86_64-linux-gnu/libdatrie.so.1.3.1
-7efb8e29e000-7efb8e29f000 rw-p 00006000 08:05 4201177 /usr/lib/x86_64-linux-gnu/libdatrie.so.1.3.1
-7efb8e29f000-7efb8e2f2000 r-xp 00000000 08:05 4201471 /usr/lib/x86_64-linux-gnu/libharfbuzz.so.0.927.0
-7efb8e2f2000-7efb8e4f2000 ---p 00053000 08:05 4201471 /usr/lib/x86_64-linux-gnu/libharfbuzz.so.0.927.0
-7efb8e4f2000-7efb8e4f3000 r--p 00053000 08:05 4201471 /usr/lib/x86_64-linux-gnu/libharfbuzz.so.0.927.0
-7efb8e4f3000-7efb8e4f4000 rw-p 00054000 08:05 4201471 /usr/lib/x86_64-linux-gnu/libharfbuzz.so.0.927.0
-7efb8e4f4000-7efb8e4fc000 r-xp 00000000 08:05 4201930 /usr/lib/x86_64-linux-gnu/libxcb-render.so.0.0.0
-7efb8e4fc000-7efb8e6fb000 ---p 00008000 08:05 4201930 /usr/lib/x86_64-linux-gnu/libxcb-render.so.0.0.0
-7efb8e6fb000-7efb8e6fc000 r--p 00007000 08:05 4201930 /usr/lib/x86_64-linux-gnu/libxcb-render.so.0.0.0
-7efb8e6fc000-7efb8e6fd000 rw-p 00008000 08:05 4201930 /usr/lib/x86_64-linux-gnu/libxcb-render.so.0.0.0
-7efb8e6fd000-7efb8e6ff000 r-xp 00000000 08:05 4201934 /usr/lib/x86_64-linux-gnu/libxcb-shm.so.0.0.0
-7efb8e6ff000-7efb8e8fe000 ---p 00002000 08:05 4201934 /usr/lib/x86_64-linux-gnu/libxcb-shm.so.0.0.0
-7efb8e8fe000-7efb8e8ff000 r--p 00001000 08:05 4201934 /usr/lib/x86_64-linux-gnu/libxcb-shm.so.0.0.0
-7efb8e8ff000-7efb8e900000 rw-p 00002000 08:05 4201934 /usr/lib/x86_64-linux-gnu/libxcb-shm.so.0.0.0
-7efb8e900000-7efb8e9a0000 r-xp 00000000 08:05 4199261 /usr/lib/x86_64-linux-gnu/libpixman-1.so.0.30.2
-7efb8e9a0000-7efb8eba0000 ---p 000a0000 08:05 4199261 /usr/lib/x86_64-linux-gnu/libpixman-1.so.0.30.2
-7efb8eba0000-7efb8eba7000 r--p 000a0000 08:05 4199261 /usr/lib/x86_64-linux-gnu/libpixman-1.so.0.30.2
-7efb8eba7000-7efb8eba8000 rw-p 000a7000 08:05 4199261 /usr/lib/x86_64-linux-gnu/libpixman-1.so.0.30.2
-7efb8eba8000-7efb8ebb0000 r-xp 00000000 08:05 4201825 /usr/lib/x86_64-linux-gnu/libthai.so.0.2.0
-7efb8ebb0000-7efb8edaf000 ---p 00008000 08:05 4201825 /usr/lib/x86_64-linux-gnu/libthai.so.0.2.0
-7efb8edaf000-7efb8edb0000 r--p 00007000 08:05 4201825 /usr/lib/x86_64-linux-gnu/libthai.so.0.2.0
-7efb8edb0000-7efb8edb1000 rw-p 00008000 08:05 4201825 /usr/lib/x86_64-linux-gnu/libthai.so.0.2.0
-7efb8edb1000-7efb8edb3000 r-xp 00000000 08:05 4200995 /usr/lib/x86_64-linux-gnu/libXcomposite.so.1.0.0
-7efb8edb3000-7efb8efb2000 ---p 00002000 08:05 4200995 /usr/lib/x86_64-linux-gnu/libXcomposite.so.1.0.0
-7efb8efb2000-7efb8efb3000 r--p 00001000 08:05 4200995 /usr/lib/x86_64-linux-gnu/libXcomposite.so.1.0.0
-7efb8efb3000-7efb8efb4000 rw-p 00002000 08:05 4200995 /usr/lib/x86_64-linux-gnu/libXcomposite.so.1.0.0
-7efb8efb4000-7efb8efbd000 r-xp 00000000 08:05 4201023 /usr/lib/x86_64-linux-gnu/libXrandr.so.2.2.0
-7efb8efbd000-7efb8f1bc000 ---p 00009000 08:05 4201023 /usr/lib/x86_64-linux-gnu/libXrandr.so.2.2.0
-7efb8f1bc000-7efb8f1bd000 r--p 00008000 08:05 4201023 /usr/lib/x86_64-linux-gnu/libXrandr.so.2.2.0
-7efb8f1bd000-7efb8f1be000 rw-p 00009000 08:05 4201023 /usr/lib/x86_64-linux-gnu/libXrandr.so.2.2.0
-7efb8f1be000-7efb8f1d2000 r-xp 00000000 08:05 4201660 /usr/lib/x86_64-linux-gnu/libpangoft2-1.0.so.0.3600.3
-7efb8f1d2000-7efb8f3d1000 ---p 00014000 08:05 4201660 /usr/lib/x86_64-linux-gnu/libpangoft2-1.0.so.0.3600.3
-7efb8f3d1000-7efb8f3d2000 r--p 00013000 08:05 4201660 /usr/lib/x86_64-linux-gnu/libpangoft2-1.0.so.0.3600.3
-7efb8f3d2000-7efb8f3d3000 rw-p 00014000 08:05 4201660 /usr/lib/x86_64-linux-gnu/libpangoft2-1.0.so.0.3600.3
-7efb8f3d3000-7efb8f4d9000 r-xp 00000000 08:05 4201116 /usr/lib/x86_64-linux-gnu/libcairo.so.2.11301.0
-7efb8f4d9000-7efb8f6d8000 ---p 00106000 08:05 4201116 /usr/lib/x86_64-linux-gnu/libcairo.so.2.11301.0
-7efb8f6d8000-7efb8f6db000 r--p 00105000 08:05 4201116 /usr/lib/x86_64-linux-gnu/libcairo.so.2.11301.0
-7efb8f6db000-7efb8f6dc000 rw-p 00108000 08:05 4201116 /usr/lib/x86_64-linux-gnu/libcairo.so.2.11301.0
-7efb8f6dc000-7efb8f6de000 rw-p 00000000 00:00 0
-7efb8f6de000-7efb8f6fd000 r-xp 00000000 08:05 4201077 /usr/lib/x86_64-linux-gnu/libatk-1.0.so.0.21009.1
-7efb8f6fd000-7efb8f8fd000 ---p 0001f000 08:05 4201077 /usr/lib/x86_64-linux-gnu/libatk-1.0.so.0.21009.1
-7efb8f8fd000-7efb8f8ff000 r--p 0001f000 08:05 4201077 /usr/lib/x86_64-linux-gnu/libatk-1.0.so.0.21009.1
-7efb8f8ff000-7efb8f900000 rw-p 00021000 08:05 4201077 /usr/lib/x86_64-linux-gnu/libatk-1.0.so.0.21009.1
-7efb8f900000-7efb8f90b000 r-xp 00000000 08:05 4201658 /usr/lib/x86_64-linux-gnu/libpangocairo-1.0.so.0.3600.3
-7efb8f90b000-7efb8fb0b000 ---p 0000b000 08:05 4201658 /usr/lib/x86_64-linux-gnu/libpangocairo-1.0.so.0.3600.3
-7efb8fb0b000-7efb8fb0c000 r--p 0000b000 08:05 4201658 /usr/lib/x86_64-linux-gnu/libpangocairo-1.0.so.0.3600.3
-7efb8fb0c000-7efb8fb0d000 rw-p 0000c000 08:05 4201658 /usr/lib/x86_64-linux-gnu/libpangocairo-1.0.so.0.3600.3
-7efb8fb0d000-7efb8fb0e000 r-xp 00000000 08:05 4201449 /usr/lib/x86_64-linux-gnu/libgthread-2.0.so.0.4002.0
-7efb8fb0e000-7efb8fd0d000 ---p 00001000 08:05 4201449 /usr/lib/x86_64-linux-gnu/libgthread-2.0.so.0.4002.0
-7efb8fd0d000-7efb8fd0e000 r--p 00000000 08:05 4201449 /usr/lib/x86_64-linux-gnu/libgthread-2.0.so.0.4002.0
-7efb8fd0e000-7efb8fd0f000 rw-p 00001000 08:05 4201449 /usr/lib/x86_64-linux-gnu/libgthread-2.0.so.0.4002.0
-7efb8fd0f000-7efb8fd59000 r-xp 00000000 08:05 4201656 /usr/lib/x86_64-linux-gnu/libpango-1.0.so.0.3600.3
-7efb8fd59000-7efb8ff59000 ---p 0004a000 08:05 4201656 /usr/lib/x86_64-linux-gnu/libpango-1.0.so.0.3600.3
-7efb8ff59000-7efb8ff5b000 r--p 0004a000 08:05 4201656 /usr/lib/x86_64-linux-gnu/libpango-1.0.so.0.3600.3
-7efb8ff5b000-7efb8ff5c000 rw-p 0004c000 08:05 4201656 /usr/lib/x86_64-linux-gnu/libpango-1.0.so.0.3600.3
-7efb8ff5c000-7efb8ff7c000 r-xp 00000000 08:05 4201303 /usr/lib/x86_64-linux-gnu/libgdk_pixbuf-2.0.so.0.3000.7
-7efb8ff7c000-7efb9017b000 ---p 00020000 08:05 4201303 /usr/lib/x86_64-linux-gnu/libgdk_pixbuf-2.0.so.0.3000.7
-7efb9017b000-7efb9017c000 r--p 0001f000 08:05 4201303 /usr/lib/x86_64-linux-gnu/libgdk_pixbuf-2.0.so.0.3000.7
-7efb9017c000-7efb9017d000 rw-p 00020000 08:05 4201303 /usr/lib/x86_64-linux-gnu/libgdk_pixbuf-2.0.so.0.3000.7
-7efb9017d000-7efb9022a000 r-xp 00000000 08:05 4201301 /usr/lib/x86_64-linux-gnu/libgdk-x11-2.0.so.0.2400.23
-7efb9022a000-7efb9042a000 ---p 000ad000 08:05 4201301 /usr/lib/x86_64-linux-gnu/libgdk-x11-2.0.so.0.2400.23
-7efb9042a000-7efb9042e000 r--p 000ad000 08:05 4201301 /usr/lib/x86_64-linux-gnu/libgdk-x11-2.0.so.0.2400.23
-7efb9042e000-7efb90430000 rw-p 000b1000 08:05 4201301 /usr/lib/x86_64-linux-gnu/libgdk-x11-2.0.so.0.2400.23
-7efb90430000-7efb90860000 r-xp 00000000 08:05 4201453 /usr/lib/x86_64-linux-gnu/libgtk-x11-2.0.so.0.2400.23
-7efb90860000-7efb90a5f000 ---p 00430000 08:05 4201453 /usr/lib/x86_64-linux-gnu/libgtk-x11-2.0.so.0.2400.23
-7efb90a5f000-7efb90a66000 r--p 0042f000 08:05 4201453 /usr/lib/x86_64-linux-gnu/libgtk-x11-2.0.so.0.2400.23
-7efb90a66000-7efb90a6a000 rw-p 00436000 08:05 4201453 /usr/lib/x86_64-linux-gnu/libgtk-x11-2.0.so.0.2400.23
-7efb90a6a000-7efb90a6d000 rw-p 00000000 00:00 0
-7efb90a6d000-7efb90a78000 r-xp 00000000 08:05 4599289 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjavagtk.so
-7efb90a78000-7efb90c77000 ---p 0000b000 08:05 4599289 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjavagtk.so
-7efb90c77000-7efb90c78000 r--p 0000a000 08:05 4599289 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjavagtk.so
-7efb90c78000-7efb90c79000 rw-p 0000b000 08:05 4599289 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjavagtk.so
-7efb90c79000-7efb90c7b000 r-xp 00000000 08:05 4201013 /usr/lib/x86_64-linux-gnu/libXinerama.so.1.0.0
-7efb90c7b000-7efb90e7a000 ---p 00002000 08:05 4201013 /usr/lib/x86_64-linux-gnu/libXinerama.so.1.0.0
-7efb90e7a000-7efb90e7b000 r--p 00001000 08:05 4201013 /usr/lib/x86_64-linux-gnu/libXinerama.so.1.0.0
-7efb90e7b000-7efb90e7c000 rw-p 00002000 08:05 4201013 /usr/lib/x86_64-linux-gnu/libXinerama.so.1.0.0
-7efb90e7c000-7efb90eb3000 r-xp 00000000 08:05 4201847 /usr/lib/x86_64-linux-gnu/libtxc_dxtn_s2tc.so.0.0.0
-7efb90eb3000-7efb910b2000 ---p 00037000 08:05 4201847 /usr/lib/x86_64-linux-gnu/libtxc_dxtn_s2tc.so.0.0.0
-7efb910b2000-7efb910b3000 r--p 00036000 08:05 4201847 /usr/lib/x86_64-linux-gnu/libtxc_dxtn_s2tc.so.0.0.0
-7efb910b3000-7efb910b4000 rw-p 00037000 08:05 4201847 /usr/lib/x86_64-linux-gnu/libtxc_dxtn_s2tc.so.0.0.0
-7efb910b4000-7efb910b5000 ---p 00000000 00:00 0
-7efb910b5000-7efb918b5000 rw-p 00000000 00:00 0 [stack:5939]
-7efb918b5000-7efb918de000 r-xp 00000000 08:05 4201224 /usr/lib/x86_64-linux-gnu/libedit.so.2.0.47
-7efb918de000-7efb91ade000 ---p 00029000 08:05 4201224 /usr/lib/x86_64-linux-gnu/libedit.so.2.0.47
-7efb91ade000-7efb91ae0000 r--p 00029000 08:05 4201224 /usr/lib/x86_64-linux-gnu/libedit.so.2.0.47
-7efb91ae0000-7efb91ae1000 rw-p 0002b000 08:05 4201224 /usr/lib/x86_64-linux-gnu/libedit.so.2.0.47
-7efb91ae1000-7efb91ae5000 rw-p 00000000 00:00 0
-7efb91ae5000-7efb937a3000 r-xp 00000000 08:05 4200978 /usr/lib/x86_64-linux-gnu/libLLVM-3.6.so.1
-7efb937a3000-7efb937a4000 ---p 01cbe000 08:05 4200978 /usr/lib/x86_64-linux-gnu/libLLVM-3.6.so.1
-7efb937a4000-7efb939bb000 r--p 01cbe000 08:05 4200978 /usr/lib/x86_64-linux-gnu/libLLVM-3.6.so.1
-7efb939bb000-7efb939c1000 rw-p 01ed5000 08:05 4200978 /usr/lib/x86_64-linux-gnu/libLLVM-3.6.so.1
-7efb939c1000-7efb939d6000 rw-p 00000000 00:00 0
-7efb939d6000-7efb939eb000 r-xp 00000000 08:05 4201225 /usr/lib/x86_64-linux-gnu/libelf-0.158.so
-7efb939eb000-7efb93bea000 ---p 00015000 08:05 4201225 /usr/lib/x86_64-linux-gnu/libelf-0.158.so
-7efb93bea000-7efb93beb000 r--p 00014000 08:05 4201225 /usr/lib/x86_64-linux-gnu/libelf-0.158.so
-7efb93beb000-7efb93bec000 rw-p 00015000 08:05 4201225 /usr/lib/x86_64-linux-gnu/libelf-0.158.so
-7efb93bec000-7efb93bf3000 r-xp 00000000 08:05 4201214 /usr/lib/x86_64-linux-gnu/libdrm_amdgpu.so.1.0.0
-7efb93bf3000-7efb93df2000 ---p 00007000 08:05 4201214 /usr/lib/x86_64-linux-gnu/libdrm_amdgpu.so.1.0.0
-7efb93df2000-7efb93df3000 r--p 00006000 08:05 4201214 /usr/lib/x86_64-linux-gnu/libdrm_amdgpu.so.1.0.0
-7efb93df3000-7efb93df4000 rw-p 00007000 08:05 4201214 /usr/lib/x86_64-linux-gnu/libdrm_amdgpu.so.1.0.0
-7efb93df4000-7efb93dff000 r-xp 00000000 08:05 4201220 /usr/lib/x86_64-linux-gnu/libdrm_radeon.so.1.0.1
-7efb93dff000-7efb93ffe000 ---p 0000b000 08:05 4201220 /usr/lib/x86_64-linux-gnu/libdrm_radeon.so.1.0.1
-7efb93ffe000-7efb93fff000 r--p 0000a000 08:05 4201220 /usr/lib/x86_64-linux-gnu/libdrm_radeon.so.1.0.1
-7efb93fff000-7efb94000000 rw-p 0000b000 08:05 4201220 /usr/lib/x86_64-linux-gnu/libdrm_radeon.so.1.0.1
-7efb94000000-7efb94267000 rw-p 00000000 00:00 0
-7efb94267000-7efb98000000 ---p 00000000 00:00 0
-7efb98000000-7efb98002000 r--s 0000b000 08:05 4738752 /usr/share/java/jrosetta-engine.jar
-7efb98002000-7efb98004000 r--s 00003000 08:05 4738751 /usr/share/java/jrosetta-api.jar
-7efb98004000-7efb98008000 r--s 0004f000 08:05 4465721 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/jsse.jar
-7efb98054000-7efb9805f000 r--s 00000000 08:05 2752596 /var/cache/fontconfig/945677eb7aeaf62f1d50efc3fb3ec7d8-le64.cache-4
-7efb9805f000-7efb98065000 r--s 00000000 08:05 2752582 /var/cache/fontconfig/2cd17615ca594fa2959ae173292e504c-le64.cache-4
-7efb98065000-7efb98066000 r--s 00000000 08:05 2752612 /var/cache/fontconfig/e7071f4a29fa870f4323321c154eba04-le64.cache-4
-7efb98066000-7efb98067000 r--s 00000000 08:05 2752579 /var/cache/fontconfig/0d8c3b2ac0904cb8a57a757ad11a4a08-le64.cache-4
-7efb98067000-7efb9806e000 r--s 00000000 08:05 2752599 /var/cache/fontconfig/a755afe4a08bf5b97852ceb7400b47bc-le64.cache-4
-7efb9806e000-7efb98082000 r--s 00000000 08:05 2752577 /var/cache/fontconfig/04aabc0a78ac019cf9454389977116d2-le64.cache-4
-7efb98082000-7efb98083000 r--s 00000000 08:05 2752581 /var/cache/fontconfig/1ac9eb803944fde146138c791f5cc56a-le64.cache-4
-7efb98083000-7efb98087000 r--s 00000000 08:05 2752585 /var/cache/fontconfig/385c0604a188198f04d133e54aba7fe7-le64.cache-4
-7efb98087000-7efb98088000 r--s 00000000 08:05 2752609 /var/cache/fontconfig/dc05db6664285cc2f12bf69c139ae4c3-le64.cache-4
-7efb98088000-7efb9808a000 r--s 00000000 08:05 2752593 /var/cache/fontconfig/767a8244fc0220cfb567a839d0392e0b-le64.cache-4
-7efb9808a000-7efb9808f000 r--s 00000000 08:05 2752595 /var/cache/fontconfig/8801497958630a81b71ace7c5f9b32a8-le64.cache-4
-7efb9808f000-7efb98096000 r--s 00000000 08:05 2752583 /var/cache/fontconfig/3047814df9a2f067bd2d96a2b9c36e5a-le64.cache-4
-7efb98096000-7efb9809c000 r--s 00000000 08:05 2752600 /var/cache/fontconfig/b47c4e1ecd0709278f4910c18777a504-le64.cache-4
-7efb9809c000-7efb980af000 r--s 00000000 08:05 2752606 /var/cache/fontconfig/d52a8644073d54c13679302ca1180695-le64.cache-4
-7efb980af000-7efb980b8000 r--s 00000000 08:05 2752586 /var/cache/fontconfig/3f7329c5293ffd510edef78f73874cfd-le64.cache-4
-7efb98154000-7efb9815a000 r-xp 00000000 08:05 4201218 /usr/lib/x86_64-linux-gnu/libdrm_nouveau.so.2.0.0
-7efb9815a000-7efb98359000 ---p 00006000 08:05 4201218 /usr/lib/x86_64-linux-gnu/libdrm_nouveau.so.2.0.0
-7efb98359000-7efb9835a000 r--p 00005000 08:05 4201218 /usr/lib/x86_64-linux-gnu/libdrm_nouveau.so.2.0.0
-7efb9835a000-7efb9835b000 rw-p 00006000 08:05 4201218 /usr/lib/x86_64-linux-gnu/libdrm_nouveau.so.2.0.0
-7efb9835b000-7efb98b21000 r-xp 00000000 08:05 4329865 /usr/lib/x86_64-linux-gnu/dri/radeonsi_dri.so
-7efb98b21000-7efb98d21000 ---p 007c6000 08:05 4329865 /usr/lib/x86_64-linux-gnu/dri/radeonsi_dri.so
-7efb98d21000-7efb98d7a000 r--p 007c6000 08:05 4329865 /usr/lib/x86_64-linux-gnu/dri/radeonsi_dri.so
-7efb98d7a000-7efb98d83000 rw-p 0081f000 08:05 4329865 /usr/lib/x86_64-linux-gnu/dri/radeonsi_dri.so
-7efb98d83000-7efb98f69000 rw-p 00000000 00:00 0
-7efb98f69000-7efb98f71000 r-xp 00000000 08:05 4461021 /lib/x86_64-linux-gnu/libnih-dbus.so.1.0.0
-7efb98f71000-7efb99171000 ---p 00008000 08:05 4461021 /lib/x86_64-linux-gnu/libnih-dbus.so.1.0.0
-7efb99171000-7efb99172000 r--p 00008000 08:05 4461021 /lib/x86_64-linux-gnu/libnih-dbus.so.1.0.0
-7efb99172000-7efb99173000 rw-p 00009000 08:05 4461021 /lib/x86_64-linux-gnu/libnih-dbus.so.1.0.0
-7efb99173000-7efb9918a000 r-xp 00000000 08:05 4461023 /lib/x86_64-linux-gnu/libnih.so.1.0.0
-7efb9918a000-7efb99389000 ---p 00017000 08:05 4461023 /lib/x86_64-linux-gnu/libnih.so.1.0.0
-7efb99389000-7efb9938a000 r--p 00016000 08:05 4461023 /lib/x86_64-linux-gnu/libnih.so.1.0.0
-7efb9938a000-7efb9938b000 rw-p 00017000 08:05 4461023 /lib/x86_64-linux-gnu/libnih.so.1.0.0
-7efb9938b000-7efb993a4000 r-xp 00000000 08:05 4460964 /lib/x86_64-linux-gnu/libcgmanager.so.0.0.0
-7efb993a4000-7efb995a3000 ---p 00019000 08:05 4460964 /lib/x86_64-linux-gnu/libcgmanager.so.0.0.0
-7efb995a3000-7efb995a5000 r--p 00018000 08:05 4460964 /lib/x86_64-linux-gnu/libcgmanager.so.0.0.0
-7efb995a5000-7efb995a6000 rw-p 0001a000 08:05 4460964 /lib/x86_64-linux-gnu/libcgmanager.so.0.0.0
-7efb995a6000-7efb995b6000 r-xp 00000000 08:05 4461105 /lib/x86_64-linux-gnu/libudev.so.1.3.5
-7efb995b6000-7efb997b5000 ---p 00010000 08:05 4461105 /lib/x86_64-linux-gnu/libudev.so.1.3.5
-7efb997b5000-7efb997b6000 r--p 0000f000 08:05 4461105 /lib/x86_64-linux-gnu/libudev.so.1.3.5
-7efb997b6000-7efb997b7000 rw-p 00010000 08:05 4461105 /lib/x86_64-linux-gnu/libudev.so.1.3.5
-7efb997b7000-7efb997bd000 r-xp 00000000 08:05 4461469 /usr/lib/x86_64-linux-gnu/mesa-egl/libGLESv2.so.2.0.0
-7efb997bd000-7efb999bd000 ---p 00006000 08:05 4461469 /usr/lib/x86_64-linux-gnu/mesa-egl/libGLESv2.so.2.0.0
-7efb999bd000-7efb999be000 r--p 00006000 08:05 4461469 /usr/lib/x86_64-linux-gnu/mesa-egl/libGLESv2.so.2.0.0
-7efb999be000-7efb999bf000 rw-p 00007000 08:05 4461469 /usr/lib/x86_64-linux-gnu/mesa-egl/libGLESv2.so.2.0.0
-7efb999bf000-7efb99a05000 r-xp 00000000 08:05 4206973 /usr/lib/jni/libjogl_mobile.so
-7efb99a05000-7efb99c04000 ---p 00046000 08:05 4206973 /usr/lib/jni/libjogl_mobile.so
-7efb99c04000-7efb99c05000 r--p 00045000 08:05 4206973 /usr/lib/jni/libjogl_mobile.so
-7efb99c05000-7efb99c06000 rw-p 00046000 08:05 4206973 /usr/lib/jni/libjogl_mobile.so
-7efb99c06000-7efb99c12000 r-xp 00000000 08:05 4201283 /usr/lib/x86_64-linux-gnu/libgbm.so.1.0.0
-7efb99c12000-7efb99e11000 ---p 0000c000 08:05 4201283 /usr/lib/x86_64-linux-gnu/libgbm.so.1.0.0
-7efb99e11000-7efb99e12000 r--p 0000b000 08:05 4201283 /usr/lib/x86_64-linux-gnu/libgbm.so.1.0.0
-7efb99e12000-7efb99e13000 rw-p 0000c000 08:05 4201283 /usr/lib/x86_64-linux-gnu/libgbm.so.1.0.0
-7efb99e13000-7efb99e22000 r-xp 00000000 08:05 4201897 /usr/lib/x86_64-linux-gnu/libwayland-server.so.0.1.0
-7efb99e22000-7efb9a021000 ---p 0000f000 08:05 4201897 /usr/lib/x86_64-linux-gnu/libwayland-server.so.0.1.0
-7efb9a021000-7efb9a023000 r--p 0000e000 08:05 4201897 /usr/lib/x86_64-linux-gnu/libwayland-server.so.0.1.0
-7efb9a023000-7efb9a024000 rw-p 00010000 08:05 4201897 /usr/lib/x86_64-linux-gnu/libwayland-server.so.0.1.0
-7efb9a024000-7efb9a02f000 r-xp 00000000 08:05 4201891 /usr/lib/x86_64-linux-gnu/libwayland-client.so.0.2.0
-7efb9a02f000-7efb9a22e000 ---p 0000b000 08:05 4201891 /usr/lib/x86_64-linux-gnu/libwayland-client.so.0.2.0
-7efb9a22e000-7efb9a230000 r--p 0000a000 08:05 4201891 /usr/lib/x86_64-linux-gnu/libwayland-client.so.0.2.0
-7efb9a230000-7efb9a231000 rw-p 0000c000 08:05 4201891 /usr/lib/x86_64-linux-gnu/libwayland-client.so.0.2.0
-7efb9a231000-7efb9a236000 r-xp 00000000 08:05 4201940 /usr/lib/x86_64-linux-gnu/libxcb-xfixes.so.0.0.0
-7efb9a236000-7efb9a436000 ---p 00005000 08:05 4201940 /usr/lib/x86_64-linux-gnu/libxcb-xfixes.so.0.0.0
-7efb9a436000-7efb9a437000 r--p 00005000 08:05 4201940 /usr/lib/x86_64-linux-gnu/libxcb-xfixes.so.0.0.0
-7efb9a437000-7efb9a438000 rw-p 00006000 08:05 4201940 /usr/lib/x86_64-linux-gnu/libxcb-xfixes.so.0.0.0
-7efb9a438000-7efb9a45e000 r-xp 00000000 08:05 4461465 /usr/lib/x86_64-linux-gnu/mesa-egl/libEGL.so.1.0.0
-7efb9a45e000-7efb9a65e000 ---p 00026000 08:05 4461465 /usr/lib/x86_64-linux-gnu/mesa-egl/libEGL.so.1.0.0
-7efb9a65e000-7efb9a65f000 r--p 00026000 08:05 4461465 /usr/lib/x86_64-linux-gnu/mesa-egl/libEGL.so.1.0.0
-7efb9a65f000-7efb9a660000 rw-p 00027000 08:05 4461465 /usr/lib/x86_64-linux-gnu/mesa-egl/libEGL.so.1.0.0
-7efb9a660000-7efb9a706000 r-xp 00000000 08:05 4206971 /usr/lib/jni/libjogl_desktop.so
-7efb9a706000-7efb9a905000 ---p 000a6000 08:05 4206971 /usr/lib/jni/libjogl_desktop.so
-7efb9a905000-7efb9a906000 r--p 000a5000 08:05 4206971 /usr/lib/jni/libjogl_desktop.so
-7efb9a906000-7efb9a907000 rw-p 000a6000 08:05 4206971 /usr/lib/jni/libjogl_desktop.so
-7efb9a907000-7efb9a913000 r-xp 00000000 08:05 4201212 /usr/lib/x86_64-linux-gnu/libdrm.so.2.4.0
-7efb9a913000-7efb9ab12000 ---p 0000c000 08:05 4201212 /usr/lib/x86_64-linux-gnu/libdrm.so.2.4.0
-7efb9ab12000-7efb9ab13000 r--p 0000b000 08:05 4201212 /usr/lib/x86_64-linux-gnu/libdrm.so.2.4.0
-7efb9ab13000-7efb9ab14000 rw-p 0000c000 08:05 4201212 /usr/lib/x86_64-linux-gnu/libdrm.so.2.4.0
-7efb9ab14000-7efb9ab15000 r-xp 00000000 08:05 4201971 /usr/lib/x86_64-linux-gnu/libxshmfence.so.1.0.0
-7efb9ab15000-7efb9ad14000 ---p 00001000 08:05 4201971 /usr/lib/x86_64-linux-gnu/libxshmfence.so.1.0.0
-7efb9ad14000-7efb9ad15000 r--p 00000000 08:05 4201971 /usr/lib/x86_64-linux-gnu/libxshmfence.so.1.0.0
-7efb9ad15000-7efb9ad16000 rw-p 00001000 08:05 4201971 /usr/lib/x86_64-linux-gnu/libxshmfence.so.1.0.0
-7efb9ad16000-7efb9ad1b000 r-xp 00000000 08:05 4201936 /usr/lib/x86_64-linux-gnu/libxcb-sync.so.1.0.0
-7efb9ad1b000-7efb9af1a000 ---p 00005000 08:05 4201936 /usr/lib/x86_64-linux-gnu/libxcb-sync.so.1.0.0
-7efb9af1a000-7efb9af1b000 r--p 00004000 08:05 4201936 /usr/lib/x86_64-linux-gnu/libxcb-sync.so.1.0.0
-7efb9af1b000-7efb9af1c000 rw-p 00005000 08:05 4201936 /usr/lib/x86_64-linux-gnu/libxcb-sync.so.1.0.0
-7efb9af1c000-7efb9af1e000 r-xp 00000000 08:05 4201928 /usr/lib/x86_64-linux-gnu/libxcb-present.so.0.0.0
-7efb9af1e000-7efb9b11d000 ---p 00002000 08:05 4201928 /usr/lib/x86_64-linux-gnu/libxcb-present.so.0.0.0
-7efb9b11d000-7efb9b11e000 r--p 00001000 08:05 4201928 /usr/lib/x86_64-linux-gnu/libxcb-present.so.0.0.0
-7efb9b11e000-7efb9b11f000 rw-p 00002000 08:05 4201928 /usr/lib/x86_64-linux-gnu/libxcb-present.so.0.0.0
-7efb9b11f000-7efb9b121000 r-xp 00000000 08:05 4201924 /usr/lib/x86_64-linux-gnu/libxcb-dri3.so.0.0.0
-7efb9b121000-7efb9b320000 ---p 00002000 08:05 4201924 /usr/lib/x86_64-linux-gnu/libxcb-dri3.so.0.0.0
-7efb9b320000-7efb9b321000 r--p 00001000 08:05 4201924 /usr/lib/x86_64-linux-gnu/libxcb-dri3.so.0.0.0
-7efb9b321000-7efb9b322000 rw-p 00002000 08:05 4201924 /usr/lib/x86_64-linux-gnu/libxcb-dri3.so.0.0.0
-7efb9b322000-7efb9b325000 r-xp 00000000 08:05 4201922 /usr/lib/x86_64-linux-gnu/libxcb-dri2.so.0.0.0
-7efb9b325000-7efb9b525000 ---p 00003000 08:05 4201922 /usr/lib/x86_64-linux-gnu/libxcb-dri2.so.0.0.0
-7efb9b525000-7efb9b526000 r--p 00003000 08:05 4201922 /usr/lib/x86_64-linux-gnu/libxcb-dri2.so.0.0.0
-7efb9b526000-7efb9b527000 rw-p 00004000 08:05 4201922 /usr/lib/x86_64-linux-gnu/libxcb-dri2.so.0.0.0
-7efb9b527000-7efb9b53c000 r-xp 00000000 08:05 4201926 /usr/lib/x86_64-linux-gnu/libxcb-glx.so.0.0.0
-7efb9b53c000-7efb9b73b000 ---p 00015000 08:05 4201926 /usr/lib/x86_64-linux-gnu/libxcb-glx.so.0.0.0
-7efb9b73b000-7efb9b73d000 r--p 00014000 08:05 4201926 /usr/lib/x86_64-linux-gnu/libxcb-glx.so.0.0.0
-7efb9b73d000-7efb9b73e000 rw-p 00016000 08:05 4201926 /usr/lib/x86_64-linux-gnu/libxcb-glx.so.0.0.0
-7efb9b73e000-7efb9b73f000 r-xp 00000000 08:05 4200984 /usr/lib/x86_64-linux-gnu/libX11-xcb.so.1.0.0
-7efb9b73f000-7efb9b93e000 ---p 00001000 08:05 4200984 /usr/lib/x86_64-linux-gnu/libX11-xcb.so.1.0.0
-7efb9b93e000-7efb9b93f000 r--p 00000000 08:05 4200984 /usr/lib/x86_64-linux-gnu/libX11-xcb.so.1.0.0
-7efb9b93f000-7efb9b940000 rw-p 00001000 08:05 4200984 /usr/lib/x86_64-linux-gnu/libX11-xcb.so.1.0.0
-7efb9b940000-7efb9b942000 r-xp 00000000 08:05 4200999 /usr/lib/x86_64-linux-gnu/libXdamage.so.1.1.0
-7efb9b942000-7efb9bb41000 ---p 00002000 08:05 4200999 /usr/lib/x86_64-linux-gnu/libXdamage.so.1.1.0
-7efb9bb41000-7efb9bb42000 r--p 00001000 08:05 4200999 /usr/lib/x86_64-linux-gnu/libXdamage.so.1.1.0
-7efb9bb42000-7efb9bb43000 rw-p 00002000 08:05 4200999 /usr/lib/x86_64-linux-gnu/libXdamage.so.1.1.0
-7efb9bb43000-7efb9bb6c000 r-xp 00000000 08:05 4201329 /usr/lib/x86_64-linux-gnu/libglapi.so.0.0.0
-7efb9bb6c000-7efb9bd6b000 ---p 00029000 08:05 4201329 /usr/lib/x86_64-linux-gnu/libglapi.so.0.0.0
-7efb9bd6b000-7efb9bd6f000 r--p 00028000 08:05 4201329 /usr/lib/x86_64-linux-gnu/libglapi.so.0.0.0
-7efb9bd6f000-7efb9bd70000 rw-p 0002c000 08:05 4201329 /usr/lib/x86_64-linux-gnu/libglapi.so.0.0.0
-7efb9bd70000-7efb9bd71000 rw-p 00000000 00:00 0
-7efb9bd71000-7efb9bdfb000 r-xp 00000000 08:05 4461462 /usr/lib/x86_64-linux-gnu/mesa/libGL.so.1.2.0
-7efb9bdfb000-7efb9bffb000 ---p 0008a000 08:05 4461462 /usr/lib/x86_64-linux-gnu/mesa/libGL.so.1.2.0
-7efb9bffb000-7efb9bffe000 r--p 0008a000 08:05 4461462 /usr/lib/x86_64-linux-gnu/mesa/libGL.so.1.2.0
-7efb9bffe000-7efb9bfff000 rw-p 0008d000 08:05 4461462 /usr/lib/x86_64-linux-gnu/mesa/libGL.so.1.2.0
-7efb9bfff000-7efb9c000000 rw-p 00000000 00:00 0
-7efb9c000000-7efb9d4be000 rw-p 00000000 00:00 0
-7efb9d4be000-7efba0000000 ---p 00000000 00:00 0
-7efba0000000-7efba0021000 rw-p 00000000 00:00 0
-7efba0021000-7efba4000000 ---p 00000000 00:00 0
-7efba4000000-7efba4021000 rw-p 00000000 00:00 0
-7efba4021000-7efba8000000 ---p 00000000 00:00 0
-7efba8000000-7efba8021000 rw-p 00000000 00:00 0
-7efba8021000-7efbac000000 ---p 00000000 00:00 0
-7efbac000000-7efbac021000 rw-p 00000000 00:00 0
-7efbac021000-7efbb0000000 ---p 00000000 00:00 0
-7efbb0000000-7efbb0021000 rw-p 00000000 00:00 0
-7efbb0021000-7efbb4000000 ---p 00000000 00:00 0
-7efbb4000000-7efbb54a0000 rw-p 00000000 00:00 0
-7efbb54a0000-7efbb8000000 ---p 00000000 00:00 0
-7efbb8000000-7efbb8f6a000 rw-p 00000000 00:00 0
-7efbb8f6a000-7efbbc000000 ---p 00000000 00:00 0
-7efbbc000000-7efbbc021000 rw-p 00000000 00:00 0
-7efbbc021000-7efbc0000000 ---p 00000000 00:00 0
-7efbc0000000-7efbc0021000 rw-p 00000000 00:00 0
-7efbc0021000-7efbc4000000 ---p 00000000 00:00 0
-7efbc4000000-7efbc40b9000 rw-p 00000000 00:00 0
-7efbc40b9000-7efbc8000000 ---p 00000000 00:00 0
-7efbc8000000-7efbc8021000 rw-p 00000000 00:00 0
-7efbc8021000-7efbcc000000 ---p 00000000 00:00 0
-7efbcc000000-7efbcc021000 rw-p 00000000 00:00 0
-7efbcc021000-7efbd0000000 ---p 00000000 00:00 0
-7efbd0000000-7efbd0021000 rw-p 00000000 00:00 0
-7efbd0021000-7efbd4000000 ---p 00000000 00:00 0
-7efbd4000000-7efbd4021000 rw-p 00000000 00:00 0
-7efbd4021000-7efbd8000000 ---p 00000000 00:00 0
-7efbd8000000-7efbd8004000 r--s 00000000 08:05 2752602 /var/cache/fontconfig/c57959a16110560c8d0fcea73374aeeb-le64.cache-4
-7efbd8004000-7efbd800f000 r--s 00000000 08:05 2752604 /var/cache/fontconfig/d589a48862398ed80a3d6066f4f56f4c-le64.cache-4
-7efbd8072000-7efbd8077000 rw-s 00000000 00:05 149127170 /SYSV00000000 (deleted)
-7efbd8077000-7efbd807a000 ---p 00000000 00:00 0
-7efbd807a000-7efbd8178000 rw-p 00000000 00:00 0 [stack:5938]
-7efbd8178000-7efbd817c000 r-xp 00000000 08:05 4201041 /usr/lib/x86_64-linux-gnu/libXxf86vm.so.1.0.0
-7efbd817c000-7efbd837c000 ---p 00004000 08:05 4201041 /usr/lib/x86_64-linux-gnu/libXxf86vm.so.1.0.0
-7efbd837c000-7efbd837d000 r--p 00004000 08:05 4201041 /usr/lib/x86_64-linux-gnu/libXxf86vm.so.1.0.0
-7efbd837d000-7efbd837e000 rw-p 00005000 08:05 4201041 /usr/lib/x86_64-linux-gnu/libXxf86vm.so.1.0.0
-7efbd837e000-7efbd8385000 r-xp 00000000 08:05 4206972 /usr/lib/jni/libnativewindow_x11.so
-7efbd8385000-7efbd8584000 ---p 00007000 08:05 4206972 /usr/lib/jni/libnativewindow_x11.so
-7efbd8584000-7efbd8585000 r--p 00006000 08:05 4206972 /usr/lib/jni/libnativewindow_x11.so
-7efbd8585000-7efbd8586000 rw-p 00007000 08:05 4206972 /usr/lib/jni/libnativewindow_x11.so
-7efbd8586000-7efbd8588000 r-xp 00000000 08:05 4206970 /usr/lib/jni/libnativewindow_awt.so
-7efbd8588000-7efbd8787000 ---p 00002000 08:05 4206970 /usr/lib/jni/libnativewindow_awt.so
-7efbd8787000-7efbd8788000 r--p 00001000 08:05 4206970 /usr/lib/jni/libnativewindow_awt.so
-7efbd8788000-7efbd8789000 rw-p 00002000 08:05 4206970 /usr/lib/jni/libnativewindow_awt.so
-7efbd8789000-7efbd878a000 r-xp 00000000 08:05 4599200 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjawt.so
-7efbd878a000-7efbd8989000 ---p 00001000 08:05 4599200 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjawt.so
-7efbd8989000-7efbd898a000 r--p 00000000 08:05 4599200 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjawt.so
-7efbd898a000-7efbd898b000 rw-p 00001000 08:05 4599200 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjawt.so
-7efbd898b000-7efbd898d000 r-xp 00000000 08:05 4206969 /usr/lib/jni/libgluegen2-rt.so
-7efbd898d000-7efbd8b8c000 ---p 00002000 08:05 4206969 /usr/lib/jni/libgluegen2-rt.so
-7efbd8b8c000-7efbd8b8d000 r--p 00001000 08:05 4206969 /usr/lib/jni/libgluegen2-rt.so
-7efbd8b8d000-7efbd8b8e000 rw-p 00002000 08:05 4206969 /usr/lib/jni/libgluegen2-rt.so
-7efbd8b8e000-7efbd8b91000 ---p 00000000 00:00 0
-7efbd8b91000-7efbd8c8f000 rw-p 00000000 00:00 0 [stack:5940]
-7efbd8c8f000-7efbd8c92000 ---p 00000000 00:00 0
-7efbd8c92000-7efbd8d90000 rw-p 00000000 00:00 0 [stack:5941]
-7efbd8d90000-7efbd8d93000 ---p 00000000 00:00 0
-7efbd8d93000-7efbd8e91000 rw-p 00000000 00:00 0 [stack:5935]
-7efbd8e91000-7efbd8e96000 r-xp 00000000 08:05 4201005 /usr/lib/x86_64-linux-gnu/libXfixes.so.3.1.0
-7efbd8e96000-7efbd9095000 ---p 00005000 08:05 4201005 /usr/lib/x86_64-linux-gnu/libXfixes.so.3.1.0
-7efbd9095000-7efbd9096000 r--p 00004000 08:05 4201005 /usr/lib/x86_64-linux-gnu/libXfixes.so.3.1.0
-7efbd9096000-7efbd9097000 rw-p 00005000 08:05 4201005 /usr/lib/x86_64-linux-gnu/libXfixes.so.3.1.0
-7efbd9097000-7efbd90a0000 r-xp 00000000 08:05 4200997 /usr/lib/x86_64-linux-gnu/libXcursor.so.1.0.2
-7efbd90a0000-7efbd929f000 ---p 00009000 08:05 4200997 /usr/lib/x86_64-linux-gnu/libXcursor.so.1.0.2
-7efbd929f000-7efbd92a0000 r--p 00008000 08:05 4200997 /usr/lib/x86_64-linux-gnu/libXcursor.so.1.0.2
-7efbd92a0000-7efbd92a1000 rw-p 00009000 08:05 4200997 /usr/lib/x86_64-linux-gnu/libXcursor.so.1.0.2
-7efbd92a1000-7efbd92a4000 ---p 00000000 00:00 0
-7efbd92a4000-7efbd93a2000 rw-p 00000000 00:00 0 [stack:5934]
-7efbd93a2000-7efbd93e6000 r-xp 00000000 08:05 4460973 /lib/x86_64-linux-gnu/libdbus-1.so.3.7.6
-7efbd93e6000-7efbd95e5000 ---p 00044000 08:05 4460973 /lib/x86_64-linux-gnu/libdbus-1.so.3.7.6
-7efbd95e5000-7efbd95e6000 r--p 00043000 08:05 4460973 /lib/x86_64-linux-gnu/libdbus-1.so.3.7.6
-7efbd95e6000-7efbd95e7000 rw-p 00044000 08:05 4460973 /lib/x86_64-linux-gnu/libdbus-1.so.3.7.6
-7efbd95e7000-7efbd9607000 r-xp 00000000 08:05 4461089 /lib/x86_64-linux-gnu/libselinux.so.1
-7efbd9607000-7efbd9806000 ---p 00020000 08:05 4461089 /lib/x86_64-linux-gnu/libselinux.so.1
-7efbd9806000-7efbd9807000 r--p 0001f000 08:05 4461089 /lib/x86_64-linux-gnu/libselinux.so.1
-7efbd9807000-7efbd9808000 rw-p 00020000 08:05 4461089 /lib/x86_64-linux-gnu/libselinux.so.1
-7efbd9808000-7efbd980a000 rw-p 00000000 00:00 0
-7efbd980a000-7efbd9910000 r-xp 00000000 08:05 4460990 /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0
-7efbd9910000-7efbd9b0f000 ---p 00106000 08:05 4460990 /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0
-7efbd9b0f000-7efbd9b10000 r--p 00105000 08:05 4460990 /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0
-7efbd9b10000-7efbd9b11000 rw-p 00106000 08:05 4460990 /lib/x86_64-linux-gnu/libglib-2.0.so.0.4002.0
-7efbd9b11000-7efbd9b12000 rw-p 00000000 00:00 0
-7efbd9b12000-7efbd9b15000 r-xp 00000000 08:05 4201335 /usr/lib/x86_64-linux-gnu/libgmodule-2.0.so.0.4002.0
-7efbd9b15000-7efbd9d14000 ---p 00003000 08:05 4201335 /usr/lib/x86_64-linux-gnu/libgmodule-2.0.so.0.4002.0
-7efbd9d14000-7efbd9d15000 r--p 00002000 08:05 4201335 /usr/lib/x86_64-linux-gnu/libgmodule-2.0.so.0.4002.0
-7efbd9d15000-7efbd9d16000 rw-p 00003000 08:05 4201335 /usr/lib/x86_64-linux-gnu/libgmodule-2.0.so.0.4002.0
-7efbd9d16000-7efbd9d25000 r-xp 00000000 08:05 4201087 /usr/lib/x86_64-linux-gnu/libavahi-client.so.3.2.9
-7efbd9d25000-7efbd9f25000 ---p 0000f000 08:05 4201087 /usr/lib/x86_64-linux-gnu/libavahi-client.so.3.2.9
-7efbd9f25000-7efbd9f26000 r--p 0000f000 08:05 4201087 /usr/lib/x86_64-linux-gnu/libavahi-client.so.3.2.9
-7efbd9f26000-7efbd9f27000 rw-p 00010000 08:05 4201087 /usr/lib/x86_64-linux-gnu/libavahi-client.so.3.2.9
-7efbd9f27000-7efbd9f32000 r-xp 00000000 08:05 4201089 /usr/lib/x86_64-linux-gnu/libavahi-common.so.3.5.3
-7efbd9f32000-7efbda131000 ---p 0000b000 08:05 4201089 /usr/lib/x86_64-linux-gnu/libavahi-common.so.3.5.3
-7efbda131000-7efbda132000 r--p 0000a000 08:05 4201089 /usr/lib/x86_64-linux-gnu/libavahi-common.so.3.5.3
-7efbda132000-7efbda133000 rw-p 0000b000 08:05 4201089 /usr/lib/x86_64-linux-gnu/libavahi-common.so.3.5.3
-7efbda133000-7efbda182000 r-xp 00000000 08:05 4201347 /usr/lib/x86_64-linux-gnu/libgobject-2.0.so.0.4002.0
-7efbda182000-7efbda382000 ---p 0004f000 08:05 4201347 /usr/lib/x86_64-linux-gnu/libgobject-2.0.so.0.4002.0
-7efbda382000-7efbda383000 r--p 0004f000 08:05 4201347 /usr/lib/x86_64-linux-gnu/libgobject-2.0.so.0.4002.0
-7efbda383000-7efbda384000 rw-p 00050000 08:05 4201347 /usr/lib/x86_64-linux-gnu/libgobject-2.0.so.0.4002.0
-7efbda384000-7efbda4f0000 r-xp 00000000 08:05 4201325 /usr/lib/x86_64-linux-gnu/libgio-2.0.so.0.4002.0
-7efbda4f0000-7efbda6ef000 ---p 0016c000 08:05 4201325 /usr/lib/x86_64-linux-gnu/libgio-2.0.so.0.4002.0
-7efbda6ef000-7efbda6f3000 r--p 0016b000 08:05 4201325 /usr/lib/x86_64-linux-gnu/libgio-2.0.so.0.4002.0
-7efbda6f3000-7efbda6f5000 rw-p 0016f000 08:05 4201325 /usr/lib/x86_64-linux-gnu/libgio-2.0.so.0.4002.0
-7efbda6f5000-7efbda6f7000 rw-p 00000000 00:00 0
-7efbda6f7000-7efbda763000 r-xp 00000000 08:05 4201163 /usr/lib/x86_64-linux-gnu/libcups.so.2
-7efbda763000-7efbda963000 ---p 0006c000 08:05 4201163 /usr/lib/x86_64-linux-gnu/libcups.so.2
-7efbda963000-7efbda96a000 r--p 0006c000 08:05 4201163 /usr/lib/x86_64-linux-gnu/libcups.so.2
-7efbda96a000-7efbda96b000 rw-p 00073000 08:05 4201163 /usr/lib/x86_64-linux-gnu/libcups.so.2
-7efbda96b000-7efbda97a000 r-xp 00000000 08:05 4201011 /usr/lib/x86_64-linux-gnu/libXi.so.6.1.0
-7efbda97a000-7efbdab79000 ---p 0000f000 08:05 4201011 /usr/lib/x86_64-linux-gnu/libXi.so.6.1.0
-7efbdab79000-7efbdab7a000 r--p 0000e000 08:05 4201011 /usr/lib/x86_64-linux-gnu/libXi.so.6.1.0
-7efbdab7a000-7efbdab7b000 rw-p 0000f000 08:05 4201011 /usr/lib/x86_64-linux-gnu/libXi.so.6.1.0
-7efbdab7b000-7efbdab80000 r-xp 00000000 08:05 4201031 /usr/lib/x86_64-linux-gnu/libXtst.so.6.1.0
-7efbdab80000-7efbdad7f000 ---p 00005000 08:05 4201031 /usr/lib/x86_64-linux-gnu/libXtst.so.6.1.0
-7efbdad7f000-7efbdad80000 r--p 00004000 08:05 4201031 /usr/lib/x86_64-linux-gnu/libXtst.so.6.1.0
-7efbdad80000-7efbdad81000 rw-p 00005000 08:05 4201031 /usr/lib/x86_64-linux-gnu/libXtst.so.6.1.0
-7efbdad81000-7efbdad82000 r--s 00000000 08:05 2752587 /var/cache/fontconfig/4794a0821666d79190d59a36cb4f44b5-le64.cache-4
-7efbdad82000-7efbdad83000 r--s 00000000 08:05 2752589 /var/cache/fontconfig/56cf4f4769d0f4abc89a4895d7bd3ae1-le64.cache-4
-7efbdad83000-7efbdad84000 r--s 00000000 08:05 2752601 /var/cache/fontconfig/b9d506c9ac06c20b433354fa67a72993-le64.cache-4
-7efbdad84000-7efbdad85000 r--s 00000000 08:05 2752578 /var/cache/fontconfig/0c9eb80ebd1c36541ebe2852d3bb0c49-le64.cache-4
-7efbdad85000-7efbdad88000 r--s 00000000 08:05 2760273 /var/cache/fontconfig/e13b20fdb08344e0e664864cc2ede53d-le64.cache-4
-7efbdad88000-7efbdad8c000 r--s 00000000 08:05 2760274 /var/cache/fontconfig/7ef2298fde41cc6eeb7af42e48b7d293-le64.cache-4
-7efbdad90000-7efbdad91000 rw-s 00000000 00:05 343574 /dev/zero (deleted)
-7efbdad95000-7efbdad96000 rwxp 00000000 00:00 0
-7efbdad96000-7efbdadde000 r-xp 00000000 08:05 4599286 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/xawt/libmawt.so
-7efbdadde000-7efbdafdd000 ---p 00048000 08:05 4599286 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/xawt/libmawt.so
-7efbdafdd000-7efbdafde000 r--p 00047000 08:05 4599286 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/xawt/libmawt.so
-7efbdafde000-7efbdafe1000 rw-p 00048000 08:05 4599286 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/xawt/libmawt.so
-7efbdafe1000-7efbdafe2000 rw-p 00000000 00:00 0
-7efbdafe2000-7efbdb082000 r-xp 00000000 08:05 4599202 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libawt.so
-7efbdb082000-7efbdb282000 ---p 000a0000 08:05 4599202 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libawt.so
-7efbdb282000-7efbdb283000 r--p 000a0000 08:05 4599202 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libawt.so
-7efbdb283000-7efbdb28e000 rw-p 000a1000 08:05 4599202 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libawt.so
-7efbdb28e000-7efbdb2b3000 rw-p 00000000 00:00 0
-7efbdb2b3000-7efbdb2be000 r--s 00203000 08:05 4465720 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/charsets.jar
-7efbdb2be000-7efbdb2c8000 r--s 000ae000 08:05 4465736 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/resources.jar
-7efbdb2c8000-7efbdb2ca000 r--s 0000b000 08:05 1448381 /usr/share/scilab/modules/external_objects_java/jar/org.scilab.modules.external_objects_java.jar
-7efbdb2ca000-7efbdb2cb000 r--s 00007000 08:05 415924 /usr/share/scilab/modules/history_browser/jar/org.scilab.modules.history_browser.jar
-7efbdb2cb000-7efbdb2d2000 r--s 00036000 08:05 1583078 /usr/share/scilab/modules/ui_data/jar/org.scilab.modules.ui_data.jar
-7efbdb2d2000-7efbdb2da000 r--s 00047000 08:05 560998 /usr/share/scilab/modules/graphic_objects/jar/org.scilab.modules.graphic_objects.jar
-7efbdb2da000-7efbdb2f3000 r--s 000cb000 08:05 1976357 /usr/share/scilab/modules/gui/jar/org.scilab.modules.gui.jar
-7efbdb2f3000-7efbdb2f4000 ---p 00000000 00:00 0
-7efbdb2f4000-7efbdb3f4000 rw-p 00000000 00:00 0 [stack:5933]
-7efbdb3f4000-7efbdb3f7000 ---p 00000000 00:00 0
-7efbdb3f7000-7efbdb4f5000 rw-p 00000000 00:00 0 [stack:5932]
-7efbdb4f5000-7efbdb4f8000 ---p 00000000 00:00 0
-7efbdb4f8000-7efbdb5f6000 rw-p 00000000 00:00 0 [stack:5931]
-7efbdb5f6000-7efbdb5f9000 ---p 00000000 00:00 0
-7efbdb5f9000-7efbdb6f7000 rw-p 00000000 00:00 0 [stack:5930]
-7efbdb6f7000-7efbdb6fa000 ---p 00000000 00:00 0
-7efbdb6fa000-7efbdb7f8000 rw-p 00000000 00:00 0 [stack:5929]
-7efbdb7f8000-7efbdb7fb000 ---p 00000000 00:00 0
-7efbdb7fb000-7efbdb8f9000 rw-p 00000000 00:00 0 [stack:5928]
-7efbdb8f9000-7efbdb8fc000 ---p 00000000 00:00 0
-7efbdb8fc000-7efbdb9fa000 rw-p 00000000 00:00 0 [stack:5927]
-7efbdb9fa000-7efbdb9fb000 ---p 00000000 00:00 0
-7efbdb9fb000-7efbdc000000 rw-p 00000000 00:00 0 [stack:5926]
-7efbdc000000-7efbdc021000 rw-p 00000000 00:00 0
-7efbdc021000-7efbe0000000 ---p 00000000 00:00 0
-7efbe0000000-7efbe0002000 r--s 00002000 08:05 560175 /usr/share/scilab/modules/javasci/jar/org.scilab.modules.javasci.jar
-7efbe0002000-7efbe0003000 r--s 00002000 08:05 560983 /usr/share/scilab/modules/core/jar/org.scilab.modules.core.jar
-7efbe0003000-7efbe0005000 r--s 00007000 08:05 1975476 /usr/share/scilab/modules/graphic_export/jar/org.scilab.modules.graphic_export.jar
-7efbe0005000-7efbe000a000 r--s 00025000 08:05 417215 /usr/share/scilab/modules/renderer/jar/org.scilab.modules.renderer.jar
-7efbe000a000-7efbe000d000 r--s 00015000 08:05 560142 /usr/share/scilab/modules/preferences/jar/org.scilab.modules.preferences.jar
-7efbe000d000-7efbe000e000 r--s 00002000 08:05 560123 /usr/share/scilab/modules/action_binding/jar/org.scilab.modules.action_binding.jar
-7efbe000e000-7efbe0010000 r--s 00000000 08:05 1186531 /usr/share/scilab/modules/localization/jar/org.scilab.modules.localization.jar
-7efbe0010000-7efbe0013000 r--s 0000f000 08:05 1976098 /usr/share/scilab/modules/console/jar/org.scilab.modules.console.jar
-7efbe0013000-7efbe0015000 r--s 00000000 08:05 561478 /usr/share/scilab/modules/history_manager/jar/org.scilab.modules.history_manager.jar
-7efbe0015000-7efbe0018000 r--s 0000a000 08:05 1583172 /usr/share/scilab/modules/commons/jar/org.scilab.modules.commons.jar
-7efbe0018000-7efbe001a000 r--s 0000a000 08:05 1848290 /usr/share/scilab/modules/types/jar/org.scilab.modules.types.jar
-7efbe001a000-7efbe0020000 r--s 00041000 08:05 4738732 /usr/share/java/gluegen2-2.1.5-rt.jar
-7efbe0020000-7efbe0041000 r--s 002c7000 08:05 4738750 /usr/share/java/jogl2.jar
-7efbe0041000-7efbe0048000 r--s 0002a000 08:05 1976451 /usr/share/scilab/modules/scirenderer/jar/scirenderer.jar
-7efbe0048000-7efbe0051000 r--s 0008e000 08:05 4738669 /usr/share/java/jhall-2.0.05.ds1.jar
-7efbe0051000-7efbe0054000 r--s 00010000 08:05 4738597 /usr/share/java/avalon-framework-4.2.0.jar
-7efbe0054000-7efbe0055000 r--s 0000d000 08:05 4738602 /usr/share/java/commons-logging-1.1.3.jar
-7efbe0055000-7efbe0057000 r--s 00006000 08:05 4738736 /usr/share/java/jgoodies-common.jar
-7efbe0057000-7efbe0060000 r--s 00057000 08:05 4738738 /usr/share/java/jgoodies-looks.jar
-7efbe0060000-7efbe0061000 r--s 00004000 08:05 4738762 /usr/share/java/laf-plugin-1.0.jar
-7efbe0061000-7efbe0067000 r--s 00044000 08:05 4738764 /usr/share/java/skinlf-6.7.jar
-7efbe0067000-7efbe0070000 r--s 00062000 08:05 4738704 /usr/share/java/flexdock-1.2.4.jar
-7efbe0070000-7efbe0074000 r--s 00034000 08:05 4599236 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/ext/sunjce_provider.jar
-7efbe0074000-7efbe0076000 r--s 00006000 08:05 4738339 /usr/share/java/java-atk-wrapper.jar
-7efbe0076000-7efbe0078000 r--s 00012000 08:05 4599237 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/ext/zipfs.jar
-7efbe0078000-7efbe007b000 r--s 0000f000 08:05 4599240 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/ext/icedtea-sound.jar
-7efbe007b000-7efbe007f000 r--s 00085000 08:05 4599235 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/ext/localedata.jar
-7efbe007f000-7efbe0083000 r--s 0003c000 08:05 4599238 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/ext/sunpkcs11.jar
-7efbe0083000-7efbe0b5a000 rw-p 00000000 00:00 0
-7efbe0b5a000-7efbe0d0c000 r--s 01d2f000 08:05 4465740 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/rt.jar
-7efbe0d0c000-7efbe1be0000 rw-p 00000000 00:00 0
-7efbe1be0000-7efbe1be1000 ---p 00000000 00:00 0
-7efbe1be1000-7efbe1ce1000 rw-p 00000000 00:00 0 [stack:5925]
-7efbe1ce1000-7efbe1ce2000 ---p 00000000 00:00 0
-7efbe1ce2000-7efbe1de2000 rw-p 00000000 00:00 0 [stack:5924]
-7efbe1de2000-7efbe1de3000 ---p 00000000 00:00 0
-7efbe1de3000-7efbe1ee3000 rw-p 00000000 00:00 0 [stack:5923]
-7efbe1ee3000-7efbe1ee4000 ---p 00000000 00:00 0
-7efbe1ee4000-7efbe200a000 rw-p 00000000 00:00 0 [stack:5922]
-7efbe200a000-7efbe2037000 rw-p 00000000 00:00 0
-7efbe2037000-7efbe2067000 rw-p 00000000 00:00 0
-7efbe2067000-7efbe208d000 rw-p 00000000 00:00 0
-7efbe208d000-7efbe24ad000 rwxp 00000000 00:00 0
-7efbe24ad000-7efbe508d000 rw-p 00000000 00:00 0
-7efbe508d000-7efbe5095000 r-xp 00000000 08:05 4599204 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libzip.so
-7efbe5095000-7efbe5294000 ---p 00008000 08:05 4599204 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libzip.so
-7efbe5294000-7efbe5295000 r--p 00007000 08:05 4599204 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libzip.so
-7efbe5295000-7efbe5296000 rw-p 00008000 08:05 4599204 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libzip.so
-7efbe5296000-7efbe52a1000 r-xp 00000000 08:05 4461034 /lib/x86_64-linux-gnu/libnss_files-2.19.so
-7efbe52a1000-7efbe54a0000 ---p 0000b000 08:05 4461034 /lib/x86_64-linux-gnu/libnss_files-2.19.so
-7efbe54a0000-7efbe54a1000 r--p 0000a000 08:05 4461034 /lib/x86_64-linux-gnu/libnss_files-2.19.so
-7efbe54a1000-7efbe54a2000 rw-p 0000b000 08:05 4461034 /lib/x86_64-linux-gnu/libnss_files-2.19.so
-7efbe54a2000-7efbe54ad000 r-xp 00000000 08:05 4461044 /lib/x86_64-linux-gnu/libnss_nis-2.19.so
-7efbe54ad000-7efbe56ac000 ---p 0000b000 08:05 4461044 /lib/x86_64-linux-gnu/libnss_nis-2.19.so
-7efbe56ac000-7efbe56ad000 r--p 0000a000 08:05 4461044 /lib/x86_64-linux-gnu/libnss_nis-2.19.so
-7efbe56ad000-7efbe56ae000 rw-p 0000b000 08:05 4461044 /lib/x86_64-linux-gnu/libnss_nis-2.19.so
-7efbe56ae000-7efbe56c5000 r-xp 00000000 08:05 4461028 /lib/x86_64-linux-gnu/libnsl-2.19.so
-7efbe56c5000-7efbe58c4000 ---p 00017000 08:05 4461028 /lib/x86_64-linux-gnu/libnsl-2.19.so
-7efbe58c4000-7efbe58c5000 r--p 00016000 08:05 4461028 /lib/x86_64-linux-gnu/libnsl-2.19.so
-7efbe58c5000-7efbe58c6000 rw-p 00017000 08:05 4461028 /lib/x86_64-linux-gnu/libnsl-2.19.so
-7efbe58c6000-7efbe58c8000 rw-p 00000000 00:00 0
-7efbe58c8000-7efbe58d1000 r-xp 00000000 08:05 4461030 /lib/x86_64-linux-gnu/libnss_compat-2.19.so
-7efbe58d1000-7efbe5ad0000 ---p 00009000 08:05 4461030 /lib/x86_64-linux-gnu/libnss_compat-2.19.so
-7efbe5ad0000-7efbe5ad1000 r--p 00008000 08:05 4461030 /lib/x86_64-linux-gnu/libnss_compat-2.19.so
-7efbe5ad1000-7efbe5ad2000 rw-p 00009000 08:05 4461030 /lib/x86_64-linux-gnu/libnss_compat-2.19.so
-7efbe5ad2000-7efbe5ad9000 r-xp 00000000 08:05 4461087 /lib/x86_64-linux-gnu/librt-2.19.so
-7efbe5ad9000-7efbe5cd8000 ---p 00007000 08:05 4461087 /lib/x86_64-linux-gnu/librt-2.19.so
-7efbe5cd8000-7efbe5cd9000 r--p 00006000 08:05 4461087 /lib/x86_64-linux-gnu/librt-2.19.so
-7efbe5cd9000-7efbe5cda000 rw-p 00007000 08:05 4461087 /lib/x86_64-linux-gnu/librt-2.19.so
-7efbe5cda000-7efbe66a8000 r--p 00000000 08:05 4199145 /usr/lib/locale/locale-archive
-7efbe66a8000-7efbe66b1000 r-xp 00000000 08:05 4460969 /lib/x86_64-linux-gnu/libcrypt-2.19.so
-7efbe66b1000-7efbe68b1000 ---p 00009000 08:05 4460969 /lib/x86_64-linux-gnu/libcrypt-2.19.so
-7efbe68b1000-7efbe68b2000 r--p 00009000 08:05 4460969 /lib/x86_64-linux-gnu/libcrypt-2.19.so
-7efbe68b2000-7efbe68b3000 rw-p 0000a000 08:05 4460969 /lib/x86_64-linux-gnu/libcrypt-2.19.so
-7efbe68b3000-7efbe68e1000 rw-p 00000000 00:00 0
-7efbe68e1000-7efbe6995000 r-xp 00000000 08:05 4201799 /usr/lib/x86_64-linux-gnu/libsqlite3.so.0.8.6
-7efbe6995000-7efbe6b95000 ---p 000b4000 08:05 4201799 /usr/lib/x86_64-linux-gnu/libsqlite3.so.0.8.6
-7efbe6b95000-7efbe6b97000 r--p 000b4000 08:05 4201799 /usr/lib/x86_64-linux-gnu/libsqlite3.so.0.8.6
-7efbe6b97000-7efbe6b99000 rw-p 000b6000 08:05 4201799 /usr/lib/x86_64-linux-gnu/libsqlite3.so.0.8.6
-7efbe6b99000-7efbe6b9a000 rw-p 00000000 00:00 0
-7efbe6b9a000-7efbe6bdf000 r-xp 00000000 08:05 4201481 /usr/lib/x86_64-linux-gnu/libhx509.so.5.0.0
-7efbe6bdf000-7efbe6dde000 ---p 00045000 08:05 4201481 /usr/lib/x86_64-linux-gnu/libhx509.so.5.0.0
-7efbe6dde000-7efbe6de0000 r--p 00044000 08:05 4201481 /usr/lib/x86_64-linux-gnu/libhx509.so.5.0.0
-7efbe6de0000-7efbe6de2000 rw-p 00046000 08:05 4201481 /usr/lib/x86_64-linux-gnu/libhx509.so.5.0.0
-7efbe6de2000-7efbe6de3000 rw-p 00000000 00:00 0
-7efbe6de3000-7efbe6df0000 r-xp 00000000 08:05 4201475 /usr/lib/x86_64-linux-gnu/libheimbase.so.1.0.0
-7efbe6df0000-7efbe6fef000 ---p 0000d000 08:05 4201475 /usr/lib/x86_64-linux-gnu/libheimbase.so.1.0.0
-7efbe6fef000-7efbe6ff0000 r--p 0000c000 08:05 4201475 /usr/lib/x86_64-linux-gnu/libheimbase.so.1.0.0
-7efbe6ff0000-7efbe6ff1000 rw-p 0000d000 08:05 4201475 /usr/lib/x86_64-linux-gnu/libheimbase.so.1.0.0
-7efbe6ff1000-7efbe7018000 r-xp 00000000 08:05 4201909 /usr/lib/x86_64-linux-gnu/libwind.so.0.0.0
-7efbe7018000-7efbe7218000 ---p 00027000 08:05 4201909 /usr/lib/x86_64-linux-gnu/libwind.so.0.0.0
-7efbe7218000-7efbe7219000 r--p 00027000 08:05 4201909 /usr/lib/x86_64-linux-gnu/libwind.so.0.0.0
-7efbe7219000-7efbe721a000 rw-p 00028000 08:05 4201909 /usr/lib/x86_64-linux-gnu/libwind.so.0.0.0
-7efbe721a000-7efbe7221000 r-xp 00000000 08:05 4201252 /usr/lib/x86_64-linux-gnu/libffi.so.6.0.1
-7efbe7221000-7efbe7420000 ---p 00007000 08:05 4201252 /usr/lib/x86_64-linux-gnu/libffi.so.6.0.1
-7efbe7420000-7efbe7421000 r--p 00006000 08:05 4201252 /usr/lib/x86_64-linux-gnu/libffi.so.6.0.1
-7efbe7421000-7efbe7422000 rw-p 00007000 08:05 4201252 /usr/lib/x86_64-linux-gnu/libffi.so.6.0.1
-7efbe7422000-7efbe7436000 r-xp 00000000 08:05 4201735 /usr/lib/x86_64-linux-gnu/libroken.so.18.1.0
-7efbe7436000-7efbe7635000 ---p 00014000 08:05 4201735 /usr/lib/x86_64-linux-gnu/libroken.so.18.1.0
-7efbe7635000-7efbe7636000 r--p 00013000 08:05 4201735 /usr/lib/x86_64-linux-gnu/libroken.so.18.1.0
-7efbe7636000-7efbe7637000 rw-p 00014000 08:05 4201735 /usr/lib/x86_64-linux-gnu/libroken.so.18.1.0
-7efbe7637000-7efbe7667000 r-xp 00000000 08:05 4201473 /usr/lib/x86_64-linux-gnu/libhcrypto.so.4.1.0
-7efbe7667000-7efbe7867000 ---p 00030000 08:05 4201473 /usr/lib/x86_64-linux-gnu/libhcrypto.so.4.1.0
-7efbe7867000-7efbe7868000 r--p 00030000 08:05 4201473 /usr/lib/x86_64-linux-gnu/libhcrypto.so.4.1.0
-7efbe7868000-7efbe7869000 rw-p 00031000 08:05 4201473 /usr/lib/x86_64-linux-gnu/libhcrypto.so.4.1.0
-7efbe7869000-7efbe786a000 rw-p 00000000 00:00 0
-7efbe786a000-7efbe7907000 r-xp 00000000 08:05 4201067 /usr/lib/x86_64-linux-gnu/libasn1.so.8.0.0
-7efbe7907000-7efbe7b07000 ---p 0009d000 08:05 4201067 /usr/lib/x86_64-linux-gnu/libasn1.so.8.0.0
-7efbe7b07000-7efbe7b08000 r--p 0009d000 08:05 4201067 /usr/lib/x86_64-linux-gnu/libasn1.so.8.0.0
-7efbe7b08000-7efbe7b0b000 rw-p 0009e000 08:05 4201067 /usr/lib/x86_64-linux-gnu/libasn1.so.8.0.0
-7efbe7b0b000-7efbe7b8d000 r-xp 00000000 08:05 4201533 /usr/lib/x86_64-linux-gnu/libkrb5.so.26.0.0
-7efbe7b8d000-7efbe7d8c000 ---p 00082000 08:05 4201533 /usr/lib/x86_64-linux-gnu/libkrb5.so.26.0.0
-7efbe7d8c000-7efbe7d8f000 r--p 00081000 08:05 4201533 /usr/lib/x86_64-linux-gnu/libkrb5.so.26.0.0
-7efbe7d8f000-7efbe7d92000 rw-p 00084000 08:05 4201533 /usr/lib/x86_64-linux-gnu/libkrb5.so.26.0.0
-7efbe7d92000-7efbe7d93000 rw-p 00000000 00:00 0
-7efbe7d93000-7efbe7d9b000 r-xp 00000000 08:05 4201477 /usr/lib/x86_64-linux-gnu/libheimntlm.so.0.1.0
-7efbe7d9b000-7efbe7f9a000 ---p 00008000 08:05 4201477 /usr/lib/x86_64-linux-gnu/libheimntlm.so.0.1.0
-7efbe7f9a000-7efbe7f9b000 r--p 00007000 08:05 4201477 /usr/lib/x86_64-linux-gnu/libheimntlm.so.0.1.0
-7efbe7f9b000-7efbe7f9c000 rw-p 00008000 08:05 4201477 /usr/lib/x86_64-linux-gnu/libheimntlm.so.0.1.0
-7efbe7f9c000-7efbe7f9e000 r-xp 00000000 08:05 4461002 /lib/x86_64-linux-gnu/libkeyutils.so.1.4
-7efbe7f9e000-7efbe819e000 ---p 00002000 08:05 4461002 /lib/x86_64-linux-gnu/libkeyutils.so.1.4
-7efbe819e000-7efbe819f000 r--p 00002000 08:05 4461002 /lib/x86_64-linux-gnu/libkeyutils.so.1.4
-7efbe819f000-7efbe81a0000 rw-p 00003000 08:05 4461002 /lib/x86_64-linux-gnu/libkeyutils.so.1.4
-7efbe81a0000-7efbe81a4000 r-xp 00000000 08:05 4460992 /lib/x86_64-linux-gnu/libgpg-error.so.0.10.0
-7efbe81a4000-7efbe83a3000 ---p 00004000 08:05 4460992 /lib/x86_64-linux-gnu/libgpg-error.so.0.10.0
-7efbe83a3000-7efbe83a4000 r--p 00003000 08:05 4460992 /lib/x86_64-linux-gnu/libgpg-error.so.0.10.0
-7efbe83a4000-7efbe83a5000 rw-p 00004000 08:05 4460992 /lib/x86_64-linux-gnu/libgpg-error.so.0.10.0
-7efbe83a5000-7efbe83e0000 r-xp 00000000 08:05 4201648 /usr/lib/x86_64-linux-gnu/libp11-kit.so.0.0.0
-7efbe83e0000-7efbe85df000 ---p 0003b000 08:05 4201648 /usr/lib/x86_64-linux-gnu/libp11-kit.so.0.0.0
-7efbe85df000-7efbe85e5000 r--p 0003a000 08:05 4201648 /usr/lib/x86_64-linux-gnu/libp11-kit.so.0.0.0
-7efbe85e5000-7efbe85e7000 rw-p 00040000 08:05 4201648 /usr/lib/x86_64-linux-gnu/libp11-kit.so.0.0.0
-7efbe85e7000-7efbe85f9000 r-xp 00000000 08:05 4201813 /usr/lib/x86_64-linux-gnu/libtasn1.so.6.2.0
-7efbe85f9000-7efbe87f9000 ---p 00012000 08:05 4201813 /usr/lib/x86_64-linux-gnu/libtasn1.so.6.2.0
-7efbe87f9000-7efbe87fa000 r--p 00012000 08:05 4201813 /usr/lib/x86_64-linux-gnu/libtasn1.so.6.2.0
-7efbe87fa000-7efbe87fb000 rw-p 00013000 08:05 4201813 /usr/lib/x86_64-linux-gnu/libtasn1.so.6.2.0
-7efbe87fb000-7efbe8800000 r-xp 00000000 08:05 4201001 /usr/lib/x86_64-linux-gnu/libXdmcp.so.6.0.0
-7efbe8800000-7efbe89ff000 ---p 00005000 08:05 4201001 /usr/lib/x86_64-linux-gnu/libXdmcp.so.6.0.0
-7efbe89ff000-7efbe8a00000 r--p 00004000 08:05 4201001 /usr/lib/x86_64-linux-gnu/libXdmcp.so.6.0.0
-7efbe8a00000-7efbe8a01000 rw-p 00005000 08:05 4201001 /usr/lib/x86_64-linux-gnu/libXdmcp.so.6.0.0
-7efbe8a01000-7efbe8a03000 r-xp 00000000 08:05 4200990 /usr/lib/x86_64-linux-gnu/libXau.so.6.0.0
-7efbe8a03000-7efbe8c03000 ---p 00002000 08:05 4200990 /usr/lib/x86_64-linux-gnu/libXau.so.6.0.0
-7efbe8c03000-7efbe8c04000 r--p 00002000 08:05 4200990 /usr/lib/x86_64-linux-gnu/libXau.so.6.0.0
-7efbe8c04000-7efbe8c05000 rw-p 00003000 08:05 4200990 /usr/lib/x86_64-linux-gnu/libXau.so.6.0.0
-7efbe8c05000-7efbe8c2a000 r-xp 00000000 08:05 4461074 /lib/x86_64-linux-gnu/libpng12.so.0.50.0
-7efbe8c2a000-7efbe8e29000 ---p 00025000 08:05 4461074 /lib/x86_64-linux-gnu/libpng12.so.0.50.0
-7efbe8e29000-7efbe8e2a000 r--p 00024000 08:05 4461074 /lib/x86_64-linux-gnu/libpng12.so.0.50.0
-7efbe8e2a000-7efbe8e2b000 rw-p 00025000 08:05 4461074 /lib/x86_64-linux-gnu/libpng12.so.0.50.0
-7efbe8e2b000-7efbe8e65000 r-xp 00000000 08:05 4201367 /usr/lib/x86_64-linux-gnu/libgssapi.so.3.0.0
-7efbe8e65000-7efbe9065000 ---p 0003a000 08:05 4201367 /usr/lib/x86_64-linux-gnu/libgssapi.so.3.0.0
-7efbe9065000-7efbe9066000 r--p 0003a000 08:05 4201367 /usr/lib/x86_64-linux-gnu/libgssapi.so.3.0.0
-7efbe9066000-7efbe9068000 rw-p 0003b000 08:05 4201367 /usr/lib/x86_64-linux-gnu/libgssapi.so.3.0.0
-7efbe9068000-7efbe9069000 rw-p 00000000 00:00 0
-7efbe9069000-7efbe9082000 r-xp 00000000 08:05 4201760 /usr/lib/x86_64-linux-gnu/libsasl2.so.2.0.25
-7efbe9082000-7efbe9282000 ---p 00019000 08:05 4201760 /usr/lib/x86_64-linux-gnu/libsasl2.so.2.0.25
-7efbe9282000-7efbe9283000 r--p 00019000 08:05 4201760 /usr/lib/x86_64-linux-gnu/libsasl2.so.2.0.25
-7efbe9283000-7efbe9284000 rw-p 0001a000 08:05 4201760 /usr/lib/x86_64-linux-gnu/libsasl2.so.2.0.25
-7efbe9284000-7efbe929b000 r-xp 00000000 08:05 4461085 /lib/x86_64-linux-gnu/libresolv-2.19.so
-7efbe929b000-7efbe949b000 ---p 00017000 08:05 4461085 /lib/x86_64-linux-gnu/libresolv-2.19.so
-7efbe949b000-7efbe949c000 r--p 00017000 08:05 4461085 /lib/x86_64-linux-gnu/libresolv-2.19.so
-7efbe949c000-7efbe949d000 rw-p 00018000 08:05 4461085 /lib/x86_64-linux-gnu/libresolv-2.19.so
-7efbe949d000-7efbe949f000 rw-p 00000000 00:00 0
-7efbe949f000-7efbe94a9000 r-xp 00000000 08:05 4201537 /usr/lib/x86_64-linux-gnu/libkrb5support.so.0.1
-7efbe94a9000-7efbe96a8000 ---p 0000a000 08:05 4201537 /usr/lib/x86_64-linux-gnu/libkrb5support.so.0.1
-7efbe96a8000-7efbe96a9000 r--p 00009000 08:05 4201537 /usr/lib/x86_64-linux-gnu/libkrb5support.so.0.1
-7efbe96a9000-7efbe96aa000 rw-p 0000a000 08:05 4201537 /usr/lib/x86_64-linux-gnu/libkrb5support.so.0.1
-7efbe96aa000-7efbe96ad000 r-xp 00000000 08:05 4460968 /lib/x86_64-linux-gnu/libcom_err.so.2.1
-7efbe96ad000-7efbe98ac000 ---p 00003000 08:05 4460968 /lib/x86_64-linux-gnu/libcom_err.so.2.1
-7efbe98ac000-7efbe98ad000 r--p 00002000 08:05 4460968 /lib/x86_64-linux-gnu/libcom_err.so.2.1
-7efbe98ad000-7efbe98ae000 rw-p 00003000 08:05 4460968 /lib/x86_64-linux-gnu/libcom_err.so.2.1
-7efbe98ae000-7efbe98da000 r-xp 00000000 08:05 4201531 /usr/lib/x86_64-linux-gnu/libk5crypto.so.3.1
-7efbe98da000-7efbe9ad9000 ---p 0002c000 08:05 4201531 /usr/lib/x86_64-linux-gnu/libk5crypto.so.3.1
-7efbe9ad9000-7efbe9adb000 r--p 0002b000 08:05 4201531 /usr/lib/x86_64-linux-gnu/libk5crypto.so.3.1
-7efbe9adb000-7efbe9adc000 rw-p 0002d000 08:05 4201531 /usr/lib/x86_64-linux-gnu/libk5crypto.so.3.1
-7efbe9adc000-7efbe9add000 rw-p 00000000 00:00 0
-7efbe9add000-7efbe9b99000 r-xp 00000000 08:05 4201535 /usr/lib/x86_64-linux-gnu/libkrb5.so.3.3
-7efbe9b99000-7efbe9d99000 ---p 000bc000 08:05 4201535 /usr/lib/x86_64-linux-gnu/libkrb5.so.3.3
-7efbe9d99000-7efbe9da6000 r--p 000bc000 08:05 4201535 /usr/lib/x86_64-linux-gnu/libkrb5.so.3.3
-7efbe9da6000-7efbe9da8000 rw-p 000c9000 08:05 4201535 /usr/lib/x86_64-linux-gnu/libkrb5.so.3.3
-7efbe9da8000-7efbe9e24000 r-xp 00000000 08:05 4460988 /lib/x86_64-linux-gnu/libgcrypt.so.11.8.2
-7efbe9e24000-7efbea024000 ---p 0007c000 08:05 4460988 /lib/x86_64-linux-gnu/libgcrypt.so.11.8.2
-7efbea024000-7efbea025000 r--p 0007c000 08:05 4460988 /lib/x86_64-linux-gnu/libgcrypt.so.11.8.2
-7efbea025000-7efbea028000 rw-p 0007d000 08:05 4460988 /lib/x86_64-linux-gnu/libgcrypt.so.11.8.2
-7efbea028000-7efbea0df000 r-xp 00000000 08:05 4197247 /usr/lib/x86_64-linux-gnu/libgnutls.so.26.22.6
-7efbea0df000-7efbea2de000 ---p 000b7000 08:05 4197247 /usr/lib/x86_64-linux-gnu/libgnutls.so.26.22.6
-7efbea2de000-7efbea2e4000 r--p 000b6000 08:05 4197247 /usr/lib/x86_64-linux-gnu/libgnutls.so.26.22.6
-7efbea2e4000-7efbea2e5000 rw-p 000bc000 08:05 4197247 /usr/lib/x86_64-linux-gnu/libgnutls.so.26.22.6
-7efbea2e5000-7efbea2e6000 rw-p 00000000 00:00 0
-7efbea2e6000-7efbea2f7000 r-xp 00000000 08:05 4201003 /usr/lib/x86_64-linux-gnu/libXext.so.6.4.0
-7efbea2f7000-7efbea4f6000 ---p 00011000 08:05 4201003 /usr/lib/x86_64-linux-gnu/libXext.so.6.4.0
-7efbea4f6000-7efbea4f7000 r--p 00010000 08:05 4201003 /usr/lib/x86_64-linux-gnu/libXext.so.6.4.0
-7efbea4f7000-7efbea4f8000 rw-p 00011000 08:05 4201003 /usr/lib/x86_64-linux-gnu/libXext.so.6.4.0
-7efbea4f8000-7efbea515000 r-xp 00000000 08:05 4201942 /usr/lib/x86_64-linux-gnu/libxcb.so.1.1.0
-7efbea515000-7efbea715000 ---p 0001d000 08:05 4201942 /usr/lib/x86_64-linux-gnu/libxcb.so.1.1.0
-7efbea715000-7efbea716000 r--p 0001d000 08:05 4201942 /usr/lib/x86_64-linux-gnu/libxcb.so.1.1.0
-7efbea716000-7efbea717000 rw-p 0001e000 08:05 4201942 /usr/lib/x86_64-linux-gnu/libxcb.so.1.1.0
-7efbea717000-7efbea73e000 r-xp 00000000 08:05 4460981 /lib/x86_64-linux-gnu/libexpat.so.1.6.0
-7efbea73e000-7efbea93e000 ---p 00027000 08:05 4460981 /lib/x86_64-linux-gnu/libexpat.so.1.6.0
-7efbea93e000-7efbea940000 r--p 00027000 08:05 4460981 /lib/x86_64-linux-gnu/libexpat.so.1.6.0
-7efbea940000-7efbea941000 rw-p 00029000 08:05 4460981 /lib/x86_64-linux-gnu/libexpat.so.1.6.0
-7efbea941000-7efbea94a000 r-xp 00000000 08:05 4201025 /usr/lib/x86_64-linux-gnu/libXrender.so.1.3.0
-7efbea94a000-7efbeab49000 ---p 00009000 08:05 4201025 /usr/lib/x86_64-linux-gnu/libXrender.so.1.3.0
-7efbeab49000-7efbeab4a000 r--p 00008000 08:05 4201025 /usr/lib/x86_64-linux-gnu/libXrender.so.1.3.0
-7efbeab4a000-7efbeab4b000 rw-p 00009000 08:05 4201025 /usr/lib/x86_64-linux-gnu/libXrender.so.1.3.0
-7efbeab4b000-7efbeabe8000 r-xp 00000000 08:05 4201272 /usr/lib/x86_64-linux-gnu/libfreetype.so.6.11.1
-7efbeabe8000-7efbeade7000 ---p 0009d000 08:05 4201272 /usr/lib/x86_64-linux-gnu/libfreetype.so.6.11.1
-7efbeade7000-7efbeaded000 r--p 0009c000 08:05 4201272 /usr/lib/x86_64-linux-gnu/libfreetype.so.6.11.1
-7efbeaded000-7efbeadee000 rw-p 000a2000 08:05 4201272 /usr/lib/x86_64-linux-gnu/libfreetype.so.6.11.1
-7efbeadee000-7efbeae0f000 r-xp 00000000 08:05 4461006 /lib/x86_64-linux-gnu/liblzma.so.5.0.0
-7efbeae0f000-7efbeb00e000 ---p 00021000 08:05 4461006 /lib/x86_64-linux-gnu/liblzma.so.5.0.0
-7efbeb00e000-7efbeb00f000 r--p 00020000 08:05 4461006 /lib/x86_64-linux-gnu/liblzma.so.5.0.0
-7efbeb00f000-7efbeb010000 rw-p 00021000 08:05 4461006 /lib/x86_64-linux-gnu/liblzma.so.5.0.0
-7efbeb010000-7efbeb028000 r-xp 00000000 08:05 4461120 /lib/x86_64-linux-gnu/libz.so.1.2.8
-7efbeb028000-7efbeb227000 ---p 00018000 08:05 4461120 /lib/x86_64-linux-gnu/libz.so.1.2.8
-7efbeb227000-7efbeb228000 r--p 00017000 08:05 4461120 /lib/x86_64-linux-gnu/libz.so.1.2.8
-7efbeb228000-7efbeb229000 rw-p 00018000 08:05 4461120 /lib/x86_64-linux-gnu/libz.so.1.2.8
-7efbeb229000-7efbeb276000 r-xp 00000000 08:05 4201544 /usr/lib/x86_64-linux-gnu/libldap_r-2.4.so.2.8.3
-7efbeb276000-7efbeb475000 ---p 0004d000 08:05 4201544 /usr/lib/x86_64-linux-gnu/libldap_r-2.4.so.2.8.3
-7efbeb475000-7efbeb477000 r--p 0004c000 08:05 4201544 /usr/lib/x86_64-linux-gnu/libldap_r-2.4.so.2.8.3
-7efbeb477000-7efbeb478000 rw-p 0004e000 08:05 4201544 /usr/lib/x86_64-linux-gnu/libldap_r-2.4.so.2.8.3
-7efbeb478000-7efbeb47a000 rw-p 00000000 00:00 0
-7efbeb47a000-7efbeb487000 r-xp 00000000 08:05 4201539 /usr/lib/x86_64-linux-gnu/liblber-2.4.so.2.8.3
-7efbeb487000-7efbeb687000 ---p 0000d000 08:05 4201539 /usr/lib/x86_64-linux-gnu/liblber-2.4.so.2.8.3
-7efbeb687000-7efbeb688000 r--p 0000d000 08:05 4201539 /usr/lib/x86_64-linux-gnu/liblber-2.4.so.2.8.3
-7efbeb688000-7efbeb689000 rw-p 0000e000 08:05 4201539 /usr/lib/x86_64-linux-gnu/liblber-2.4.so.2.8.3
-7efbeb689000-7efbeb6cd000 r-xp 00000000 08:05 4201369 /usr/lib/x86_64-linux-gnu/libgssapi_krb5.so.2.2
-7efbeb6cd000-7efbeb8cd000 ---p 00044000 08:05 4201369 /usr/lib/x86_64-linux-gnu/libgssapi_krb5.so.2.2
-7efbeb8cd000-7efbeb8ce000 r--p 00044000 08:05 4201369 /usr/lib/x86_64-linux-gnu/libgssapi_krb5.so.2.2
-7efbeb8ce000-7efbeb8d0000 rw-p 00045000 08:05 4201369 /usr/lib/x86_64-linux-gnu/libgssapi_krb5.so.2.2
-7efbeb8d0000-7efbeba83000 r-xp 00000000 08:05 4465802 /lib/x86_64-linux-gnu/libcrypto.so.1.0.0
-7efbeba83000-7efbebc82000 ---p 001b3000 08:05 4465802 /lib/x86_64-linux-gnu/libcrypto.so.1.0.0
-7efbebc82000-7efbebc9d000 r--p 001b2000 08:05 4465802 /lib/x86_64-linux-gnu/libcrypto.so.1.0.0
-7efbebc9d000-7efbebca8000 rw-p 001cd000 08:05 4465802 /lib/x86_64-linux-gnu/libcrypto.so.1.0.0
-7efbebca8000-7efbebcac000 rw-p 00000000 00:00 0
-7efbebcac000-7efbebd01000 r-xp 00000000 08:05 4465801 /lib/x86_64-linux-gnu/libssl.so.1.0.0
-7efbebd01000-7efbebf01000 ---p 00055000 08:05 4465801 /lib/x86_64-linux-gnu/libssl.so.1.0.0
-7efbebf01000-7efbebf04000 r--p 00055000 08:05 4465801 /lib/x86_64-linux-gnu/libssl.so.1.0.0
-7efbebf04000-7efbebf0b000 rw-p 00058000 08:05 4465801 /lib/x86_64-linux-gnu/libssl.so.1.0.0
-7efbebf0b000-7efbebf24000 r-xp 00000000 08:05 4201743 /usr/lib/x86_64-linux-gnu/librtmp.so.0
-7efbebf24000-7efbec123000 ---p 00019000 08:05 4201743 /usr/lib/x86_64-linux-gnu/librtmp.so.0
-7efbec123000-7efbec124000 r--p 00018000 08:05 4201743 /usr/lib/x86_64-linux-gnu/librtmp.so.0
-7efbec124000-7efbec125000 rw-p 00019000 08:05 4201743 /usr/lib/x86_64-linux-gnu/librtmp.so.0
-7efbec125000-7efbec156000 r-xp 00000000 08:05 4201499 /usr/lib/x86_64-linux-gnu/libidn.so.11.6.11
-7efbec156000-7efbec356000 ---p 00031000 08:05 4201499 /usr/lib/x86_64-linux-gnu/libidn.so.11.6.11
-7efbec356000-7efbec357000 r--p 00031000 08:05 4201499 /usr/lib/x86_64-linux-gnu/libidn.so.11.6.11
-7efbec357000-7efbec358000 rw-p 00032000 08:05 4201499 /usr/lib/x86_64-linux-gnu/libidn.so.11.6.11
-7efbec358000-7efbec35a000 r-xp 00000000 08:05 4201027 /usr/lib/x86_64-linux-gnu/libXss.so.1.0.0
-7efbec35a000-7efbec55a000 ---p 00002000 08:05 4201027 /usr/lib/x86_64-linux-gnu/libXss.so.1.0.0
-7efbec55a000-7efbec55b000 r--p 00002000 08:05 4201027 /usr/lib/x86_64-linux-gnu/libXss.so.1.0.0
-7efbec55b000-7efbec55c000 rw-p 00003000 08:05 4201027 /usr/lib/x86_64-linux-gnu/libXss.so.1.0.0
-7efbec55c000-7efbec68c000 r-xp 00000000 08:05 4200986 /usr/lib/x86_64-linux-gnu/libX11.so.6.3.0
-7efbec68c000-7efbec88c000 ---p 00130000 08:05 4200986 /usr/lib/x86_64-linux-gnu/libX11.so.6.3.0
-7efbec88c000-7efbec88d000 r--p 00130000 08:05 4200986 /usr/lib/x86_64-linux-gnu/libX11.so.6.3.0
-7efbec88d000-7efbec891000 rw-p 00131000 08:05 4200986 /usr/lib/x86_64-linux-gnu/libX11.so.6.3.0
-7efbec891000-7efbec8cb000 r-xp 00000000 08:05 4201260 /usr/lib/x86_64-linux-gnu/libfontconfig.so.1.8.0
-7efbec8cb000-7efbecaca000 ---p 0003a000 08:05 4201260 /usr/lib/x86_64-linux-gnu/libfontconfig.so.1.8.0
-7efbecaca000-7efbecacc000 r--p 00039000 08:05 4201260 /usr/lib/x86_64-linux-gnu/libfontconfig.so.1.8.0
-7efbecacc000-7efbecacd000 rw-p 0003b000 08:05 4201260 /usr/lib/x86_64-linux-gnu/libfontconfig.so.1.8.0
-7efbecacd000-7efbecae1000 r-xp 00000000 08:05 4201009 /usr/lib/x86_64-linux-gnu/libXft.so.2.3.1
-7efbecae1000-7efbecce0000 ---p 00014000 08:05 4201009 /usr/lib/x86_64-linux-gnu/libXft.so.2.3.1
-7efbecce0000-7efbecce1000 r--p 00013000 08:05 4201009 /usr/lib/x86_64-linux-gnu/libXft.so.2.3.1
-7efbecce1000-7efbecce2000 rw-p 00014000 08:05 4201009 /usr/lib/x86_64-linux-gnu/libXft.so.2.3.1
-7efbecce2000-7efbece9d000 r-xp 00000000 08:05 4460959 /lib/x86_64-linux-gnu/libc-2.19.so
-7efbece9d000-7efbed09c000 ---p 001bb000 08:05 4460959 /lib/x86_64-linux-gnu/libc-2.19.so
-7efbed09c000-7efbed0a0000 r--p 001ba000 08:05 4460959 /lib/x86_64-linux-gnu/libc-2.19.so
-7efbed0a0000-7efbed0a2000 rw-p 001be000 08:05 4460959 /lib/x86_64-linux-gnu/libc-2.19.so
-7efbed0a2000-7efbed0a7000 rw-p 00000000 00:00 0
-7efbed0a7000-7efbed0bd000 r-xp 00000000 08:05 4460986 /lib/x86_64-linux-gnu/libgcc_s.so.1
-7efbed0bd000-7efbed2bc000 ---p 00016000 08:05 4460986 /lib/x86_64-linux-gnu/libgcc_s.so.1
-7efbed2bc000-7efbed2bd000 rw-p 00015000 08:05 4460986 /lib/x86_64-linux-gnu/libgcc_s.so.1
-7efbed2bd000-7efbed3c2000 r-xp 00000000 08:05 4461009 /lib/x86_64-linux-gnu/libm-2.19.so
-7efbed3c2000-7efbed5c1000 ---p 00105000 08:05 4461009 /lib/x86_64-linux-gnu/libm-2.19.so
-7efbed5c1000-7efbed5c2000 r--p 00104000 08:05 4461009 /lib/x86_64-linux-gnu/libm-2.19.so
-7efbed5c2000-7efbed5c3000 rw-p 00105000 08:05 4461009 /lib/x86_64-linux-gnu/libm-2.19.so
-7efbed5c3000-7efbed5e8000 r-xp 00000000 08:05 4461103 /lib/x86_64-linux-gnu/libtinfo.so.5.9
-7efbed5e8000-7efbed7e7000 ---p 00025000 08:05 4461103 /lib/x86_64-linux-gnu/libtinfo.so.5.9
-7efbed7e7000-7efbed7eb000 r--p 00024000 08:05 4461103 /lib/x86_64-linux-gnu/libtinfo.so.5.9
-7efbed7eb000-7efbed7ec000 rw-p 00028000 08:05 4461103 /lib/x86_64-linux-gnu/libtinfo.so.5.9
-7efbed7ec000-7efbed80e000 r-xp 00000000 08:05 4461015 /lib/x86_64-linux-gnu/libncurses.so.5.9
-7efbed80e000-7efbeda0d000 ---p 00022000 08:05 4461015 /lib/x86_64-linux-gnu/libncurses.so.5.9
-7efbeda0d000-7efbeda0e000 r--p 00021000 08:05 4461015 /lib/x86_64-linux-gnu/libncurses.so.5.9
-7efbeda0e000-7efbeda0f000 rw-p 00022000 08:05 4461015 /lib/x86_64-linux-gnu/libncurses.so.5.9
-7efbeda0f000-7efbeda12000 r-xp 00000000 08:05 4460976 /lib/x86_64-linux-gnu/libdl-2.19.so
-7efbeda12000-7efbedc11000 ---p 00003000 08:05 4460976 /lib/x86_64-linux-gnu/libdl-2.19.so
-7efbedc11000-7efbedc12000 r--p 00002000 08:05 4460976 /lib/x86_64-linux-gnu/libdl-2.19.so
-7efbedc12000-7efbedc13000 rw-p 00003000 08:05 4460976 /lib/x86_64-linux-gnu/libdl-2.19.so
-7efbedc13000-7efbedc2c000 r-xp 00000000 08:05 4461079 /lib/x86_64-linux-gnu/libpthread-2.19.so
-7efbedc2c000-7efbede2b000 ---p 00019000 08:05 4461079 /lib/x86_64-linux-gnu/libpthread-2.19.so
-7efbede2b000-7efbede2c000 r--p 00018000 08:05 4461079 /lib/x86_64-linux-gnu/libpthread-2.19.so
-7efbede2c000-7efbede2d000 rw-p 00019000 08:05 4461079 /lib/x86_64-linux-gnu/libpthread-2.19.so
-7efbede2d000-7efbede31000 rw-p 00000000 00:00 0
-7efbede31000-7efbedf17000 r-xp 00000000 08:05 4201805 /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.19
-7efbedf17000-7efbee116000 ---p 000e6000 08:05 4201805 /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.19
-7efbee116000-7efbee11e000 r--p 000e5000 08:05 4201805 /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.19
-7efbee11e000-7efbee120000 rw-p 000ed000 08:05 4201805 /usr/lib/x86_64-linux-gnu/libstdc++.so.6.0.19
-7efbee120000-7efbee135000 rw-p 00000000 00:00 0
-7efbee135000-7efbeec5a000 r-xp 00000000 08:05 4599206 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/server/libjvm.so
-7efbeec5a000-7efbeee5a000 ---p 00b25000 08:05 4599206 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/server/libjvm.so
-7efbeee5a000-7efbeeef4000 r--p 00b25000 08:05 4599206 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/server/libjvm.so
-7efbeeef4000-7efbeef17000 rw-p 00bbf000 08:05 4599206 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/server/libjvm.so
-7efbeef17000-7efbeef45000 rw-p 00000000 00:00 0
-7efbeef45000-7efbeef55000 r-xp 00000000 08:05 4599210 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libverify.so
-7efbeef55000-7efbef154000 ---p 00010000 08:05 4599210 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libverify.so
-7efbef154000-7efbef156000 r--p 0000f000 08:05 4599210 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libverify.so
-7efbef156000-7efbef157000 rw-p 00011000 08:05 4599210 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libverify.so
-7efbef157000-7efbef182000 r-xp 00000000 08:05 4599227 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjava.so
-7efbef182000-7efbef382000 ---p 0002b000 08:05 4599227 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjava.so
-7efbef382000-7efbef383000 r--p 0002b000 08:05 4599227 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjava.so
-7efbef383000-7efbef385000 rw-p 0002c000 08:05 4599227 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/libjava.so
-7efbef385000-7efbef4e1000 r-xp 00000000 08:05 4201969 /usr/lib/x86_64-linux-gnu/libxml2.so.2.9.1
-7efbef4e1000-7efbef6e1000 ---p 0015c000 08:05 4201969 /usr/lib/x86_64-linux-gnu/libxml2.so.2.9.1
-7efbef6e1000-7efbef6e9000 r--p 0015c000 08:05 4201969 /usr/lib/x86_64-linux-gnu/libxml2.so.2.9.1
-7efbef6e9000-7efbef6eb000 rw-p 00164000 08:05 4201969 /usr/lib/x86_64-linux-gnu/libxml2.so.2.9.1
-7efbef6eb000-7efbef6ec000 rw-p 00000000 00:00 0
-7efbef6ec000-7efbef6f6000 r-xp 00000000 08:05 4206999 /usr/lib/scilab/libsciconsole-minimal.so.5.5.0
-7efbef6f6000-7efbef8f5000 ---p 0000a000 08:05 4206999 /usr/lib/scilab/libsciconsole-minimal.so.5.5.0
-7efbef8f5000-7efbef8f6000 r--p 00009000 08:05 4206999 /usr/lib/scilab/libsciconsole-minimal.so.5.5.0
-7efbef8f6000-7efbef8f7000 rw-p 0000a000 08:05 4206999 /usr/lib/scilab/libsciconsole-minimal.so.5.5.0
-7efbef8f7000-7efbef932000 r-xp 00000000 08:05 4201721 /usr/lib/x86_64-linux-gnu/libquadmath.so.0.0.0
-7efbef932000-7efbefb31000 ---p 0003b000 08:05 4201721 /usr/lib/x86_64-linux-gnu/libquadmath.so.0.0.0
-7efbefb31000-7efbefb32000 r--p 0003a000 08:05 4201721 /usr/lib/x86_64-linux-gnu/libquadmath.so.0.0.0
-7efbefb32000-7efbefb33000 rw-p 0003b000 08:05 4201721 /usr/lib/x86_64-linux-gnu/libquadmath.so.0.0.0
-7efbefb33000-7efbefc4a000 r-xp 00000000 08:05 4201323 /usr/lib/x86_64-linux-gnu/libgfortran.so.3.0.0
-7efbefc4a000-7efbefe4a000 ---p 00117000 08:05 4201323 /usr/lib/x86_64-linux-gnu/libgfortran.so.3.0.0
-7efbefe4a000-7efbefe4b000 r--p 00117000 08:05 4201323 /usr/lib/x86_64-linux-gnu/libgfortran.so.3.0.0
-7efbefe4b000-7efbefe4d000 rw-p 00118000 08:05 4201323 /usr/lib/x86_64-linux-gnu/libgfortran.so.3.0.0
-7efbefe4d000-7efbefec9000 r-xp 00000000 08:05 4199131 /usr/lib/libblas/libblas.so.3.0
-7efbefec9000-7efbf00c8000 ---p 0007c000 08:05 4199131 /usr/lib/libblas/libblas.so.3.0
-7efbf00c8000-7efbf00c9000 r--p 0007b000 08:05 4199131 /usr/lib/libblas/libblas.so.3.0
-7efbf00c9000-7efbf00ca000 rw-p 0007c000 08:05 4199131 /usr/lib/libblas/libblas.so.3.0
-7efbf00ca000-7efbf0662000 r-xp 00000000 08:05 4199047 /usr/lib/lapack/liblapack.so.3.0
-7efbf0662000-7efbf0861000 ---p 00598000 08:05 4199047 /usr/lib/lapack/liblapack.so.3.0
-7efbf0861000-7efbf0862000 r--p 00597000 08:05 4199047 /usr/lib/lapack/liblapack.so.3.0
-7efbf0862000-7efbf0866000 rw-p 00598000 08:05 4199047 /usr/lib/lapack/liblapack.so.3.0
-7efbf0866000-7efbf0867000 r-xp 00000000 08:05 4207021 /usr/lib/scilab/libscicommons-disable.so.5.5.0
-7efbf0867000-7efbf0a66000 ---p 00001000 08:05 4207021 /usr/lib/scilab/libscicommons-disable.so.5.5.0
-7efbf0a66000-7efbf0a67000 r--p 00000000 08:05 4207021 /usr/lib/scilab/libscicommons-disable.so.5.5.0
-7efbf0a67000-7efbf0a68000 rw-p 00001000 08:05 4207021 /usr/lib/scilab/libscicommons-disable.so.5.5.0
-7efbf0a68000-7efbf0a69000 r-xp 00000000 08:05 4207017 /usr/lib/scilab/libscihistory_browser-disable.so.5.5.0
-7efbf0a69000-7efbf0c68000 ---p 00001000 08:05 4207017 /usr/lib/scilab/libscihistory_browser-disable.so.5.5.0
-7efbf0c68000-7efbf0c69000 r--p 00000000 08:05 4207017 /usr/lib/scilab/libscihistory_browser-disable.so.5.5.0
-7efbf0c69000-7efbf0c6a000 rw-p 00001000 08:05 4207017 /usr/lib/scilab/libscihistory_browser-disable.so.5.5.0
-7efbf0c6a000-7efbf0c6b000 r-xp 00000000 08:05 4207024 /usr/lib/scilab/libsciui_data-disable.so.5.5.0
-7efbf0c6b000-7efbf0e6a000 ---p 00001000 08:05 4207024 /usr/lib/scilab/libsciui_data-disable.so.5.5.0
-7efbf0e6a000-7efbf0e6b000 r--p 00000000 08:05 4207024 /usr/lib/scilab/libsciui_data-disable.so.5.5.0
-7efbf0e6b000-7efbf0e6c000 rw-p 00001000 08:05 4207024 /usr/lib/scilab/libsciui_data-disable.so.5.5.0
-7efbf0e6c000-7efbf0e6d000 r-xp 00000000 08:05 4206990 /usr/lib/scilab/libsciscinotes-disable.so.5.5.0
-7efbf0e6d000-7efbf106c000 ---p 00001000 08:05 4206990 /usr/lib/scilab/libsciscinotes-disable.so.5.5.0
-7efbf106c000-7efbf106d000 r--p 00000000 08:05 4206990 /usr/lib/scilab/libsciscinotes-disable.so.5.5.0
-7efbf106d000-7efbf106e000 rw-p 00001000 08:05 4206990 /usr/lib/scilab/libsciscinotes-disable.so.5.5.0
-7efbf106e000-7efbf106f000 r-xp 00000000 08:05 4206991 /usr/lib/scilab/libscigraphic_objects-disable.so.5.5.0
-7efbf106f000-7efbf126e000 ---p 00001000 08:05 4206991 /usr/lib/scilab/libscigraphic_objects-disable.so.5.5.0
-7efbf126e000-7efbf126f000 r--p 00000000 08:05 4206991 /usr/lib/scilab/libscigraphic_objects-disable.so.5.5.0
-7efbf126f000-7efbf1270000 rw-p 00001000 08:05 4206991 /usr/lib/scilab/libscigraphic_objects-disable.so.5.5.0
-7efbf1270000-7efbf1271000 r-xp 00000000 08:05 4207008 /usr/lib/scilab/libscixcos-disable.so.5.5.0
-7efbf1271000-7efbf1470000 ---p 00001000 08:05 4207008 /usr/lib/scilab/libscixcos-disable.so.5.5.0
-7efbf1470000-7efbf1471000 r--p 00000000 08:05 4207008 /usr/lib/scilab/libscixcos-disable.so.5.5.0
-7efbf1471000-7efbf1472000 rw-p 00001000 08:05 4207008 /usr/lib/scilab/libscixcos-disable.so.5.5.0
-7efbf1472000-7efbf1473000 r-xp 00000000 08:05 4206996 /usr/lib/scilab/libscijvm-disable.so.5.5.0
-7efbf1473000-7efbf1672000 ---p 00001000 08:05 4206996 /usr/lib/scilab/libscijvm-disable.so.5.5.0
-7efbf1672000-7efbf1673000 r--p 00000000 08:05 4206996 /usr/lib/scilab/libscijvm-disable.so.5.5.0
-7efbf1673000-7efbf1674000 rw-p 00001000 08:05 4206996 /usr/lib/scilab/libscijvm-disable.so.5.5.0
-7efbf1674000-7efbf1675000 r-xp 00000000 08:05 4206989 /usr/lib/scilab/libsciaction_binding-disable.so.5.5.0
-7efbf1675000-7efbf1874000 ---p 00001000 08:05 4206989 /usr/lib/scilab/libsciaction_binding-disable.so.5.5.0
-7efbf1874000-7efbf1875000 r--p 00000000 08:05 4206989 /usr/lib/scilab/libsciaction_binding-disable.so.5.5.0
-7efbf1875000-7efbf1876000 rw-p 00001000 08:05 4206989 /usr/lib/scilab/libsciaction_binding-disable.so.5.5.0
-7efbf1876000-7efbf1877000 r-xp 00000000 08:05 4207007 /usr/lib/scilab/libscigraphic_export-disable.so.5.5.0
-7efbf1877000-7efbf1a76000 ---p 00001000 08:05 4207007 /usr/lib/scilab/libscigraphic_export-disable.so.5.5.0
-7efbf1a76000-7efbf1a77000 r--p 00000000 08:05 4207007 /usr/lib/scilab/libscigraphic_export-disable.so.5.5.0
-7efbf1a77000-7efbf1a78000 rw-p 00001000 08:05 4207007 /usr/lib/scilab/libscigraphic_export-disable.so.5.5.0
-7efbf1a78000-7efbf1a7a000 r-xp 00000000 08:05 4207004 /usr/lib/scilab/libscigraphics-disable.so.5.5.0
-7efbf1a7a000-7efbf1c7a000 ---p 00002000 08:05 4207004 /usr/lib/scilab/libscigraphics-disable.so.5.5.0
-7efbf1c7a000-7efbf1c7b000 r--p 00002000 08:05 4207004 /usr/lib/scilab/libscigraphics-disable.so.5.5.0
-7efbf1c7b000-7efbf1c7c000 rw-p 00003000 08:05 4207004 /usr/lib/scilab/libscigraphics-disable.so.5.5.0
-7efbf1c7c000-7efbf1c7e000 r-xp 00000000 08:05 4207003 /usr/lib/scilab/libscigui-disable.so.5.5.0
-7efbf1c7e000-7efbf1e7d000 ---p 00002000 08:05 4207003 /usr/lib/scilab/libscigui-disable.so.5.5.0
-7efbf1e7d000-7efbf1e7e000 r--p 00001000 08:05 4207003 /usr/lib/scilab/libscigui-disable.so.5.5.0
-7efbf1e7e000-7efbf1e7f000 rw-p 00002000 08:05 4207003 /usr/lib/scilab/libscigui-disable.so.5.5.0
-7efbf1e7f000-7efbf1e81000 r-xp 00000000 08:05 4207023 /usr/lib/scilab/libscipreferences-cli.so.5.5.0
-7efbf1e81000-7efbf2081000 ---p 00002000 08:05 4207023 /usr/lib/scilab/libscipreferences-cli.so.5.5.0
-7efbf2081000-7efbf2082000 r--p 00002000 08:05 4207023 /usr/lib/scilab/libscipreferences-cli.so.5.5.0
-7efbf2082000-7efbf2083000 rw-p 00003000 08:05 4207023 /usr/lib/scilab/libscipreferences-cli.so.5.5.0
-7efbf2083000-7efbf20ad000 r-xp 00000000 08:05 4207013 /usr/lib/scilab/libsciexternal_objects.so.5.5.0
-7efbf20ad000-7efbf22ad000 ---p 0002a000 08:05 4207013 /usr/lib/scilab/libsciexternal_objects.so.5.5.0
-7efbf22ad000-7efbf22ae000 r--p 0002a000 08:05 4207013 /usr/lib/scilab/libsciexternal_objects.so.5.5.0
-7efbf22ae000-7efbf22b0000 rw-p 0002b000 08:05 4207013 /usr/lib/scilab/libsciexternal_objects.so.5.5.0
-7efbf22b0000-7efbf22e6000 r-xp 00000000 08:05 4207019 /usr/lib/scilab/libscixml.so.5.5.0
-7efbf22e6000-7efbf24e5000 ---p 00036000 08:05 4207019 /usr/lib/scilab/libscixml.so.5.5.0
-7efbf24e5000-7efbf24e6000 r--p 00035000 08:05 4207019 /usr/lib/scilab/libscixml.so.5.5.0
-7efbf24e6000-7efbf24e8000 rw-p 00036000 08:05 4207019 /usr/lib/scilab/libscixml.so.5.5.0
-7efbf24e8000-7efbf2504000 r-xp 00000000 08:05 4207011 /usr/lib/scilab/libscistatistics.so.5.5.0
-7efbf2504000-7efbf2703000 ---p 0001c000 08:05 4207011 /usr/lib/scilab/libscistatistics.so.5.5.0
-7efbf2703000-7efbf2704000 r--p 0001b000 08:05 4207011 /usr/lib/scilab/libscistatistics.so.5.5.0
-7efbf2704000-7efbf2705000 rw-p 0001c000 08:05 4207011 /usr/lib/scilab/libscistatistics.so.5.5.0
-7efbf2705000-7efbf27bf000 rw-p 00000000 00:00 0
-7efbf27bf000-7efbf29a6000 r-xp 00000000 08:05 4206834 /usr/lib/x86_64-linux-gnu/libfftw3.so.3.3.2
-7efbf29a6000-7efbf2ba5000 ---p 001e7000 08:05 4206834 /usr/lib/x86_64-linux-gnu/libfftw3.so.3.3.2
-7efbf2ba5000-7efbf2bb6000 r--p 001e6000 08:05 4206834 /usr/lib/x86_64-linux-gnu/libfftw3.so.3.3.2
-7efbf2bb6000-7efbf2bb7000 rw-p 001f7000 08:05 4206834 /usr/lib/x86_64-linux-gnu/libfftw3.so.3.3.2
-7efbf2bb7000-7efbf2bd5000 r-xp 00000000 08:05 4206843 /usr/lib/x86_64-linux-gnu/libhdf5_hl.so.7.0.0
-7efbf2bd5000-7efbf2dd4000 ---p 0001e000 08:05 4206843 /usr/lib/x86_64-linux-gnu/libhdf5_hl.so.7.0.0
-7efbf2dd4000-7efbf2dd5000 r--p 0001d000 08:05 4206843 /usr/lib/x86_64-linux-gnu/libhdf5_hl.so.7.0.0
-7efbf2dd5000-7efbf2dd6000 rw-p 0001e000 08:05 4206843 /usr/lib/x86_64-linux-gnu/libhdf5_hl.so.7.0.0
-7efbf2dd6000-7efbf2de7000 rw-p 00000000 00:00 0
-7efbf2de7000-7efbf3079000 r-xp 00000000 08:05 4206844 /usr/lib/x86_64-linux-gnu/libhdf5.so.7.0.0
-7efbf3079000-7efbf3278000 ---p 00292000 08:05 4206844 /usr/lib/x86_64-linux-gnu/libhdf5.so.7.0.0
-7efbf3278000-7efbf327d000 r--p 00291000 08:05 4206844 /usr/lib/x86_64-linux-gnu/libhdf5.so.7.0.0
-7efbf327d000-7efbf3281000 rw-p 00296000 08:05 4206844 /usr/lib/x86_64-linux-gnu/libhdf5.so.7.0.0
-7efbf3281000-7efbf3283000 rw-p 00000000 00:00 0
-7efbf3283000-7efbf333b000 r-xp 00000000 08:05 4207009 /usr/lib/scilab/libscihdf5.so.5.5.0
-7efbf333b000-7efbf353b000 ---p 000b8000 08:05 4207009 /usr/lib/scilab/libscihdf5.so.5.5.0
-7efbf353b000-7efbf3541000 r--p 000b8000 08:05 4207009 /usr/lib/scilab/libscihdf5.so.5.5.0
-7efbf3541000-7efbf3543000 rw-p 000be000 08:05 4207009 /usr/lib/scilab/libscihdf5.so.5.5.0
-7efbf3543000-7efbf3580000 r-xp 00000000 08:05 4461062 /lib/x86_64-linux-gnu/libpcre.so.3.13.1
-7efbf3580000-7efbf377f000 ---p 0003d000 08:05 4461062 /lib/x86_64-linux-gnu/libpcre.so.3.13.1
-7efbf377f000-7efbf3780000 r--p 0003c000 08:05 4461062 /lib/x86_64-linux-gnu/libpcre.so.3.13.1
-7efbf3780000-7efbf3781000 rw-p 0003d000 08:05 4461062 /lib/x86_64-linux-gnu/libpcre.so.3.13.1
-7efbf3781000-7efbf3783000 r-xp 00000000 08:05 4201674 /usr/lib/x86_64-linux-gnu/libpcreposix.so.3.13.1
-7efbf3783000-7efbf3982000 ---p 00002000 08:05 4201674 /usr/lib/x86_64-linux-gnu/libpcreposix.so.3.13.1
-7efbf3982000-7efbf3983000 r--p 00001000 08:05 4201674 /usr/lib/x86_64-linux-gnu/libpcreposix.so.3.13.1
-7efbf3983000-7efbf3984000 rw-p 00002000 08:05 4201674 /usr/lib/x86_64-linux-gnu/libpcreposix.so.3.13.1
-7efbf3984000-7efbf3993000 r-xp 00000000 08:05 4207018 /usr/lib/scilab/libscihistory_manager.so.5.5.0
-7efbf3993000-7efbf3b92000 ---p 0000f000 08:05 4207018 /usr/lib/scilab/libscihistory_manager.so.5.5.0
-7efbf3b92000-7efbf3b93000 r--p 0000e000 08:05 4207018 /usr/lib/scilab/libscihistory_manager.so.5.5.0
-7efbf3b93000-7efbf3b94000 rw-p 0000f000 08:05 4207018 /usr/lib/scilab/libscihistory_manager.so.5.5.0
-7efbf3b94000-7efbf3ba4000 r-xp 00000000 08:05 4206997 /usr/lib/scilab/libscicompletion.so.5.5.0
-7efbf3ba4000-7efbf3da4000 ---p 00010000 08:05 4206997 /usr/lib/scilab/libscicompletion.so.5.5.0
-7efbf3da4000-7efbf3da5000 r--p 00010000 08:05 4206997 /usr/lib/scilab/libscicompletion.so.5.5.0
-7efbf3da5000-7efbf3da6000 rw-p 00011000 08:05 4206997 /usr/lib/scilab/libscicompletion.so.5.5.0
-7efbf3da6000-7efbf3dc3000 r-xp 00000000 08:05 4206995 /usr/lib/scilab/libscispecial_functions.so.5.5.0
-7efbf3dc3000-7efbf3fc2000 ---p 0001d000 08:05 4206995 /usr/lib/scilab/libscispecial_functions.so.5.5.0
-7efbf3fc2000-7efbf3fc3000 r--p 0001c000 08:05 4206995 /usr/lib/scilab/libscispecial_functions.so.5.5.0
-7efbf3fc3000-7efbf3fc4000 rw-p 0001d000 08:05 4206995 /usr/lib/scilab/libscispecial_functions.so.5.5.0
-7efbf3fc4000-7efbf3fca000 r-xp 00000000 08:05 4206998 /usr/lib/scilab/libscilocalization.so.5.5.0
-7efbf3fca000-7efbf41c9000 ---p 00006000 08:05 4206998 /usr/lib/scilab/libscilocalization.so.5.5.0
-7efbf41c9000-7efbf41ca000 r--p 00005000 08:05 4206998 /usr/lib/scilab/libscilocalization.so.5.5.0
-7efbf41ca000-7efbf41d1000 rw-p 00006000 08:05 4206998 /usr/lib/scilab/libscilocalization.so.5.5.0
-7efbf41d1000-7efbf41d5000 r-xp 00000000 08:05 4207010 /usr/lib/scilab/libscicall_scilab.so.5.5.0
-7efbf41d5000-7efbf43d4000 ---p 00004000 08:05 4207010 /usr/lib/scilab/libscicall_scilab.so.5.5.0
-7efbf43d4000-7efbf43d5000 r--p 00003000 08:05 4207010 /usr/lib/scilab/libscicall_scilab.so.5.5.0
-7efbf43d5000-7efbf43d6000 rw-p 00004000 08:05 4207010 /usr/lib/scilab/libscicall_scilab.so.5.5.0
-7efbf43d6000-7efbf43df000 r-xp 00000000 08:05 4207015 /usr/lib/scilab/libscifunctions.so.5.5.0
-7efbf43df000-7efbf45de000 ---p 00009000 08:05 4207015 /usr/lib/scilab/libscifunctions.so.5.5.0
-7efbf45de000-7efbf45df000 r--p 00008000 08:05 4207015 /usr/lib/scilab/libscifunctions.so.5.5.0
-7efbf45df000-7efbf45e0000 rw-p 00009000 08:05 4207015 /usr/lib/scilab/libscifunctions.so.5.5.0
-7efbf45e0000-7efbf469a000 rw-p 00000000 00:00 0
-7efbf469a000-7efbf46fe000 r-xp 00000000 08:05 4201175 /usr/lib/x86_64-linux-gnu/libcurl.so.4.3.0
-7efbf46fe000-7efbf48fe000 ---p 00064000 08:05 4201175 /usr/lib/x86_64-linux-gnu/libcurl.so.4.3.0
-7efbf48fe000-7efbf4900000 r--p 00064000 08:05 4201175 /usr/lib/x86_64-linux-gnu/libcurl.so.4.3.0
-7efbf4900000-7efbf4901000 rw-p 00066000 08:05 4201175 /usr/lib/x86_64-linux-gnu/libcurl.so.4.3.0
-7efbf4901000-7efbf4d19000 r-xp 00000000 08:05 4207020 /usr/lib/scilab/libscilab-cli.so.0.0.0
-7efbf4d19000-7efbf4f18000 ---p 00418000 08:05 4207020 /usr/lib/scilab/libscilab-cli.so.0.0.0
-7efbf4f18000-7efbf4f1a000 r--p 00417000 08:05 4207020 /usr/lib/scilab/libscilab-cli.so.0.0.0
-7efbf4f1a000-7efbf4f26000 rw-p 00419000 08:05 4207020 /usr/lib/scilab/libscilab-cli.so.0.0.0
-7efbf4f26000-7efbf5079000 rw-p 00000000 00:00 0
-7efbf5079000-7efbf5081000 r-xp 00000000 08:05 4207224 /usr/lib/scilab/libscijvm.so.5.5.0
-7efbf5081000-7efbf5280000 ---p 00008000 08:05 4207224 /usr/lib/scilab/libscijvm.so.5.5.0
-7efbf5280000-7efbf5281000 r--p 00007000 08:05 4207224 /usr/lib/scilab/libscijvm.so.5.5.0
-7efbf5281000-7efbf5282000 rw-p 00008000 08:05 4207224 /usr/lib/scilab/libscijvm.so.5.5.0
-7efbf5282000-7efbf528b000 r-xp 00000000 08:05 4207233 /usr/lib/scilab/libscicommons.so.5.5.0
-7efbf528b000-7efbf548b000 ---p 00009000 08:05 4207233 /usr/lib/scilab/libscicommons.so.5.5.0
-7efbf548b000-7efbf548c000 r--p 00009000 08:05 4207233 /usr/lib/scilab/libscicommons.so.5.5.0
-7efbf548c000-7efbf548d000 rw-p 0000a000 08:05 4207233 /usr/lib/scilab/libscicommons.so.5.5.0
-7efbf548d000-7efbf54a6000 r-xp 00000000 08:05 4207217 /usr/lib/scilab/libscitypes.so.5.5.0
-7efbf54a6000-7efbf56a5000 ---p 00019000 08:05 4207217 /usr/lib/scilab/libscitypes.so.5.5.0
-7efbf56a5000-7efbf56a6000 r--p 00018000 08:05 4207217 /usr/lib/scilab/libscitypes.so.5.5.0
-7efbf56a6000-7efbf56a7000 rw-p 00019000 08:05 4207217 /usr/lib/scilab/libscitypes.so.5.5.0
-7efbf56a7000-7efbf56b0000 r-xp 00000000 08:05 4207218 /usr/lib/scilab/libscihelptools.so.5.5.0
-7efbf56b0000-7efbf58b0000 ---p 00009000 08:05 4207218 /usr/lib/scilab/libscihelptools.so.5.5.0
-7efbf58b0000-7efbf58b1000 r--p 00009000 08:05 4207218 /usr/lib/scilab/libscihelptools.so.5.5.0
-7efbf58b1000-7efbf58b2000 rw-p 0000a000 08:05 4207218 /usr/lib/scilab/libscihelptools.so.5.5.0
-7efbf58b2000-7efbf58e8000 r-xp 00000000 08:05 4207220 /usr/lib/scilab/libsciexternal_objects_java.so.5.5.0
-7efbf58e8000-7efbf5ae7000 ---p 00036000 08:05 4207220 /usr/lib/scilab/libsciexternal_objects_java.so.5.5.0
-7efbf5ae7000-7efbf5ae9000 r--p 00035000 08:05 4207220 /usr/lib/scilab/libsciexternal_objects_java.so.5.5.0
-7efbf5ae9000-7efbf5aea000 rw-p 00037000 08:05 4207220 /usr/lib/scilab/libsciexternal_objects_java.so.5.5.0
-7efbf5aea000-7efbf5af1000 r-xp 00000000 08:05 4207228 /usr/lib/scilab/libscipreferences.so.5.5.0
-7efbf5af1000-7efbf5cf0000 ---p 00007000 08:05 4207228 /usr/lib/scilab/libscipreferences.so.5.5.0
-7efbf5cf0000-7efbf5cf1000 r--p 00006000 08:05 4207228 /usr/lib/scilab/libscipreferences.so.5.5.0
-7efbf5cf1000-7efbf5cf2000 rw-p 00007000 08:05 4207228 /usr/lib/scilab/libscipreferences.so.5.5.0
-7efbf5cf2000-7efbf5e05000 r-xp 00000000 08:05 4206888 /usr/lib/x86_64-linux-gnu/libtcl8.5.so
-7efbf5e05000-7efbf6004000 ---p 00113000 08:05 4206888 /usr/lib/x86_64-linux-gnu/libtcl8.5.so
-7efbf6004000-7efbf6008000 r--p 00112000 08:05 4206888 /usr/lib/x86_64-linux-gnu/libtcl8.5.so
-7efbf6008000-7efbf600e000 rw-p 00116000 08:05 4206888 /usr/lib/x86_64-linux-gnu/libtcl8.5.so
-7efbf600e000-7efbf600f000 rw-p 00000000 00:00 0
-7efbf600f000-7efbf6138000 r-xp 00000000 08:05 4206890 /usr/lib/x86_64-linux-gnu/libtk8.5.so
-7efbf6138000-7efbf6337000 ---p 00129000 08:05 4206890 /usr/lib/x86_64-linux-gnu/libtk8.5.so
-7efbf6337000-7efbf6345000 r--p 00128000 08:05 4206890 /usr/lib/x86_64-linux-gnu/libtk8.5.so
-7efbf6345000-7efbf6356000 rw-p 00136000 08:05 4206890 /usr/lib/x86_64-linux-gnu/libtk8.5.so
-7efbf6356000-7efbf6360000 r-xp 00000000 08:05 4206993 /usr/lib/scilab/libscitclsci.so.5.5.0
-7efbf6360000-7efbf655f000 ---p 0000a000 08:05 4206993 /usr/lib/scilab/libscitclsci.so.5.5.0
-7efbf655f000-7efbf6560000 r--p 00009000 08:05 4206993 /usr/lib/scilab/libscitclsci.so.5.5.0
-7efbf6560000-7efbf6561000 rw-p 0000a000 08:05 4206993 /usr/lib/scilab/libscitclsci.so.5.5.0
-7efbf6561000-7efbf6566000 r-xp 00000000 08:05 4207223 /usr/lib/scilab/libscihistory_browser.so.5.5.0
-7efbf6566000-7efbf6766000 ---p 00005000 08:05 4207223 /usr/lib/scilab/libscihistory_browser.so.5.5.0
-7efbf6766000-7efbf6767000 r--p 00005000 08:05 4207223 /usr/lib/scilab/libscihistory_browser.so.5.5.0
-7efbf6767000-7efbf6768000 rw-p 00006000 08:05 4207223 /usr/lib/scilab/libscihistory_browser.so.5.5.0
-7efbf6768000-7efbf6782000 r-xp 00000000 08:05 4207234 /usr/lib/scilab/libsciui_data.so.5.5.0
-7efbf6782000-7efbf6982000 ---p 0001a000 08:05 4207234 /usr/lib/scilab/libsciui_data.so.5.5.0
-7efbf6982000-7efbf6983000 r--p 0001a000 08:05 4207234 /usr/lib/scilab/libsciui_data.so.5.5.0
-7efbf6983000-7efbf6984000 rw-p 0001b000 08:05 4207234 /usr/lib/scilab/libsciui_data.so.5.5.0
-7efbf6984000-7efbf698c000 r-xp 00000000 08:05 4207221 /usr/lib/scilab/libsciscinotes.so.5.5.0
-7efbf698c000-7efbf6b8b000 ---p 00008000 08:05 4207221 /usr/lib/scilab/libsciscinotes.so.5.5.0
-7efbf6b8b000-7efbf6b8c000 r--p 00007000 08:05 4207221 /usr/lib/scilab/libsciscinotes.so.5.5.0
-7efbf6b8c000-7efbf6b8d000 rw-p 00008000 08:05 4207221 /usr/lib/scilab/libsciscinotes.so.5.5.0
-7efbf6b8d000-7efbf6c09000 r-xp 00000000 08:05 4207216 /usr/lib/scilab/libscigraphic_objects.so.5.5.0
-7efbf6c09000-7efbf6e09000 ---p 0007c000 08:05 4207216 /usr/lib/scilab/libscigraphic_objects.so.5.5.0
-7efbf6e09000-7efbf6e0a000 r--p 0007c000 08:05 4207216 /usr/lib/scilab/libscigraphic_objects.so.5.5.0
-7efbf6e0a000-7efbf6e0c000 rw-p 0007d000 08:05 4207216 /usr/lib/scilab/libscigraphic_objects.so.5.5.0
-7efbf6e0c000-7efbf6eca000 rw-p 00000000 00:00 0
-7efbf6eca000-7efbf6ece000 r-xp 00000000 08:05 4207225 /usr/lib/scilab/libsciaction_binding.so.5.5.0
-7efbf6ece000-7efbf70ce000 ---p 00004000 08:05 4207225 /usr/lib/scilab/libsciaction_binding.so.5.5.0
-7efbf70ce000-7efbf70cf000 r--p 00004000 08:05 4207225 /usr/lib/scilab/libsciaction_binding.so.5.5.0
-7efbf70cf000-7efbf70d0000 rw-p 00005000 08:05 4207225 /usr/lib/scilab/libsciaction_binding.so.5.5.0
-7efbf70d0000-7efbf70d9000 r-xp 00000000 08:05 4207226 /usr/lib/scilab/libsciconsole.so.5.5.0
-7efbf70d9000-7efbf72d8000 ---p 00009000 08:05 4207226 /usr/lib/scilab/libsciconsole.so.5.5.0
-7efbf72d8000-7efbf72d9000 r--p 00008000 08:05 4207226 /usr/lib/scilab/libsciconsole.so.5.5.0
-7efbf72d9000-7efbf72da000 rw-p 00009000 08:05 4207226 /usr/lib/scilab/libsciconsole.so.5.5.0
-7efbf72da000-7efbf72e3000 r-xp 00000000 08:05 4207232 /usr/lib/scilab/libscigraphic_export.so.5.5.0
-7efbf72e3000-7efbf74e2000 ---p 00009000 08:05 4207232 /usr/lib/scilab/libscigraphic_export.so.5.5.0
-7efbf74e2000-7efbf74e3000 r--p 00008000 08:05 4207232 /usr/lib/scilab/libscigraphic_export.so.5.5.0
-7efbf74e3000-7efbf74e4000 rw-p 00009000 08:05 4207232 /usr/lib/scilab/libscigraphic_export.so.5.5.0
-7efbf74e4000-7efbf7562000 r-xp 00000000 08:05 4207231 /usr/lib/scilab/libscigraphics.so.5.5.0
-7efbf7562000-7efbf7762000 ---p 0007e000 08:05 4207231 /usr/lib/scilab/libscigraphics.so.5.5.0
-7efbf7762000-7efbf7766000 r--p 0007e000 08:05 4207231 /usr/lib/scilab/libscigraphics.so.5.5.0
-7efbf7766000-7efbf7769000 rw-p 00082000 08:05 4207231 /usr/lib/scilab/libscigraphics.so.5.5.0
-7efbf7769000-7efbf7773000 r-xp 00000000 08:05 4207229 /usr/lib/scilab/libscirenderer.so.5.5.0
-7efbf7773000-7efbf7972000 ---p 0000a000 08:05 4207229 /usr/lib/scilab/libscirenderer.so.5.5.0
-7efbf7972000-7efbf7973000 r--p 00009000 08:05 4207229 /usr/lib/scilab/libscirenderer.so.5.5.0
-7efbf7973000-7efbf7974000 rw-p 0000a000 08:05 4207229 /usr/lib/scilab/libscirenderer.so.5.5.0
-7efbf7974000-7efbf79d6000 r-xp 00000000 08:05 4207214 /usr/lib/scilab/libscigui.so.5.5.0
-7efbf79d6000-7efbf7bd6000 ---p 00062000 08:05 4207214 /usr/lib/scilab/libscigui.so.5.5.0
-7efbf7bd6000-7efbf7bd7000 r--p 00062000 08:05 4207214 /usr/lib/scilab/libscigui.so.5.5.0
-7efbf7bd7000-7efbf7bd9000 rw-p 00063000 08:05 4207214 /usr/lib/scilab/libscigui.so.5.5.0
-7efbf7bd9000-7efbf7bda000 r-xp 00000000 08:05 4207222 /usr/lib/scilab/libscilab.so.0.0.0
-7efbf7bda000-7efbf7dda000 ---p 00001000 08:05 4207222 /usr/lib/scilab/libscilab.so.0.0.0
-7efbf7dda000-7efbf7ddb000 r--p 00001000 08:05 4207222 /usr/lib/scilab/libscilab.so.0.0.0
-7efbf7ddb000-7efbf7ddc000 rw-p 00002000 08:05 4207222 /usr/lib/scilab/libscilab.so.0.0.0
-7efbf7ddc000-7efbf7dff000 r-xp 00000000 08:05 4460935 /lib/x86_64-linux-gnu/ld-2.19.so
-7efbf7dff000-7efbf7e00000 r--s 00001000 08:05 1448415 /usr/share/scilab/modules/jvm/jar/org.scilab.modules.jvm.jar
-7efbf7e00000-7efbf7e47000 rw-p 00000000 00:00 0
-7efbf7e47000-7efbf7e74000 rw-p 00000000 00:00 0
-7efbf7e74000-7efbf7ea4000 rw-p 00000000 00:00 0
-7efbf7ea4000-7efbf7ec9000 rw-p 00000000 00:00 0
-7efbf7ec9000-7efbf7ef4000 rw-p 00000000 00:00 0
-7efbf7ef4000-7efbf7f06000 rw-p 00000000 00:00 0
-7efbf7f06000-7efbf7fb5000 rw-p 00000000 00:00 0
-7efbf7fb5000-7efbf7fe3000 rw-p 00000000 00:00 0
-7efbf7fe3000-7efbf7fe4000 r--s 00002000 08:05 4599239 /usr/lib/jvm/java-7-openjdk-amd64/jre/lib/ext/dnsns.jar
-7efbf7fe4000-7efbf7fed000 rw-p 00000000 00:00 0
-7efbf7fed000-7efbf7ff5000 rw-s 00000000 08:05 2621456 /tmp/hsperfdata_harpreet/5921
-7efbf7ff5000-7efbf7ff6000 rw-p 00000000 00:00 0
-7efbf7ff6000-7efbf7ff7000 r--p 00000000 00:00 0
-7efbf7ff7000-7efbf7ff8000 rw-s 00000000 00:05 343248 /dev/zero (deleted)
-7efbf7ff8000-7efbf7ffe000 rw-p 00000000 00:00 0
-7efbf7ffe000-7efbf7fff000 r--p 00022000 08:05 4460935 /lib/x86_64-linux-gnu/ld-2.19.so
-7efbf7fff000-7efbf8000000 rw-p 00023000 08:05 4460935 /lib/x86_64-linux-gnu/ld-2.19.so
-7efbf8000000-7efbf8001000 rw-p 00000000 00:00 0
-7ffbffefe000-7ffbfff01000 ---p 00000000 00:00 0
-7ffbfff02000-7ffbffffe000 rw-p 00000000 00:00 0 [stack]
-7ffc0001d000-7ffc0001f000 r--p 00000000 00:00 0 [vvar]
-7ffc0001f000-7ffc00021000 r-xp 00000000 00:00 0 [vdso]
-ffffffffff600000-ffffffffff601000 r-xp 00000000 00:00 0 [vsyscall]
-
-VM Arguments:
-jvm_args: -Djava.library.path= -Djava.util.logging.config.file=/usr/share/scilab//etc/logging.properties -Djava.compiler=JIT -Xmx256m -Xrs -Dawt.useSystemAAFontSettings=on -Djogamp.gluegen.UseTempJarCache=false
-java_command:
-Launcher Type: generic
-
-Environment Variables:
-JAVA_HOME=/usr/lib/jvm/java-7-openjdk-amd64
-PATH=/usr/share/scilab/:/usr/share/scilab//bin:/usr/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games
-LD_LIBRARY_PATH=/usr/lib/scilab/:/usr/lib64/scilab/:.:/usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/:/usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/server/:/usr/lib/jvm/java-7-openjdk-amd64/jre/lib/amd64/native_threads/
-SHELL=/bin/bash
-DISPLAY=:0.0
-
-Signal Handlers:
-SIGSEGV: [libjvm.so+0x955bc0], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
-SIGBUS: [libjvm.so+0x955bc0], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
-SIGFPE: [libjvm.so+0x7caff0], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
-SIGPIPE: SIG_IGN, sa_mask[0]=0x00001000, sa_flags=0x10000000
-SIGXFSZ: [libjvm.so+0x7caff0], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
-SIGILL: [libjvm.so+0x7caff0], sa_mask[0]=0x7ffbfeff, sa_flags=0x10000004
-SIGUSR1: SIG_DFL, sa_mask[0]=0x00000000, sa_flags=0x00000000
-SIGUSR2: [libjvm.so+0x7cae90], sa_mask[0]=0x00000000, sa_flags=0x10000004
-SIGHUP: SIG_DFL, sa_mask[0]=0x00000000, sa_flags=0x00000000
-SIGINT: [libscilab-cli.so.0+0x169220], sa_mask[0]=0x00000000, sa_flags=0x00000000
-SIGTERM: SIG_DFL, sa_mask[0]=0x00000000, sa_flags=0x00000000
-SIGQUIT: SIG_DFL, sa_mask[0]=0x00000000, sa_flags=0x00000000
-SIGTRAP: SIG_DFL, sa_mask[0]=0x00000000, sa_flags=0x00000000
-
-
---------------- S Y S T E M ---------------
-
-OS:Ubuntu 14.04 (trusty)
-uname:Linux 4.2.0-30-generic #36~14.04.1-Ubuntu SMP Fri Feb 26 18:49:23 UTC 2016 x86_64
-libc:glibc 2.19 NPTL 2.19
-rlimit: STACK 8192k, CORE 0k, NPROC 13554, NOFILE 4096, AS infinity
-load average:1.43 0.73 0.52
-
-/proc/meminfo:
-MemTotal: 3491528 kB
-MemFree: 789760 kB
-MemAvailable: 1871420 kB
-Buffers: 110392 kB
-Cached: 916116 kB
-SwapCached: 0 kB
-Active: 1870228 kB
-Inactive: 477752 kB
-Active(anon): 1323168 kB
-Inactive(anon): 9140 kB
-Active(file): 547060 kB
-Inactive(file): 468612 kB
-Unevictable: 32 kB
-Mlocked: 32 kB
-SwapTotal: 14647292 kB
-SwapFree: 14647292 kB
-Dirty: 1000 kB
-Writeback: 0 kB
-AnonPages: 1321524 kB
-Mapped: 263988 kB
-Shmem: 10844 kB
-Slab: 126236 kB
-SReclaimable: 93564 kB
-SUnreclaim: 32672 kB
-KernelStack: 6688 kB
-PageTables: 27028 kB
-NFS_Unstable: 0 kB
-Bounce: 0 kB
-WritebackTmp: 0 kB
-CommitLimit: 16393056 kB
-Committed_AS: 3583556 kB
-VmallocTotal: 34359738367 kB
-VmallocUsed: 122952 kB
-VmallocChunk: 34359537660 kB
-HardwareCorrupted: 0 kB
-AnonHugePages: 581632 kB
-CmaTotal: 0 kB
-CmaFree: 0 kB
-HugePages_Total: 0
-HugePages_Free: 0
-HugePages_Rsvd: 0
-HugePages_Surp: 0
-Hugepagesize: 2048 kB
-DirectMap4k: 290268 kB
-DirectMap2M: 3340288 kB
-DirectMap1G: 0 kB
-
-
-CPU:total 4 (4 cores per cpu, 1 threads per core) family 22 model 48 stepping 1, cmov, cx8, fxsr, mmx, sse, sse2, sse3, ssse3, sse4.1, sse4.2, popcnt, avx, aes, mmxext, 3dnowpref, lzcnt, sse4a, tsc, tscinvbit, tscinv
-
-/proc/cpuinfo:
-processor : 0
-vendor_id : AuthenticAMD
-cpu family : 22
-model : 48
-model name : AMD A8-6410 APU with AMD Radeon R5 Graphics
-stepping : 1
-microcode : 0x7030104
-cpu MHz : 2000.000
-cache size : 2048 KB
-physical id : 0
-siblings : 4
-core id : 0
-cpu cores : 4
-apicid : 0
-initial apicid : 0
-fpu : yes
-fpu_exception : yes
-cpuid level : 13
-wp : yes
-flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm constant_tsc rep_good nopl nonstop_tsc extd_apicid aperfmperf eagerfpu pni pclmulqdq monitor ssse3 cx16 sse4_1 sse4_2 movbe popcnt aes xsave avx f16c rdrand lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt topoext perfctr_nb bpext perfctr_l2 arat cpb hw_pstate npt lbrv svm_lock nrip_save tsc_scale flushbyasid decodeassists pausefilter pfthreshold vmmcall bmi1 xsaveopt
-bugs : fxsave_leak sysret_ss_attrs
-bogomips : 3992.81
-TLB size : 1024 4K pages
-clflush size : 64
-cache_alignment : 64
-address sizes : 40 bits physical, 48 bits virtual
-power management: ts ttp tm 100mhzsteps hwpstate cpb [12] [13]
-
-processor : 1
-vendor_id : AuthenticAMD
-cpu family : 22
-model : 48
-model name : AMD A8-6410 APU with AMD Radeon R5 Graphics
-stepping : 1
-microcode : 0x7030104
-cpu MHz : 1800.000
-cache size : 2048 KB
-physical id : 0
-siblings : 4
-core id : 1
-cpu cores : 4
-apicid : 1
-initial apicid : 1
-fpu : yes
-fpu_exception : yes
-cpuid level : 13
-wp : yes
-flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm constant_tsc rep_good nopl nonstop_tsc extd_apicid aperfmperf eagerfpu pni pclmulqdq monitor ssse3 cx16 sse4_1 sse4_2 movbe popcnt aes xsave avx f16c rdrand lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt topoext perfctr_nb bpext perfctr_l2 arat cpb hw_pstate npt lbrv svm_lock nrip_save tsc_scale flushbyasid decodeassists pausefilter pfthreshold vmmcall bmi1 xsaveopt
-bugs : fxsave_leak sysret_ss_attrs
-bogomips : 3992.81
-TLB size : 1024 4K pages
-clflush size : 64
-cache_alignment : 64
-address sizes : 40 bits physical, 48 bits virtual
-power management: ts ttp tm 100mhzsteps hwpstate cpb [12] [13]
-
-processor : 2
-vendor_id : AuthenticAMD
-cpu family : 22
-model : 48
-model name : AMD A8-6410 APU with AMD Radeon R5 Graphics
-stepping : 1
-microcode : 0x7030104
-cpu MHz : 2000.000
-cache size : 2048 KB
-physical id : 0
-siblings : 4
-core id : 2
-cpu cores : 4
-apicid : 2
-initial apicid : 2
-fpu : yes
-fpu_exception : yes
-cpuid level : 13
-wp : yes
-flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm constant_tsc rep_good nopl nonstop_tsc extd_apicid aperfmperf eagerfpu pni pclmulqdq monitor ssse3 cx16 sse4_1 sse4_2 movbe popcnt aes xsave avx f16c rdrand lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt topoext perfctr_nb bpext perfctr_l2 arat cpb hw_pstate npt lbrv svm_lock nrip_save tsc_scale flushbyasid decodeassists pausefilter pfthreshold vmmcall bmi1 xsaveopt
-bugs : fxsave_leak sysret_ss_attrs
-bogomips : 3992.81
-TLB size : 1024 4K pages
-clflush size : 64
-cache_alignment : 64
-address sizes : 40 bits physical, 48 bits virtual
-power management: ts ttp tm 100mhzsteps hwpstate cpb [12] [13]
-
-processor : 3
-vendor_id : AuthenticAMD
-cpu family : 22
-model : 48
-model name : AMD A8-6410 APU with AMD Radeon R5 Graphics
-stepping : 1
-microcode : 0x7030104
-cpu MHz : 2000.000
-cache size : 2048 KB
-physical id : 0
-siblings : 4
-core id : 3
-cpu cores : 4
-apicid : 3
-initial apicid : 3
-fpu : yes
-fpu_exception : yes
-cpuid level : 13
-wp : yes
-flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm constant_tsc rep_good nopl nonstop_tsc extd_apicid aperfmperf eagerfpu pni pclmulqdq monitor ssse3 cx16 sse4_1 sse4_2 movbe popcnt aes xsave avx f16c rdrand lahf_lm cmp_legacy svm extapic cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw ibs skinit wdt topoext perfctr_nb bpext perfctr_l2 arat cpb hw_pstate npt lbrv svm_lock nrip_save tsc_scale flushbyasid decodeassists pausefilter pfthreshold vmmcall bmi1 xsaveopt
-bugs : fxsave_leak sysret_ss_attrs
-bogomips : 3992.81
-TLB size : 1024 4K pages
-clflush size : 64
-cache_alignment : 64
-address sizes : 40 bits physical, 48 bits virtual
-power management: ts ttp tm 100mhzsteps hwpstate cpb [12] [13]
-
-
-
-Memory: 4k page, physical 3491528k(789744k free), swap 14647292k(14647292k free)
-
-vm_info: OpenJDK 64-Bit Server VM (24.95-b01) for linux-amd64 JRE (1.7.0_95-b00), built on Jan 21 2016 03:31:40 by "buildd" with gcc 4.8.4
-
-time: Mon Mar 14 15:52:10 2016
-elapsed time: 1594 seconds
-
diff --git a/jar/scilab_en_US_help.jar b/jar/scilab_en_US_help.jar
index f06df33..01dc38a 100644
Binary files a/jar/scilab_en_US_help.jar and b/jar/scilab_en_US_help.jar differ
diff --git a/macros/Checkdims.bin b/macros/Checkdims.bin
index 40e385a..8df0367 100644
Binary files a/macros/Checkdims.bin and b/macros/Checkdims.bin differ
diff --git a/macros/Checklhs.bin b/macros/Checklhs.bin
index 7156107..34561dc 100644
Binary files a/macros/Checklhs.bin and b/macros/Checklhs.bin differ
diff --git a/macros/Checkrhs.bin b/macros/Checkrhs.bin
index 2c45876..2ec00b7 100644
Binary files a/macros/Checkrhs.bin and b/macros/Checkrhs.bin differ
diff --git a/macros/Checktype.bin b/macros/Checktype.bin
index bbe1585..a43e55c 100644
Binary files a/macros/Checktype.bin and b/macros/Checktype.bin differ
diff --git a/macros/Checkvector.bin b/macros/Checkvector.bin
index 710f1ff..9a6bfdc 100644
Binary files a/macros/Checkvector.bin and b/macros/Checkvector.bin differ
diff --git a/macros/Checkvector.sci b/macros/Checkvector.sci
index f24a92d..76bdcc6 100644
--- a/macros/Checkvector.sci
+++ b/macros/Checkvector.sci
@@ -49,7 +49,7 @@ function errmsg = Checkvector ( funname , var , varname , ivar , nbval )
ncols = size(var,"c")
if ( nrows <> 1 & ncols <> 1 ) then
strcomp = strcat(string(size(var))," ")
- errmsg = msprintf(gettext("%s: Expected a vector matrix for input argument %s at input #%d, but current dimensions are [%s] instead."), funname, varname , ivar , strcomp );
+ errmsg = msprintf(gettext("%s: Expected a vector matrix for input argument %s at input #%d, but got [%s] instead."), funname, varname , ivar , strcomp );
error(errmsg)
end
if ( ( nrows == 1 & ncols <> nbval ) | ( ncols == 1 & nrows <> nbval ) ) then
diff --git a/macros/cleanmacros.sce b/macros/cleanmacros.sce
new file mode 100644
index 0000000..56d0240
--- /dev/null
+++ b/macros/cleanmacros.sce
@@ -0,0 +1,20 @@
+// ====================================================================
+// This file is released under the 3-clause BSD license. See COPYING-BSD.
+// ====================================================================
+function cleanmacros()
+
+ libpath = get_absolute_file_path("cleanmacros.sce");
+
+ binfiles = ls(libpath+"/*.bin");
+ for i = 1:size(binfiles,"*")
+ mdelete(binfiles(i));
+ end
+
+ mdelete(libpath+"/names");
+ mdelete(libpath+"/lib");
+endfunction
+
+cleanmacros();
+clear cleanmacros; // remove cleanmacros on stack
+
+// ====================================================================
diff --git a/macros/fgoalattain.bin b/macros/fgoalattain.bin
index faa0821..c329f4a 100644
Binary files a/macros/fgoalattain.bin and b/macros/fgoalattain.bin differ
diff --git a/macros/fminbnd.bin b/macros/fminbnd.bin
index 24cd387..c9ddb2e 100644
Binary files a/macros/fminbnd.bin and b/macros/fminbnd.bin differ
diff --git a/macros/fmincon.bin b/macros/fmincon.bin
index ef503f1..dacdfd9 100644
Binary files a/macros/fmincon.bin and b/macros/fmincon.bin differ
diff --git a/macros/fminimax.bin b/macros/fminimax.bin
index c023720..9704302 100644
Binary files a/macros/fminimax.bin and b/macros/fminimax.bin differ
diff --git a/macros/fminimax.sci b/macros/fminimax.sci
index b649640..c775b1b 100644
--- a/macros/fminimax.sci
+++ b/macros/fminimax.sci
@@ -19,11 +19,11 @@ function [x,fval,maxfval,exitflag,output,lambda] = fminimax(varargin)
// xopt = fminimax(fun,x0,A,b,Aeq,beq,lb,ub)
// xopt = fminimax(fun,x0,A,b,Aeq,beq,lb,ub,nonlinfun)
// xopt = fminimax(fun,x0,A,b,Aeq,beq,lb,ub,nonlinfun,options)
- // [xopt, fval] = fminimax(.....)
- // [xopt, fval, maxfval]= fminimax(.....)
- // [xopt, fval, maxfval, exitflag]= fminimax(.....)
- // [xopt, fval, maxfval, exitflag, output]= fminimax(.....)
- // [xopt, fval, maxfval, exitflag, output, lambda]= fminimax(.....)
+ // [xopt, fval] = fmincon(.....)
+ // [xopt, fval, maxfval]= fmincon(.....)
+ // [xopt, fval, maxfval, exitflag]= fmincon(.....)
+ // [xopt, fval, maxfval, exitflag, output]= fmincon(.....)
+ // [xopt, fval, maxfval, exitflag, output, lambda]= fmincon(.....)
//
// Parameters
// fun: The function to be minimized. fun is a function that accepts a vector x and returns a vector F, the objective functions evaluated at x.
diff --git a/macros/fminunc.bin b/macros/fminunc.bin
index 0160e5f..ab53755 100644
Binary files a/macros/fminunc.bin and b/macros/fminunc.bin differ
diff --git a/macros/fminunc.sci b/macros/fminunc.sci
index a24f1f9..38b76ec 100644
--- a/macros/fminunc.sci
+++ b/macros/fminunc.sci
@@ -280,7 +280,7 @@ function [xopt,fopt,exitflag,output,gradient,hessian] = fminunc (varargin)
else
options(4) = param(2*i); //Setting the maximum CPU time as per user entry
end
- case "gradient" then
+ case "gradobj" then
if (type(param(2*i))==10) then
if (convstr(param(2*i))=="off") then
flag1 =0;
diff --git a/macros/lib b/macros/lib
index 9b74ed8..1c23fc4 100644
Binary files a/macros/lib and b/macros/lib differ
diff --git a/macros/linprog.bin b/macros/linprog.bin
index 1d3a5aa..7ba3ab3 100644
Binary files a/macros/linprog.bin and b/macros/linprog.bin differ
diff --git a/macros/lsqlin.bin b/macros/lsqlin.bin
index 4e07959..56c1e69 100644
Binary files a/macros/lsqlin.bin and b/macros/lsqlin.bin differ
diff --git a/macros/lsqlin.sci b/macros/lsqlin.sci
index f140772..f236c0d 100644
--- a/macros/lsqlin.sci
+++ b/macros/lsqlin.sci
@@ -230,9 +230,9 @@ function [xopt,resnorm,residual,exitflag,output,lambda] = lsqlin (varargin)
select convstr(param(2*i-1),'l')
case "maxiter" then
- options(2) = param(2*i);
+ options(2*i) = param(2*i);
case "cputime" then
- options(4) = param(2*i);
+ options(2*i) = param(2*i);
else
errmsg = msprintf(gettext("%s: Unrecognized parameter name ''%s''."), "lsqlin", param(2*i-1));
error(errmsg)
diff --git a/macros/lsqnonneg.bin b/macros/lsqnonneg.bin
index 01a1a7d..17b5808 100644
Binary files a/macros/lsqnonneg.bin and b/macros/lsqnonneg.bin differ
diff --git a/macros/lsqnonneg.sci b/macros/lsqnonneg.sci
index 62ae37f..a60d417 100644
--- a/macros/lsqnonneg.sci
+++ b/macros/lsqnonneg.sci
@@ -140,9 +140,9 @@ function [xopt,resnorm,residual,exitflag,output,lambda] = lsqnonneg (varargin)
select convstr(param(2*i-1),'l')
case "maxiter" then
- options(2) = param(2*i);
+ options(2*i) = param(2*i);
case "cputime" then
- options(4) = param(2*i);
+ options(2*i) = param(2*i);
else
errmsg = msprintf(gettext("%s: Unrecognized parameter name ''%s''."), "lsqlin", param(2*i-1));
error(errmsg)
diff --git a/macros/matrix_linprog.bin b/macros/matrix_linprog.bin
index a490aaf..2b4af21 100644
Binary files a/macros/matrix_linprog.bin and b/macros/matrix_linprog.bin differ
diff --git a/macros/matrix_linprog.sci b/macros/matrix_linprog.sci
old mode 100755
new mode 100644
index 667fd3d..469066c
--- a/macros/matrix_linprog.sci
+++ b/macros/matrix_linprog.sci
@@ -109,7 +109,7 @@ function [xopt,fopt,exitflag,output,lambda] = matrix_linprog (varargin)
select convstr(param(2*i-1),'l')
case "maxiter" then
- options(2) = param(2*i);
+ options(2*i) = param(2*i);
else
errmsg = msprintf(gettext("%s: Unrecognized parameter name ''%s''."), "linprog", param(2*i-1));
error(errmsg)
@@ -205,14 +205,14 @@ function [xopt,fopt,exitflag,output,lambda] = matrix_linprog (varargin)
"constrviolation" , []);
output.Iterations = iter;
- output.constrviolation = max([0;norm(Aeq*xopt-beq, 'inf');(lb-xopt);(xopt-ub);(A*xopt-b)]);
+ output.constrviolation = []//max([0;norm(Aeq*xopt-beq, 'inf');(lb-xopt);(xopt-ub);(A*xopt-b)]);
lambda = struct("lower" , [], ..
"ineqlin" , [], ..
"eqlin" , []);
- lambda.lower = Zl;
- lambda.eqlin = dual(1:nbConEq);
- lambda.ineqlin = dual(nbConEq+1:nbCon);
+ lambda.lower = []//Zl;
+ lambda.eqlin = []//dual(1:nbConEq);
+ lambda.ineqlin = []//dual(nbConEq+1:nbCon);
select status
case 0 then
diff --git a/macros/mps_linprog.bin b/macros/mps_linprog.bin
index 2bc6eca..f45ed06 100644
Binary files a/macros/mps_linprog.bin and b/macros/mps_linprog.bin differ
diff --git a/macros/mps_linprog.sci b/macros/mps_linprog.sci
index b1be48a..aa61d02 100644
--- a/macros/mps_linprog.sci
+++ b/macros/mps_linprog.sci
@@ -51,7 +51,7 @@ function [xopt,fopt,exitflag,output,lambda] =mps_linprog(varargin)
for i = 1:(size(param))/2
select convstr(param(2*i-1),'l')
case "maxiter" then
- options(2) = param(2*i);
+ options(2*i) = param(2*i);
else
errmsg = msprintf(gettext("%s: Unrecognized parameter name ''%s''."), "linprog", param(2*i-1));
error(errmsg)
diff --git a/macros/names b/macros/names
index 21c7d4e..2f20196 100644
--- a/macros/names
+++ b/macros/names
@@ -9,6 +9,7 @@ fmincon
fminimax
fminunc
fseminf
+intlinprog
linprog
lsqlin
lsqnonlin
diff --git a/macros/qpipopt.bin b/macros/qpipopt.bin
index f6de035..d33679e 100644
Binary files a/macros/qpipopt.bin and b/macros/qpipopt.bin differ
diff --git a/macros/qpipopt.sci b/macros/qpipopt.sci
index 1696967..c900f0c 100644
--- a/macros/qpipopt.sci
+++ b/macros/qpipopt.sci
@@ -218,9 +218,9 @@ function [xopt,fopt,exitflag,output,lambda] = qpipopt (varargin)
select convstr(param(2*i-1),'l')
case "maxiter" then
- options(2) = param(2*i);
+ options(2*i) = param(2*i);
case "cputime" then
- options(4) = param(2*i);
+ options(2*i) = param(2*i);
else
errmsg = msprintf(gettext("%s: Unrecognized parameter name ''%s''."), "lsqlin", param(2*i-1));
error(errmsg)
diff --git a/macros/qpipoptmat.bin b/macros/qpipoptmat.bin
index 3e9d8f6..0bd1c14 100644
Binary files a/macros/qpipoptmat.bin and b/macros/qpipoptmat.bin differ
diff --git a/macros/qpipoptmat.sci b/macros/qpipoptmat.sci
index 5a210a1..41ec8e7 100644
--- a/macros/qpipoptmat.sci
+++ b/macros/qpipoptmat.sci
@@ -230,9 +230,9 @@ function [xopt,fopt,exitflag,output,lambda] = qpipoptmat (varargin)
select convstr(param(2*i-1),'l')
case "maxiter" then
- options(2) = param(2*i);
+ options(2*i) = param(2*i);
case "cputime" then
- options(4) = param(2*i);
+ options(2*i) = param(2*i);
else
errmsg = msprintf(gettext("%s: Unrecognized parameter name ''%s''."), "lsqlin", param(2*i-1));
error(errmsg)
diff --git a/macros/setOptions.bin b/macros/setOptions.bin
index 8d23e73..8953829 100644
Binary files a/macros/setOptions.bin and b/macros/setOptions.bin differ
diff --git a/macros/symphony.bin b/macros/symphony.bin
index 2c3a43a..3dacf06 100644
Binary files a/macros/symphony.bin and b/macros/symphony.bin differ
diff --git a/macros/symphony.sci b/macros/symphony.sci
index 111f84c..7efdeeb 100644
--- a/macros/symphony.sci
+++ b/macros/symphony.sci
@@ -170,7 +170,7 @@ function [xopt,fopt,status,output] = symphony (varargin)
// 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 1 1 0 0 1 0 ..
// 0 1 0 1 0 0 1 0 0 1 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 1 0 0 1 0]
// // Optimal value
- // fopt = [ 24381 ]
+ // fopt = [ -24381 ]
// // Calling Symphony
// [x,f,status,output] = symphony(nbVar,nbCon,c,isInt,lb,ub,A,conLB,conUB,-1,options);
// Authors
diff --git a/macros/symphony_call.bin b/macros/symphony_call.bin
index 5e0d5e1..57ce782 100644
Binary files a/macros/symphony_call.bin and b/macros/symphony_call.bin differ
diff --git a/macros/symphony_call.sci b/macros/symphony_call.sci
index 80b22d0..5d49a6f 100644
--- a/macros/symphony_call.sci
+++ b/macros/symphony_call.sci
@@ -41,11 +41,8 @@ function [xopt,fopt,status,output] = symphony_call(nbVar,nbCon,objCoef,isInt,lb,
fopt = sym_getObjVal();
end
-
status = sym_getStatus();
-
- output = struct("Iterations" , []);
-
+ output = struct("Iterations", []);
output.Iterations = sym_getIterCount();
diff --git a/macros/symphonymat.bin b/macros/symphonymat.bin
index 7dffa2f..9d7271a 100644
Binary files a/macros/symphonymat.bin and b/macros/symphonymat.bin differ
diff --git a/macros/symphonymat.sci b/macros/symphonymat.sci
index 2016f00..76b38bf 100644
--- a/macros/symphonymat.sci
+++ b/macros/symphonymat.sci
@@ -162,7 +162,7 @@ function [xopt,fopt,status,iter] = symphonymat (varargin)
// 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 1 0 0 0 0 1 1 ..
// 0 0 1 0 0 1 0 1 0 0 1 0 0 1 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 1 0 0 1 0]
// // Optimal value
- // fopt = [ 24381 ]
+ // fopt = [ -24381 ]
// // Calling Symphony
// [x,f,status,output] = symphonymat(c,intcon,A,b,[],[],lb,ub,options);
// Authors
diff --git a/sci_gateway/cpp/LinCLP.hpp b/sci_gateway/cpp/LinCLP.hpp
old mode 100755
new mode 100644
diff --git a/sci_gateway/cpp/Makelib.mak b/sci_gateway/cpp/Makelib.mak
new file mode 100644
index 0000000..ebf94b1
--- /dev/null
+++ b/sci_gateway/cpp/Makelib.mak
@@ -0,0 +1,70 @@
+# ------------------------------------------------------
+# generated by builder.sce : Please do not edit this file
+# see TEMPLATE makefile for Visual Studio
+# see SCI/modules/dynamic_link/src/scripts/TEMPLATE_MAKEFILE.VC
+# ------------------------------------------------------
+SCIDIR = C:/PROGRA~1/SCILAB~1.2
+# ------------------------------------------------------
+# default include options
+INCLUDES = -I"$(SCIDIR)/libs/MALLOC/includes" \
+-I"$(SCIDIR)/libs/f2c" \
+-I"$(SCIDIR)/libs/hashtable" \
+-I"$(SCIDIR)/libs/intl" \
+-I"$(SCIDIR)/modules/core/includes" \
+-I"$(SCIDIR)/modules/api_scilab/includes" \
+-I"$(SCIDIR)/modules/call_scilab/includes" \
+-I"$(SCIDIR)/modules/output_stream/includes" \
+-I"$(SCIDIR)/modules/jvm/includes" \
+-I"$(SCIDIR)/modules/localization/includes" \
+-I"$(SCIDIR)/modules/dynamic_link/includes" \
+-I"$(SCIDIR)/modules/mexlib/includes" \
+-I"$(SCIDIR)/modules/time/includes" \
+-I"$(SCIDIR)/modules/windows_tools/includes"
+# ------------------------------------------------------
+# SCILAB_LIBS is used by the binary version of Scilab for linking external codes
+SCILAB_LIBS = "$(SCIDIR)/bin/blasplus.lib" \
+"$(SCIDIR)/bin/libf2c.lib" \
+"$(SCIDIR)/bin/core.lib" \
+"$(SCIDIR)/bin/core_f.lib" \
+"$(SCIDIR)/bin/lapack.lib" \
+"$(SCIDIR)/bin/libintl.lib" \
+"$(SCIDIR)/bin/intersci.lib" \
+"$(SCIDIR)/bin/output_stream.lib" \
+"$(SCIDIR)/bin/dynamic_link.lib" \
+"$(SCIDIR)/bin/integer.lib" \
+"$(SCIDIR)/bin/optimization_f.lib" \
+"$(SCIDIR)/bin/libjvm.lib" \
+"$(SCIDIR)/bin/scilocalization.lib" \
+"$(SCIDIR)/bin/linpack_f.lib" \
+"$(SCIDIR)/bin/call_scilab.lib" \
+"$(SCIDIR)/bin/time.lib" \
+"$(SCIDIR)/bin/api_scilab.lib" \
+"$(SCIDIR)/bin/libintl.lib" \
+"$(SCIDIR)/bin/scilab_windows.lib"
+# ------------------------------------------------------
+# name of the dll to be built
+LIBRARY = FOSSEE_Optimization_Toolbox
+# ------------------------------------------------------
+# list of files
+FILES_SRC = FOSSEE_Optimization_Toolbox.c globals.cpp read_mps.cpp sci_LinProg.cpp sci_QuadNLP.cpp sci_iofunc.cpp sci_ipopt.cpp sci_ipoptfminbnd.cpp sci_ipoptfmincon.cpp sci_ipoptfminunc.cpp sci_minbndNLP.cpp sci_minconNLP.cpp sci_minuncNLP.cpp sci_solver_status_query_functions.cpp sci_sym_addrowcol.cpp sci_sym_get_dbl_arr.cpp sci_sym_get_iteration_count.cpp sci_sym_get_matrix.cpp sci_sym_get_num_int.cpp sci_sym_getinfinity.cpp sci_sym_getobjsense.cpp sci_sym_getrowact.cpp sci_sym_isenvactive.cpp sci_sym_load_mps.cpp sci_sym_loadproblem.cpp sci_sym_openclose.cpp sci_sym_primalbound.cpp sci_sym_remove.cpp sci_sym_rowmod.cpp sci_sym_set_indices.cpp sci_sym_set_variables.cpp sci_sym_setcolsoln.cpp sci_sym_setobj.cpp sci_sym_solution.cpp sci_sym_solve.cpp sci_sym_varbounds.cpp sci_vartype.cpp
+# ------------------------------------------------------
+# list of objects file
+OBJS = FOSSEE_Optimization_Toolbox.obj globals.obj read_mps.obj sci_LinProg.obj sci_QuadNLP.obj sci_iofunc.obj sci_ipopt.obj sci_ipoptfminbnd.obj sci_ipoptfmincon.obj sci_ipoptfminunc.obj sci_minbndNLP.obj sci_minconNLP.obj sci_minuncNLP.obj sci_solver_status_query_functions.obj sci_sym_addrowcol.obj sci_sym_get_dbl_arr.obj sci_sym_get_iteration_count.obj sci_sym_get_matrix.obj sci_sym_get_num_int.obj sci_sym_getinfinity.obj sci_sym_getobjsense.obj sci_sym_getrowact.obj sci_sym_isenvactive.obj sci_sym_load_mps.obj sci_sym_loadproblem.obj sci_sym_openclose.obj sci_sym_primalbound.obj sci_sym_remove.obj sci_sym_rowmod.obj sci_sym_set_indices.obj sci_sym_set_variables.obj sci_sym_setcolsoln.obj sci_sym_setobj.obj sci_sym_solution.obj sci_sym_solve.obj sci_sym_varbounds.obj sci_vartype.obj
+OBJS_WITH_PATH = Release/FOSSEE_Optimization_Toolbox.obj Release/globals.obj Release/read_mps.obj Release/sci_LinProg.obj Release/sci_QuadNLP.obj Release/sci_iofunc.obj Release/sci_ipopt.obj Release/sci_ipoptfminbnd.obj Release/sci_ipoptfmincon.obj Release/sci_ipoptfminunc.obj Release/sci_minbndNLP.obj Release/sci_minconNLP.obj Release/sci_minuncNLP.obj Release/sci_solver_status_query_functions.obj Release/sci_sym_addrowcol.obj Release/sci_sym_get_dbl_arr.obj Release/sci_sym_get_iteration_count.obj Release/sci_sym_get_matrix.obj Release/sci_sym_get_num_int.obj Release/sci_sym_getinfinity.obj Release/sci_sym_getobjsense.obj Release/sci_sym_getrowact.obj Release/sci_sym_isenvactive.obj Release/sci_sym_load_mps.obj Release/sci_sym_loadproblem.obj Release/sci_sym_openclose.obj Release/sci_sym_primalbound.obj Release/sci_sym_remove.obj Release/sci_sym_rowmod.obj Release/sci_sym_set_indices.obj Release/sci_sym_set_variables.obj Release/sci_sym_setcolsoln.obj Release/sci_sym_setobj.obj Release/sci_sym_solution.obj Release/sci_sym_solve.obj Release/sci_sym_varbounds.obj Release/sci_vartype.obj
+# ------------------------------------------------------
+# added libraries
+FORTRAN_RUNTIME_LIBRARIES =
+OTHERLIBS =
+# ------------------------------------------------------
+!include $(SCIDIR)\modules\dynamic_link\src\scripts\Makefile.incl.mak
+# ------------------------------------------------------
+#CC =
+# ------------------------------------------------------
+CFLAGS = $(CC_OPTIONS) -D__SCILAB_TOOLBOX__ -DFORDLL -D__USE_DEPRECATED_STACK_FUNCTIONS__ -w -I C:\Users\harpreet\Desktop\symphony-work\symphony\sci_gateway\cpp\ -I C:\Users\harpreet\Desktop\symphony-work\symphony\sci_gateway\cpp\\..\..\thirdparty\windows\include\coin
+# ------------------------------------------------------
+FFLAGS = $(FC_OPTIONS) -DFORDLL
+# ------------------------------------------------------
+EXTRA_LDFLAGS = C:\Users\harpreet\Desktop\symphony-work\symphony\sci_gateway\cpp\\..\..\thirdparty\windows\lib\x64\libClp.lib C:\Users\harpreet\Desktop\symphony-work\symphony\sci_gateway\cpp\\..\..\thirdparty\windows\lib\x64\libCgl.lib C:\Users\harpreet\Desktop\symphony-work\symphony\sci_gateway\cpp\\..\..\thirdparty\windows\lib\x64\libOsi.lib C:\Users\harpreet\Desktop\symphony-work\symphony\sci_gateway\cpp\\..\..\thirdparty\windows\lib\x64\libOsiClp.lib C:\Users\harpreet\Desktop\symphony-work\symphony\sci_gateway\cpp\\..\..\thirdparty\windows\lib\x64\libCoinUtils.lib C:\Users\harpreet\Desktop\symphony-work\symphony\sci_gateway\cpp\\..\..\thirdparty\windows\lib\x64\libSymphony.lib C:\Users\harpreet\Desktop\symphony-work\symphony\sci_gateway\cpp\\..\..\thirdparty\windows\lib\x64\IpOptFSS.lib C:\Users\harpreet\Desktop\symphony-work\symphony\sci_gateway\cpp\\..\..\thirdparty\windows\lib\x64\IpOpt-vc10.lib
+# ------------------------------------------------------
+!include $(SCIDIR)\modules\dynamic_link\src\scripts\Makedll.incl
+# ------------------------------------------------------
diff --git a/sci_gateway/cpp/QuadNLP.hpp b/sci_gateway/cpp/QuadNLP.hpp
index 4020913..4e0da42 100644
--- a/sci_gateway/cpp/QuadNLP.hpp
+++ b/sci_gateway/cpp/QuadNLP.hpp
@@ -26,46 +26,44 @@ class QuadNLP : public TNLP
Index numConstr_; // Number of constraints.
- const Number *qMatrix_ = NULL; //qMatrix_ is a pointer to matrix of size numVars X numVars_
+ const Number *qMatrix_; //qMatrix_ is a pointer to matrix of size numVars X numVars_
// with coefficents of quadratic terms in objective function.
- const Number *lMatrix_ = NULL;//lMatrix_ is a pointer to matrix of size 1*numVars_
+ const Number *lMatrix_;//lMatrix_ is a pointer to matrix of size 1*numVars_
// with coefficents of linear terms in objective function.
- const Number *conMatrix_ = NULL;//conMatrix_ is a pointer to matrix of size numConstr X numVars
// with coefficients of terms in a each objective in each row.
+ const Number *conMatrix_ ;//conMatrix_ is a pointer to matrix of size numConstr X numVars
- const Number *conUB_= NULL; //conUB_ is a pointer to a matrix of size of 1*numConstr_
+ const Number *conUB_; //conUB_ is a pointer to a matrix of size of 1*numConstr_
// with upper bounds of all constraints.
- const Number *conLB_ = NULL; //conLB_ is a pointer to a matrix of size of 1*numConstr_
+ const Number *conLB_ ; //conLB_ is a pointer to a matrix of size of 1*numConstr_
// with lower bounds of all constraints.
- const Number *varUB_= NULL; //varUB_ is a pointer to a matrix of size of 1*numVar_
+ const Number *varUB_; //varUB_ is a pointer to a matrix of size of 1*numVar_
// with upper bounds of all variables.
- const Number *varLB_= NULL; //varLB_ is a pointer to a matrix of size of 1*numVar_
+ const Number *varLB_; //varLB_ is a pointer to a matrix of size of 1*numVar_
// with lower bounds of all variables.
- const Number *varGuess_= NULL; //varGuess_ is a pointer to a matrix of size of 1*numVar_
+ const Number *varGuess_; //varGuess_ is a pointer to a matrix of size of 1*numVar_
// with initial guess of all variables.
- Number *finalX_= NULL; //finalX_ is a pointer to a matrix of size of 1*numVar_
+ Number *finalX_; //finalX_ is a pointer to a matrix of size of 1*numVar_
// with final value for the primal variables.
- Number *finalZl_= NULL; //finalZl_ is a pointer to a matrix of size of 1*numVar_
+ Number *finalZl_; //finalZl_ is a pointer to a matrix of size of 1*numVar_
// with final values for the lower bound multipliers
- Number *finalZu_= NULL; //finalZu_ is a pointer to a matrix of size of 1*numVar_
+ Number *finalZu_; //finalZu_ is a pointer to a matrix of size of 1*numVar_
// with final values for the upper bound multipliers
- Number *finalLambda_= NULL; //finalLambda_ is a pointer to a matrix of size of 1*numConstr_
+ Number *finalLambda_; //finalLambda_ is a pointer to a matrix of size of 1*numConstr_
// with final values for the upper bound multipliers
Number finalObjVal_; //finalObjVal_ is a scalar with the final value of the objective.
- int iter_; //Number of iteration.
-
int status_; //Solver return status
QuadNLP(const QuadNLP&);
@@ -123,8 +121,6 @@ class QuadNLP : public TNLP
double getObjVal(); //Returns the output of the final value of the objective.
- double iterCount(); //Returns the iteration count
-
int returnStatus(); //Returns the status count
diff --git a/sci_gateway/cpp/builder_gateway_cpp.sce b/sci_gateway/cpp/builder_gateway_cpp.sce
index c92bd7f..f0890d9 100644
--- a/sci_gateway/cpp/builder_gateway_cpp.sce
+++ b/sci_gateway/cpp/builder_gateway_cpp.sce
@@ -14,20 +14,10 @@ lines(0)
toolbox_title = "FOSSEE_Optimization_Toolbox";
-[a, opt] = getversion();
-Version = opt(2);
-
-Build_64Bits = %f;
+Build_64Bits = %t;
path_builder = get_absolute_file_path('builder_gateway_cpp.sce');
-tools_path = path_builder + "../../thirdparty/linux/";
-
-C_Flags=["-D__USE_DEPRECATED_STACK_FUNCTIONS__ -w -fpermissive -I"+tools_path+"include/coin -Wl,-rpath="+tools_path+"lib/"+Version+filesep()+" "]
-
-Linker_Flag = ["-L"+tools_path+"lib/"+Version+filesep()+"libSym"+" "+"-L"+tools_path+"lib/"+Version+filesep()+"libipopt"+" "+"-L"+tools_path+"lib/"+Version+filesep()+"libClp"+" "+"-L"+tools_path+"lib/"+Version+filesep()+"libOsiClp"+" "+"-L"+tools_path+"lib/"+Version+filesep()+"libCoinUtils" ]
-
-
//Name of All the Functions
Function_Names = [
//for opening/closing environment and checking if it is open/close
@@ -79,7 +69,6 @@ Function_Names = [
"sym_setConstrUpper","sci_sym_setConstrBound";
"sym_setConstrType","sci_sym_setConstrType";
"sym_getMatrix","sci_sym_get_matrix";
- "sym_getConstrSense","sci_sym_get_row_sense";
//add/remove variables and constraints
"sym_addConstr","sci_sym_addConstr";
@@ -126,18 +115,20 @@ Function_Names = [
//Name of all the files to be compiled
Files = [
"globals.cpp",
- "sci_iofunc.hpp",
"sci_iofunc.cpp",
"sci_sym_openclose.cpp",
"sci_solver_status_query_functions.cpp",
- "sci_sym_solve.cpp",
+ "sci_sym_solve.cpp",
"sci_sym_loadproblem.cpp",
"sci_sym_isenvactive.cpp",
"sci_sym_load_mps.cpp",
"sci_vartype.cpp",
"sci_sym_getinfinity.cpp",
"sci_sym_solution.cpp",
- "sym_data_query_functions.cpp"
+ "sci_sym_get_dbl_arr.cpp",
+ "sci_sym_get_iteration_count.cpp",
+ "sci_sym_get_matrix.cpp",
+ "sci_sym_get_num_int.cpp",
"sci_sym_set_variables.cpp",
"sci_sym_setobj.cpp",
"sci_sym_varbounds.cpp",
@@ -150,24 +141,42 @@ Files = [
"sci_sym_getobjsense.cpp",
"sci_sym_remove.cpp",
"sci_QuadNLP.cpp",
- "QuadNLP.hpp",
"sci_ipopt.cpp",
- "minuncNLP.hpp",
+ "sci_QuadNLP.cpp",
+ "sci_ipopt.cpp",
"sci_minuncNLP.cpp",
"sci_ipoptfminunc.cpp",
- "minbndNLP.hpp",
"sci_minbndNLP.cpp",
"sci_ipoptfminbnd.cpp",
- "minconNLP.hpp",
"sci_minconNLP.cpp",
"sci_ipoptfmincon.cpp",
- "sci_ipopt.cpp",
"sci_LinProg.cpp",
- "sci_LinCLP.cpp",
- "LinCLP.hpp",
"read_mps.cpp"
]
-tbx_build_gateway(toolbox_title,Function_Names,Files,get_absolute_file_path("builder_gateway_cpp.sce"), [], Linker_Flag, C_Flags, [], "g++");
+[a, opt] = getversion();
+Version = opt(2);
-clear WITHOUT_AUTO_PUTLHSVAR toolbox_title Function_Names Files Linker_Flag C_Flags;
+//Build_64Bits = %f;
+
+if getos()=="Windows" then
+ third_dir = path_builder+filesep()+'..'+filesep()+'..'+filesep()+'thirdparty';
+ lib_base_dir = third_dir + filesep() + 'windows' + filesep() + 'lib' + filesep() + Version + filesep();
+ inc_base_dir = third_dir + filesep() + 'windows' + filesep() + 'include' + filesep() + 'coin';
+ C_Flags=['-D__USE_DEPRECATED_STACK_FUNCTIONS__ -w -I '+path_builder+' '+ '-I '+inc_base_dir+' ']
+ Linker_Flag = [lib_base_dir+"libClp.lib "+lib_base_dir+"libCgl.lib "+lib_base_dir+"libOsi.lib "+lib_base_dir+"libOsiClp.lib "+lib_base_dir+"libCoinUtils.lib "+lib_base_dir+"libSymphony.lib "+lib_base_dir+"IpOptFSS.lib "+lib_base_dir+"IpOpt-vc10.lib "]
+
+else
+ third_dir = path_builder+filesep()+'..'+filesep()+'..'+filesep()+'thirdparty';
+ lib_base_dir = third_dir + filesep() + 'linux' + filesep() + 'lib' + filesep() + Version + filesep();
+ inc_base_dir = third_dir + filesep() + 'linux' + filesep() + 'include' + filesep() + 'coin';
+
+ C_Flags=["-D__USE_DEPRECATED_STACK_FUNCTIONS__ -w -fpermissive -I"+path_builder+" -I"+inc_base_dir+" -Wl,-rpath="+lib_base_dir+" "]
+
+ Linker_Flag = ["-L"+lib_base_dir+"libSym"+" "+"-L"+lib_base_dir+"libipopt"+" "+"-L"+lib_base_dir+"libClp"+" "+"-L"+lib_base_dir+"libOsiClp"+" "+"-L"+lib_base_dir+"libCoinUtils" ]
+
+end
+
+tbx_build_gateway(toolbox_title,Function_Names,Files,get_absolute_file_path("builder_gateway_cpp.sce"), [], Linker_Flag, C_Flags);
+
+clear toolbox_title Function_Names Files Linker_Flag C_Flags;
diff --git a/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.c b/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.c
index cd53066..5e5ce31 100644
--- a/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.c
+++ b/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.c
@@ -44,7 +44,6 @@ extern Gatefunc sci_sym_setConstrBound;
extern Gatefunc sci_sym_setConstrBound;
extern Gatefunc sci_sym_setConstrType;
extern Gatefunc sci_sym_get_matrix;
-extern Gatefunc sci_sym_get_row_sense;
extern Gatefunc sci_sym_addConstr;
extern Gatefunc sci_sym_addVar;
extern Gatefunc sci_sym_delete_cols;
@@ -109,7 +108,6 @@ static GenericTable Tab[]={
{(Myinterfun)sci_gateway,sci_sym_setConstrBound,"sym_setConstrUpper"},
{(Myinterfun)sci_gateway,sci_sym_setConstrType,"sym_setConstrType"},
{(Myinterfun)sci_gateway,sci_sym_get_matrix,"sym_getMatrix"},
- {(Myinterfun)sci_gateway,sci_sym_get_row_sense,"sym_getConstrSense"},
{(Myinterfun)sci_gateway,sci_sym_addConstr,"sym_addConstr"},
{(Myinterfun)sci_gateway,sci_sym_addVar,"sym_addVar"},
{(Myinterfun)sci_gateway,sci_sym_delete_cols,"sym_deleteVars"},
diff --git a/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so b/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so
index 28c2d3b..78cf4da 100755
Binary files a/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so and b/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so differ
diff --git a/sci_gateway/cpp/loader.sce b/sci_gateway/cpp/loader.sce
index 1ec953f..8b15fde 100644
--- a/sci_gateway/cpp/loader.sce
+++ b/sci_gateway/cpp/loader.sce
@@ -48,7 +48,6 @@ list_functions = [ 'sym_open';
'sym_setConstrUpper';
'sym_setConstrType';
'sym_getMatrix';
- 'sym_getConstrSense';
'sym_addConstr';
'sym_addVar';
'sym_deleteVars';
diff --git a/sci_gateway/cpp/minbndNLP.hpp b/sci_gateway/cpp/minbndNLP.hpp
index 17d5a7e..684d905 100644
--- a/sci_gateway/cpp/minbndNLP.hpp
+++ b/sci_gateway/cpp/minbndNLP.hpp
@@ -24,26 +24,24 @@ class minbndNLP : public TNLP
Index numConstr_; //Number of constraints
- Number *finalX_= NULL; //finalX_ is a pointer to a matrix of size of 1*1
+ Number *finalX_; //finalX_ is a pointer to a matrix of size of 1*1
//with final value for the primal variable.
- Number *finalZl_= NULL; //finalZl_ is a pointer to a matrix of size of 1*numVar_
+ Number *finalZl_; //finalZl_ is a pointer to a matrix of size of 1*numVar_
// with final values for the lower bound multipliers
- Number *finalZu_= NULL; //finalZu_ is a pointer to a matrix of size of 1*numVar_
+ Number *finalZu_; //finalZu_ is a pointer to a matrix of size of 1*numVar_
// with final values for the upper bound multipliers
Number finalObjVal_; //finalObjVal_ is a scalar with the final value of the objective.
- int iter_; //Number of iteration.
-
int status_; //Solver return status
- const Number *varUB_= NULL; //varUB_ is a pointer to a matrix of size of 1*1
+ const Number *varUB_; //varUB_ is a pointer to a matrix of size of 1*1
// with upper bounds of all variable.
- const Number *varLB_= NULL; //varLB_ is a pointer to a matrix of size of 1*1
+ const Number *varLB_; //varLB_ is a pointer to a matrix of size of 1*1
// with lower bounds of all variable.
minbndNLP(const minbndNLP&);
@@ -106,8 +104,6 @@ class minbndNLP : public TNLP
double getObjVal(); //Returns the output of the final value of the objective.
- double iterCount(); //Returns the iteration count
-
int returnStatus(); //Returns the status count
};
diff --git a/sci_gateway/cpp/minconNLP.hpp b/sci_gateway/cpp/minconNLP.hpp
index 0dcaf26..b768ec5 100644
--- a/sci_gateway/cpp/minconNLP.hpp
+++ b/sci_gateway/cpp/minconNLP.hpp
@@ -28,13 +28,13 @@ class minconNLP : public TNLP
Number nonlinIneqCon_; //Number of non-linear inequality constraints
- const Number *A_= NULL; //Matrix for linear inequality constraints
+ const Number *A_; //Matrix for linear inequality constraints
- const Number *b_= NULL; //Matrix for bounds of linear inequality constraints
+ const Number *b_; //Matrix for bounds of linear inequality constraints
- const Number *Aeq_= NULL; //Matrix for linear equality constraints
+ const Number *Aeq_; //Matrix for linear equality constraints
- const Number *beq_= NULL; //Matrix for bounds of linear equality constraints
+ const Number *beq_; //Matrix for bounds of linear equality constraints
Index Arows_; //Number of rows of linear inequality constraints
@@ -53,39 +53,37 @@ class minconNLP : public TNLP
Index beqcols_; //Number of columns of bounds of linear equality constraints
- const Number *varGuess_= NULL; //varGuess_ is a pointer to a matrix of size of 1*numVars_
+ const Number *varGuess_; //varGuess_ is a pointer to a matrix of size of 1*numVars_
//with initial guess of all variables.
- const Number *varUB_= NULL; //varUB_ is a pointer to a matrix of size of 1*numVar_
+ const Number *varUB_; //varUB_ is a pointer to a matrix of size of 1*numVar_
// with upper bounds of all variables.
- const Number *varLB_= NULL; //varLB_ is a pointer to a matrix of size of 1*numVar_
+ const Number *varLB_; //varLB_ is a pointer to a matrix of size of 1*numVar_
// with lower bounds of all variables.
- Number *finalZl_= NULL; //finalZl_ is a pointer to a matrix of size of 1*numVar_
+ Number *finalZl_; //finalZl_ is a pointer to a matrix of size of 1*numVar_
// with final values for the lower bound multipliers
- Number *finalZu_= NULL; //finalZu_ is a pointer to a matrix of size of 1*numVar_
+ Number *finalZu_; //finalZu_ is a pointer to a matrix of size of 1*numVar_
// with final values for the upper bound multipliers
- Number *finalLambda_= NULL; //finalLambda_ is a pointer to a matrix of size of 1*numConstr_
+ Number *finalLambda_; //finalLambda_ is a pointer to a matrix of size of 1*numConstr_
// with final values for the upper bound multipliers
- Number *finalX_= NULL; //finalX_ is a pointer to a matrix of size of 1*numVars_
+ Number *finalX_; //finalX_ is a pointer to a matrix of size of 1*numVars_
//with final value for the primal variables.
- Number *finalGradient_=NULL; //finalGradient_ is a pointer to a matrix of size of numVars_*numVars_
+ Number *finalGradient_; //finalGradient_ is a pointer to a matrix of size of numVars_*numVars_
//with final value of gradient for the primal variables.
- Number *finalHessian_=NULL; //finalHessian_ is a pointer to a matrix of size of 1*numVar_
+ Number *finalHessian_; //finalHessian_ is a pointer to a matrix of size of 1*numVar_
//with final value of hessian for the primal variables.
Number finalObjVal_; //finalObjVal_ is a scalar with the final value of the objective.
- int iter_; //Number of iteration.
-
int status_; //Solver return status
@@ -158,8 +156,6 @@ class minconNLP : public TNLP
double getObjVal(); //Returns the output of the final value of the objective.
- double iterCount(); //Returns the iteration count
-
int returnStatus(); //Returns the status count
};
diff --git a/sci_gateway/cpp/minuncNLP.hpp b/sci_gateway/cpp/minuncNLP.hpp
index 70910e5..fba38f7 100644
--- a/sci_gateway/cpp/minuncNLP.hpp
+++ b/sci_gateway/cpp/minuncNLP.hpp
@@ -28,18 +28,16 @@ class minuncNLP : public TNLP
Number flag2_; //Used for Hessian ON/OFF
- const Number *varGuess_= NULL; //varGuess_ is a pointer to a matrix of size of 1*numVars_ with initial guess of all variables.
+ const Number *varGuess_; //varGuess_ is a pointer to a matrix of size of 1*numVars_ with initial guess of all variables.
- Number *finalX_= NULL; //finalX_ is a pointer to a matrix of size of 1*numVars_ with final value for the primal variables.
+ Number *finalX_; //finalX_ is a pointer to a matrix of size of 1*numVars_ with final value for the primal variables.
- Number *finalGradient_=NULL; //finalGradient_ is a pointer to a matrix of size of numVars_*numVars_ with final value of gradient for the primal variables.
+ Number *finalGradient_; //finalGradient_ is a pointer to a matrix of size of numVars_*numVars_ with final value of gradient for the primal variables.
- Number *finalHessian_=NULL; //finalHessian_ is a pointer to a matrix of size of 1*numVar_ with final value of hessian for the primal variables.
+ Number *finalHessian_; //finalHessian_ is a pointer to a matrix of size of 1*numVar_ with final value of hessian for the primal variables.
Number finalObjVal_; //finalObjVal_ is a scalar with the final value of the objective.
- int iter_; //Number of iteration.
-
int status_; //Solver return status
@@ -103,8 +101,6 @@ class minuncNLP : public TNLP
double getObjVal(); //Returns the output of the final value of the objective.
- double iterCount(); //Returns the iteration count
-
int returnStatus(); //Returns the status count
};
diff --git a/sci_gateway/cpp/read_mps.cpp b/sci_gateway/cpp/read_mps.cpp
index 31f71b8..79a78c4 100644
--- a/sci_gateway/cpp/read_mps.cpp
+++ b/sci_gateway/cpp/read_mps.cpp
@@ -102,12 +102,8 @@ int sci_rmps(char *fname)
returnDoubleMatrixToScilab(5 , 1 , numVars_ , reducedCost);
returnDoubleMatrixToScilab(6 , 1 , numCons_ , dual);
- free(xValue);
- free(dual);
- free(reducedCost);
+ free((double *)xValue);
+ free((double *)dual);
+ free((double *)reducedCost);
+ }
}
-}
-
-
-
-
diff --git a/sci_gateway/cpp/sci_LinProg.cpp b/sci_gateway/cpp/sci_LinProg.cpp
index 95538ec..6be41cd 100644
--- a/sci_gateway/cpp/sci_LinProg.cpp
+++ b/sci_gateway/cpp/sci_LinProg.cpp
@@ -6,7 +6,10 @@
*/
#include "sci_iofunc.hpp"
-#include "LinCLP.hpp"
+#include"OsiSolverInterface.hpp"
+#include "OsiClpSolverInterface.hpp"
+#include "CoinPackedMatrix.hpp"
+#include "CoinPackedVector.hpp"
extern "C"{
#include
@@ -33,8 +36,6 @@ int sci_linearprog(char *fname)
double* options;
//Flag for Mps
double flagMps;
- //mps file path
- char * mpsFile;
//Error structure in Scilab
SciErr sciErr;
//Number of rows and columns in objective function
@@ -113,35 +114,70 @@ int sci_linearprog(char *fname)
return 1;
}
- //Call to the Clp Solver
- LinCLP* Prob = new LinCLP(nVars,nCons,obj,conMatrix,conlb,conub,lb,ub,options);
-
+ OsiSolverInterface* si = new OsiClpSolverInterface();
+ //Defining the constraint matrix
+ CoinPackedMatrix *matrix = new CoinPackedMatrix(false , 0 , 0);
+ matrix->setDimensions(0 , nVars);
+ for(int i=0 ; iappendRow(row);
+ }
+ //setting options for maximum iterations
+ si->setIntParam(OsiMaxNumIteration,options[0]);
+
+ //Load the problem to OSI
+ si->loadProblem(*matrix , lb , ub, obj , conlb , conub);
+
+ //Solve the problem
+ si->initialSolve();
//Output the solution to Scilab
//get solution for x
- double* xValue = Prob->getX();
-
+ const double* xValue = si->getColSolution();
+ for(int i=0;igetObjVal();
-
- //get Status value
- double status = Prob->returnStatus();
-
+ double objValue = si->getObjValue();
+
+ //get Status value
+ double status_ = 0;
+ if(si->isProvenOptimal())
+ status_=0;
+ else if(si->isProvenPrimalInfeasible())
+ status_=1;
+ else if(si->isProvenDualInfeasible())
+ status_=2;
+ else if(si->isIterationLimitReached())
+ status_=3;
+ else if(si->isAbandoned())
+ status_=4;
+ else if(si->isPrimalObjectiveLimitReached())
+ status_=5;
+ else if(si->isDualObjectiveLimitReached())
+ status_=6;
+
//get number of iterations
- double iterations = Prob->iterCount();
-
+ double iterations = si->getIterationCount();
+
//get reduced cost
- double* Zl = Prob->getReducedCost();
-
+ const double* Zl = si->getReducedCost();
+
//get dual vector
- double* dual = Prob->getDual();
+ const double* dual = si->getRowPrice();
returnDoubleMatrixToScilab(1 , 1 , nVars , xValue);
returnDoubleMatrixToScilab(2 , 1 , 1 , &objValue);
- returnDoubleMatrixToScilab(3 , 1 , 1 , &status);
+ returnDoubleMatrixToScilab(3 , 1 , 1 , &status_);
returnDoubleMatrixToScilab(4 , 1 , 1 , &iterations);
returnDoubleMatrixToScilab(5 , 1 , nVars , Zl);
returnDoubleMatrixToScilab(6 , 1 , nCons , dual);
-
+
}
}
diff --git a/sci_gateway/cpp/sci_QuadNLP.cpp b/sci_gateway/cpp/sci_QuadNLP.cpp
index b1a0e04..8ec6f40 100644
--- a/sci_gateway/cpp/sci_QuadNLP.cpp
+++ b/sci_gateway/cpp/sci_QuadNLP.cpp
@@ -10,7 +10,11 @@
// Email: toolbox@scilab.in
#include "QuadNLP.hpp"
-#include "IpIpoptData.hpp"
+#include
+#include
+#include
+#include
+#include
extern "C"{
#include
@@ -18,7 +22,11 @@ extern "C"{
#include
#include
#include
-
+#if defined(_MSC_VER)
+#include "config_ipopt.h"
+#else
+#include "IpoptConfig.h"
+#endif
double x_static,i, *op_obj_x = NULL,*op_obj_value = NULL;
@@ -214,9 +222,6 @@ void QuadNLP::finalize_solution(SolverReturn status,
finalObjVal_ = obj_value;
status_ = status;
- if (status_ == 0 | status_ == 1 | status_ == 2){
- iter_ = ip_data->iter_count();
- }
}
const double * QuadNLP::getX()
@@ -244,11 +249,6 @@ void QuadNLP::finalize_solution(SolverReturn status,
return finalObjVal_;
}
- double QuadNLP::iterCount()
- {
- return (double)iter_;
- }
-
int QuadNLP::returnStatus()
{
return status_;
diff --git a/sci_gateway/cpp/sci_iofunc.cpp b/sci_gateway/cpp/sci_iofunc.cpp
index 8dc2acf..978a017 100644
--- a/sci_gateway/cpp/sci_iofunc.cpp
+++ b/sci_gateway/cpp/sci_iofunc.cpp
@@ -267,7 +267,7 @@ int returnDoubleToScilab(double retVal)
return 0;
}
-int returnDoubleMatrixToScilab(int itemPos, int rows, int cols, double *dest)
+int returnDoubleMatrixToScilab(int itemPos, int rows, int cols, const double *dest)
{
SciErr sciErr;
//same steps as above
diff --git a/sci_gateway/cpp/sci_iofunc.hpp b/sci_gateway/cpp/sci_iofunc.hpp
index 2c84c82..287002a 100644
--- a/sci_gateway/cpp/sci_iofunc.hpp
+++ b/sci_gateway/cpp/sci_iofunc.hpp
@@ -18,7 +18,7 @@ int getStringFromScilab(int argNum,char** dest);
//output
int return0toScilab();
int returnDoubleToScilab(double retVal);
-int returnDoubleMatrixToScilab(int itemPos, int rows, int cols, double *dest);
+int returnDoubleMatrixToScilab(int itemPos, int rows, int cols,const double *dest);
int returnIntegerMatrixToScilab(int itemPos, int rows, int cols, int *dest);
#endif //SCI_IOFUNCHEADER
diff --git a/sci_gateway/cpp/sci_ipopt.cpp b/sci_gateway/cpp/sci_ipopt.cpp
index 635003e..e25ccd0 100644
--- a/sci_gateway/cpp/sci_ipopt.cpp
+++ b/sci_gateway/cpp/sci_ipopt.cpp
@@ -11,6 +11,7 @@
#include "sci_iofunc.hpp"
#include "IpIpoptApplication.hpp"
+#include "IpSolveStatistics.hpp"
#include "QuadNLP.hpp"
extern "C"{
@@ -33,11 +34,12 @@ int sci_solveqp(char *fname)
// Input arguments
double *QItems=NULL,*PItems=NULL,*ConItems=NULL,*conUB=NULL,*conLB=NULL;
double *cpu_time=NULL,*max_iter=NULL,*varUB=NULL,*varLB=NULL,*init_guess=NULL;
- static unsigned int nVars = 0,nCons = 0;
+ static int nVars = 0,nCons = 0;
unsigned int temp1 = 0,temp2 = 0, iret = 0;
// Output arguments
- double *fX = NULL, ObjVal=0,iteration=0, *Zl=NULL, *Zu=NULL, *Lambda=NULL;
+ const double *fX = NULL, *Zl=NULL, *Zu=NULL, *Lambda=NULL;
+ double ObjVal=0,iteration=0;
int rstatus = 0;
////////// Manage the input argument //////////
@@ -140,7 +142,6 @@ int sci_solveqp(char *fname)
new QuadNLP(nVars,nCons,QItems,PItems,ConItems,conUB,conLB,varUB,varLB,init_guess);
SmartPtr app = IpoptApplicationFactory();
- app->RethrowNonIpoptException(true);
////////// Managing the parameters //////////
@@ -164,7 +165,7 @@ int sci_solveqp(char *fname)
}
// Ask Ipopt to solve the problem
- status = app->OptimizeTNLP(Prob);
+ status = app->OptimizeTNLP((SmartPtr&)Prob);
rstatus = Prob->returnStatus();
@@ -173,7 +174,7 @@ int sci_solveqp(char *fname)
if (rstatus >= 0 | rstatus <= 7){
fX = Prob->getX();
ObjVal = Prob->getObjVal();
- iteration = Prob->iterCount();
+ iteration = (double)app->Statistics()->IterationCount();
if (returnDoubleMatrixToScilab(1, 1, nVars, fX))
{
diff --git a/sci_gateway/cpp/sci_ipoptfminbnd.cpp b/sci_gateway/cpp/sci_ipoptfminbnd.cpp
index aa5addf..b06c741 100644
--- a/sci_gateway/cpp/sci_ipoptfminbnd.cpp
+++ b/sci_gateway/cpp/sci_ipoptfminbnd.cpp
@@ -49,9 +49,9 @@ int sci_solveminbndp(char *fname)
int x1_rows, x1_cols, x2_rows, x2_cols;
// Output arguments
- double *fX = NULL, ObjVal=0,iteration=0,cpuTime=0,fobj_eval=0;
- double *fZl=NULL;
- double *fZu=NULL;
+ double ObjVal=0,iteration=0,cpuTime=0,fobj_eval=0;
+ const double *fX = NULL,*fZl=NULL;
+ const double *fZu=NULL;
double dual_inf, constr_viol, complementarity, kkt_error;
int rstatus = 0;
int int_fobj_eval, int_constr_eval, int_fobj_grad_eval, int_constr_jac_eval, int_hess_eval;
@@ -110,7 +110,6 @@ int sci_solveminbndp(char *fname)
SmartPtr Prob = new minbndNLP(nVars,nCons,varLB,varUB);
SmartPtr app = IpoptApplicationFactory();
- app->RethrowNonIpoptException(true);
////////// Managing the parameters //////////
@@ -126,7 +125,7 @@ int sci_solveminbndp(char *fname)
return (int) status;
}
// Ask Ipopt to solve the problem
- status = app->OptimizeTNLP(Prob);
+ status = app->OptimizeTNLP((SmartPtr&)Prob);
//Get the solve statistics
cpuTime = app->Statistics()->TotalCPUTime();
@@ -139,7 +138,7 @@ int sci_solveminbndp(char *fname)
fX = Prob->getX();
ObjVal = Prob->getObjVal();
- iteration = Prob->iterCount();
+ iteration = (double)app->Statistics()->IterationCount();
fobj_eval=(double)int_fobj_eval;
fZl = Prob->getZl();
fZu = Prob->getZu();
diff --git a/sci_gateway/cpp/sci_ipoptfmincon.cpp b/sci_gateway/cpp/sci_ipoptfmincon.cpp
index c19687d..4f9ea71 100644
--- a/sci_gateway/cpp/sci_ipoptfmincon.cpp
+++ b/sci_gateway/cpp/sci_ipoptfmincon.cpp
@@ -48,13 +48,13 @@ int sci_solveminconp(char *fname)
int x0_rows=0, x0_cols=0, lb_rows=0, lb_cols=0, ub_rows=0, ub_cols=0, A_rows=0, A_cols=0, b_rows=0, b_cols=0, Aeq_rows=0, Aeq_cols=0, beq_rows=0, beq_cols=0;
// Output arguments
- double *fX = NULL, ObjVal=0,iteration=0,cpuTime=0,fobj_eval=0;
+ double ObjVal=0,iteration=0,cpuTime=0,fobj_eval=0;
double dual_inf, constr_viol, complementarity, kkt_error;
- double *fGrad = NULL;
- double *fHess = NULL;
- double *fLambda = NULL;
- double *fZl=NULL;
- double *fZu=NULL;
+ const double *fX = NULL, *fGrad = NULL;
+ const double *fHess = NULL;
+ const double *fLambda = NULL;
+ const double *fZl=NULL;
+ const double *fZu=NULL;
int rstatus = 0;
int int_fobj_eval, int_constr_eval, int_fobj_grad_eval, int_constr_jac_eval, int_hess_eval;
@@ -136,7 +136,6 @@ int sci_solveminconp(char *fname)
SmartPtr Prob = new minconNLP(nVars, nCons, x0ptr, Aptr, bptr, Aeqptr, beqptr, A_rows, A_cols, b_rows, b_cols, Aeq_rows, Aeq_cols, beq_rows, beq_cols, lbptr, ubptr, nonlinCon, nonlinIneqCon);
SmartPtr app = IpoptApplicationFactory();
- app->RethrowNonIpoptException(true);
////////// Managing the parameters //////////
@@ -155,7 +154,7 @@ int sci_solveminconp(char *fname)
}
// Ask Ipopt to solve the problem
- status = app->OptimizeTNLP(Prob);
+ status = app->OptimizeTNLP((SmartPtr&)Prob);
//Get the solve statistics
cpuTime = app->Statistics()->TotalCPUTime();
@@ -173,7 +172,7 @@ int sci_solveminconp(char *fname)
fZl = Prob->getZl();
fZu = Prob->getZu();
ObjVal = Prob->getObjVal();
- iteration = Prob->iterCount();
+ iteration = (double)app->Statistics()->IterationCount();
if (returnDoubleMatrixToScilab(1, 1, nVars, fX))
{
diff --git a/sci_gateway/cpp/sci_ipoptfminunc.cpp b/sci_gateway/cpp/sci_ipoptfminunc.cpp
index 19c59ac..1d74815 100644
--- a/sci_gateway/cpp/sci_ipoptfminunc.cpp
+++ b/sci_gateway/cpp/sci_ipoptfminunc.cpp
@@ -50,10 +50,10 @@ int sci_solveminuncp(char *fname)
int x0_rows, x0_cols;
// Output arguments
- double *fX = NULL, ObjVal=0,iteration=0,cpuTime=0,fobj_eval=0;
+ double ObjVal=0,iteration=0,cpuTime=0,fobj_eval=0;
double dual_inf, constr_viol, complementarity, kkt_error;
- double *fGrad= NULL;
- double *fHess= NULL;
+ const double *fX = NULL, *fGrad= NULL;
+ const double *fHess= NULL;
int rstatus = 0;
int int_fobj_eval, int_constr_eval, int_fobj_grad_eval, int_constr_jac_eval, int_hess_eval;
@@ -110,7 +110,6 @@ int sci_solveminuncp(char *fname)
SmartPtr Prob = new minuncNLP(nVars, nCons, x0ptr, flag1, flag2);
SmartPtr app = IpoptApplicationFactory();
- app->RethrowNonIpoptException(true);
////////// Managing the parameters //////////
@@ -128,7 +127,7 @@ int sci_solveminuncp(char *fname)
}
// Ask Ipopt to solve the problem
- status = app->OptimizeTNLP(Prob);
+ status = app->OptimizeTNLP((SmartPtr&)Prob);
cpuTime = app->Statistics()->TotalCPUTime();
@@ -144,7 +143,7 @@ int sci_solveminuncp(char *fname)
fGrad = Prob->getGrad();
fHess = Prob->getHess();
ObjVal = Prob->getObjVal();
- iteration = Prob->iterCount();
+ iteration = (double)app->Statistics()->IterationCount();
fobj_eval = (double)int_fobj_eval;
if (returnDoubleMatrixToScilab(1, 1, nVars, fX))
diff --git a/sci_gateway/cpp/sci_minbndNLP.cpp b/sci_gateway/cpp/sci_minbndNLP.cpp
index 9a7024e..481a796 100644
--- a/sci_gateway/cpp/sci_minbndNLP.cpp
+++ b/sci_gateway/cpp/sci_minbndNLP.cpp
@@ -11,7 +11,6 @@
#include "minbndNLP.hpp"
-#include "IpIpoptData.hpp"
#include "sci_iofunc.hpp"
extern "C"
@@ -23,7 +22,6 @@ extern "C"
#include
#include
#include
-#include
using namespace std;
using namespace Ipopt;
@@ -98,7 +96,7 @@ bool minbndNLP::eval_f(Index n, const Number* x, bool new_x, Number& obj_value)
}
char name[20]="f";
double obj=0;
- double *xNew=x;
+ const Number *xNew=x;
createMatrixOfDouble(pvApiCtx, 3, 1, numVars_, xNew);
int positionFirstElementOnStackForScilabFunction = 3;
int numberOfRhsOnScilabFunction = 1;
@@ -137,7 +135,7 @@ bool minbndNLP::eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f
{
return 1;
}
- double *xNew=x;
+ const Number *xNew=x;
Index i;
double t=1;
createMatrixOfDouble(pvApiCtx, 3, 1, numVars_, xNew);
@@ -230,7 +228,7 @@ bool minbndNLP::eval_h(Index n, const Number* x, bool new_x,Number obj_factor, I
return 1;
}
- double *xNew=x;
+ const Number *xNew=x;
Index i;
double t=2;
@@ -312,10 +310,7 @@ void minbndNLP::finalize_solution(SolverReturn status,Index n, const Number* x,
finalObjVal_ = obj_value;
status_ = status;
- if (status_ == 0 | status_ == 1 | status_ == 2)
- {
- iter_ = ip_data->iter_count();
- }
+
}
@@ -339,11 +334,6 @@ const double * minbndNLP::getZu()
return finalZu_;
}
-double minbndNLP::iterCount()
-{
- return (double)iter_;
-}
-
int minbndNLP::returnStatus()
{
return status_;
diff --git a/sci_gateway/cpp/sci_minconNLP.cpp b/sci_gateway/cpp/sci_minconNLP.cpp
index 845e983..71e6b53 100644
--- a/sci_gateway/cpp/sci_minconNLP.cpp
+++ b/sci_gateway/cpp/sci_minconNLP.cpp
@@ -11,7 +11,6 @@
#include "minconNLP.hpp"
-#include "IpIpoptData.hpp"
#include "sci_iofunc.hpp"
extern "C"
@@ -24,7 +23,6 @@ extern "C"
#include
#include
#include
-#include
using namespace std;
using namespace Ipopt;
@@ -138,7 +136,7 @@ bool minconNLP::eval_f(Index n, const Number* x, bool new_x, Number& obj_value)
}
char name[18]="f";
double obj=0;
- double *xNew=x;
+ const Number *xNew=x;
double check;
createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
int positionFirstElementOnStackForScilabFunction = 14;
@@ -182,7 +180,7 @@ bool minconNLP::eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f
{
return 1;
}
- double *xNew=x;
+ const Number *xNew=x;
createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
int positionFirstElementOnStackForScilabFunction = 14;
int numberOfRhsOnScilabFunction = 1;
@@ -247,7 +245,7 @@ bool minconNLP::eval_g(Index n, const Number* x, bool new_x, Index m, Number* g)
return 1;
}
- double *xNew=x;
+ const Number *xNew=x;
double check;
createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
int positionFirstElementOnStackForScilabFunction = 14;
@@ -352,7 +350,7 @@ bool minconNLP::eval_jac_g(Index n, const Number* x, bool new_x,Index m, Index n
return 1;
}
- double *xNew=x;
+ const Number *xNew=x;
createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
int positionFirstElementOnStackForScilabFunction = 14;
int numberOfRhsOnScilabFunction = 1;
@@ -448,8 +446,8 @@ bool minconNLP::eval_h(Index n, const Number* x, bool new_x,Number obj_factor, I
{
return 1;
}
- double *xNew=x;
- double *lambdaNew=lambda;
+ const Number *xNew=x;
+ const Number *lambdaNew=lambda;
double objfac=obj_factor;
createMatrixOfDouble(pvApiCtx, 14, 1, numVars_, xNew);
createScalarDouble(pvApiCtx, 15,objfac);
@@ -543,7 +541,6 @@ void minconNLP::finalize_solution(SolverReturn status,Index n, const Number* x,
finalObjVal_ = obj_value;
status_ = status;
- iter_ = ip_data->iter_count();
}
@@ -582,11 +579,6 @@ double minconNLP::getObjVal()
return finalObjVal_;
}
-double minconNLP::iterCount()
-{
- return (double)iter_;
-}
-
int minconNLP::returnStatus()
{
return status_;
diff --git a/sci_gateway/cpp/sci_minuncNLP.cpp b/sci_gateway/cpp/sci_minuncNLP.cpp
index 874c093..fe4c0e5 100644
--- a/sci_gateway/cpp/sci_minuncNLP.cpp
+++ b/sci_gateway/cpp/sci_minuncNLP.cpp
@@ -11,7 +11,6 @@
#include "minuncNLP.hpp"
-#include "IpIpoptData.hpp"
#include "sci_iofunc.hpp"
extern "C"
@@ -24,7 +23,6 @@ extern "C"
#include
#include
#include
-#include
using namespace std;
using namespace Ipopt;
@@ -100,7 +98,7 @@ bool minuncNLP::eval_f(Index n, const Number* x, bool new_x, Number& obj_value)
}
char name[20]="f";
double obj=0;
- double *xNew=x;
+ const Number *xNew=x;
createMatrixOfDouble(pvApiCtx, 7, 1, numVars_, xNew);
int positionFirstElementOnStackForScilabFunction = 7;
int numberOfRhsOnScilabFunction = 1;
@@ -142,7 +140,7 @@ bool minuncNLP::eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f
{
return 1;
}
- double *xNew=x;
+ const Number *xNew=x;
double t=1;
createMatrixOfDouble(pvApiCtx, 7, 1, numVars_, xNew);
createScalarDouble(pvApiCtx, 8,t);
@@ -164,7 +162,7 @@ bool minuncNLP::eval_grad_f(Index n, const Number* x, bool new_x, Number* grad_f
{
return 1;
}
- double *xNew=x;
+ const Number *xNew=x;
createMatrixOfDouble(pvApiCtx, 7, 1, numVars_, xNew);
int positionFirstElementOnStackForScilabFunction = 7;
int numberOfRhsOnScilabFunction = 1;
@@ -253,7 +251,7 @@ bool minuncNLP::eval_h(Index n, const Number* x, bool new_x,Number obj_factor, I
{
return 1;
}
- double *xNew=x;
+ const Number *xNew=x;
double t=2;
createMatrixOfDouble(pvApiCtx, 7, 1, numVars_, xNew);
createScalarDouble(pvApiCtx, 8,t);
@@ -275,7 +273,7 @@ bool minuncNLP::eval_h(Index n, const Number* x, bool new_x,Number obj_factor, I
{
return 1;
}
- double *xNew=x;
+ const Number *xNew=x;
createMatrixOfDouble(pvApiCtx, 7, 1, numVars_, xNew);
int positionFirstElementOnStackForScilabFunction = 7;
int numberOfRhsOnScilabFunction = 1;
@@ -337,7 +335,6 @@ void minuncNLP::finalize_solution(SolverReturn status,Index n, const Number* x,
finalObjVal_ = obj_value;
status_ = status;
- iter_ = ip_data->iter_count();
}
@@ -361,11 +358,6 @@ double minuncNLP::getObjVal()
return finalObjVal_;
}
-double minuncNLP::iterCount()
-{
- return (double)iter_;
-}
-
int minuncNLP::returnStatus()
{
return status_;
diff --git a/sci_gateway/cpp/sci_sym_get_dbl_arr.cpp b/sci_gateway/cpp/sci_sym_get_dbl_arr.cpp
new file mode 100644
index 0000000..5cafce9
--- /dev/null
+++ b/sci_gateway/cpp/sci_sym_get_dbl_arr.cpp
@@ -0,0 +1,122 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution. The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+// Author: Sai Kiran
+// Organization: FOSSEE, IIT Bombay
+// Email: toolbox@scilab.in
+
+#include
+#include
+extern sym_environment* global_sym_env;//defined in globals.cpp
+
+extern "C" {
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+/* This is generelized function for
+ * sym_getVarLower,sym_getVarUpper,sym_getRhs,sym_getConstrRange,sym_getConstrLower,
+ * sym_getConstrUpper and sym_getObjCoeff .
+ * (Functions taking symphony env and pointer to array of doubles as arguments)
+*/
+int sci_sym_get_dbl_arr(char *fname, unsigned long fname_len){
+
+ int result_len=0;/* Length of the output double array */
+ double *result=NULL;/* Pointer to output double array */
+
+ //check whether we have no input and one output argument or not
+ CheckInputArgument(pvApiCtx, 0, 0) ; //no input argument
+ CheckOutputArgument(pvApiCtx, 1, 1) ; //one output argument
+
+ /* Array of possible callers of this function */
+ char* arr_caller[]={"sym_getVarLower","sym_getVarUpper",
+ "sym_getRhs","sym_getConstrRange",
+ "sym_getConstrLower","sym_getConstrUpper",
+ "sym_getObjCoeff"};
+
+ /* Array of functions to be called */
+ int (*fun[])(sym_environment*,double*)= {sym_get_col_lower,sym_get_col_upper,
+ sym_get_rhs,sym_get_row_range,
+ sym_get_row_lower,sym_get_row_upper,
+ sym_get_obj_coeff };
+
+ /* Array of functions the above functions depend on */
+ int (*fun_depends[])(sym_environment*,int*) = {sym_get_num_cols,sym_get_num_cols,
+ sym_get_num_rows,sym_get_num_rows,
+ sym_get_num_rows,sym_get_num_rows,
+ sym_get_num_cols };
+
+ /* We want to ouput row-matrix if we are dealing with column data .
+ * column matrix if we are dealing with row data .
+ * 0 - output a row matrix.
+ * 1 - output a column matrix.
+ */
+ int representation = 0; //output a row matrix
+
+ /* Array of representations of output depending on the above functions.
+ * It's length is same as above arrays.
+ */
+ int matrix_representation[] = { 0 ,0 , 1, 1, 1, 1, 0};
+ if(global_sym_env==NULL) //There is no environment opened.
+ sciprint("Error: Symphony environment is not initialized.\n");
+ else {
+ //There is an environment opened
+ int iter=0,length=sizeof(arr_caller)/sizeof(char*),found_at= -1;
+ for (;iter < length ;++iter){
+ if (!strcmp(fname,arr_caller[iter]))
+ found_at=iter;
+ }
+ if (found_at != -1){
+ int status1=fun_depends[found_at](global_sym_env,&result_len);
+ if ( status1 == FUNCTION_TERMINATED_NORMALLY && result_len ) {
+ result=(double*)malloc( sizeof(double) * result_len );
+ int ret_val=fun[found_at](global_sym_env,result);
+ sciprint("\nFunction invoked unsuccessfully.\n");
+ if (ret_val == FUNCTION_TERMINATED_ABNORMALLY)
+ result_len=0;
+ else {
+ if (found_at == 6) {//if called function is sym_getObjCoeff
+ int iter=0,sense=0,status2 = sym_get_obj_sense(global_sym_env,&sense);
+ if (sense == -1) // Multiply with -1 while showing
+ for (;iter < result_len;++iter) result[iter] *= -1;
+ }
+ representation = matrix_representation[found_at];
+ }
+ }
+ else
+ sciprint("\n Is a problem loaded ? \n");
+ }
+ else //very rare case
+ sciprint("\nError in function mapping in scilab script\n");
+ }
+
+ //Copy the result to scilab. Location is position next to input arguments.
+ SciErr err;
+ if (representation) // output a column-matrix
+ err=createMatrixOfDouble(pvApiCtx,nbInputArgument(pvApiCtx)+1,result_len,1,result);
+ else // output a row-matrix
+ err=createMatrixOfDouble(pvApiCtx,nbInputArgument(pvApiCtx)+1,1,result_len,result);
+ free(result); //Free the allocated space
+ result=NULL; //Set to NULL
+ if (err.iErr){ //Process error
+ AssignOutputVariable(pvApiCtx, 1) = 0;
+ printError(&err, 0);
+ return 1;
+ }
+
+ //assign result position to output argument
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+ //ReturnArguments(pvApiCtx);
+ return 0;
+ }
+}
diff --git a/sci_gateway/cpp/sci_sym_get_iteration_count.cpp b/sci_gateway/cpp/sci_sym_get_iteration_count.cpp
new file mode 100644
index 0000000..007943c
--- /dev/null
+++ b/sci_gateway/cpp/sci_sym_get_iteration_count.cpp
@@ -0,0 +1,51 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution. The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+// Author: Sai Kiran
+// Organization: FOSSEE, IIT Bombay
+// Email: toolbox@scilab.in
+
+#include
+#include
+extern sym_environment* global_sym_env;//defined in globals.cpp
+
+extern "C" {
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+/*
+ * This function is used to get iteration count after solving a problem
+*/
+int sci_sym_get_iteration_count(char *fname, unsigned long fname_len){
+
+ //check whether we have no input and one output argument or not
+ CheckInputArgument(pvApiCtx, 0, 0) ; //no input argument
+ CheckOutputArgument(pvApiCtx, 1, 1) ; //one output argument
+
+ int iteration_count=0; // return value to the caller
+ if(global_sym_env==NULL) //There is no environment opened.
+ sciprint("Error: Symphony environment is not initialized.\n");
+ else { //There is an environment opened
+ //Call symphony function
+ int status=sym_get_iteration_count(global_sym_env,&iteration_count);
+ if (status == FUNCTION_TERMINATED_ABNORMALLY) {
+ sciprint("\nHave you solved a problem ?\n");
+ iteration_count = 0;
+ }
+ }
+ // Write the result to scilab
+ return returnDoubleToScilab(iteration_count);
+ }
+
+}
diff --git a/sci_gateway/cpp/sci_sym_get_matrix.cpp b/sci_gateway/cpp/sci_sym_get_matrix.cpp
new file mode 100644
index 0000000..8b8f620
--- /dev/null
+++ b/sci_gateway/cpp/sci_sym_get_matrix.cpp
@@ -0,0 +1,165 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution. The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+// Author: Sai Kiran
+// Organization: FOSSEE, IIT Bombay
+// Email: toolbox@scilab.in
+
+#include
+#include
+extern sym_environment* global_sym_env;//defined in globals.cpp
+
+extern "C" {
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+/*
+ * Proto-type of function that converts column-major (sparse) representation
+ * to row-major (sparse) representation .
+*/
+void column_major_to_row_major(int,int,int,double *,int *,int *,double *,int *,int *);
+
+
+/* This function is to retrieve the problem's constraint matrix (sparse) .
+ * Symphony uses column-major (sparse) representation.
+ * Scilab uses row-major (sparse) representation.
+ * So, This function takes column-major (sparse) representation from symphony ,
+ * converts that to row-major (sparse) representation and writes to scilab's memory.
+ *
+ **/
+int sci_sym_get_matrix(char *fname, unsigned long fname_len){
+ int nz_ele=0;// No.of non-zero elements of the matrix
+ int rows=0; //No. of rows in constraint matrix
+ int columns=0; //No. of columns in constraint matrix
+
+ /* Variables that store column-major representation of matrix.
+ * These variables will be filled by symphony
+ */
+ int *column_start=NULL;// Starting index(in elements array) of each column
+ int *row_indices=NULL;// Row indices corresponding to each non-zero element
+ double *elements=NULL;// Non-zero elements of matrix
+
+ /* Variables that store row-major representation of matrix.
+ * Filled by a function column_major_to_row_major.
+ */
+ double *new_list=NULL; // Non-zero elements of row-major representation
+ int *count_per_row=NULL; //Count of non-zero elements in earch row
+ int *column_position=NULL; //Column of each non-zero element
+
+ //check whether we have no input and one output argument or not
+ CheckInputArgument(pvApiCtx, 0, 0) ; //no input argument
+ CheckOutputArgument(pvApiCtx, 1, 1) ; //one output argument
+
+ if(global_sym_env==NULL) //There is no environment opened.
+ sciprint("Error: Symphony environment is not initialized.\n");
+ else { //There is an environment opened
+ int status1=sym_get_num_elements(global_sym_env,&nz_ele); //No. of non-zero elements
+ int status2=sym_get_num_cols(global_sym_env , &columns); //Columns
+ int status3=sym_get_num_rows(global_sym_env , &rows); //Rows
+ int status4=FUNCTION_TERMINATED_ABNORMALLY;
+
+ //Make sure functions terminated normally
+ if (status1 == status2 && status1 == status3 && status1 == FUNCTION_TERMINATED_NORMALLY){
+ //Allocate memory for column-major representation
+ column_start=(int*)malloc(sizeof(int) * (columns+1));
+ row_indices=(int*)malloc(sizeof(int) * nz_ele);
+ elements=(double*)malloc(sizeof(double) * nz_ele);
+
+ //Take column-major representation from symphony
+ status4=sym_get_matrix(global_sym_env,&nz_ele,column_start,row_indices,elements);
+ if (status1 == status4) { //Check termination status of function, if normal
+
+ //Allocate memory for row-major representation
+ new_list=(double*) calloc( nz_ele , sizeof(double));
+ count_per_row=(int*) calloc( rows, sizeof(int ) );
+ column_position=(int*) calloc( nz_ele, sizeof(int));
+
+ //Convert column-major representation to row-major representation
+ column_major_to_row_major(rows,columns,nz_ele,elements,row_indices,column_start,new_list,count_per_row,column_position);
+
+ /*
+ (Important)Scilab considers indices from 1 , But we have column indices starting from 0 in column_position.
+ Hence add 1 to each index
+ */
+ int iter=0;
+ for (;iter < nz_ele ; ++iter) column_position[iter]++;
+
+ }
+ else { //If termination status is abnormal
+ sciprint("\nFunction invoked unsuccessfully.\n");
+ sciprint("\n Is a problem loaded ? \n");
+ }
+ }
+ else //If termination status of any of functions is abnormal
+ sciprint("\nFunction invoked unsuccessfully.\n");
+
+ }
+
+ //Copy the result to scilab. Location is position next to input arguments.
+ SciErr err=createSparseMatrix(pvApiCtx,nbInputArgument(pvApiCtx)+1,rows,columns,nz_ele,count_per_row,column_position,new_list);
+
+ /*
+ *Free allocated memory before exit
+ */
+ free(row_indices);
+ free(column_start);
+ free(elements);
+ free(new_list);
+ free(count_per_row);
+ free(column_position);
+
+ if (err.iErr){ //Process error
+ printError(&err, 0);
+ AssignOutputVariable(pvApiCtx, 1) = 0;
+ return 1;
+ }
+
+ //assign result position to output argument
+ AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+ //ReturnArguments(pvApiCtx);
+ return 0;
+ }
+}
+
+/*
+ * It converts column-major representation to row-major representation
+ * :: ARGUMENTS ::
+ * rows - No. of rows IN
+ * columns - No. of columns IN
+ * nz_ele - No. of non-zero elements IN
+ * elements - Non-zero elements in column-major representation IN
+ * row_indices - Row index( starts from 0 : symphony) of each non-zero element IN
+ * column_start - Starting index in elements of each column IN
+ * new_list - Non-zero elements in row-major representation OUT
+ * count_per_row - Count of non-zero elements in each row OUT
+ * column_position - Column index ( starts from 0 (we'll add 1 to each index later)) of each non-zero element OUT
+*/
+void column_major_to_row_major(int rows,int columns,int nz_ele,double *elements,int *row_indices,int *column_start,double *new_list,int *count_per_row,int *column_position) {
+
+ int iter=0,iter2,iter3=0,index=0;
+ for (iter=0;iter < rows;++iter) {
+ for (iter2=0;iter2 < nz_ele;++iter2) {
+ if (row_indices[iter2] == iter) {
+ count_per_row[iter]++; //Count of non-zero elements per row.
+ new_list[index]=elements[iter2];
+ for (iter3=0; iter3 < columns+1 ; ++iter3) {
+ if (iter2 < column_start[iter3])
+ break;
+ }
+ column_position[index] = iter3 - 1;
+ index++ ;
+ }
+ }
+ }
+ }
\ No newline at end of file
diff --git a/sci_gateway/cpp/sci_sym_get_num_int.cpp b/sci_gateway/cpp/sci_sym_get_num_int.cpp
new file mode 100644
index 0000000..0d0bd39
--- /dev/null
+++ b/sci_gateway/cpp/sci_sym_get_num_int.cpp
@@ -0,0 +1,70 @@
+// Copyright (C) 2015 - IIT Bombay - FOSSEE
+//
+// This file must be used under the terms of the CeCILL.
+// This source file is licensed as described in the file COPYING, which
+// you should have received as part of this distribution. The terms
+// are also available at
+// http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+// Author: Sai Kiran
+// Organization: FOSSEE, IIT Bombay
+// Email: toolbox@scilab.in
+
+#include
+#include
+extern sym_environment* global_sym_env;//defined in globals.cpp
+
+extern "C" {
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+
+/*
+ * Generelized function for sym_getNumVars,
+ * sym_getNumConstrs,sym_get_NumElements
+*/
+int sci_sym_get_num_int(char *fname, unsigned long fname_len){
+
+ int result=-1;/* Result of the callar */
+
+ //check whether we have no input and one output argument or not
+ CheckInputArgument(pvApiCtx, 0, 0) ; //no input argument
+ CheckOutputArgument(pvApiCtx, 1, 1) ; //one output argument
+
+ /* Array of possible callers of this function */
+ char* arr_caller[]={"sym_getNumConstr","sym_getNumVar","sym_getNumElements"};
+
+ /* Array of functions to be called */
+ int (*fun[])(sym_environment*,int*)= { sym_get_num_rows,
+ sym_get_num_cols,
+ sym_get_num_elements
+ };
+
+ if(global_sym_env==NULL) //There is no environment opened.
+ sciprint("Error: Symphony environment is not initialized.\n");
+ else {
+ //There is an environment opened
+ int iter=0,length=sizeof(arr_caller)/sizeof(char*),found_at= -1;
+ for (;iter < length ;++iter){
+ if (!strcmp(fname,arr_caller[iter]))
+ found_at=iter;
+ }
+ if (found_at != -1) {
+ int ret_val=fun[found_at](global_sym_env,&result);
+ sciprint("\nFunction invoked unsuccessfully.\n");
+ if (ret_val == FUNCTION_TERMINATED_ABNORMALLY)
+ result=-1;
+ }
+ else //very rare case
+ sciprint("\nError in function mapping in scilab script\n");
+ }
+
+ //Copy the result to scilab. Location is position next to input arguments.
+ return returnDoubleToScilab(result);
+ }
+}
\ No newline at end of file
diff --git a/sci_gateway/cpp/sci_sym_loadproblem.cpp b/sci_gateway/cpp/sci_sym_loadproblem.cpp
index 5294082..1a00092 100644
--- a/sci_gateway/cpp/sci_sym_loadproblem.cpp
+++ b/sci_gateway/cpp/sci_sym_loadproblem.cpp
@@ -198,6 +198,9 @@ static int commonCodePart2()
cleanupBeforeExit();
return 1;
}
+ #ifdef _MSC_VER
+ double INFINITY = sym_get_infinity();
+ #endif
if(conLower[rowIter]==(-INFINITY) && conUpper[rowIter]==INFINITY){
conType[rowIter]='N';
conRange[rowIter]=0;
diff --git a/sci_gateway/cpp/sci_sym_remove.cpp b/sci_gateway/cpp/sci_sym_remove.cpp
index 0289064..c09cbc7 100644
--- a/sci_gateway/cpp/sci_sym_remove.cpp
+++ b/sci_gateway/cpp/sci_sym_remove.cpp
@@ -17,6 +17,8 @@ extern "C" {
#include
#include
#include
+#include
+#include
#include
#include
//function to remove specified columns
@@ -30,7 +32,7 @@ int sci_sym_delete_cols(char *fname, unsigned long fname_len){
int num_cols;//stores the number of columns in the loaded problem
int iType= 0;//stores the datatype of matrix
int rows=0,columns=0;//integer variables to denote the number of rows and columns in the array denoting the column numbers to be deleted
- unsigned int *value=NULL;//pointer to integer array allocated dynamically having the indices to be deleted
+ int *value=NULL;//pointer to integer array allocated dynamically having the indices to be deleted
double *array_ptr=NULL;//double array pointer to the array denoting the column numbers to be deleted
int *piAddressVarOne = NULL;//pointer used to access first and second arguments of the function
int output=0;//output parameter for the symphony sym_delete_cols function
@@ -63,11 +65,11 @@ int sci_sym_delete_cols(char *fname, unsigned long fname_len){
}
//dynamically allocate the integer array
- value=(unsigned int *)malloc(sizeof(unsigned int)*columns);
+ value=(int *)malloc(sizeof(int)*columns);
//store double values in the integer array by typecasting
while(countSymmetric Matrix function of size [2 X 2] is Expected
diff --git a/tests/general_tests/fminunc/fminunc_logical1.sce b/tests/general_tests/fminunc/fminunc_logical1.sce
index 54c4d7f..4621f81 100644
--- a/tests/general_tests/fminunc/fminunc_logical1.sce
+++ b/tests/general_tests/fminunc/fminunc_logical1.sce
@@ -5,7 +5,7 @@ function y = fun(x)
y = -(x(1)^2 + x(2)^2);
endfunction
x0 = [1,2];
-options=list("MaxIter", [1500], "CpuTime", [500], "Gradient", "OFF", "Hessian", "OFF");
+options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", "OFF", "Hessian", "OFF");
//Output
//
diff --git a/tests/general_tests/fminunc/fminunc_logical2.sce b/tests/general_tests/fminunc/fminunc_logical2.sce
index 27d6cdd..c6e17c3 100644
--- a/tests/general_tests/fminunc/fminunc_logical2.sce
+++ b/tests/general_tests/fminunc/fminunc_logical2.sce
@@ -5,7 +5,7 @@ function y = fun(x)
y = log(x);
endfunction
x0 = [1];
-options=list("MaxIter", [1500], "CpuTime", [500], "Gradient", "OFF", "Hessian", "OFF");
+options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", "OFF", "Hessian", "OFF");
//Output
//
diff --git a/tests/general_tests/fminunc/fminunc_logical3.sce b/tests/general_tests/fminunc/fminunc_logical3.sce
index 15ea3ad..2d746c7 100644
--- a/tests/general_tests/fminunc/fminunc_logical3.sce
+++ b/tests/general_tests/fminunc/fminunc_logical3.sce
@@ -5,7 +5,7 @@ function y = fun(x)
y = (x(1)-x(2))^2 + x(1);
endfunction
x0 = [1,2];
-options=list("MaxIter", [1000], "CpuTime", [500], "Gradient", "OFF", "Hessian", "OFF");
+options=list("MaxIter", [1000], "CpuTime", [500], "GradObj", "OFF", "Hessian", "OFF");
//Output
//
diff --git a/tests/general_tests/fminunc/fminunc_logical4.sce b/tests/general_tests/fminunc/fminunc_logical4.sce
index 60d75c5..b031c09 100644
--- a/tests/general_tests/fminunc/fminunc_logical4.sce
+++ b/tests/general_tests/fminunc/fminunc_logical4.sce
@@ -5,7 +5,7 @@ function y = fun(x)
y = (x(1)-x(2))^2 + x(1);
endfunction
x0 = [1,2];
-options=list("MaxIter", [1000], "CpuTime", [1.5], "Gradient", "OFF", "Hessian", "OFF");
+options=list("MaxIter", [1000], "CpuTime", [1.5], "GradObj", "OFF", "Hessian", "OFF");
//Output
//
diff --git a/tests/general_tests/fminunc/fminunc_options1.sce b/tests/general_tests/fminunc/fminunc_options1.sce
index eb939d5..a9cecf0 100644
--- a/tests/general_tests/fminunc/fminunc_options1.sce
+++ b/tests/general_tests/fminunc/fminunc_options1.sce
@@ -5,7 +5,7 @@ function y = fun(x)
y = x(1)^2 + x(2)^2;
endfunction
x0 = [1,2];
-options=list("MaxIter", "", "CpuTime", [500], "Gradient", "OFF", "Hessian", "OFF");
+options=list("MaxIter", "", "CpuTime", [500], "GradObj", "OFF", "Hessian", "OFF");
//Error
//fminunc: Value for Maximum Iteration should be a Constant
diff --git a/tests/general_tests/fminunc/fminunc_options2.sce b/tests/general_tests/fminunc/fminunc_options2.sce
index 1cf09ef..d5aa22b 100644
--- a/tests/general_tests/fminunc/fminunc_options2.sce
+++ b/tests/general_tests/fminunc/fminunc_options2.sce
@@ -5,7 +5,7 @@ function y = fun(x)
y = x(1)^2 + x(2)^2;
endfunction
x0 = [1,2];
-options=list("MaxIter", [1000], "CpuTime", , "Gradient", "OFF", "Hessian", "OFF");
+options=list("MaxIter", [1000], "CpuTime", , "GradObj", "OFF", "Hessian", "OFF");
//Error
//fminunc: Value for Maximum Cpu-time should be a Constant
diff --git a/tests/general_tests/fminunc/fminunc_x0a.sce b/tests/general_tests/fminunc/fminunc_x0a.sce
index e71b455..ae06be9 100644
--- a/tests/general_tests/fminunc/fminunc_x0a.sce
+++ b/tests/general_tests/fminunc/fminunc_x0a.sce
@@ -5,7 +5,7 @@ function y = fun(x)
y = x(1)^2 + x(2)^2;
endfunction
x0 = [];
-options=list("MaxIter", [1500], "CpuTime", [500], "Gradient", "OFF", "Hessian", "OFF");
+options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", "OFF", "Hessian", "OFF");
//Error
//fminunc: Expected Row Vector or Column Vector for x0 (Initial Value)
diff --git a/tests/general_tests/fminunc/fminunc_x0b.sce b/tests/general_tests/fminunc/fminunc_x0b.sce
index a08b458..76ce489 100644
--- a/tests/general_tests/fminunc/fminunc_x0b.sce
+++ b/tests/general_tests/fminunc/fminunc_x0b.sce
@@ -5,7 +5,7 @@ function y = fun(x)
y = x(1)^2 + x(2)^2;
endfunction
x0 = [1];
-options=list("MaxIter", [1500], "CpuTime", [500], "Gradient", "OFF", "Hessian", "OFF");
+options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", "OFF", "Hessian", "OFF");
//Error
//fminunc: Objective function and x0 did not match
diff --git a/tests/unit_tests/fminunc.dia.ref b/tests/unit_tests/fminunc.dia.ref
index d8cc387..c0581c4 100644
--- a/tests/unit_tests/fminunc.dia.ref
+++ b/tests/unit_tests/fminunc.dia.ref
@@ -69,7 +69,7 @@ function y= fHess(x)
y= [1200*x(1)^2- 400*x(2) + 2, -400*x(1);-400*x(1), 200 ];
endfunction
//Options
-options=list("MaxIter", [1500], "CpuTime", [500], "Gradient", fGrad, "Hessian", fHess);
+options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", fGrad, "Hessian", fHess);
//Calling Ipopt
[xopt,fopt,exitflag,output,gradient,hessian]=fminunc(f,x0,options)
diff --git a/tests/unit_tests/fminunc.tst b/tests/unit_tests/fminunc.tst
index d8cc387..c0581c4 100644
--- a/tests/unit_tests/fminunc.tst
+++ b/tests/unit_tests/fminunc.tst
@@ -69,7 +69,7 @@ function y= fHess(x)
y= [1200*x(1)^2- 400*x(2) + 2, -400*x(1);-400*x(1), 200 ];
endfunction
//Options
-options=list("MaxIter", [1500], "CpuTime", [500], "Gradient", fGrad, "Hessian", fHess);
+options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", fGrad, "Hessian", fHess);
//Calling Ipopt
[xopt,fopt,exitflag,output,gradient,hessian]=fminunc(f,x0,options)
diff --git a/thirdparty/linux/lib/x64/libcoinblas.so.1.4.4 b/thirdparty/linux/lib/x64/libcoinblas.so.1.4.4
index 93ce388..ea97588 100755
Binary files a/thirdparty/linux/lib/x64/libcoinblas.so.1.4.4 and b/thirdparty/linux/lib/x64/libcoinblas.so.1.4.4 differ
diff --git a/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4 b/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4
index 038c68d..73eac4c 100755
Binary files a/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4 and b/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4 differ
diff --git a/thirdparty/linux/lib/x64/libcoinmetis.la b/thirdparty/linux/lib/x64/libcoinmetis.la
new file mode 100755
index 0000000..12ba84b
--- /dev/null
+++ b/thirdparty/linux/lib/x64/libcoinmetis.la
@@ -0,0 +1,35 @@
+# libcoinmetis.la - a libtool library file
+# Generated by ltmain.sh - GNU libtool 1.5.22 (1.1220.2.365 2005/12/18 22:14:06)
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='libcoinmetis.so.1'
+
+# Names of this library.
+library_names='libcoinmetis.so.1.3.4 libcoinmetis.so.1 libcoinmetis.so'
+
+# The name of the static archive.
+old_library=''
+
+# Libraries that this one depends upon.
+dependency_libs=' -lm'
+
+# Version information for libcoinmetis.
+current=4
+age=3
+revision=4
+
+# Is this an already installed library?
+installed=yes
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=no
+
+# Files to dlopen/dlpreopen
+dlopen=''
+dlpreopen=''
+
+# Directory that this library needs to be installed in:
+libdir='/home/harpreet/symphony_work/Ipopt-3.12.4/build3//lib'
diff --git a/thirdparty/linux/lib/x64/libcoinmetis.so b/thirdparty/linux/lib/x64/libcoinmetis.so
new file mode 120000
index 0000000..10ed913
--- /dev/null
+++ b/thirdparty/linux/lib/x64/libcoinmetis.so
@@ -0,0 +1 @@
+libcoinmetis.so.1.3.4
\ No newline at end of file
diff --git a/thirdparty/linux/lib/x64/libcoinmetis.so.1 b/thirdparty/linux/lib/x64/libcoinmetis.so.1
new file mode 120000
index 0000000..10ed913
--- /dev/null
+++ b/thirdparty/linux/lib/x64/libcoinmetis.so.1
@@ -0,0 +1 @@
+libcoinmetis.so.1.3.4
\ No newline at end of file
diff --git a/thirdparty/linux/lib/x64/libcoinmetis.so.1.3.4 b/thirdparty/linux/lib/x64/libcoinmetis.so.1.3.4
new file mode 100755
index 0000000..48b6591
Binary files /dev/null and b/thirdparty/linux/lib/x64/libcoinmetis.so.1.3.4 differ
diff --git a/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4 b/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4
index 6f582d8..6a33b7c 100755
Binary files a/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4 and b/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4 differ
diff --git a/thirdparty/windows/include/coin/CbcOrClpParam.cpp b/thirdparty/windows/include/coin/CbcOrClpParam.cpp
new file mode 100644
index 0000000..86365ca
--- /dev/null
+++ b/thirdparty/windows/include/coin/CbcOrClpParam.cpp
@@ -0,0 +1,4134 @@
+/* $Id: CbcOrClpParam.cpp 2175 2015-10-06 08:56:43Z forrest $ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#include "CoinPragma.hpp"
+#include "CoinTime.hpp"
+#include "CbcOrClpParam.hpp"
+
+#include
+#include
+#include
+
+#ifdef COIN_HAS_CBC
+#ifdef COIN_HAS_CLP
+#include "OsiClpSolverInterface.hpp"
+#include "ClpSimplex.hpp"
+#endif
+#include "CbcModel.hpp"
+#endif
+#include "CoinHelperFunctions.hpp"
+#ifdef COIN_HAS_CLP
+#include "ClpSimplex.hpp"
+#include "ClpFactorization.hpp"
+#endif
+#ifdef COIN_HAS_READLINE
+#include
+#include
+#endif
+#ifdef COIN_HAS_CBC
+// from CoinSolve
+static char coin_prompt[] = "Coin:";
+#else
+static char coin_prompt[] = "Clp:";
+#endif
+#ifdef CLP_CILK
+#ifndef CBC_THREAD
+#define CBC_THREAD
+#endif
+#endif
+#if defined(COIN_HAS_WSMP) && ! defined(USE_EKKWSSMP)
+#ifndef CBC_THREAD
+#define CBC_THREAD
+#endif
+#endif
+#include "ClpConfig.h"
+#ifdef CLP_HAS_ABC
+#include "AbcCommon.hpp"
+#endif
+static bool doPrinting = true;
+static std::string afterEquals = "";
+static char printArray[200];
+#if COIN_INT_MAX==0
+#undef COIN_INT_MAX
+#define COIN_INT_MAX 2147483647
+#endif
+#if FLUSH_PRINT_BUFFER > 2
+int coinFlushBufferFlag=0;
+#endif
+void setCbcOrClpPrinting(bool yesNo)
+{
+ doPrinting = yesNo;
+}
+//#############################################################################
+// Constructors / Destructor / Assignment
+//#############################################################################
+
+//-------------------------------------------------------------------
+// Default Constructor
+//-------------------------------------------------------------------
+CbcOrClpParam::CbcOrClpParam ()
+ : type_(CBC_PARAM_NOTUSED_INVALID),
+ lowerDoubleValue_(0.0),
+ upperDoubleValue_(0.0),
+ lowerIntValue_(0),
+ upperIntValue_(0),
+ lengthName_(0),
+ lengthMatch_(0),
+ definedKeyWords_(),
+ name_(),
+ shortHelp_(),
+ longHelp_(),
+ action_(CBC_PARAM_NOTUSED_INVALID),
+ currentKeyWord_(-1),
+ display_(0),
+ intValue_(-1),
+ doubleValue_(-1.0),
+ stringValue_(""),
+ whereUsed_(7),
+ fakeKeyWord_(-1),
+ fakeValue_(0)
+{
+}
+// Other constructors
+CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
+ double lower, double upper, CbcOrClpParameterType type,
+ int display)
+ : type_(type),
+ lowerIntValue_(0),
+ upperIntValue_(0),
+ definedKeyWords_(),
+ name_(name),
+ shortHelp_(help),
+ longHelp_(),
+ action_(type),
+ currentKeyWord_(-1),
+ display_(display),
+ intValue_(-1),
+ doubleValue_(-1.0),
+ stringValue_(""),
+ whereUsed_(7),
+ fakeKeyWord_(-1),
+ fakeValue_(0)
+{
+ lowerDoubleValue_ = lower;
+ upperDoubleValue_ = upper;
+ gutsOfConstructor();
+}
+CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
+ int lower, int upper, CbcOrClpParameterType type,
+ int display)
+ : type_(type),
+ lowerDoubleValue_(0.0),
+ upperDoubleValue_(0.0),
+ definedKeyWords_(),
+ name_(name),
+ shortHelp_(help),
+ longHelp_(),
+ action_(type),
+ currentKeyWord_(-1),
+ display_(display),
+ intValue_(-1),
+ doubleValue_(-1.0),
+ stringValue_(""),
+ whereUsed_(7),
+ fakeKeyWord_(-1),
+ fakeValue_(0)
+{
+ gutsOfConstructor();
+ lowerIntValue_ = lower;
+ upperIntValue_ = upper;
+}
+// Other strings will be added by append
+CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
+ std::string firstValue,
+ CbcOrClpParameterType type, int whereUsed,
+ int display)
+ : type_(type),
+ lowerDoubleValue_(0.0),
+ upperDoubleValue_(0.0),
+ lowerIntValue_(0),
+ upperIntValue_(0),
+ definedKeyWords_(),
+ name_(name),
+ shortHelp_(help),
+ longHelp_(),
+ action_(type),
+ currentKeyWord_(0),
+ display_(display),
+ intValue_(-1),
+ doubleValue_(-1.0),
+ stringValue_(""),
+ whereUsed_(whereUsed),
+ fakeKeyWord_(-1),
+ fakeValue_(0)
+{
+ gutsOfConstructor();
+ definedKeyWords_.push_back(firstValue);
+}
+// Action
+CbcOrClpParam::CbcOrClpParam (std::string name, std::string help,
+ CbcOrClpParameterType type, int whereUsed,
+ int display)
+ : type_(type),
+ lowerDoubleValue_(0.0),
+ upperDoubleValue_(0.0),
+ lowerIntValue_(0),
+ upperIntValue_(0),
+ definedKeyWords_(),
+ name_(name),
+ shortHelp_(help),
+ longHelp_(),
+ action_(type),
+ currentKeyWord_(-1),
+ display_(display),
+ intValue_(-1),
+ doubleValue_(-1.0),
+ stringValue_(""),
+ fakeKeyWord_(-1),
+ fakeValue_(0)
+{
+ whereUsed_ = whereUsed;
+ gutsOfConstructor();
+}
+
+//-------------------------------------------------------------------
+// Copy constructor
+//-------------------------------------------------------------------
+CbcOrClpParam::CbcOrClpParam (const CbcOrClpParam & rhs)
+{
+ type_ = rhs.type_;
+ lowerDoubleValue_ = rhs.lowerDoubleValue_;
+ upperDoubleValue_ = rhs.upperDoubleValue_;
+ lowerIntValue_ = rhs.lowerIntValue_;
+ upperIntValue_ = rhs.upperIntValue_;
+ lengthName_ = rhs.lengthName_;
+ lengthMatch_ = rhs.lengthMatch_;
+ definedKeyWords_ = rhs.definedKeyWords_;
+ name_ = rhs.name_;
+ shortHelp_ = rhs.shortHelp_;
+ longHelp_ = rhs.longHelp_;
+ action_ = rhs.action_;
+ currentKeyWord_ = rhs.currentKeyWord_;
+ display_ = rhs.display_;
+ intValue_ = rhs.intValue_;
+ doubleValue_ = rhs.doubleValue_;
+ stringValue_ = rhs.stringValue_;
+ whereUsed_ = rhs.whereUsed_;
+ fakeKeyWord_ = rhs.fakeKeyWord_;
+ fakeValue_ = rhs.fakeValue_;
+}
+
+//-------------------------------------------------------------------
+// Destructor
+//-------------------------------------------------------------------
+CbcOrClpParam::~CbcOrClpParam ()
+{
+}
+
+//----------------------------------------------------------------
+// Assignment operator
+//-------------------------------------------------------------------
+CbcOrClpParam &
+CbcOrClpParam::operator=(const CbcOrClpParam & rhs)
+{
+ if (this != &rhs) {
+ type_ = rhs.type_;
+ lowerDoubleValue_ = rhs.lowerDoubleValue_;
+ upperDoubleValue_ = rhs.upperDoubleValue_;
+ lowerIntValue_ = rhs.lowerIntValue_;
+ upperIntValue_ = rhs.upperIntValue_;
+ lengthName_ = rhs.lengthName_;
+ lengthMatch_ = rhs.lengthMatch_;
+ definedKeyWords_ = rhs.definedKeyWords_;
+ name_ = rhs.name_;
+ shortHelp_ = rhs.shortHelp_;
+ longHelp_ = rhs.longHelp_;
+ action_ = rhs.action_;
+ currentKeyWord_ = rhs.currentKeyWord_;
+ display_ = rhs.display_;
+ intValue_ = rhs.intValue_;
+ doubleValue_ = rhs.doubleValue_;
+ stringValue_ = rhs.stringValue_;
+ whereUsed_ = rhs.whereUsed_;
+ fakeKeyWord_ = rhs.fakeKeyWord_;
+ fakeValue_ = rhs.fakeValue_;
+ }
+ return *this;
+}
+void
+CbcOrClpParam::gutsOfConstructor()
+{
+ std::string::size_type shriekPos = name_.find('!');
+ lengthName_ = static_cast(name_.length());
+ if ( shriekPos == std::string::npos ) {
+ //does not contain '!'
+ lengthMatch_ = lengthName_;
+ } else {
+ lengthMatch_ = static_cast(shriekPos);
+ name_ = name_.substr(0, shriekPos) + name_.substr(shriekPos + 1);
+ lengthName_--;
+ }
+}
+// Sets value of fake keyword to current size of keywords
+void
+CbcOrClpParam::setFakeKeyWord(int fakeValue)
+{
+ fakeKeyWord_ = static_cast(definedKeyWords_.size());
+ assert (fakeKeyWord_>0);
+ fakeValue_ = fakeValue;
+ assert (fakeValue_>=0);
+}
+/* Returns current parameter option position
+ but if fake keyword returns fakeValue_
+*/
+int
+CbcOrClpParam::currentOptionAsInteger ( ) const
+{
+ int fakeInteger;
+ return currentOptionAsInteger(fakeInteger);
+}
+/* Returns current parameter option position
+ but if fake keyword returns fakeValue_ and sets
+ fakeInteger to value
+*/
+int
+CbcOrClpParam::currentOptionAsInteger ( int & fakeInteger ) const
+{
+ fakeInteger=-COIN_INT_MAX;
+ if (fakeKeyWord_<0) {
+ return currentKeyWord_;
+ } else if (currentKeyWord_>=0&¤tKeyWord_ lengthName_) {
+ return 0;
+ } else {
+ unsigned int i;
+ for (i = 0; i < input.length(); i++) {
+ if (tolower(name_[i]) != tolower(input[i]))
+ break;
+ }
+ if (i < input.length()) {
+ return 0;
+ } else if (i >= lengthMatch_) {
+ return 1;
+ } else {
+ // matched but too short
+ return 2;
+ }
+ }
+}
+// Returns name which could match
+std::string
+CbcOrClpParam::matchName ( ) const
+{
+ if (lengthMatch_ == lengthName_)
+ return name_;
+ else
+ return name_.substr(0, lengthMatch_) + "(" + name_.substr(lengthMatch_) + ")";
+}
+
+// Returns parameter option which matches (-1 if none)
+int
+CbcOrClpParam::parameterOption ( std::string check ) const
+{
+ int numberItems = static_cast(definedKeyWords_.size());
+ if (!numberItems) {
+ return -1;
+ } else {
+ int whichItem = 0;
+ unsigned int it;
+ for (it = 0; it < definedKeyWords_.size(); it++) {
+ std::string thisOne = definedKeyWords_[it];
+ std::string::size_type shriekPos = thisOne.find('!');
+ size_t length1 = thisOne.length();
+ size_t length2 = length1;
+ if ( shriekPos != std::string::npos ) {
+ //contains '!'
+ length2 = shriekPos;
+ thisOne = thisOne.substr(0, shriekPos) +
+ thisOne.substr(shriekPos + 1);
+ length1 = thisOne.length();
+ }
+ if (check.length() <= length1 && length2 <= check.length()) {
+ unsigned int i;
+ for (i = 0; i < check.length(); i++) {
+ if (tolower(thisOne[i]) != tolower(check[i]))
+ break;
+ }
+ if (i < check.length()) {
+ whichItem++;
+ } else if (i >= length2) {
+ break;
+ }
+ } else {
+ whichItem++;
+ }
+ }
+ if (whichItem < numberItems) {
+ return whichItem;
+ } else {
+ if (fakeKeyWord_<=0)
+ return -1;
+ // allow plus or minus
+ int n;
+ if (check.substr(0,4)=="plus"||check.substr(0,4)=="PLUS") {
+ n = 4;
+ } else if (check.substr(0,5)=="minus"||check.substr(0,5)=="MINUS") {
+ n = 5;
+ } else {
+ return -1;
+ }
+ int value = 0;
+ std::string field=check.substr(n);
+ if (field != "EOL") {
+ const char * start = field.c_str();
+ char * endPointer = NULL;
+ // check valid
+ value = static_cast(strtol(start, &endPointer, 10));
+ if (*endPointer != '\0') {
+ return -1;
+ }
+ if (n==4)
+ return value + 1000;
+ else
+ return -value - 1000;
+ } else {
+ return -1;
+ }
+ }
+ }
+}
+// Prints parameter options
+void
+CbcOrClpParam::printOptions ( ) const
+{
+ std::cout << "= 0 && currentKeyWord_ < static_cast(definedKeyWords_.size()));
+ std::string current = definedKeyWords_[currentKeyWord_];
+ std::string::size_type shriekPos = current.find('!');
+ if ( shriekPos != std::string::npos ) {
+ //contains '!'
+ current = current.substr(0, shriekPos) +
+ "(" + current.substr(shriekPos + 1) + ")";
+ }
+ std::cout << ";\n\tcurrent " << current << ">" << std::endl;
+}
+// Print action and string
+void
+CbcOrClpParam::printString() const
+{
+ if (name_ == "directory")
+ std::cout << "Current working directory is " << stringValue_ << std::endl;
+ else if (name_.substr(0, 6) == "printM")
+ std::cout << "Current value of printMask is " << stringValue_ << std::endl;
+ else
+ std::cout << "Current default (if $ as parameter) for " << name_
+ << " is " << stringValue_ << std::endl;
+}
+void CoinReadPrintit(const char * input)
+{
+ int length = static_cast(strlen(input));
+ char temp[101];
+ int i;
+ int n = 0;
+ for (i = 0; i < length; i++) {
+ if (input[i] == '\n') {
+ temp[n] = '\0';
+ std::cout << temp << std::endl;
+ n = 0;
+ } else if (n >= 65 && input[i] == ' ') {
+ temp[n] = '\0';
+ std::cout << temp << std::endl;
+ n = 0;
+ } else if (n || input[i] != ' ') {
+ temp[n++] = input[i];
+ }
+ }
+ if (n) {
+ temp[n] = '\0';
+ std::cout << temp << std::endl;
+ }
+}
+// Print Long help
+void
+CbcOrClpParam::printLongHelp() const
+{
+ if (type_ >= 1 && type_ < 400) {
+ CoinReadPrintit(longHelp_.c_str());
+ if (type_ < CLP_PARAM_INT_SOLVERLOGLEVEL) {
+ printf("\n", lowerDoubleValue_, upperDoubleValue_, doubleValue_);
+ assert (upperDoubleValue_ > lowerDoubleValue_);
+ } else if (type_ < CLP_PARAM_STR_DIRECTION) {
+ printf("\n", lowerIntValue_, upperIntValue_, intValue_);
+ assert (upperIntValue_ > lowerIntValue_);
+ } else if (type_ < CLP_PARAM_ACTION_DIRECTORY) {
+ printOptions();
+ }
+ }
+}
+#ifdef COIN_HAS_CBC
+int
+CbcOrClpParam::setDoubleParameter (OsiSolverInterface * model, double value)
+{
+ int returnCode;
+ setDoubleParameterWithMessage(model, value, returnCode);
+ if (doPrinting && strlen(printArray))
+ std::cout << printArray << std::endl;
+ return returnCode;
+}
+// Sets double parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setDoubleParameterWithMessage ( OsiSolverInterface * model, double value , int & returnCode)
+{
+ if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+ sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+ value, name_.c_str(), lowerDoubleValue_, upperDoubleValue_);
+ std::cout << value << " was provided for " << name_ <<
+ " - valid range is " << lowerDoubleValue_ << " to " <<
+ upperDoubleValue_ << std::endl;
+ returnCode = 1;
+ } else {
+ double oldValue = doubleValue_;
+ doubleValue_ = value;
+ switch (type_) {
+ case CLP_PARAM_DBL_DUALTOLERANCE:
+ model->getDblParam(OsiDualTolerance, oldValue);
+ model->setDblParam(OsiDualTolerance, value);
+ break;
+ case CLP_PARAM_DBL_PRIMALTOLERANCE:
+ model->getDblParam(OsiPrimalTolerance, oldValue);
+ model->setDblParam(OsiPrimalTolerance, value);
+ break;
+ default:
+ break;
+ }
+ sprintf(printArray, "%s was changed from %g to %g",
+ name_.c_str(), oldValue, value);
+ returnCode = 0;
+ }
+ return printArray;
+}
+#endif
+#ifdef COIN_HAS_CLP
+int
+CbcOrClpParam::setDoubleParameter (ClpSimplex * model, double value)
+{
+ int returnCode;
+ setDoubleParameterWithMessage(model, value, returnCode);
+ if (doPrinting && strlen(printArray))
+ std::cout << printArray << std::endl;
+ return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setDoubleParameterWithMessage ( ClpSimplex * model, double value , int & returnCode)
+{
+ double oldValue = doubleValue_;
+ if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+ sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+ value, name_.c_str(), lowerDoubleValue_, upperDoubleValue_);
+ returnCode = 1;
+ } else {
+ sprintf(printArray, "%s was changed from %g to %g",
+ name_.c_str(), oldValue, value);
+ returnCode = 0;
+ doubleValue_ = value;
+ switch (type_) {
+ case CLP_PARAM_DBL_DUALTOLERANCE:
+ model->setDualTolerance(value);
+ break;
+ case CLP_PARAM_DBL_PRIMALTOLERANCE:
+ model->setPrimalTolerance(value);
+ break;
+ case CLP_PARAM_DBL_ZEROTOLERANCE:
+ model->setSmallElementValue(value);
+ break;
+ case CLP_PARAM_DBL_DUALBOUND:
+ model->setDualBound(value);
+ break;
+ case CLP_PARAM_DBL_PRIMALWEIGHT:
+ model->setInfeasibilityCost(value);
+ break;
+#ifndef COIN_HAS_CBC
+ case CLP_PARAM_DBL_TIMELIMIT:
+ model->setMaximumSeconds(value);
+ break;
+#endif
+ case CLP_PARAM_DBL_OBJSCALE:
+ model->setObjectiveScale(value);
+ break;
+ case CLP_PARAM_DBL_RHSSCALE:
+ model->setRhsScale(value);
+ break;
+ case CLP_PARAM_DBL_PRESOLVETOLERANCE:
+ model->setDblParam(ClpPresolveTolerance, value);
+ break;
+ default:
+ break;
+ }
+ }
+ return printArray;
+}
+double
+CbcOrClpParam::doubleParameter (ClpSimplex * model) const
+{
+ double value;
+ switch (type_) {
+#ifndef COIN_HAS_CBC
+ case CLP_PARAM_DBL_DUALTOLERANCE:
+ value = model->dualTolerance();
+ break;
+ case CLP_PARAM_DBL_PRIMALTOLERANCE:
+ value = model->primalTolerance();
+ break;
+#endif
+ case CLP_PARAM_DBL_ZEROTOLERANCE:
+ value = model->getSmallElementValue();
+ break;
+ case CLP_PARAM_DBL_DUALBOUND:
+ value = model->dualBound();
+ break;
+ case CLP_PARAM_DBL_PRIMALWEIGHT:
+ value = model->infeasibilityCost();
+ break;
+#ifndef COIN_HAS_CBC
+ case CLP_PARAM_DBL_TIMELIMIT:
+ value = model->maximumSeconds();
+ break;
+#endif
+ case CLP_PARAM_DBL_OBJSCALE:
+ value = model->objectiveScale();
+ break;
+ case CLP_PARAM_DBL_RHSSCALE:
+ value = model->rhsScale();
+ break;
+ default:
+ value = doubleValue_;
+ break;
+ }
+ return value;
+}
+int
+CbcOrClpParam::setIntParameter (ClpSimplex * model, int value)
+{
+ int returnCode;
+ setIntParameterWithMessage(model, value, returnCode);
+ if (doPrinting && strlen(printArray))
+ std::cout << printArray << std::endl;
+ return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setIntParameterWithMessage ( ClpSimplex * model, int value , int & returnCode)
+{
+ int oldValue = intValue_;
+ if (value < lowerIntValue_ || value > upperIntValue_) {
+ sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+ value, name_.c_str(), lowerIntValue_, upperIntValue_);
+ returnCode = 1;
+ } else {
+ intValue_ = value;
+ sprintf(printArray, "%s was changed from %d to %d",
+ name_.c_str(), oldValue, value);
+ returnCode = 0;
+ switch (type_) {
+ case CLP_PARAM_INT_SOLVERLOGLEVEL:
+ model->setLogLevel(value);
+ if (value > 2)
+ model->factorization()->messageLevel(8);
+ else
+ model->factorization()->messageLevel(0);
+ break;
+ case CLP_PARAM_INT_MAXFACTOR:
+ model->factorization()->maximumPivots(value);
+ break;
+ case CLP_PARAM_INT_PERTVALUE:
+ model->setPerturbation(value);
+ break;
+ case CLP_PARAM_INT_MAXITERATION:
+ model->setMaximumIterations(value);
+ break;
+ case CLP_PARAM_INT_SPECIALOPTIONS:
+ model->setSpecialOptions(value);
+ break;
+ case CLP_PARAM_INT_RANDOMSEED:
+ {
+ if (value==0) {
+ double time = fabs(CoinGetTimeOfDay());
+ while (time>=COIN_INT_MAX)
+ time *= 0.5;
+ value = static_cast(time);
+ sprintf(printArray, "using time of day %s was changed from %d to %d",
+ name_.c_str(), oldValue, value);
+ }
+ model->setRandomSeed(value);
+ }
+ break;
+ case CLP_PARAM_INT_MORESPECIALOPTIONS:
+ model->setMoreSpecialOptions(value);
+ break;
+#ifndef COIN_HAS_CBC
+#ifdef CBC_THREAD
+ case CBC_PARAM_INT_THREADS:
+ model->setNumberThreads(value);
+ break;
+#endif
+#endif
+ default:
+ break;
+ }
+ }
+ return printArray;
+}
+int
+CbcOrClpParam::intParameter (ClpSimplex * model) const
+{
+ int value;
+ switch (type_) {
+#ifndef COIN_HAS_CBC
+ case CLP_PARAM_INT_SOLVERLOGLEVEL:
+ value = model->logLevel();
+ break;
+#endif
+ case CLP_PARAM_INT_MAXFACTOR:
+ value = model->factorization()->maximumPivots();
+ break;
+ break;
+ case CLP_PARAM_INT_PERTVALUE:
+ value = model->perturbation();
+ break;
+ case CLP_PARAM_INT_MAXITERATION:
+ value = model->maximumIterations();
+ break;
+ case CLP_PARAM_INT_SPECIALOPTIONS:
+ value = model->specialOptions();
+ break;
+ case CLP_PARAM_INT_RANDOMSEED:
+ value = model->randomNumberGenerator()->getSeed();
+ break;
+ case CLP_PARAM_INT_MORESPECIALOPTIONS:
+ value = model->moreSpecialOptions();
+ break;
+#ifndef COIN_HAS_CBC
+#ifdef CBC_THREAD
+ case CBC_PARAM_INT_THREADS:
+ value = model->numberThreads();
+ break;
+#endif
+#endif
+ default:
+ value = intValue_;
+ break;
+ }
+ return value;
+}
+#endif
+int
+CbcOrClpParam::checkDoubleParameter (double value) const
+{
+ if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+ std::cout << value << " was provided for " << name_ <<
+ " - valid range is " << lowerDoubleValue_ << " to " <<
+ upperDoubleValue_ << std::endl;
+ return 1;
+ } else {
+ return 0;
+ }
+}
+#ifdef COIN_HAS_CBC
+double
+CbcOrClpParam::doubleParameter (OsiSolverInterface *
+#ifndef NDEBUG
+ model
+#endif
+ ) const
+{
+ double value = 0.0;
+ switch (type_) {
+ case CLP_PARAM_DBL_DUALTOLERANCE:
+ assert(model->getDblParam(OsiDualTolerance, value));
+ break;
+ case CLP_PARAM_DBL_PRIMALTOLERANCE:
+ assert(model->getDblParam(OsiPrimalTolerance, value));
+ break;
+ default:
+ return doubleValue_;
+ break;
+ }
+ return value;
+}
+int
+CbcOrClpParam::setIntParameter (OsiSolverInterface * model, int value)
+{
+ int returnCode;
+ setIntParameterWithMessage(model, value, returnCode);
+ if (doPrinting && strlen(printArray))
+ std::cout << printArray << std::endl;
+ return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setIntParameterWithMessage ( OsiSolverInterface * model, int value , int & returnCode)
+{
+ if (value < lowerIntValue_ || value > upperIntValue_) {
+ sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+ value, name_.c_str(), lowerIntValue_, upperIntValue_);
+ returnCode = 1;
+ } else {
+ int oldValue = intValue_;
+ intValue_ = oldValue;
+ switch (type_) {
+ case CLP_PARAM_INT_SOLVERLOGLEVEL:
+ model->messageHandler()->setLogLevel(value);
+ break;
+ default:
+ break;
+ }
+ sprintf(printArray, "%s was changed from %d to %d",
+ name_.c_str(), oldValue, value);
+ returnCode = 0;
+ }
+ return printArray;
+}
+int
+CbcOrClpParam::intParameter (OsiSolverInterface * model) const
+{
+ int value = 0;
+ switch (type_) {
+ case CLP_PARAM_INT_SOLVERLOGLEVEL:
+ value = model->messageHandler()->logLevel();
+ break;
+ default:
+ value = intValue_;
+ break;
+ }
+ return value;
+}
+int
+CbcOrClpParam::setDoubleParameter (CbcModel &model, double value)
+{
+ int returnCode=0;
+ setDoubleParameterWithMessage(model, value, returnCode);
+ if (doPrinting && strlen(printArray))
+ std::cout << printArray << std::endl;
+ return returnCode;
+}
+// Sets double parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setDoubleParameterWithMessage ( CbcModel & model, double value , int & returnCode)
+{
+ if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+ sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+ value, name_.c_str(), lowerDoubleValue_, upperDoubleValue_);
+ returnCode = 1;
+ } else {
+ double oldValue = doubleValue_;
+ doubleValue_ = value;
+ switch (type_) {
+ case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
+ oldValue = model.getDblParam(CbcModel::CbcInfeasibilityWeight);
+ model.setDblParam(CbcModel::CbcInfeasibilityWeight, value);
+ break;
+ case CBC_PARAM_DBL_INTEGERTOLERANCE:
+ oldValue = model.getDblParam(CbcModel::CbcIntegerTolerance);
+ model.setDblParam(CbcModel::CbcIntegerTolerance, value);
+ break;
+ case CBC_PARAM_DBL_INCREMENT:
+ oldValue = model.getDblParam(CbcModel::CbcCutoffIncrement);
+ model.setDblParam(CbcModel::CbcCutoffIncrement, value);
+ case CBC_PARAM_DBL_ALLOWABLEGAP:
+ oldValue = model.getDblParam(CbcModel::CbcAllowableGap);
+ model.setDblParam(CbcModel::CbcAllowableGap, value);
+ break;
+ case CBC_PARAM_DBL_GAPRATIO:
+ oldValue = model.getDblParam(CbcModel::CbcAllowableFractionGap);
+ model.setDblParam(CbcModel::CbcAllowableFractionGap, value);
+ break;
+ case CBC_PARAM_DBL_CUTOFF:
+ oldValue = model.getCutoff();
+ model.setCutoff(value);
+ break;
+ case CBC_PARAM_DBL_TIMELIMIT_BAB:
+ oldValue = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
+ {
+ //OsiClpSolverInterface * clpSolver = dynamic_cast< OsiClpSolverInterface*> (model.solver());
+ //ClpSimplex * lpSolver = clpSolver->getModelPtr();
+ //lpSolver->setMaximumSeconds(value);
+ model.setDblParam(CbcModel::CbcMaximumSeconds, value) ;
+ }
+ break ;
+ case CLP_PARAM_DBL_DUALTOLERANCE:
+ case CLP_PARAM_DBL_PRIMALTOLERANCE:
+ setDoubleParameter(model.solver(), value);
+ return 0; // to avoid message
+ default:
+ break;
+ }
+ sprintf(printArray, "%s was changed from %g to %g",
+ name_.c_str(), oldValue, value);
+ returnCode = 0;
+ }
+ return printArray;
+}
+double
+CbcOrClpParam::doubleParameter (CbcModel &model) const
+{
+ double value;
+ switch (type_) {
+ case CBC_PARAM_DBL_INFEASIBILITYWEIGHT:
+ value = model.getDblParam(CbcModel::CbcInfeasibilityWeight);
+ break;
+ case CBC_PARAM_DBL_INTEGERTOLERANCE:
+ value = model.getDblParam(CbcModel::CbcIntegerTolerance);
+ break;
+ case CBC_PARAM_DBL_INCREMENT:
+ value = model.getDblParam(CbcModel::CbcCutoffIncrement);
+ break;
+ case CBC_PARAM_DBL_ALLOWABLEGAP:
+ value = model.getDblParam(CbcModel::CbcAllowableGap);
+ break;
+ case CBC_PARAM_DBL_GAPRATIO:
+ value = model.getDblParam(CbcModel::CbcAllowableFractionGap);
+ break;
+ case CBC_PARAM_DBL_CUTOFF:
+ value = model.getCutoff();
+ break;
+ case CBC_PARAM_DBL_TIMELIMIT_BAB:
+ value = model.getDblParam(CbcModel::CbcMaximumSeconds) ;
+ break ;
+ case CLP_PARAM_DBL_DUALTOLERANCE:
+ case CLP_PARAM_DBL_PRIMALTOLERANCE:
+ value = doubleParameter(model.solver());
+ break;
+ default:
+ value = doubleValue_;
+ break;
+ }
+ return value;
+}
+int
+CbcOrClpParam::setIntParameter (CbcModel &model, int value)
+{
+ int returnCode;
+ setIntParameterWithMessage(model, value, returnCode);
+ if (doPrinting && strlen(printArray))
+ std::cout << printArray << std::endl;
+ return returnCode;
+}
+// Sets int parameter and returns printable string and error code
+const char *
+CbcOrClpParam::setIntParameterWithMessage ( CbcModel & model, int value , int & returnCode)
+{
+ if (value < lowerIntValue_ || value > upperIntValue_) {
+ sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+ value, name_.c_str(), lowerIntValue_, upperIntValue_);
+ returnCode = 1;
+ } else {
+ printArray[0] = '\0';
+ if (value==intValue_)
+ return printArray;
+ int oldValue = intValue_;
+ intValue_ = value;
+ switch (type_) {
+ case CLP_PARAM_INT_LOGLEVEL:
+ oldValue = model.messageHandler()->logLevel();
+ model.messageHandler()->setLogLevel(CoinAbs(value));
+ break;
+ case CLP_PARAM_INT_SOLVERLOGLEVEL:
+ oldValue = model.solver()->messageHandler()->logLevel();
+ model.solver()->messageHandler()->setLogLevel(value);
+ break;
+ case CBC_PARAM_INT_MAXNODES:
+ oldValue = model.getIntParam(CbcModel::CbcMaxNumNode);
+ model.setIntParam(CbcModel::CbcMaxNumNode, value);
+ break;
+ case CBC_PARAM_INT_MAXSOLS:
+ oldValue = model.getIntParam(CbcModel::CbcMaxNumSol);
+ model.setIntParam(CbcModel::CbcMaxNumSol, value);
+ break;
+ case CBC_PARAM_INT_MAXSAVEDSOLS:
+ oldValue = model.maximumSavedSolutions();
+ model.setMaximumSavedSolutions(value);
+ break;
+ case CBC_PARAM_INT_STRONGBRANCHING:
+ oldValue = model.numberStrong();
+ model.setNumberStrong(value);
+ break;
+ case CBC_PARAM_INT_NUMBERBEFORE:
+ oldValue = model.numberBeforeTrust();
+ model.setNumberBeforeTrust(value);
+ break;
+ case CBC_PARAM_INT_NUMBERANALYZE:
+ oldValue = model.numberAnalyzeIterations();
+ model.setNumberAnalyzeIterations(value);
+ break;
+ case CBC_PARAM_INT_CUTPASSINTREE:
+ oldValue = model.getMaximumCutPasses();
+ model.setMaximumCutPasses(value);
+ break;
+ case CBC_PARAM_INT_CUTPASS:
+ oldValue = model.getMaximumCutPassesAtRoot();
+ model.setMaximumCutPassesAtRoot(value);
+ break;
+#ifdef COIN_HAS_CBC
+#ifdef CBC_THREAD
+ case CBC_PARAM_INT_THREADS:
+ oldValue = model.getNumberThreads();
+ model.setNumberThreads(value);
+ break;
+#endif
+ case CBC_PARAM_INT_RANDOMSEED:
+ oldValue = model.getRandomSeed();
+ model.setRandomSeed(value);
+ break;
+#endif
+ default:
+ break;
+ }
+ sprintf(printArray, "%s was changed from %d to %d",
+ name_.c_str(), oldValue, value);
+ returnCode = 0;
+ }
+ return printArray;
+}
+int
+CbcOrClpParam::intParameter (CbcModel &model) const
+{
+ int value;
+ switch (type_) {
+ case CLP_PARAM_INT_LOGLEVEL:
+ value = model.messageHandler()->logLevel();
+ break;
+ case CLP_PARAM_INT_SOLVERLOGLEVEL:
+ value = model.solver()->messageHandler()->logLevel();
+ break;
+ case CBC_PARAM_INT_MAXNODES:
+ value = model.getIntParam(CbcModel::CbcMaxNumNode);
+ break;
+ case CBC_PARAM_INT_MAXSOLS:
+ value = model.getIntParam(CbcModel::CbcMaxNumSol);
+ break;
+ case CBC_PARAM_INT_MAXSAVEDSOLS:
+ value = model.maximumSavedSolutions();
+ break;
+ case CBC_PARAM_INT_STRONGBRANCHING:
+ value = model.numberStrong();
+ break;
+ case CBC_PARAM_INT_NUMBERBEFORE:
+ value = model.numberBeforeTrust();
+ break;
+ case CBC_PARAM_INT_NUMBERANALYZE:
+ value = model.numberAnalyzeIterations();
+ break;
+ case CBC_PARAM_INT_CUTPASSINTREE:
+ value = model.getMaximumCutPasses();
+ break;
+ case CBC_PARAM_INT_CUTPASS:
+ value = model.getMaximumCutPassesAtRoot();
+ break;
+#ifdef COIN_HAS_CBC
+#ifdef CBC_THREAD
+ case CBC_PARAM_INT_THREADS:
+ value = model.getNumberThreads();
+#endif
+ case CBC_PARAM_INT_RANDOMSEED:
+ value = model.getRandomSeed();
+ break;
+#endif
+ default:
+ value = intValue_;
+ break;
+ }
+ return value;
+}
+#endif
+// Sets current parameter option using string
+void
+CbcOrClpParam::setCurrentOption ( const std::string value )
+{
+ int action = parameterOption(value);
+ if (action >= 0)
+ currentKeyWord_ = action;
+#if FLUSH_PRINT_BUFFER > 2
+ if (name_=="bufferedMode")
+ coinFlushBufferFlag=action;
+#endif
+}
+// Sets current parameter option
+void
+CbcOrClpParam::setCurrentOption ( int value , bool printIt)
+{
+ if (printIt && value != currentKeyWord_)
+ std::cout << "Option for " << name_ << " changed from "
+ << definedKeyWords_[currentKeyWord_] << " to "
+ << definedKeyWords_[value] << std::endl;
+
+#if FLUSH_PRINT_BUFFER > 2
+ if (name_=="bufferedMode")
+ coinFlushBufferFlag=value;
+#endif
+ currentKeyWord_ = value;
+}
+// Sets current parameter option and returns printable string
+const char *
+CbcOrClpParam::setCurrentOptionWithMessage ( int value )
+{
+ if (value != currentKeyWord_) {
+ char current[100];
+ char newString[100];
+ if (currentKeyWord_>=0&&(fakeKeyWord_<=0||currentKeyWord_=0&&(fakeKeyWord_<=0||value 2
+ if (name_=="bufferedMode")
+ coinFlushBufferFlag=value;
+#endif
+ currentKeyWord_ = value;
+ } else {
+ printArray[0] = '\0';
+ }
+ return printArray;
+}
+// Sets current parameter option using string with message
+const char *
+CbcOrClpParam::setCurrentOptionWithMessage ( const std::string value )
+{
+ int action = parameterOption(value);
+ char current[100];
+ printArray[0] = '\0';
+ if (action >= 0) {
+#if FLUSH_PRINT_BUFFER > 2
+ if (name_=="bufferedMode")
+ coinFlushBufferFlag=action;
+#endif
+ if (action == currentKeyWord_)
+ return NULL;
+ if (currentKeyWord_>=0&&(fakeKeyWord_<=0||currentKeyWord_ upperIntValue_) {
+ std::cout << value << " was provided for " << name_ <<
+ " - valid range is " << lowerIntValue_ << " to " <<
+ upperIntValue_ << std::endl;
+ } else {
+ intValue_ = value;
+ }
+}
+const char *
+CbcOrClpParam::setIntValueWithMessage ( int value )
+{
+ printArray[0] = '\0';
+ if (value < lowerIntValue_ || value > upperIntValue_) {
+ sprintf(printArray, "%d was provided for %s - valid range is %d to %d",
+ value,name_.c_str(),lowerIntValue_,upperIntValue_);
+ } else {
+ if (value==intValue_)
+ return NULL;
+ sprintf(printArray, "%s was changed from %d to %d",
+ name_.c_str(), intValue_, value);
+ intValue_ = value;
+ }
+ return printArray;
+}
+void
+CbcOrClpParam::setDoubleValue ( double value )
+{
+ if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+ std::cout << value << " was provided for " << name_ <<
+ " - valid range is " << lowerDoubleValue_ << " to " <<
+ upperDoubleValue_ << std::endl;
+ } else {
+ doubleValue_ = value;
+ }
+}
+const char *
+CbcOrClpParam::setDoubleValueWithMessage ( double value )
+{
+ printArray[0] = '\0';
+ if (value < lowerDoubleValue_ || value > upperDoubleValue_) {
+ sprintf(printArray, "%g was provided for %s - valid range is %g to %g",
+ value,name_.c_str(),lowerDoubleValue_,upperDoubleValue_);
+ } else {
+ if (value==doubleValue_)
+ return NULL;
+ sprintf(printArray, "%s was changed from %g to %g",
+ name_.c_str(), doubleValue_, value);
+ doubleValue_ = value;
+ }
+ return printArray;
+}
+void
+CbcOrClpParam::setStringValue ( std::string value )
+{
+ stringValue_ = value;
+}
+static char line[1000];
+static char * where = NULL;
+extern int CbcOrClpRead_mode;
+int CbcOrClpEnvironmentIndex = -1;
+static size_t fillEnv()
+{
+#if defined(_MSC_VER) || defined(__MSVCRT__)
+ return 0;
+#else
+ // Don't think it will work on Windows
+ char * environ = getenv("CBC_CLP_ENVIRONMENT");
+ size_t length = 0;
+ if (environ) {
+ length = strlen(environ);
+ if (CbcOrClpEnvironmentIndex < static_cast(length)) {
+ // find next non blank
+ char * whereEnv = environ + CbcOrClpEnvironmentIndex;
+ // munch white space
+ while (*whereEnv == ' ' || *whereEnv == '\t' || *whereEnv < ' ')
+ whereEnv++;
+ // copy
+ char * put = line;
+ while ( *whereEnv != '\0' ) {
+ if ( *whereEnv == ' ' || *whereEnv == '\t' || *whereEnv < ' ' ) {
+ break;
+ }
+ *put = *whereEnv;
+ put++;
+ assert (put - line < 1000);
+ whereEnv++;
+ }
+ CbcOrClpEnvironmentIndex = static_cast(whereEnv - environ);
+ *put = '\0';
+ length = strlen(line);
+ } else {
+ length = 0;
+ }
+ }
+ if (!length)
+ CbcOrClpEnvironmentIndex = -1;
+ return length;
+#endif
+}
+extern FILE * CbcOrClpReadCommand;
+// Simple read stuff
+std::string
+CoinReadNextField()
+{
+ std::string field;
+ if (!where) {
+ // need new line
+#ifdef COIN_HAS_READLINE
+ if (CbcOrClpReadCommand == stdin) {
+ // Get a line from the user.
+ where = readline (coin_prompt);
+
+ // If the line has any text in it, save it on the history.
+ if (where) {
+ if ( *where)
+ add_history (where);
+ strcpy(line, where);
+ free(where);
+ }
+ } else {
+ where = fgets(line, 1000, CbcOrClpReadCommand);
+ }
+#else
+ if (CbcOrClpReadCommand == stdin) {
+ fputs(coin_prompt,stdout);
+ fflush(stdout);
+ }
+ where = fgets(line, 1000, CbcOrClpReadCommand);
+#endif
+ if (!where)
+ return field; // EOF
+ where = line;
+ // clean image
+ char * lastNonBlank = line - 1;
+ while ( *where != '\0' ) {
+ if ( *where != '\t' && *where < ' ' ) {
+ break;
+ } else if ( *where != '\t' && *where != ' ') {
+ lastNonBlank = where;
+ }
+ where++;
+ }
+ where = line;
+ *(lastNonBlank + 1) = '\0';
+ }
+ // munch white space
+ while (*where == ' ' || *where == '\t')
+ where++;
+ char * saveWhere = where;
+ while (*where != ' ' && *where != '\t' && *where != '\0')
+ where++;
+ if (where != saveWhere) {
+ char save = *where;
+ *where = '\0';
+ //convert to string
+ field = saveWhere;
+ *where = save;
+ } else {
+ where = NULL;
+ field = "EOL";
+ }
+ return field;
+}
+
+std::string
+CoinReadGetCommand(int argc, const char *argv[])
+{
+ std::string field = "EOL";
+ // say no =
+ afterEquals = "";
+ while (field == "EOL") {
+ if (CbcOrClpRead_mode > 0) {
+ if ((CbcOrClpRead_mode < argc && argv[CbcOrClpRead_mode]) ||
+ CbcOrClpEnvironmentIndex >= 0) {
+ if (CbcOrClpEnvironmentIndex < 0) {
+ field = argv[CbcOrClpRead_mode++];
+ } else {
+ if (fillEnv()) {
+ field = line;
+ } else {
+ // not there
+ continue;
+ }
+ }
+ if (field == "-") {
+ std::cout << "Switching to line mode" << std::endl;
+ CbcOrClpRead_mode = -1;
+ field = CoinReadNextField();
+ } else if (field[0] != '-') {
+ if (CbcOrClpRead_mode != 2) {
+ // now allow std::cout<<"skipping non-command "< 0) {
+ if (CbcOrClpRead_mode < argc || CbcOrClpEnvironmentIndex >= 0) {
+ if (CbcOrClpEnvironmentIndex < 0) {
+ if (argv[CbcOrClpRead_mode][0] != '-') {
+ field = argv[CbcOrClpRead_mode++];
+ } else if (!strcmp(argv[CbcOrClpRead_mode], "--")) {
+ field = argv[CbcOrClpRead_mode++];
+ // -- means import from stdin
+ field = "-";
+ }
+ } else {
+ fillEnv();
+ field = line;
+ }
+ }
+ } else {
+ field = CoinReadNextField();
+ }
+ } else {
+ field = afterEquals;
+ afterEquals = "";
+ }
+ //std::cout< 0) {
+ if (CbcOrClpRead_mode < argc || CbcOrClpEnvironmentIndex >= 0) {
+ if (CbcOrClpEnvironmentIndex < 0) {
+ // may be negative value so do not check for -
+ field = argv[CbcOrClpRead_mode++];
+ } else {
+ fillEnv();
+ field = line;
+ }
+ }
+ } else {
+ field = CoinReadNextField();
+ }
+ } else {
+ field = afterEquals;
+ afterEquals = "";
+ }
+ long int value = 0;
+ //std::cout<(value);
+}
+double
+CoinReadGetDoubleField(int argc, const char *argv[], int * valid)
+{
+ std::string field = "EOL";
+ if (afterEquals == "") {
+ if (CbcOrClpRead_mode > 0) {
+ if (CbcOrClpRead_mode < argc || CbcOrClpEnvironmentIndex >= 0) {
+ if (CbcOrClpEnvironmentIndex < 0) {
+ // may be negative value so do not check for -
+ field = argv[CbcOrClpRead_mode++];
+ } else {
+ fillEnv();
+ field = line;
+ }
+ }
+ } else {
+ field = CoinReadNextField();
+ }
+ } else {
+ field = afterEquals;
+ afterEquals = "";
+ }
+ double value = 0.0;
+ //std::cout<= this treated as artificials in feasibility pump",
+ 0.0, COIN_DBL_MAX, CBC_PARAM_DBL_ARTIFICIALCOST, 1);
+ parameters[numberParameters-1].setDoubleValue(0.0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "0.0 off - otherwise variables with costs >= this are treated as artificials and fixed to lower bound in feasibility pump"
+ );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("auto!Scale", "Whether to scale objective, rhs and bounds of problem if they look odd",
+ "off", CLP_PARAM_STR_AUTOSCALE, 7, 0);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If you think you may get odd objective values or large equality rows etc then\
+ it may be worth setting this true. It is still experimental and you may prefer\
+ to use objective!Scale and rhs!Scale."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("barr!ier", "Solve using primal dual predictor corrector algorithm",
+ CLP_PARAM_ACTION_BARRIER);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This command solves the current model using the primal dual predictor \
+corrector algorithm. You may want to link in an alternative \
+ordering and factorization. It will also solve models \
+with quadratic objectives."
+
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("basisI!n", "Import basis from bas file",
+ CLP_PARAM_ACTION_BASISIN, 3);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This will read an MPS format basis file from the given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to '', i.e. it must be set. If you have libz then it can read compressed\
+ files 'xxxxxxxx.gz' or xxxxxxxx.bz2."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("basisO!ut", "Export basis as bas file",
+ CLP_PARAM_ACTION_BASISOUT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This will write an MPS format basis file to the given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to 'default.bas'."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("biasLU", "Whether factorization biased towards U",
+ "UU", CLP_PARAM_STR_BIASLU, 2, 0);
+ parameters[numberParameters-1].append("UX");
+ parameters[numberParameters-1].append("LX");
+ parameters[numberParameters-1].append("LL");
+ parameters[numberParameters-1].setCurrentOption("LX");
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("branch!AndCut", "Do Branch and Cut",
+ CBC_PARAM_ACTION_BAB);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This does branch and cut. There are many parameters which can affect the performance. \
+First just try with default settings and look carefully at the log file. Did cuts help? Did they take too long? \
+Look at output to see which cuts were effective and then do some tuning. You will see that the \
+options for cuts are off, on, root and ifmove, forceon. Off is \
+obvious, on means that this cut generator will be tried in the branch and cut tree (you can fine tune using \
+'depth'). Root means just at the root node while 'ifmove' means that cuts will be used in the tree if they \
+look as if they are doing some good and moving the objective value. Forceon is same as on but forces code to use \
+cut generator at every node. For probing forceonbut just does fixing probing in tree - not strengthening etc. \
+If pre-processing reduced the size of the \
+problem or strengthened many coefficients then it is probably wise to leave it on. Switch off heuristics \
+which did not provide solutions. The other major area to look at is the search. Hopefully good solutions \
+were obtained fairly early in the search so the important point is to select the best variable to branch on. \
+See whether strong branching did a good job - or did it just take a lot of iterations. Adjust the strongBranching \
+and trustPseudoCosts parameters. If cuts did a good job, then you may wish to \
+have more rounds of cuts - see passC!uts and passT!ree."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("bscale", "Whether to scale in barrier (and ordering speed)",
+ "off", CLP_PARAM_STR_BARRIERSCALE, 7, 0);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("off1");
+ parameters[numberParameters-1].append("on1");
+ parameters[numberParameters-1].append("off2");
+ parameters[numberParameters-1].append("on2");
+#if FLUSH_PRINT_BUFFER > 2
+ parameters[numberParameters++] =
+ CbcOrClpParam("buff!eredMode", "Whether to flush print buffer",
+ "on", CLP_PARAM_STR_BUFFER_MODE);
+ parameters[numberParameters-1].append("off");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Default is on, off switches on unbuffered output"
+ );
+ parameters[numberParameters-1].setIntValue(0);
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("chol!esky", "Which cholesky algorithm",
+ "native", CLP_PARAM_STR_CHOLESKY, 7);
+ parameters[numberParameters-1].append("dense");
+ //#ifdef FOREIGN_BARRIER
+#ifdef COIN_HAS_WSMP
+ parameters[numberParameters-1].append("fudge!Long");
+ parameters[numberParameters-1].append("wssmp");
+#else
+ parameters[numberParameters-1].append("fudge!Long_dummy");
+ parameters[numberParameters-1].append("wssmp_dummy");
+#endif
+#if defined(COIN_HAS_AMD) || defined(COIN_HAS_CHOLMOD) || defined(COIN_HAS_GLPK)
+ parameters[numberParameters-1].append("Uni!versityOfFlorida");
+#else
+ parameters[numberParameters-1].append("Uni!versityOfFlorida_dummy");
+#endif
+#ifdef TAUCS_BARRIER
+ parameters[numberParameters-1].append("Taucs");
+#else
+ parameters[numberParameters-1].append("Taucs_dummy");
+#endif
+#ifdef COIN_HAS_MUMPS
+ parameters[numberParameters-1].append("Mumps");
+#else
+ parameters[numberParameters-1].append("Mumps_dummy");
+#endif
+ parameters[numberParameters-1].setLonghelp
+ (
+ "For a barrier code to be effective it needs a good Cholesky ordering and factorization. \
+The native ordering and factorization is not state of the art, although acceptable. \
+You may want to link in one from another source. See Makefile.locations for some \
+possibilities."
+ );
+ //#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("clique!Cuts", "Whether to use Clique cuts",
+ "off", CBC_PARAM_STR_CLIQUECUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].append("onglobal");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on clique cuts (either at root or in entire tree) \
+See branchAndCut for information on options."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("combine!Solutions", "Whether to use combine solution heuristic",
+ "off", CBC_PARAM_STR_COMBINE);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].append("onquick");
+ parameters[numberParameters-1].append("bothquick");
+ parameters[numberParameters-1].append("beforequick");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on a heuristic which does branch and cut on the problem given by just \
+using variables which have appeared in one or more solutions. \
+It obviously only tries after two or more solutions. \
+See Rounding for meaning of on,both,before"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("combine2!Solutions", "Whether to use crossover solution heuristic",
+ "off", CBC_PARAM_STR_CROSSOVER2);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on a heuristic which does branch and cut on the problem given by \
+fixing variables which have same value in two or more solutions. \
+It obviously only tries after two or more solutions. \
+See Rounding for meaning of on,both,before"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("constraint!fromCutoff", "Whether to use cutoff as constraint",
+ "off", CBC_PARAM_STR_CUTOFF_CONSTRAINT);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("variable");
+ parameters[numberParameters-1].append("forcevariable");
+ parameters[numberParameters-1].append("conflict");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This adds the objective as a constraint with best solution as RHS"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("cost!Strategy", "How to use costs as priorities",
+ "off", CBC_PARAM_STR_COSTSTRATEGY);
+ parameters[numberParameters-1].append("pri!orities");
+ parameters[numberParameters-1].append("column!Order?");
+ parameters[numberParameters-1].append("01f!irst?");
+ parameters[numberParameters-1].append("01l!ast?");
+ parameters[numberParameters-1].append("length!?");
+ parameters[numberParameters-1].append("singletons");
+ parameters[numberParameters-1].append("nonzero");
+ parameters[numberParameters-1].append("general!Force?");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This orders the variables in order of their absolute costs - with largest cost ones being branched on \
+first. This primitive strategy can be surprsingly effective. The column order\
+ option is obviously not on costs but easy to code here."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("cplex!Use", "Whether to use Cplex!",
+ "off", CBC_PARAM_STR_CPX);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].setLonghelp
+ (
+ " If the user has Cplex, but wants to use some of Cbc's heuristics \
+then you can! If this is on, then Cbc will get to the root node and then \
+hand over to Cplex. If heuristics find a solution this can be significantly \
+quicker. You will probably want to switch off Cbc's cuts as Cplex thinks \
+they are genuine constraints. It is also probable that you want to switch \
+off preprocessing, although for difficult problems it is worth trying \
+both."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("cpp!Generate", "Generates C++ code",
+ -1, 50000, CLP_PARAM_INT_CPP, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Once you like what the stand-alone solver does then this allows \
+you to generate user_driver.cpp which approximates the code. \
+0 gives simplest driver, 1 generates saves and restores, 2 \
+generates saves and restores even for variables at default value. \
+4 bit in cbc generates size dependent code rather than computed values. \
+This is now deprecated as you can call stand-alone solver - see \
+Cbc/examples/driver4.cpp."
+ );
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("crash", "Whether to create basis for problem",
+ "off", CLP_PARAM_STR_CRASH);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("so!low_halim");
+ parameters[numberParameters-1].append("lots");
+#ifdef CLP_INHERIT_MODE
+ parameters[numberParameters-1].append("dual");
+ parameters[numberParameters-1].append("dw");
+ parameters[numberParameters-1].append("idiot");
+#else
+ parameters[numberParameters-1].append("idiot1");
+ parameters[numberParameters-1].append("idiot2");
+ parameters[numberParameters-1].append("idiot3");
+ parameters[numberParameters-1].append("idiot4");
+ parameters[numberParameters-1].append("idiot5");
+ parameters[numberParameters-1].append("idiot6");
+ parameters[numberParameters-1].append("idiot7");
+#endif
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If crash is set on and there is an all slack basis then Clp will flip or put structural\
+ variables into basis with the aim of getting dual feasible. On the whole dual seems to be\
+ better without it and there are alternative types of 'crash' for primal e.g. 'idiot' or 'sprint'. \
+I have also added a variant due to Solow and Halim which is as on but just flip.");
+ parameters[numberParameters++] =
+ CbcOrClpParam("cross!over", "Whether to get a basic solution after barrier",
+ "on", CLP_PARAM_STR_CROSSOVER);
+ parameters[numberParameters-1].append("off");
+ parameters[numberParameters-1].append("maybe");
+ parameters[numberParameters-1].append("presolve");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Interior point algorithms do not obtain a basic solution (and \
+the feasibility criterion is a bit suspect (JJF)). This option will crossover \
+to a basic solution suitable for ranging or branch and cut. With the current state \
+of quadratic it may be a good idea to switch off crossover for quadratic (and maybe \
+presolve as well) - the option maybe does this."
+ );
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("csv!Statistics", "Create one line of statistics",
+ CLP_PARAM_ACTION_CSVSTATISTICS, 2, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This appends statistics to given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to '', i.e. it must be set. Adds header if file empty or does not exist."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("cutD!epth", "Depth in tree at which to do cuts",
+ -1, 999999, CBC_PARAM_INT_CUTDEPTH);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Cut generators may be - off, on only at root, on if they look possible \
+and on. If they are done every node then that is that, but it may be worth doing them \
+every so often. The original method was every so many nodes but it is more logical \
+to do it whenever depth in tree is a multiple of K. This option does that and defaults \
+to -1 (off -> code decides)."
+ );
+ parameters[numberParameters-1].setIntValue(-1);
+ parameters[numberParameters++] =
+ CbcOrClpParam("cutL!ength", "Length of a cut",
+ -1, COIN_INT_MAX, CBC_PARAM_INT_CUTLENGTH);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "At present this only applies to Gomory cuts. -1 (default) leaves as is. \
+Any value >0 says that all cuts <= this length can be generated both at \
+root node and in tree. 0 says to use some dynamic lengths. If value >=10,000,000 \
+then the length in tree is value%10000000 - so 10000100 means unlimited length \
+at root and 100 in tree."
+ );
+ parameters[numberParameters-1].setIntValue(-1);
+ parameters[numberParameters++] =
+ CbcOrClpParam("cuto!ff", "All solutions must be better than this",
+ -1.0e60, 1.0e60, CBC_PARAM_DBL_CUTOFF);
+ parameters[numberParameters-1].setDoubleValue(1.0e50);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "All solutions must be better than this value (in a minimization sense). \
+This is also set by code whenever it obtains a solution and is set to value of \
+objective for solution minus cutoff increment."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("cuts!OnOff", "Switches all cuts on or off",
+ "off", CBC_PARAM_STR_CUTSSTRATEGY);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This can be used to switch on or off all cuts (apart from Reduce and Split). Then you can do \
+individual ones off or on \
+See branchAndCut for information on options."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("debug!In", "read valid solution from file",
+ CLP_PARAM_ACTION_DEBUG, 7, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This will read a solution file from the given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to '', i.e. it must be set.\n\n\
+If set to create it will create a file called debug.file after search.\n\n\
+The idea is that if you suspect a bad cut generator \
+you can do a good run with debug set to 'create' and then switch on the cuts you suspect and \
+re-run with debug set to 'debug.file' The create case has same effect as saveSolution."
+ );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("decomp!ose", "Whether to try decomposition",
+ -COIN_INT_MAX, COIN_INT_MAX, CLP_PARAM_INT_DECOMPOSE_BLOCKS, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "0 - off, 1 choose blocks >1 use as blocks \
+Dantzig Wolfe if primal, Benders if dual \
+- uses sprint pass for number of passes"
+ );
+ parameters[numberParameters-1].setIntValue(0);
+#if CLP_MULTIPLE_FACTORIZATIONS >0
+ parameters[numberParameters++] =
+ CbcOrClpParam("dense!Threshold", "Whether to use dense factorization",
+ -1, 10000, CBC_PARAM_INT_DENSE, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If processed problem <= this use dense factorization"
+ );
+ parameters[numberParameters-1].setIntValue(-1);
+#endif
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("depth!MiniBab", "Depth at which to try mini BAB",
+ -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_DEPTHMINIBAB);
+ parameters[numberParameters-1].setIntValue(-1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Rather a complicated parameter but can be useful. -1 means off for large problems but on as if -12 for problems where rows+columns<500, -2 \
+means use Cplex if it is linked in. Otherwise if negative then go into depth first complete search fast branch and bound when depth>= -value-2 (so -3 will use this at depth>=1). This mode is only switched on after 500 nodes. If you really want to switch it off for small problems then set this to -999. If >=0 the value doesn't matter very much. The code will do approximately 100 nodes of fast branch and bound every now and then at depth>=5. The actual logic is too twisted to describe here."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("dextra3", "Extra double parameter 3",
+ -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA3, 0);
+ parameters[numberParameters-1].setDoubleValue(0.0);
+ parameters[numberParameters++] =
+ CbcOrClpParam("dextra4", "Extra double parameter 4",
+ -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA4, 0);
+ parameters[numberParameters-1].setDoubleValue(0.0);
+ parameters[numberParameters++] =
+ CbcOrClpParam("dextra5", "Extra double parameter 5",
+ -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_DEXTRA5, 0);
+ parameters[numberParameters-1].setDoubleValue(0.0);
+ parameters[numberParameters++] =
+ CbcOrClpParam("Dins", "Whether to try Distance Induced Neighborhood Search",
+ "off", CBC_PARAM_STR_DINS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].append("often");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on Distance induced neighborhood Search. \
+See Rounding for meaning of on,both,before"
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("direction", "Minimize or Maximize",
+ "min!imize", CLP_PARAM_STR_DIRECTION);
+ parameters[numberParameters-1].append("max!imize");
+ parameters[numberParameters-1].append("zero");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "The default is minimize - use 'direction maximize' for maximization.\n\
+You can also use the parameters 'maximize' or 'minimize'."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("directory", "Set Default directory for import etc.",
+ CLP_PARAM_ACTION_DIRECTORY);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This sets the directory which import, export, saveModel, restoreModel etc will use.\
+ It is initialized to './'"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("dirSample", "Set directory where the COIN-OR sample problems are.",
+ CLP_PARAM_ACTION_DIRSAMPLE, 7, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This sets the directory where the COIN-OR sample problems reside. It is\
+ used only when -unitTest is passed to clp. clp will pick up the test problems\
+ from this directory.\
+ It is initialized to '../../Data/Sample'"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("dirNetlib", "Set directory where the netlib problems are.",
+ CLP_PARAM_ACTION_DIRNETLIB, 7, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This sets the directory where the netlib problems reside. One can get\
+ the netlib problems from COIN-OR or from the main netlib site. This\
+ parameter is used only when -netlib is passed to clp. clp will pick up the\
+ netlib problems from this directory. If clp is built without zlib support\
+ then the problems must be uncompressed.\
+ It is initialized to '../../Data/Netlib'"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("dirMiplib", "Set directory where the miplib 2003 problems are.",
+ CBC_PARAM_ACTION_DIRMIPLIB, 7, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This sets the directory where the miplib 2003 problems reside. One can\
+ get the miplib problems from COIN-OR or from the main miplib site. This\
+ parameter is used only when -miplib is passed to cbc. cbc will pick up the\
+ miplib problems from this directory. If cbc is built without zlib support\
+ then the problems must be uncompressed.\
+ It is initialized to '../../Data/miplib3'"
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("diveO!pt", "Diving options",
+ -1, 200000, CBC_PARAM_INT_DIVEOPT, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If >2 && <20 then modify diving options - \
+ \n\t3 only at root and if no solution, \
+ \n\t4 only at root and if this heuristic has not got solution, \
+ \n\t5 decay only if no solution, \
+ \n\t6 if depth <3 or decay, \
+ \n\t7 run up to 2 times if solution found 4 otherwise, \
+ \n\t>10 All only at root (DivingC normal as value-10), \
+ \n\t>20 All with value-20)."
+ );
+ parameters[numberParameters-1].setIntValue(-1);
+ parameters[numberParameters++] =
+ CbcOrClpParam("diveS!olves", "Diving solve option",
+ -1, 200000, CBC_PARAM_INT_DIVEOPTSOLVES, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If >0 then do up to this many solves. Last digit is ignored \
+and used for extra options - \
+ \n\t1-3 allow fixing of satisfied integers (but not at bound) \
+ \n\t1 switch off above for that dive if goes infeasible \
+ \n\t2 switch off above permanently if goes infeasible"
+ );
+ parameters[numberParameters-1].setIntValue(100);
+ parameters[numberParameters++] =
+ CbcOrClpParam("DivingS!ome", "Whether to try Diving heuristics",
+ "off", CBC_PARAM_STR_DIVINGS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on a random diving heuristic at various times. \
+C - Coefficient, F - Fractional, G - Guided, L - LineSearch, P - PseudoCost, V - VectorLength. \
+You may prefer to use individual on/off \
+See Rounding for meaning of on,both,before"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("DivingC!oefficient", "Whether to try DiveCoefficient",
+ "off", CBC_PARAM_STR_DIVINGC);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters++] =
+ CbcOrClpParam("DivingF!ractional", "Whether to try DiveFractional",
+ "off", CBC_PARAM_STR_DIVINGF);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters++] =
+ CbcOrClpParam("DivingG!uided", "Whether to try DiveGuided",
+ "off", CBC_PARAM_STR_DIVINGG);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters++] =
+ CbcOrClpParam("DivingL!ineSearch", "Whether to try DiveLineSearch",
+ "off", CBC_PARAM_STR_DIVINGL);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters++] =
+ CbcOrClpParam("DivingP!seudoCost", "Whether to try DivePseudoCost",
+ "off", CBC_PARAM_STR_DIVINGP);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters++] =
+ CbcOrClpParam("DivingV!ectorLength", "Whether to try DiveVectorLength",
+ "off", CBC_PARAM_STR_DIVINGV);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters++] =
+ CbcOrClpParam("doH!euristic", "Do heuristics before any preprocessing",
+ CBC_PARAM_ACTION_DOHEURISTIC, 3);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Normally heuristics are done in branch and bound. It may be useful to do them outside. \
+Only those heuristics with 'both' or 'before' set will run. \
+Doing this may also set cutoff, which can help with preprocessing."
+ );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("dualB!ound", "Initially algorithm acts as if no \
+gap between bounds exceeds this value",
+ 1.0e-20, 1.0e12, CLP_PARAM_DBL_DUALBOUND);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "The dual algorithm in Clp is a single phase algorithm as opposed to a two phase\
+ algorithm where you first get feasible then optimal. If a problem has both upper and\
+ lower bounds then it is trivial to get dual feasible by setting non basic variables\
+ to correct bound. If the gap between the upper and lower bounds of a variable is more\
+ than the value of dualBound Clp introduces fake bounds so that it can make the problem\
+ dual feasible. This has the same effect as a composite objective function in the\
+ primal algorithm. Too high a value may mean more iterations, while too low a bound means\
+ the code may go all the way and then have to increase the bounds. OSL had a heuristic to\
+ adjust bounds, maybe we need that here."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("dualize", "Solves dual reformulation",
+ 0, 4, CLP_PARAM_INT_DUALIZE, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Don't even think about it."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("dualP!ivot", "Dual pivot choice algorithm",
+ "auto!matic", CLP_PARAM_STR_DUALPIVOT, 7, 1);
+ parameters[numberParameters-1].append("dant!zig");
+ parameters[numberParameters-1].append("partial");
+ parameters[numberParameters-1].append("steep!est");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Clp can use any pivot selection algorithm which the user codes as long as it\
+ implements the features in the abstract pivot base class. The Dantzig method is implemented\
+ to show a simple method but its use is deprecated. Steepest is the method of choice and there\
+ are two variants which keep all weights updated but only scan a subset each iteration.\
+ Partial switches this on while automatic decides at each iteration based on information\
+ about the factorization."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("dualS!implex", "Do dual simplex algorithm",
+ CLP_PARAM_ACTION_DUALSIMPLEX);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This command solves the continuous relaxation of the current model using the dual steepest edge algorithm.\
+The time and iterations may be affected by settings such as presolve, scaling, crash\
+ and also by dual pivot method, fake bound on variables and dual and primal tolerances."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("dualT!olerance", "For an optimal solution \
+no dual infeasibility may exceed this value",
+ 1.0e-20, 1.0e12, CLP_PARAM_DBL_DUALTOLERANCE);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Normally the default tolerance is fine, but you may want to increase it a\
+ bit if a dual run seems to be having a hard time. One method which can be faster is \
+to use a large tolerance e.g. 1.0e-4 and dual and then clean up problem using primal and the \
+correct tolerance (remembering to switch off presolve for this final short clean up phase)."
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("dw!Heuristic", "Whether to try DW heuristic",
+ "off", CBC_PARAM_STR_DW);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "See Rounding for meaning of on,both,before"
+ );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("either!Simplex", "Do dual or primal simplex algorithm",
+ CLP_PARAM_ACTION_EITHERSIMPLEX);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This command solves the continuous relaxation of the current model using the dual or primal algorithm,\
+ based on a dubious analysis of model."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("end", "Stops clp execution",
+ CLP_PARAM_ACTION_EXIT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This stops execution ; end, exit, quit and stop are synonyms"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("environ!ment", "Read commands from environment",
+ CLP_PARAM_ACTION_ENVIRONMENT, 7, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This starts reading from environment variable CBC_CLP_ENVIRONMENT."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("error!sAllowed", "Whether to allow import errors",
+ "off", CLP_PARAM_STR_ERRORSALLOWED, 3);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "The default is not to use any model which had errors when reading the mps file.\
+ Setting this to 'on' will allow all errors from which the code can recover\
+ simply by ignoring the error. There are some errors from which the code can not recover \
+e.g. no ENDATA. This has to be set before import i.e. -errorsAllowed on -import xxxxxx.mps."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("exit", "Stops clp execution",
+ CLP_PARAM_ACTION_EXIT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This stops the execution of Clp, end, exit, quit and stop are synonyms"
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("exper!iment", "Whether to use testing features",
+ -1, 200, CBC_PARAM_INT_EXPERIMENT, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Defines how adventurous you want to be in using new ideas. \
+0 then no new ideas, 1 fairly sensible, 2 a bit dubious, 3 you are on your own!"
+ );
+ parameters[numberParameters-1].setIntValue(0);
+ parameters[numberParameters++] =
+ CbcOrClpParam("expensive!Strong", "Whether to do even more strong branching",
+ 0, COIN_INT_MAX, CBC_PARAM_INT_STRONG_STRATEGY, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Strategy for extra strong branching \n\
+\n\t0 - normal\n\
+\n\twhen to do all fractional\n\
+\n\t1 - root node\n\
+\n\t2 - depth less than modifier\n\
+\n\t4 - if objective == best possible\n\
+\n\t6 - as 2+4\n\
+\n\twhen to do all including satisfied\n\
+\n\t10 - root node etc.\n\
+\n\tIf >=100 then do when depth <= strategy/100 (otherwise 5)"
+ );
+ parameters[numberParameters-1].setIntValue(0);
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("export", "Export model as mps file",
+ CLP_PARAM_ACTION_EXPORT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This will write an MPS format file to the given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to 'default.mps'. \
+It can be useful to get rid of the original names and go over to using Rnnnnnnn and Cnnnnnnn. This can be done by setting 'keepnames' off before importing mps file."
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("extra1", "Extra integer parameter 1",
+ -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA1, 0);
+ parameters[numberParameters-1].setIntValue(-1);
+ parameters[numberParameters++] =
+ CbcOrClpParam("extra2", "Extra integer parameter 2",
+ -100, COIN_INT_MAX, CBC_PARAM_INT_EXTRA2, 0);
+ parameters[numberParameters-1].setIntValue(-1);
+ parameters[numberParameters++] =
+ CbcOrClpParam("extra3", "Extra integer parameter 3",
+ -1, COIN_INT_MAX, CBC_PARAM_INT_EXTRA3, 0);
+ parameters[numberParameters-1].setIntValue(-1);
+ parameters[numberParameters++] =
+ CbcOrClpParam("extra4", "Extra integer parameter 4",
+ -1, COIN_INT_MAX, CBC_PARAM_INT_EXTRA4, 0);
+ parameters[numberParameters-1].setIntValue(-1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on yet more special options!! \
+The bottom digit is a strategy when to used shadow price stuff e.g. 3 \
+means use until a solution is found. The next two digits say what sort \
+of dual information to use. After that it goes back to powers of 2 so -\n\
+\n\t1000 - switches on experimental hotstart\n\
+\n\t2,4,6000 - switches on experimental methods of stopping cuts\n\
+\n\t8000 - increase minimum drop gradually\n\
+\n\t16000 - switches on alternate gomory criterion"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("extraV!ariables", "Allow creation of extra integer variables",
+ -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA_VARIABLES, 0);
+ parameters[numberParameters-1].setIntValue(0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on creation of extra integer variables \
+to gather all variables with same cost."
+ );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("fact!orization", "Which factorization to use",
+ "normal", CLP_PARAM_STR_FACTORIZATION);
+ parameters[numberParameters-1].append("dense");
+ parameters[numberParameters-1].append("simple");
+ parameters[numberParameters-1].append("osl");
+ parameters[numberParameters-1].setLonghelp
+ (
+#ifndef ABC_INHERIT
+ "The default is to use the normal CoinFactorization, but \
+other choices are a dense one, osl's or one designed for small problems."
+#else
+ "Normally the default is to use the normal CoinFactorization, but \
+other choices are a dense one, osl's or one designed for small problems. \
+However if at Aboca then the default is CoinAbcFactorization and other choices are \
+a dense one, one designed for small problems or if enabled a long factorization."
+#endif
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("fakeB!ound", "All bounds <= this value - DEBUG",
+ 1.0, 1.0e15, CLP_PARAM_ACTION_FAKEBOUND, 0);
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("feas!ibilityPump", "Whether to try Feasibility Pump",
+ "off", CBC_PARAM_STR_FPUMP);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on feasibility pump heuristic at root. This is due to Fischetti, Lodi and Glover \
+and uses a sequence of Lps to try and get an integer feasible solution. \
+Some fine tuning is available by passFeasibilityPump and also pumpTune. \
+See Rounding for meaning of on,both,before"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("fix!OnDj", "Try heuristic based on fixing variables with \
+reduced costs greater than this",
+ -1.0e20, 1.0e20, CBC_PARAM_DBL_DJFIX, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If this is set integer variables with reduced costs greater than this will be fixed \
+before branch and bound - use with extreme caution!"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("flow!CoverCuts", "Whether to use Flow Cover cuts",
+ "off", CBC_PARAM_STR_FLOWCUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].append("onglobal");
+ parameters[numberParameters-1].setFakeKeyWord(3);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on flow cover cuts (either at root or in entire tree) \
+See branchAndCut for information on options. \
+Can also enter testing values by plusnn (==ifmove)"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("force!Solution", "Whether to use given solution as crash for BAB",
+ -1, 20000000, CLP_PARAM_INT_USESOLUTION);
+ parameters[numberParameters-1].setIntValue(-1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "-1 off. If 1 then tries to branch to solution given by AMPL or priorities file. \
+If 0 then just tries to set as best solution \
+If >1 then also does that many nodes on fixed problem."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("fraction!forBAB", "Fraction in feasibility pump",
+ 1.0e-5, 1.1, CBC_PARAM_DBL_SMALLBAB, 1);
+ parameters[numberParameters-1].setDoubleValue(0.5);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "After a pass in feasibility pump, variables which have not moved \
+about are fixed and if the preprocessed model is small enough a few nodes \
+of branch and bound are done on reduced problem. Small problem has to be less than this fraction of original."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("gamma!(Delta)", "Whether to regularize barrier",
+ "off", CLP_PARAM_STR_GAMMA, 7, 1);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("gamma");
+ parameters[numberParameters-1].append("delta");
+ parameters[numberParameters-1].append("onstrong");
+ parameters[numberParameters-1].append("gammastrong");
+ parameters[numberParameters-1].append("deltastrong");
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("GMI!Cuts", "Whether to use alternative Gomory cuts",
+ "off", CBC_PARAM_STR_GMICUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].append("endonly");
+ parameters[numberParameters-1].append("long");
+ parameters[numberParameters-1].append("longroot");
+ parameters[numberParameters-1].append("longifmove");
+ parameters[numberParameters-1].append("forceLongOn");
+ parameters[numberParameters-1].append("longendonly");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on an alternative Gomory cut generator (either at root or in entire tree) \
+This version is by Giacomo Nannicini and may be more robust \
+See branchAndCut for information on options."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("gomory!Cuts", "Whether to use Gomory cuts",
+ "off", CBC_PARAM_STR_GOMORYCUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].append("onglobal");
+ parameters[numberParameters-1].append("forceandglobal");
+ parameters[numberParameters-1].append("forceLongOn");
+ parameters[numberParameters-1].append("long");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "The original cuts - beware of imitations! Having gone out of favor, they are now more \
+fashionable as LP solvers are more robust and they interact well with other cuts. They will almost always \
+give cuts (although in this executable they are limited as to number of variables in cut). \
+However the cuts may be dense so it is worth experimenting (Long allows any length). \
+See branchAndCut for information on options."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("greedy!Heuristic", "Whether to use a greedy heuristic",
+ "off", CBC_PARAM_STR_GREEDY);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ //parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Switches on a greedy heuristic which will try and obtain a solution. It may just fix a \
+percentage of variables and then try a small branch and cut run. \
+See Rounding for meaning of on,both,before"
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("gsolu!tion", "Puts glpk solution to file",
+ CLP_PARAM_ACTION_GMPL_SOLUTION);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Will write a glpk solution file to the given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to 'stdout' (this defaults to ordinary solution if stdout). \
+If problem created from gmpl model - will do any reports."
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("heur!isticsOnOff", "Switches most heuristics on or off",
+ "off", CBC_PARAM_STR_HEURISTICSTRATEGY);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This can be used to switch on or off all heuristics. Then you can do \
+individual ones off or on. CbcTreeLocal is not included as it dramatically \
+alters search."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("help", "Print out version, non-standard options and some help",
+ CLP_PARAM_ACTION_HELP, 3);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This prints out some help to get user started. If you have printed this then \
+you should be past that stage:-)"
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("hOp!tions", "Heuristic options",
+ -9999999, 9999999, CBC_PARAM_INT_HOPTIONS, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "1 says stop heuristic immediately allowable gap reached. \
+Others are for feasibility pump - \
+2 says do exact number of passes given, \
+4 only applies if initial cutoff given and says relax after 50 passes, \
+while 8 will adapt cutoff rhs after first solution if it looks as if code is stalling."
+ );
+ parameters[numberParameters-1].setIntValue(0);
+ parameters[numberParameters++] =
+ CbcOrClpParam("hot!StartMaxIts", "Maximum iterations on hot start",
+ 0, COIN_INT_MAX, CBC_PARAM_INT_MAXHOTITS);
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("idiot!Crash", "Whether to try idiot crash",
+ -1, 99999999, CLP_PARAM_INT_IDIOT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This is a type of 'crash' which works well on some homogeneous problems.\
+ It works best on problems with unit elements and rhs but will do something to any model. It should only be\
+ used before primal. It can be set to -1 when the code decides for itself whether to use it,\
+ 0 to switch off or n > 0 to do n passes."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("import", "Import model from mps file",
+ CLP_PARAM_ACTION_IMPORT, 3);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This will read an MPS format file from the given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to '', i.e. it must be set. If you have libgz then it can read compressed\
+ files 'xxxxxxxx.gz' or 'xxxxxxxx.bz2'. \
+If 'keepnames' is off, then names are dropped -> Rnnnnnnn and Cnnnnnnn."
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("inc!rement", "A valid solution must be at least this \
+much better than last integer solution",
+ -1.0e20, 1.0e20, CBC_PARAM_DBL_INCREMENT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Whenever a solution is found the bound on solutions is set to solution (in a minimization\
+sense) plus this. If it is not set then the code will try and work one out e.g. if \
+all objective coefficients are multiples of 0.01 and only integer variables have entries in \
+objective then this can be set to 0.01. Be careful if you set this negative!"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("inf!easibilityWeight", "Each integer infeasibility is expected \
+to cost this much",
+ 0.0, 1.0e20, CBC_PARAM_DBL_INFEASIBILITYWEIGHT, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "A primitive way of deciding which node to explore next. Satisfying each integer infeasibility is \
+expected to cost this much."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("initialS!olve", "Solve to continuous",
+ CLP_PARAM_ACTION_SOLVECONTINUOUS);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This just solves the problem to continuous - without adding any cuts"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("integerT!olerance", "For an optimal solution \
+no integer variable may be this away from an integer value",
+ 1.0e-20, 0.5, CBC_PARAM_DBL_INTEGERTOLERANCE);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Beware of setting this smaller than the primal tolerance."
+ );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("keepN!ames", "Whether to keep names from import",
+ "on", CLP_PARAM_STR_KEEPNAMES);
+ parameters[numberParameters-1].append("off");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "It saves space to get rid of names so if you need to you can set this to off. \
+This needs to be set before the import of model - so -keepnames off -import xxxxx.mps."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("KKT", "Whether to use KKT factorization",
+ "off", CLP_PARAM_STR_KKT, 7, 1);
+ parameters[numberParameters-1].append("on");
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("knapsack!Cuts", "Whether to use Knapsack cuts",
+ "off", CBC_PARAM_STR_KNAPSACKCUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].append("onglobal");
+ parameters[numberParameters-1].append("forceandglobal");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on knapsack cuts (either at root or in entire tree) \
+See branchAndCut for information on options."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("lagomory!Cuts", "Whether to use Lagrangean Gomory cuts",
+ "off", CBC_PARAM_STR_LAGOMORYCUTS);
+ parameters[numberParameters-1].append("endonlyroot");
+ parameters[numberParameters-1].append("endcleanroot");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("endonly");
+ parameters[numberParameters-1].append("endclean");
+ parameters[numberParameters-1].append("endboth");
+ parameters[numberParameters-1].append("onlyaswell");
+ parameters[numberParameters-1].append("cleanaswell");
+ parameters[numberParameters-1].append("bothaswell");
+ parameters[numberParameters-1].append("onlyinstead");
+ parameters[numberParameters-1].append("cleaninstead");
+ parameters[numberParameters-1].append("bothinstead");
+ parameters[numberParameters-1].append("onlyaswellroot");
+ parameters[numberParameters-1].append("cleanaswellroot");
+ parameters[numberParameters-1].append("bothaswellroot");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This is a gross simplification of 'A Relax-and-Cut Framework for Gomory's Mixed-Integer Cuts' \
+by Matteo Fischetti & Domenico Salvagnin. This simplification \
+just uses original constraints while modifying objective using other cuts. \
+So you don't use messy constraints generated by Gomory etc. \
+A variant is to allow non messy cuts e.g. clique cuts. \
+So 'only' does this while clean also allows integral valued cuts. \
+'End' is recommended which waits until other cuts have finished and then \
+does a few passes. \
+The length options for gomory cuts are used."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("latwomir!Cuts", "Whether to use Lagrangean TwoMir cuts",
+ "off", CBC_PARAM_STR_LATWOMIRCUTS);
+ parameters[numberParameters-1].append("endonlyroot");
+ parameters[numberParameters-1].append("endcleanroot");
+ parameters[numberParameters-1].append("endbothroot");
+ parameters[numberParameters-1].append("endonly");
+ parameters[numberParameters-1].append("endclean");
+ parameters[numberParameters-1].append("endboth");
+ parameters[numberParameters-1].append("onlyaswell");
+ parameters[numberParameters-1].append("cleanaswell");
+ parameters[numberParameters-1].append("bothaswell");
+ parameters[numberParameters-1].append("onlyinstead");
+ parameters[numberParameters-1].append("cleaninstead");
+ parameters[numberParameters-1].append("bothinstead");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This is a lagrangean relaxation for TwoMir cuts. See \
+lagomoryCuts for description of options."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("lift!AndProjectCuts", "Whether to use Lift and Project cuts",
+ "off", CBC_PARAM_STR_LANDPCUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Lift and project cuts. \
+May be slow \
+See branchAndCut for information on options."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("local!TreeSearch", "Whether to use local treesearch",
+ "off", CBC_PARAM_STR_LOCALTREE);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on a local search algorithm when a solution is found. This is from \
+Fischetti and Lodi and is not really a heuristic although it can be used as one. \
+When used from Coin solve it has limited functionality. It is not switched on when \
+heuristics are switched on."
+ );
+#endif
+#ifndef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("log!Level", "Level of detail in Solver output",
+ -1, 999999, CLP_PARAM_INT_SOLVERLOGLEVEL);
+#else
+ parameters[numberParameters++] =
+ CbcOrClpParam("log!Level", "Level of detail in Coin branch and Cut output",
+ -63, 63, CLP_PARAM_INT_LOGLEVEL);
+ parameters[numberParameters-1].setIntValue(1);
+#endif
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If 0 then there should be no output in normal circumstances. 1 is probably the best\
+ value for most uses, while 2 and 3 give more information."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("max!imize", "Set optimization direction to maximize",
+ CLP_PARAM_ACTION_MAXIMIZE, 7);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "The default is minimize - use 'maximize' for maximization.\n\
+You can also use the parameters 'direction maximize'."
+ );
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("maxF!actor", "Maximum number of iterations between \
+refactorizations",
+ 1, 999999, CLP_PARAM_INT_MAXFACTOR);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If this is at its initial value of 200 then in this executable clp will guess at a\
+ value to use. Otherwise the user can set a value. The code may decide to re-factorize\
+ earlier for accuracy."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("maxIt!erations", "Maximum number of iterations before \
+stopping",
+ 0, 2147483647, CLP_PARAM_INT_MAXITERATION);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This can be used for testing purposes. The corresponding library call\n\
+ \tsetMaximumIterations(value)\n can be useful. If the code stops on\
+ seconds or by an interrupt this will be treated as stopping on maximum iterations. This is ignored in branchAndCut - use maxN!odes."
+ );
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("maxN!odes", "Maximum number of nodes to do",
+ -1, 2147483647, CBC_PARAM_INT_MAXNODES);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This is a repeatable way to limit search. Normally using time is easier \
+but then the results may not be repeatable."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("maxSaved!Solutions", "Maximum number of solutions to save",
+ 0, 2147483647, CBC_PARAM_INT_MAXSAVEDSOLS);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Number of solutions to save."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("maxSo!lutions", "Maximum number of solutions to get",
+ 1, 2147483647, CBC_PARAM_INT_MAXSOLS);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "You may want to stop after (say) two solutions or an hour. \
+This is checked every node in tree, so it is possible to get more solutions from heuristics."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("min!imize", "Set optimization direction to minimize",
+ CLP_PARAM_ACTION_MINIMIZE, 7);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "The default is minimize - use 'maximize' for maximization.\n\
+This should only be necessary if you have previously set maximization \
+You can also use the parameters 'direction minimize'."
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("mipO!ptions", "Dubious options for mip",
+ 0, COIN_INT_MAX, CBC_PARAM_INT_MIPOPTIONS, 0);
+ parameters[numberParameters++] =
+ CbcOrClpParam("more!MipOptions", "More dubious options for mip",
+ -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMIPOPTIONS, 0);
+ parameters[numberParameters++] =
+ CbcOrClpParam("more2!MipOptions", "More more dubious options for mip",
+ -1, COIN_INT_MAX, CBC_PARAM_INT_MOREMOREMIPOPTIONS, 0);
+ parameters[numberParameters-1].setIntValue(0);
+ parameters[numberParameters++] =
+ CbcOrClpParam("mixed!IntegerRoundingCuts", "Whether to use Mixed Integer Rounding cuts",
+ "off", CBC_PARAM_STR_MIXEDCUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].append("onglobal");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on mixed integer rounding cuts (either at root or in entire tree) \
+See branchAndCut for information on options."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("mess!ages", "Controls if Clpnnnn is printed",
+ "off", CLP_PARAM_STR_MESSAGES);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].setLonghelp
+ ("The default behavior is to put out messages such as:\n\
+ Clp0005 2261 Objective 109.024 Primal infeas 944413 (758)\n\
+but this program turns this off to make it look more friendly. It can be useful\
+ to turn them back on if you want to be able to 'grep' for particular messages or if\
+ you intend to override the behavior of a particular message. This only affects Clp not Cbc."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("miplib", "Do some of miplib test set",
+ CBC_PARAM_ACTION_MIPLIB, 3, 1);
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("mips!tart", "reads an initial feasible solution from file",
+ CBC_PARAM_ACTION_MIPSTART);
+ parameters[numberParameters-1].setLonghelp
+ ("\
+The MIPStart allows one to enter an initial integer feasible solution \
+to CBC. Values of the main decision variables which are active (have \
+non-zero values) in this solution are specified in a text file. The \
+text file format used is the same of the solutions saved by CBC, but \
+not all fields are required to be filled. First line may contain the \
+solution status and will be ignored, remaining lines contain column \
+indexes, names and values as in this example:\n\
+\n\
+Stopped on iterations - objective value 57597.00000000\n\
+ 0 x(1,1,2,2) 1 \n\
+ 1 x(3,1,3,2) 1 \n\
+ 5 v(5,1) 2 \n\
+ 33 x(8,1,5,2) 1 \n\
+ ...\n\
+\n\
+Column indexes are also ignored since pre-processing can change them. \
+There is no need to include values for continuous or integer auxiliary \
+variables, since they can be computed based on main decision variables. \
+Starting CBC with an integer feasible solution can dramatically improve \
+its performance: several MIP heuristics (e.g. RINS) rely on having at \
+least one feasible solution available and can start immediately if the \
+user provides one. Feasibility Pump (FP) is a heuristic which tries to \
+overcome the problem of taking too long to find feasible solution (or \
+not finding at all), but it not always succeeds. If you provide one \
+starting solution you will probably save some time by disabling FP. \
+\n\n\
+Knowledge specific to your problem can be considered to write an \
+external module to quickly produce an initial feasible solution - some \
+alternatives are the implementation of simple greedy heuristics or the \
+solution (by CBC for example) of a simpler model created just to find \
+a feasible solution. \
+\n\n\
+Question and suggestions regarding MIPStart can be directed to\n\
+haroldo.santos@gmail.com.\
+");
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("moreS!pecialOptions", "Yet more dubious options for Simplex - see ClpSimplex.hpp",
+ 0, COIN_INT_MAX, CLP_PARAM_INT_MORESPECIALOPTIONS, 0);
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("moreT!une", "Yet more dubious ideas for feasibility pump",
+ 0, 100000000, CBC_PARAM_INT_FPUMPTUNE2, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Yet more ideas for Feasibility Pump \n\
+\t/100000 == 1 use box constraints and original obj in cleanup\n\
+\t/1000 == 1 Pump will run twice if no solution found\n\
+\t/1000 == 2 Pump will only run after root cuts if no solution found\n\
+\t/1000 >10 as above but even if solution found\n\
+\t/100 == 1,3.. exact 1.0 for objective values\n\
+\t/100 == 2,3.. allow more iterations per pass\n\
+\t n fix if value of variable same for last n iterations."
+ );
+ parameters[numberParameters-1].setIntValue(0);
+ parameters[numberParameters++] =
+ CbcOrClpParam("multiple!RootPasses", "Do multiple root passes to collect cuts and solutions",
+ 0, 100000000, CBC_PARAM_INT_MULTIPLEROOTS, 0);
+ parameters[numberParameters-1].setIntValue(0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Do (in parallel if threads enabled) the root phase this number of times \
+ and collect all solutions and cuts generated. The actual format is aabbcc \
+where aa is number of extra passes, if bb is non zero \
+then it is number of threads to use (otherwise uses threads setting) and \
+cc is number of times to do root phase. Yet another one from the Italian idea factory \
+(This time - Andrea Lodi , Matteo Fischetti , Michele Monaci , Domenico Salvagnin , \
+and Andrea Tramontani). \
+The solvers do not interact with each other. However if extra passes are specified \
+then cuts are collected and used in later passes - so there is interaction there."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("naive!Heuristics", "Whether to try some stupid heuristic",
+ "off", CBC_PARAM_STR_NAIVE, 7, 1);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Really silly stuff e.g. fix all integers with costs to zero!. \
+Doh option does heuristic before preprocessing" );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("netlib", "Solve entire netlib test set",
+ CLP_PARAM_ACTION_NETLIB_EITHER, 3, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This exercises the unit test for clp and then solves the netlib test set using dual or primal.\
+The user can set options before e.g. clp -presolve off -netlib"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("netlibB!arrier", "Solve entire netlib test set with barrier",
+ CLP_PARAM_ACTION_NETLIB_BARRIER, 3, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This exercises the unit test for clp and then solves the netlib test set using barrier.\
+The user can set options before e.g. clp -kkt on -netlib"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("netlibD!ual", "Solve entire netlib test set (dual)",
+ CLP_PARAM_ACTION_NETLIB_DUAL, 3, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This exercises the unit test for clp and then solves the netlib test set using dual.\
+The user can set options before e.g. clp -presolve off -netlib"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("netlibP!rimal", "Solve entire netlib test set (primal)",
+ CLP_PARAM_ACTION_NETLIB_PRIMAL, 3, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This exercises the unit test for clp and then solves the netlib test set using primal.\
+The user can set options before e.g. clp -presolve off -netlibp"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("netlibT!une", "Solve entire netlib test set with 'best' algorithm",
+ CLP_PARAM_ACTION_NETLIB_TUNE, 3, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This exercises the unit test for clp and then solves the netlib test set using whatever \
+works best. I know this is cheating but it also stresses the code better by doing a \
+mixture of stuff. The best algorithm was chosen on a Linux ThinkPad using native cholesky \
+with University of Florida ordering."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("network", "Tries to make network matrix",
+ CLP_PARAM_ACTION_NETWORK, 7, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Clp will go faster if the matrix can be converted to a network. The matrix\
+ operations may be a bit faster with more efficient storage, but the main advantage\
+ comes from using a network factorization. It will probably not be as fast as a \
+specialized network code."
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("nextB!estSolution", "Prints next best saved solution to file",
+ CLP_PARAM_ACTION_NEXTBESTSOLUTION);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "To write best solution, just use solution. This prints next best (if exists) \
+ and then deletes it. \
+ This will write a primitive solution file to the given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to 'stdout'. The amount of output can be varied using printi!ngOptions or printMask."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("node!Strategy", "What strategy to use to select nodes",
+ "hybrid", CBC_PARAM_STR_NODESTRATEGY);
+ parameters[numberParameters-1].append("fewest");
+ parameters[numberParameters-1].append("depth");
+ parameters[numberParameters-1].append("upfewest");
+ parameters[numberParameters-1].append("downfewest");
+ parameters[numberParameters-1].append("updepth");
+ parameters[numberParameters-1].append("downdepth");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Normally before a solution the code will choose node with fewest infeasibilities. \
+You can choose depth as the criterion. You can also say if up or down branch must \
+be done first (the up down choice will carry on after solution). \
+Default has now been changed to hybrid which is breadth first on small depth nodes then fewest."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("numberA!nalyze", "Number of analysis iterations",
+ -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_NUMBERANALYZE, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This says how many iterations to spend at root node analyzing problem. \
+This is a first try and will hopefully become more sophisticated."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("objective!Scale", "Scale factor to apply to objective",
+ -1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If the objective function has some very large values, you may wish to scale them\
+ internally by this amount. It can also be set by autoscale. It is applied after scaling. You are unlikely to need this."
+ );
+ parameters[numberParameters-1].setDoubleValue(1.0);
+#endif
+#ifdef COIN_HAS_CBC
+#ifdef COIN_HAS_NTY
+ parameters[numberParameters++] =
+ CbcOrClpParam("Orbit!alBranching", "Whether to try orbital branching",
+ "off", CBC_PARAM_STR_ORBITAL);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("strong");
+ parameters[numberParameters-1].append("force");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on Orbital branching. \
+On just adds orbital, strong tries extra fixing in strong branching");
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("outDup!licates", "takes duplicate rows etc out of integer model",
+ CLP_PARAM_ACTION_OUTDUPROWS, 7, 0);
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("output!Format", "Which output format to use",
+ 1, 6, CLP_PARAM_INT_OUTPUTFORMAT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Normally export will be done using normal representation for numbers and two values\
+ per line. You may want to do just one per line (for grep or suchlike) and you may wish\
+ to save with absolute accuracy using a coded version of the IEEE value. A value of 2 is normal.\
+ otherwise odd values gives one value per line, even two. Values 1,2 give normal format, 3,4\
+ gives greater precision, while 5,6 give IEEE values. When used for exporting a basis 1 does not save \
+values, 2 saves values, 3 with greater accuracy and 4 in IEEE."
+ );
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("para!metrics", "Import data from file and do parametrics",
+ CLP_PARAM_ACTION_PARAMETRICS, 3);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This will read a file with parametric data from the given file name \
+and then do parametrics. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to '', i.e. it must be set. This can not read from compressed files. \
+File is in modified csv format - a line ROWS will be followed by rows data \
+while a line COLUMNS will be followed by column data. The last line \
+should be ENDATA. The ROWS line must exist and is in the format \
+ROWS, inital theta, final theta, interval theta, n where n is 0 to get \
+CLPI0062 message at interval or at each change of theta \
+and 1 to get CLPI0063 message at each iteration. If interval theta is 0.0 \
+or >= final theta then no interval reporting. n may be missed out when it is \
+taken as 0. If there is Row data then \
+there is a headings line with allowed headings - name, number, \
+lower(rhs change), upper(rhs change), rhs(change). Either the lower and upper \
+fields should be given or the rhs field. \
+The optional COLUMNS line is followed by a headings line with allowed \
+headings - name, number, objective(change), lower(change), upper(change). \
+ Exactly one of name and number must be given for either section and \
+missing ones have value 0.0."
+ );
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("passC!uts", "Number of cut passes at root node",
+ -9999999, 9999999, CBC_PARAM_INT_CUTPASS);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "The default is 100 passes if less than 500 columns, 100 passes (but \
+stop if drop small if less than 5000 columns, 20 otherwise"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("passF!easibilityPump", "How many passes in feasibility pump",
+ 0, 10000, CBC_PARAM_INT_FPUMPITS);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This fine tunes Feasibility Pump by doing more or fewer passes."
+ );
+ parameters[numberParameters-1].setIntValue(20);
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("passP!resolve", "How many passes in presolve",
+ -200, 100, CLP_PARAM_INT_PRESOLVEPASS, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Normally Presolve does 10 passes but you may want to do less to make it\
+ more lightweight or do more if improvements are still being made. As Presolve will return\
+ if nothing is being taken out, you should not normally need to use this fine tuning."
+ );
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("passT!reeCuts", "Number of cut passes in tree",
+ -9999999, 9999999, CBC_PARAM_INT_CUTPASSINTREE);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "The default is one pass"
+ );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("pertV!alue", "Method of perturbation",
+ -5000, 102, CLP_PARAM_INT_PERTVALUE, 1);
+ parameters[numberParameters++] =
+ CbcOrClpParam("perturb!ation", "Whether to perturb problem",
+ "on", CLP_PARAM_STR_PERTURBATION);
+ parameters[numberParameters-1].append("off");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Perturbation helps to stop cycling, but Clp uses other measures for this.\
+ However large problems and especially ones with unit elements and unit rhs or costs\
+ benefit from perturbation. Normally Clp tries to be intelligent, but you can switch this off.\
+ The Clp library has this off by default. This program has it on by default."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("PFI", "Whether to use Product Form of Inverse in simplex",
+ "off", CLP_PARAM_STR_PFI, 7, 0);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "By default clp uses Forrest-Tomlin L-U update. If you are masochistic you can switch it off."
+ );
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("pivotAndC!omplement", "Whether to try Pivot and Complement heuristic",
+ "off", CBC_PARAM_STR_PIVOTANDCOMPLEMENT);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "stuff needed. \
+Doh option does heuristic before preprocessing" );
+ parameters[numberParameters++] =
+ CbcOrClpParam("pivotAndF!ix", "Whether to try Pivot and Fix heuristic",
+ "off", CBC_PARAM_STR_PIVOTANDFIX);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "stuff needed. \
+Doh option does heuristic before preprocessing" );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("plus!Minus", "Tries to make +- 1 matrix",
+ CLP_PARAM_ACTION_PLUSMINUS, 7, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Clp will go slightly faster if the matrix can be converted so that the elements are\
+ not stored and are known to be unit. The main advantage is memory use. Clp may automatically\
+ see if it can convert the problem so you should not need to use this."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("pO!ptions", "Dubious print options",
+ 0, COIN_INT_MAX, CLP_PARAM_INT_PRINTOPTIONS, 1);
+ parameters[numberParameters-1].setIntValue(0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If this is > 0 then presolve will give more information and branch and cut will give statistics"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("preO!pt", "Presolve options",
+ 0, COIN_INT_MAX, CLP_PARAM_INT_PRESOLVEOPTIONS, 0);
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("presolve", "Whether to presolve problem",
+ "on", CLP_PARAM_STR_PRESOLVE);
+ parameters[numberParameters-1].append("off");
+ parameters[numberParameters-1].append("more");
+ parameters[numberParameters-1].append("file");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Presolve analyzes the model to find such things as redundant equations, equations\
+ which fix some variables, equations which can be transformed into bounds etc etc. For the\
+ initial solve of any problem this is worth doing unless you know that it will have no effect. \
+on will normally do 5 passes while using 'more' will do 10. If the problem is very large you may need \
+to write the original to file using 'file'."
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("preprocess", "Whether to use integer preprocessing",
+ "off", CBC_PARAM_STR_PREPROCESS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("save");
+ parameters[numberParameters-1].append("equal");
+ parameters[numberParameters-1].append("sos");
+ parameters[numberParameters-1].append("trysos");
+ parameters[numberParameters-1].append("equalall");
+ parameters[numberParameters-1].append("strategy");
+ parameters[numberParameters-1].append("aggregate");
+ parameters[numberParameters-1].append("forcesos");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This tries to reduce size of model in a similar way to presolve and \
+it also tries to strengthen the model - this can be very useful and is worth trying. \
+ Save option saves on file presolved.mps. equal will turn <= cliques into \
+==. sos will create sos sets if all 0-1 in sets (well one extra is allowed) \
+and no overlaps. trysos is same but allows any number extra. equalall will turn all \
+valid inequalities into equalities with integer slacks. strategy is as \
+on but uses CbcStrategy."
+ );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("preT!olerance", "Tolerance to use in presolve",
+ 1.0e-20, 1.0e12, CLP_PARAM_DBL_PRESOLVETOLERANCE);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "The default is 1.0e-8 - you may wish to try 1.0e-7 if presolve says the problem is \
+infeasible and you have awkward numbers and you are sure the problem is really feasible."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("primalP!ivot", "Primal pivot choice algorithm",
+ "auto!matic", CLP_PARAM_STR_PRIMALPIVOT, 7, 1);
+ parameters[numberParameters-1].append("exa!ct");
+ parameters[numberParameters-1].append("dant!zig");
+ parameters[numberParameters-1].append("part!ial");
+ parameters[numberParameters-1].append("steep!est");
+ parameters[numberParameters-1].append("change");
+ parameters[numberParameters-1].append("sprint");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Clp can use any pivot selection algorithm which the user codes as long as it\
+ implements the features in the abstract pivot base class. The Dantzig method is implemented\
+ to show a simple method but its use is deprecated. Exact devex is the method of choice and there\
+ are two variants which keep all weights updated but only scan a subset each iteration.\
+ Partial switches this on while change initially does dantzig until the factorization\
+ becomes denser. This is still a work in progress."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("primalS!implex", "Do primal simplex algorithm",
+ CLP_PARAM_ACTION_PRIMALSIMPLEX);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This command solves the continuous relaxation of the current model using the primal algorithm.\
+ The default is to use exact devex.\
+ The time and iterations may be affected by settings such as presolve, scaling, crash\
+ and also by column selection method, infeasibility weight and dual and primal tolerances."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("primalT!olerance", "For an optimal solution \
+no primal infeasibility may exceed this value",
+ 1.0e-20, 1.0e12, CLP_PARAM_DBL_PRIMALTOLERANCE);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Normally the default tolerance is fine, but you may want to increase it a\
+ bit if a primal run seems to be having a hard time"
+ );
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("primalW!eight", "Initially algorithm acts as if it \
+costs this much to be infeasible",
+ 1.0e-20, 1.0e20, CLP_PARAM_DBL_PRIMALWEIGHT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "The primal algorithm in Clp is a single phase algorithm as opposed to a two phase\
+ algorithm where you first get feasible then optimal. So Clp is minimizing this weight times\
+ the sum of primal infeasibilities plus the true objective function (in minimization sense).\
+ Too high a value may mean more iterations, while too low a bound means\
+ the code may go all the way and then have to increase the weight in order to get feasible.\
+ OSL had a heuristic to\
+ adjust bounds, maybe we need that here."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("printi!ngOptions", "Print options",
+ "normal", CLP_PARAM_STR_INTPRINT, 3);
+ parameters[numberParameters-1].append("integer");
+ parameters[numberParameters-1].append("special");
+ parameters[numberParameters-1].append("rows");
+ parameters[numberParameters-1].append("all");
+ parameters[numberParameters-1].append("csv");
+ parameters[numberParameters-1].append("bound!ranging");
+ parameters[numberParameters-1].append("rhs!ranging");
+ parameters[numberParameters-1].append("objective!ranging");
+ parameters[numberParameters-1].append("stats");
+ parameters[numberParameters-1].append("boundsint");
+ parameters[numberParameters-1].append("boundsall");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This changes the amount and format of printing a solution:\nnormal - nonzero column variables \n\
+integer - nonzero integer column variables\n\
+special - in format suitable for OsiRowCutDebugger\n\
+rows - nonzero column variables and row activities\n\
+all - all column variables and row activities.\n\
+\nFor non-integer problems 'integer' and 'special' act like 'normal'. \
+Also see printMask for controlling output."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("printM!ask", "Control printing of solution on a mask",
+ CLP_PARAM_ACTION_PRINTMASK, 3);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If set then only those names which match mask are printed in a solution. \
+'?' matches any character and '*' matches any set of characters. \
+ The default is '' i.e. unset so all variables are printed. \
+This is only active if model has names."
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("prio!rityIn", "Import priorities etc from file",
+ CBC_PARAM_ACTION_PRIORITYIN, 3);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This will read a file with priorities from the given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to '', i.e. it must be set. This can not read from compressed files. \
+File is in csv format with allowed headings - name, number, priority, direction, up, down, solution. Exactly one of\
+ name and number must be given."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("probing!Cuts", "Whether to use Probing cuts",
+ "off", CBC_PARAM_STR_PROBINGCUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].append("onglobal");
+ parameters[numberParameters-1].append("forceonglobal");
+ parameters[numberParameters-1].append("forceOnBut");
+ parameters[numberParameters-1].append("forceOnStrong");
+ parameters[numberParameters-1].append("forceOnButStrong");
+ parameters[numberParameters-1].append("strongRoot");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on probing cuts (either at root or in entire tree) \
+See branchAndCut for information on options. \
+but strong options do more probing"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("proximity!Search", "Whether to do proximity search heuristic",
+ "off", CBC_PARAM_STR_PROXIMITY);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].append("10");
+ parameters[numberParameters-1].append("100");
+ parameters[numberParameters-1].append("300");
+ // but allow numbers after this (returning 1)
+ parameters[numberParameters-1].setFakeKeyWord(1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on a heuristic which looks for a solution close \
+to incumbent solution (Fischetti and Monaci). \
+See Rounding for meaning of on,both,before. \
+Can also set different maxNode settings by plusnnnn (and are 'on'(on==30))."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("pumpC!utoff", "Fake cutoff for use in feasibility pump",
+ -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_FAKECUTOFF);
+ parameters[numberParameters-1].setDoubleValue(0.0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "0.0 off - otherwise add a constraint forcing objective below this value\
+ in feasibility pump"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("pumpI!ncrement", "Fake increment for use in feasibility pump",
+ -COIN_DBL_MAX, COIN_DBL_MAX, CBC_PARAM_DBL_FAKEINCREMENT, 1);
+ parameters[numberParameters-1].setDoubleValue(0.0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "0.0 off - otherwise use as absolute increment to cutoff \
+when solution found in feasibility pump"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("pumpT!une", "Dubious ideas for feasibility pump",
+ 0, 100000000, CBC_PARAM_INT_FPUMPTUNE);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This fine tunes Feasibility Pump \n\
+\t>=10000000 use as objective weight switch\n\
+\t>=1000000 use as accumulate switch\n\
+\t>=1000 use index+1 as number of large loops\n\
+\t==100 use objvalue +0.05*fabs(objvalue) as cutoff OR fakeCutoff if set\n\
+\t%100 == 10,20 affects how each solve is done\n\
+\t1 == fix ints at bounds, 2 fix all integral ints, 3 and continuous at bounds. \
+If accumulate is on then after a major pass, variables which have not moved \
+are fixed and a small branch and bound is tried."
+ );
+ parameters[numberParameters-1].setIntValue(0);
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("quit", "Stops clp execution",
+ CLP_PARAM_ACTION_EXIT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This stops the execution of Clp, end, exit, quit and stop are synonyms"
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("randomC!bcSeed", "Random seed for Cbc",
+ -1, COIN_INT_MAX, CBC_PARAM_INT_RANDOMSEED);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This sets a random seed for Cbc \
+- 0 says use time of day, -1 is as now."
+ );
+ parameters[numberParameters-1].setIntValue(-1);
+ parameters[numberParameters++] =
+ CbcOrClpParam("randomi!zedRounding", "Whether to try randomized rounding heuristic",
+ "off", CBC_PARAM_STR_RANDROUND);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "stuff needed. \
+Doh option does heuristic before preprocessing" );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("randomS!eed", "Random seed for Clp",
+ 0, COIN_INT_MAX, CLP_PARAM_INT_RANDOMSEED);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This sets a random seed for Clp \
+- 0 says use time of day."
+ );
+ parameters[numberParameters-1].setIntValue(1234567);
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("ratio!Gap", "Stop when gap between best possible and \
+best less than this fraction of larger of two",
+ 0.0, 1.0e20, CBC_PARAM_DBL_GAPRATIO);
+ parameters[numberParameters-1].setDoubleValue(0.0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If the gap between best solution and best possible solution is less than this fraction \
+of the objective value at the root node then the search will terminate. See 'allowableGap' for a \
+way of using absolute value rather than fraction."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("restoreS!olution", "reads solution from file",
+ CLP_PARAM_ACTION_RESTORESOL);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This will read a binary solution file from the given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to 'solution.file'. This reads in a file from saveSolution"
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("readSt!ored", "Import stored cuts from file",
+ CLP_PARAM_ACTION_STOREDFILE, 3, 0);
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("reallyO!bjectiveScale", "Scale factor to apply to objective in place",
+ -1.0e20, 1.0e20, CLP_PARAM_DBL_OBJSCALE2, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "You can set this to -1.0 to test maximization or other to stress code"
+ );
+ parameters[numberParameters-1].setDoubleValue(1.0);
+ parameters[numberParameters++] =
+ CbcOrClpParam("reallyS!cale", "Scales model in place",
+ CLP_PARAM_ACTION_REALLY_SCALE, 7, 0);
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("reduce!AndSplitCuts", "Whether to use Reduce-and-Split cuts",
+ "off", CBC_PARAM_STR_REDSPLITCUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on reduce and split cuts (either at root or in entire tree). \
+May be slow \
+See branchAndCut for information on options."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
+ "off", CBC_PARAM_STR_REDSPLIT2CUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("longOn");
+ parameters[numberParameters-1].append("longRoot");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on reduce and split cuts (either at root or in entire tree) \
+This version is by Giacomo Nannicini based on Francois Margot's version \
+Standard setting only uses rows in tableau <=256, long uses all \
+May be slow \
+See branchAndCut for information on options."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
+ "off", CBC_PARAM_STR_REDSPLIT2CUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("longOn");
+ parameters[numberParameters-1].append("longRoot");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on reduce and split cuts (either at root or in entire tree) \
+This version is by Giacomo Nannicini based on Francois Margot's version \
+Standard setting only uses rows in tableau <=256, long uses all \
+See branchAndCut for information on options."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("residual!CapacityCuts", "Whether to use Residual Capacity cuts",
+ "off", CBC_PARAM_STR_RESIDCUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Residual capacity cuts. \
+See branchAndCut for information on options."
+ );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("restore!Model", "Restore model from binary file",
+ CLP_PARAM_ACTION_RESTORE, 7, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This reads data save by saveModel from the given file. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to 'default.prob'."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("reverse", "Reverses sign of objective",
+ CLP_PARAM_ACTION_REVERSE, 7, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Useful for testing if maximization works correctly"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("rhs!Scale", "Scale factor to apply to rhs and bounds",
+ -1.0e20, 1.0e20, CLP_PARAM_DBL_RHSSCALE, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If the rhs or bounds have some very large meaningful values, you may wish to scale them\
+ internally by this amount. It can also be set by autoscale. This should not be needed."
+ );
+ parameters[numberParameters-1].setDoubleValue(1.0);
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("Rens", "Whether to try Relaxation Enforced Neighborhood Search",
+ "off", CBC_PARAM_STR_RENS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].append("200");
+ parameters[numberParameters-1].append("1000");
+ parameters[numberParameters-1].append("10000");
+ parameters[numberParameters-1].append("dj");
+ parameters[numberParameters-1].append("djbefore");
+ parameters[numberParameters-1].append("usesolution");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on Relaxation enforced neighborhood Search. \
+on just does 50 nodes \
+200 or 1000 does that many nodes. \
+Doh option does heuristic before preprocessing" );
+ parameters[numberParameters++] =
+ CbcOrClpParam("Rins", "Whether to try Relaxed Induced Neighborhood Search",
+ "off", CBC_PARAM_STR_RINS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].append("often");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on Relaxed induced neighborhood Search. \
+Doh option does heuristic before preprocessing" );
+ parameters[numberParameters++] =
+ CbcOrClpParam("round!ingHeuristic", "Whether to use Rounding heuristic",
+ "off", CBC_PARAM_STR_ROUNDING);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on a simple (but effective) rounding heuristic at each node of tree. \
+On means do in solve i.e. after preprocessing, \
+Before means do if doHeuristics used, off otherwise, \
+and both means do if doHeuristics and in solve."
+ );
+
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("saveM!odel", "Save model to binary file",
+ CLP_PARAM_ACTION_SAVE, 7, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This will save the problem to the given file name for future use\
+ by restoreModel. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to 'default.prob'."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("saveS!olution", "saves solution to file",
+ CLP_PARAM_ACTION_SAVESOL);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This will write a binary solution file to the given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to 'solution.file'. To read the file use fread(int) twice to pick up number of rows \
+and columns, then fread(double) to pick up objective value, then pick up row activities, row duals, column \
+activities and reduced costs - see bottom of CbcOrClpParam.cpp for code that reads or writes file. \
+If name contains '_fix_read_' then does not write but reads and will fix all variables"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("scal!ing", "Whether to scale problem",
+ "off", CLP_PARAM_STR_SCALING);
+ parameters[numberParameters-1].append("equi!librium");
+ parameters[numberParameters-1].append("geo!metric");
+ parameters[numberParameters-1].append("auto!matic");
+ parameters[numberParameters-1].append("dynamic");
+ parameters[numberParameters-1].append("rows!only");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Scaling can help in solving problems which might otherwise fail because of lack of\
+ accuracy. It can also reduce the number of iterations. It is not applied if the range\
+ of elements is small. When unscaled it is possible that there may be small primal and/or\
+ infeasibilities."
+ );
+ parameters[numberParameters-1].setCurrentOption(3); // say auto
+#ifndef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("sec!onds", "Maximum seconds",
+ -1.0, 1.0e12, CLP_PARAM_DBL_TIMELIMIT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "After this many seconds clp will act as if maximum iterations had been reached \
+(if value >=0)."
+ );
+#else
+ parameters[numberParameters++] =
+ CbcOrClpParam("sec!onds", "maximum seconds",
+ -1.0, 1.0e12, CBC_PARAM_DBL_TIMELIMIT_BAB);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "After this many seconds coin solver will act as if maximum nodes had been reached."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("sleep", "for debug",
+ CLP_PARAM_ACTION_DUMMY, 7, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If passed to solver fom ampl, then ampl will wait so that you can copy .nl file for debug."
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("slow!cutpasses", "Maximum number of tries for slower cuts",
+ -1, COIN_INT_MAX, CBC_PARAM_INT_MAX_SLOW_CUTS);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Some cut generators are fairly slow - this limits the number of times they are tried."
+ );
+ parameters[numberParameters-1].setIntValue(10);
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("slp!Value", "Number of slp passes before primal",
+ -50000, 50000, CLP_PARAM_INT_SLPVALUE, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If you are solving a quadratic problem using primal then it may be helpful to do some \
+sequential Lps to get a good approximate solution."
+ );
+#if CLP_MULTIPLE_FACTORIZATIONS > 0
+ parameters[numberParameters++] =
+ CbcOrClpParam("small!Factorization", "Whether to use small factorization",
+ -1, 10000, CBC_PARAM_INT_SMALLFACT, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If processed problem <= this use small factorization"
+ );
+ parameters[numberParameters-1].setIntValue(-1);
+#endif
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("solu!tion", "Prints solution to file",
+ CLP_PARAM_ACTION_SOLUTION);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This will write a primitive solution file to the given file name. It will use the default\
+ directory given by 'directory'. A name of '$' will use the previous value for the name. This\
+ is initialized to 'stdout'. The amount of output can be varied using printi!ngOptions or printMask."
+ );
+#ifdef COIN_HAS_CLP
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("solv!e", "Solve problem",
+ CBC_PARAM_ACTION_BAB);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If there are no integer variables then this just solves LP. If there are integer variables \
+this does branch and cut."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("sos!Options", "Whether to use SOS from AMPL",
+ "off", CBC_PARAM_STR_SOS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].setCurrentOption("on");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Normally if AMPL says there are SOS variables they should be used, but sometime sthey should\
+ be turned off - this does so."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("slog!Level", "Level of detail in (LP) Solver output",
+ -1, 63, CLP_PARAM_INT_SOLVERLOGLEVEL);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If 0 then there should be no output in normal circumstances. 1 is probably the best\
+ value for most uses, while 2 and 3 give more information. This parameter is only used inside MIP - for Clp use 'log'"
+ );
+#else
+ // allow solve as synonym for possible dual
+ parameters[numberParameters++] =
+ CbcOrClpParam("solv!e", "Solve problem using dual simplex (probably)",
+ CLP_PARAM_ACTION_EITHERSIMPLEX);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Just so can use solve for clp as well as in cbc"
+ );
+#endif
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("spars!eFactor", "Whether factorization treated as sparse",
+ "on", CLP_PARAM_STR_SPARSEFACTOR, 7, 0);
+ parameters[numberParameters-1].append("off");
+ parameters[numberParameters++] =
+ CbcOrClpParam("special!Options", "Dubious options for Simplex - see ClpSimplex.hpp",
+ 0, COIN_INT_MAX, CLP_PARAM_INT_SPECIALOPTIONS, 0);
+ parameters[numberParameters++] =
+ CbcOrClpParam("sprint!Crash", "Whether to try sprint crash",
+ -1, 5000000, CLP_PARAM_INT_SPRINT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "For long and thin problems this program may solve a series of small problems\
+ created by taking a subset of the columns. I introduced the idea as 'Sprint' after\
+ an LP code of that name of the 60's which tried the same tactic (not totally successfully).\
+ Cplex calls it 'sifting'. -1 is automatic choice, 0 is off, n is number of passes"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("stat!istics", "Print some statistics",
+ CLP_PARAM_ACTION_STATISTICS);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This command prints some statistics for the current model.\
+ If log level >1 then more is printed.\
+ These are for presolved model if presolve on (and unscaled)."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("stop", "Stops clp execution",
+ CLP_PARAM_ACTION_EXIT);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This stops the execution of Clp, end, exit, quit and stop are synonyms"
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("strat!egy", "Switches on groups of features",
+ 0, 2, CBC_PARAM_INT_STRATEGY);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This turns on newer features. \
+Use 0 for easy problems, 1 is default, 2 is aggressive. \
+1 uses Gomory cuts using tolerance of 0.01 at root, \
+does a possible restart after 100 nodes if can fix many \
+and activates a diving and RINS heuristic and makes feasibility pump \
+more aggressive. \
+This does not apply to unit tests (where 'experiment' may have similar effects)."
+ );
+ parameters[numberParameters-1].setIntValue(1);
+#ifdef CBC_KEEP_DEPRECATED
+ parameters[numberParameters++] =
+ CbcOrClpParam("strengthen", "Create strengthened problem",
+ CBC_PARAM_ACTION_STRENGTHEN, 3);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This creates a new problem by applying the root node cuts. All tight constraints \
+will be in resulting problem"
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("strong!Branching", "Number of variables to look at in strong branching",
+ 0, COIN_INT_MAX, CBC_PARAM_INT_STRONGBRANCHING);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "In order to decide which variable to branch on, the code will choose up to this number \
+of unsatisfied variables to do mini up and down branches on. Then the most effective one is chosen. \
+If a variable is branched on many times then the previous average up and down costs may be used - \
+see number before trust."
+ );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("subs!titution", "How long a column to substitute for in presolve",
+ 0, 10000, CLP_PARAM_INT_SUBSTITUTION, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Normally Presolve gets rid of 'free' variables when there are no more than 3 \
+ variables in column. If you increase this the number of rows may decrease but number of \
+ elements may increase."
+ );
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("testO!si", "Test OsiObject stuff",
+ -1, COIN_INT_MAX, CBC_PARAM_INT_TESTOSI, 0);
+#endif
+#ifdef CBC_THREAD
+ parameters[numberParameters++] =
+ CbcOrClpParam("thread!s", "Number of threads to try and use",
+ -100, 100000, CBC_PARAM_INT_THREADS, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "To use multiple threads, set threads to number wanted. It may be better \
+to use one or two more than number of cpus available. If 100+n then n threads and \
+search is repeatable (maybe be somewhat slower), \
+if 200+n use threads for root cuts, 400+n threads used in sub-trees."
+ );
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("tighten!Factor", "Tighten bounds using this times largest \
+activity at continuous solution",
+ 1.0e-3, 1.0e20, CBC_PARAM_DBL_TIGHTENFACTOR, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This sleazy trick can help on some problems."
+ );
+#endif
+#ifdef COIN_HAS_CLP
+ parameters[numberParameters++] =
+ CbcOrClpParam("tightLP", "Poor person's preSolve for now",
+ CLP_PARAM_ACTION_TIGHTEN, 7, 0);
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("timeM!ode", "Whether to use CPU or elapsed time",
+ "cpu", CLP_PARAM_STR_TIME_MODE);
+ parameters[numberParameters-1].append("elapsed");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "cpu uses CPU time for stopping, while elapsed uses elapsed time. \
+(On Windows, elapsed time is always used)."
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("trust!PseudoCosts", "Number of branches before we trust pseudocosts",
+ -3, 2000000000, CBC_PARAM_INT_NUMBERBEFORE);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Using strong branching computes pseudo-costs. After this many times for a variable we just \
+trust the pseudo costs and do not do any more strong branching."
+ );
+#endif
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("tune!PreProcess", "Dubious tuning parameters",
+ 0, 2000000000, CLP_PARAM_INT_PROCESSTUNE, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Format aabbcccc - \n If aa then this is number of major passes (i.e. with presolve) \n \
+If bb and bb>0 then this is number of minor passes (if unset or 0 then 10) \n \
+cccc is bit set \n 0 - 1 Heavy probing \n 1 - 2 Make variables integer if possible (if obj value)\n \
+2 - 4 As above but even if zero objective value\n \
+7 - 128 Try and create cliques\n 8 - 256 If all +1 try hard for dominated rows\n \
+10 - 1024 Use a larger feasibility tolerance in presolve\n \
+11 - 2048 Try probing before creating cliques"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("two!MirCuts", "Whether to use Two phase Mixed Integer Rounding cuts",
+ "off", CBC_PARAM_STR_TWOMIRCUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].append("onglobal");
+ parameters[numberParameters-1].append("forceandglobal");
+ parameters[numberParameters-1].append("forceLongOn");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on two phase mixed integer rounding cuts (either at root or in entire tree) \
+See branchAndCut for information on options."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("unitTest", "Do unit test",
+ CLP_PARAM_ACTION_UNITTEST, 3, 1);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This exercises the unit test for clp"
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("userClp", "Hand coded Clp stuff",
+ CLP_PARAM_ACTION_USERCLP, 0, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "There are times e.g. when using AMPL interface when you may wish to do something unusual. \
+Look for USERCLP in main driver and modify sample code."
+ );
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("userCbc", "Hand coded Cbc stuff",
+ CBC_PARAM_ACTION_USERCBC, 0, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "There are times e.g. when using AMPL interface when you may wish to do something unusual. \
+Look for USERCBC in main driver and modify sample code. \
+It is possible you can get same effect by using example driver4.cpp."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("Vnd!VariableNeighborhoodSearch", "Whether to try Variable Neighborhood Search",
+ "off", CBC_PARAM_STR_VND);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("both");
+ parameters[numberParameters-1].append("before");
+ parameters[numberParameters-1].append("intree");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on variable neighborhood Search. \
+Doh option does heuristic before preprocessing" );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("vector", "Whether to use vector? Form of matrix in simplex",
+ "off", CLP_PARAM_STR_VECTOR, 7, 0);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If this is on ClpPackedMatrix uses extra column copy in odd format."
+ );
+ parameters[numberParameters++] =
+ CbcOrClpParam("verbose", "Switches on longer help on single ?",
+ 0, 31, CLP_PARAM_INT_VERBOSE, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "Set to 1 to get short help with ? list, 2 to get long help, 3 for both. (add 4 to just get ampl ones)."
+ );
+ parameters[numberParameters-1].setIntValue(0);
+#ifdef COIN_HAS_CBC
+ parameters[numberParameters++] =
+ CbcOrClpParam("vub!heuristic", "Type of vub heuristic",
+ -2, 20, CBC_PARAM_INT_VUBTRY, 0);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "If set will try and fix some integer variables"
+ );
+ parameters[numberParameters-1].setIntValue(-1);
+ parameters[numberParameters++] =
+ CbcOrClpParam("zero!HalfCuts", "Whether to use zero half cuts",
+ "off", CBC_PARAM_STR_ZEROHALFCUTS);
+ parameters[numberParameters-1].append("on");
+ parameters[numberParameters-1].append("root");
+ parameters[numberParameters-1].append("ifmove");
+ parameters[numberParameters-1].append("forceOn");
+ parameters[numberParameters-1].append("onglobal");
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This switches on zero-half cuts (either at root or in entire tree) \
+See branchAndCut for information on options. This implementation was written by \
+Alberto Caprara."
+ );
+#endif
+ parameters[numberParameters++] =
+ CbcOrClpParam("zeroT!olerance", "Kill all coefficients \
+whose absolute value is less than this value",
+ 1.0e-100, 1.0e-5, CLP_PARAM_DBL_ZEROTOLERANCE);
+ parameters[numberParameters-1].setLonghelp
+ (
+ "This applies to reading mps files (and also lp files \
+if KILL_ZERO_READLP defined)"
+ );
+ parameters[numberParameters-1].setDoubleValue(1.0e-20);
+ assert(numberParameters < CBCMAXPARAMETERS);
+}
+// Given a parameter type - returns its number in list
+int whichParam (CbcOrClpParameterType name,
+ int numberParameters, CbcOrClpParam *const parameters)
+{
+ int i;
+ for (i = 0; i < numberParameters; i++) {
+ if (parameters[i].type() == name)
+ break;
+ }
+ assert (i < numberParameters);
+ return i;
+}
+#ifdef COIN_HAS_CLP
+/* Restore a solution from file.
+ mode 0 normal, 1 swap rows and columns and primal and dual
+ if 2 set then also change signs
+*/
+void restoreSolution(ClpSimplex * lpSolver, std::string fileName, int mode)
+{
+ FILE * fp = fopen(fileName.c_str(), "rb");
+ if (fp) {
+ int numberRows = lpSolver->numberRows();
+ int numberColumns = lpSolver->numberColumns();
+ int numberRowsFile;
+ int numberColumnsFile;
+ double objectiveValue;
+ size_t nRead;
+ nRead = fread(&numberRowsFile, sizeof(int), 1, fp);
+ if (nRead != 1)
+ throw("Error in fread");
+ nRead = fread(&numberColumnsFile, sizeof(int), 1, fp);
+ if (nRead != 1)
+ throw("Error in fread");
+ nRead = fread(&objectiveValue, sizeof(double), 1, fp);
+ if (nRead != 1)
+ throw("Error in fread");
+ double * dualRowSolution = lpSolver->dualRowSolution();
+ double * primalRowSolution = lpSolver->primalRowSolution();
+ double * dualColumnSolution = lpSolver->dualColumnSolution();
+ double * primalColumnSolution = lpSolver->primalColumnSolution();
+ if (mode) {
+ // swap
+ int k = numberRows;
+ numberRows = numberColumns;
+ numberColumns = k;
+ double * temp;
+ temp = dualRowSolution;
+ dualRowSolution = primalColumnSolution;
+ primalColumnSolution = temp;
+ temp = dualColumnSolution;
+ dualColumnSolution = primalRowSolution;
+ primalRowSolution = temp;
+ }
+ if (numberRows > numberRowsFile || numberColumns > numberColumnsFile) {
+ std::cout << "Mismatch on rows and/or columns - giving up" << std::endl;
+ } else {
+ lpSolver->setObjectiveValue(objectiveValue);
+ if (numberRows == numberRowsFile && numberColumns == numberColumnsFile) {
+ nRead = fread(primalRowSolution, sizeof(double), numberRows, fp);
+ if (nRead != static_cast(numberRows))
+ throw("Error in fread");
+ nRead = fread(dualRowSolution, sizeof(double), numberRows, fp);
+ if (nRead != static_cast(numberRows))
+ throw("Error in fread");
+ nRead = fread(primalColumnSolution, sizeof(double), numberColumns, fp);
+ if (nRead != static_cast(numberColumns))
+ throw("Error in fread");
+ nRead = fread(dualColumnSolution, sizeof(double), numberColumns, fp);
+ if (nRead != static_cast(numberColumns))
+ throw("Error in fread");
+ } else {
+ std::cout << "Mismatch on rows and/or columns - truncating" << std::endl;
+ double * temp = new double [CoinMax(numberRowsFile, numberColumnsFile)];
+ nRead = fread(temp, sizeof(double), numberRowsFile, fp);
+ if (nRead != static_cast(numberRowsFile))
+ throw("Error in fread");
+ CoinMemcpyN(temp, numberRows, primalRowSolution);
+ nRead = fread(temp, sizeof(double), numberRowsFile, fp);
+ if (nRead != static_cast(numberRowsFile))
+ throw("Error in fread");
+ CoinMemcpyN(temp, numberRows, dualRowSolution);
+ nRead = fread(temp, sizeof(double), numberColumnsFile, fp);
+ if (nRead != static_cast(numberColumnsFile))
+ throw("Error in fread");
+ CoinMemcpyN(temp, numberColumns, primalColumnSolution);
+ nRead = fread(temp, sizeof(double), numberColumnsFile, fp);
+ if (nRead != static_cast(numberColumnsFile))
+ throw("Error in fread");
+ CoinMemcpyN(temp, numberColumns, dualColumnSolution);
+ delete [] temp;
+ }
+ if (mode == 3) {
+ int i;
+ for (i = 0; i < numberRows; i++) {
+ primalRowSolution[i] = -primalRowSolution[i];
+ dualRowSolution[i] = -dualRowSolution[i];
+ }
+ for (i = 0; i < numberColumns; i++) {
+ primalColumnSolution[i] = -primalColumnSolution[i];
+ dualColumnSolution[i] = -dualColumnSolution[i];
+ }
+ }
+ }
+ fclose(fp);
+ } else {
+ std::cout << "Unable to open file " << fileName << std::endl;
+ }
+}
+// Dump a solution to file
+void saveSolution(const ClpSimplex * lpSolver, std::string fileName)
+{
+ if (strstr(fileName.c_str(), "_fix_read_")) {
+ FILE * fp = fopen(fileName.c_str(), "rb");
+ if (fp) {
+ ClpSimplex * solver = const_cast(lpSolver);
+ restoreSolution(solver, fileName, 0);
+ // fix all
+ int logLevel = solver->logLevel();
+ int iColumn;
+ int numberColumns = solver->numberColumns();
+ double * primalColumnSolution =
+ solver->primalColumnSolution();
+ double * columnLower = solver->columnLower();
+ double * columnUpper = solver->columnUpper();
+ for (iColumn = 0; iColumn < numberColumns; iColumn++) {
+ double value = primalColumnSolution[iColumn];
+ if (value > columnUpper[iColumn]) {
+ if (value > columnUpper[iColumn] + 1.0e-6 && logLevel > 1)
+ printf("%d value of %g - bounds %g %g\n",
+ iColumn, value, columnLower[iColumn], columnUpper[iColumn]);
+ value = columnUpper[iColumn];
+ } else if (value < columnLower[iColumn]) {
+ if (value < columnLower[iColumn] - 1.0e-6 && logLevel > 1)
+ printf("%d value of %g - bounds %g %g\n",
+ iColumn, value, columnLower[iColumn], columnUpper[iColumn]);
+ value = columnLower[iColumn];
+ }
+ columnLower[iColumn] = value;
+ columnUpper[iColumn] = value;
+ }
+ return;
+ }
+ }
+ FILE * fp = fopen(fileName.c_str(), "wb");
+ if (fp) {
+ int numberRows = lpSolver->numberRows();
+ int numberColumns = lpSolver->numberColumns();
+ double objectiveValue = lpSolver->objectiveValue();
+ size_t nWrite;
+ nWrite = fwrite(&numberRows, sizeof(int), 1, fp);
+ if (nWrite != 1)
+ throw("Error in fwrite");
+ nWrite = fwrite(&numberColumns, sizeof(int), 1, fp);
+ if (nWrite != 1)
+ throw("Error in fwrite");
+ nWrite = fwrite(&objectiveValue, sizeof(double), 1, fp);
+ if (nWrite != 1)
+ throw("Error in fwrite");
+ double * dualRowSolution = lpSolver->dualRowSolution();
+ double * primalRowSolution = lpSolver->primalRowSolution();
+ nWrite = fwrite(primalRowSolution, sizeof(double), numberRows, fp);
+ if (nWrite != static_cast(numberRows))
+ throw("Error in fwrite");
+ nWrite = fwrite(dualRowSolution, sizeof(double), numberRows, fp);
+ if (nWrite != static_cast(numberRows))
+ throw("Error in fwrite");
+ double * dualColumnSolution = lpSolver->dualColumnSolution();
+ double * primalColumnSolution = lpSolver->primalColumnSolution();
+ nWrite = fwrite(primalColumnSolution, sizeof(double), numberColumns, fp);
+ if (nWrite != static_cast(numberColumns))
+ throw("Error in fwrite");
+ nWrite = fwrite(dualColumnSolution, sizeof(double), numberColumns, fp);
+ if (nWrite != static_cast(numberColumns))
+ throw("Error in fwrite");
+ fclose(fp);
+ } else {
+ std::cout << "Unable to open file " << fileName << std::endl;
+ }
+}
+#endif
diff --git a/thirdparty/windows/include/coin/CbcOrClpParam.hpp b/thirdparty/windows/include/coin/CbcOrClpParam.hpp
new file mode 100644
index 0000000..5e0794a
--- /dev/null
+++ b/thirdparty/windows/include/coin/CbcOrClpParam.hpp
@@ -0,0 +1,532 @@
+
+/* $Id: CbcOrClpParam.hpp 2175 2015-10-06 08:56:43Z forrest $ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifdef USE_CBCCONFIG
+# include "CbcConfig.h"
+#else
+# include "ClpConfig.h"
+#endif
+
+#ifndef CbcOrClpParam_H
+#define CbcOrClpParam_H
+/**
+ This has parameter handling stuff which can be shared between Cbc and Clp (and Dylp etc).
+
+ This (and .cpp) should be copied so that it is the same in Cbc/Test and Clp/Test.
+ I know this is not elegant but it seems simplest.
+
+ It uses COIN_HAS_CBC for parameters wanted by CBC
+ It uses COIN_HAS_CLP for parameters wanted by CLP (or CBC using CLP)
+ It could use COIN_HAS_DYLP for parameters wanted by DYLP
+ It could use COIN_HAS_DYLP_OR_CLP for parameters wanted by DYLP or CLP etc etc
+
+ */
+class OsiSolverInterface;
+class CbcModel;
+class ClpSimplex;
+/*! \brief Parameter codes
+
+ Parameter type ranges are allocated as follows
+
+ - 1 -- 100 double parameters
+
- 101 -- 200 integer parameters
+
- 201 -- 250 string parameters
+
- 251 -- 300 cuts etc(string but broken out for clarity)
+
- 301 -- 400 `actions'
+
+
+ `Actions' do not necessarily invoke an immediate action; it's just that they
+ don't fit neatly into the parameters array.
+
+ This coding scheme is in flux.
+*/
+
+enum CbcOrClpParameterType
+
+{
+ CBC_PARAM_GENERALQUERY = -100,
+ CBC_PARAM_FULLGENERALQUERY,
+
+ CLP_PARAM_DBL_PRIMALTOLERANCE = 1,
+ CLP_PARAM_DBL_DUALTOLERANCE,
+ CLP_PARAM_DBL_TIMELIMIT,
+ CLP_PARAM_DBL_DUALBOUND,
+ CLP_PARAM_DBL_PRIMALWEIGHT,
+ CLP_PARAM_DBL_OBJSCALE,
+ CLP_PARAM_DBL_RHSSCALE,
+ CLP_PARAM_DBL_ZEROTOLERANCE,
+
+ CBC_PARAM_DBL_INFEASIBILITYWEIGHT = 51,
+ CBC_PARAM_DBL_CUTOFF,
+ CBC_PARAM_DBL_INTEGERTOLERANCE,
+ CBC_PARAM_DBL_INCREMENT,
+ CBC_PARAM_DBL_ALLOWABLEGAP,
+ CBC_PARAM_DBL_TIMELIMIT_BAB,
+ CBC_PARAM_DBL_GAPRATIO,
+
+ CBC_PARAM_DBL_DJFIX = 81,
+ CBC_PARAM_DBL_TIGHTENFACTOR,
+ CLP_PARAM_DBL_PRESOLVETOLERANCE,
+ CLP_PARAM_DBL_OBJSCALE2,
+ CBC_PARAM_DBL_FAKEINCREMENT,
+ CBC_PARAM_DBL_FAKECUTOFF,
+ CBC_PARAM_DBL_ARTIFICIALCOST,
+ CBC_PARAM_DBL_DEXTRA3,
+ CBC_PARAM_DBL_SMALLBAB,
+ CBC_PARAM_DBL_DEXTRA4,
+ CBC_PARAM_DBL_DEXTRA5,
+
+ CLP_PARAM_INT_SOLVERLOGLEVEL = 101,
+#ifndef COIN_HAS_CBC
+ CLP_PARAM_INT_LOGLEVEL = 101,
+#endif
+ CLP_PARAM_INT_MAXFACTOR,
+ CLP_PARAM_INT_PERTVALUE,
+ CLP_PARAM_INT_MAXITERATION,
+ CLP_PARAM_INT_PRESOLVEPASS,
+ CLP_PARAM_INT_IDIOT,
+ CLP_PARAM_INT_SPRINT,
+ CLP_PARAM_INT_OUTPUTFORMAT,
+ CLP_PARAM_INT_SLPVALUE,
+ CLP_PARAM_INT_PRESOLVEOPTIONS,
+ CLP_PARAM_INT_PRINTOPTIONS,
+ CLP_PARAM_INT_SPECIALOPTIONS,
+ CLP_PARAM_INT_SUBSTITUTION,
+ CLP_PARAM_INT_DUALIZE,
+ CLP_PARAM_INT_VERBOSE,
+ CLP_PARAM_INT_CPP,
+ CLP_PARAM_INT_PROCESSTUNE,
+ CLP_PARAM_INT_USESOLUTION,
+ CLP_PARAM_INT_RANDOMSEED,
+ CLP_PARAM_INT_MORESPECIALOPTIONS,
+ CLP_PARAM_INT_DECOMPOSE_BLOCKS,
+
+ CBC_PARAM_INT_STRONGBRANCHING = 151,
+ CBC_PARAM_INT_CUTDEPTH,
+ CBC_PARAM_INT_MAXNODES,
+ CBC_PARAM_INT_NUMBERBEFORE,
+ CBC_PARAM_INT_NUMBERANALYZE,
+ CBC_PARAM_INT_MIPOPTIONS,
+ CBC_PARAM_INT_MOREMIPOPTIONS,
+ CBC_PARAM_INT_MAXHOTITS,
+ CBC_PARAM_INT_FPUMPITS,
+ CBC_PARAM_INT_MAXSOLS,
+ CBC_PARAM_INT_FPUMPTUNE,
+ CBC_PARAM_INT_TESTOSI,
+ CBC_PARAM_INT_EXTRA1,
+ CBC_PARAM_INT_EXTRA2,
+ CBC_PARAM_INT_EXTRA3,
+ CBC_PARAM_INT_EXTRA4,
+ CBC_PARAM_INT_DEPTHMINIBAB,
+ CBC_PARAM_INT_CUTPASSINTREE,
+ CBC_PARAM_INT_THREADS,
+ CBC_PARAM_INT_CUTPASS,
+ CBC_PARAM_INT_VUBTRY,
+ CBC_PARAM_INT_DENSE,
+ CBC_PARAM_INT_EXPERIMENT,
+ CBC_PARAM_INT_DIVEOPT,
+ CBC_PARAM_INT_DIVEOPTSOLVES,
+ CBC_PARAM_INT_STRATEGY,
+ CBC_PARAM_INT_SMALLFACT,
+ CBC_PARAM_INT_HOPTIONS,
+ CBC_PARAM_INT_CUTLENGTH,
+ CBC_PARAM_INT_FPUMPTUNE2,
+#ifdef COIN_HAS_CBC
+ CLP_PARAM_INT_LOGLEVEL ,
+#endif
+ CBC_PARAM_INT_MAXSAVEDSOLS,
+ CBC_PARAM_INT_RANDOMSEED,
+ CBC_PARAM_INT_MULTIPLEROOTS,
+ CBC_PARAM_INT_STRONG_STRATEGY,
+ CBC_PARAM_INT_EXTRA_VARIABLES,
+ CBC_PARAM_INT_MAX_SLOW_CUTS,
+ CBC_PARAM_INT_MOREMOREMIPOPTIONS,
+
+ CLP_PARAM_STR_DIRECTION = 201,
+ CLP_PARAM_STR_DUALPIVOT,
+ CLP_PARAM_STR_SCALING,
+ CLP_PARAM_STR_ERRORSALLOWED,
+ CLP_PARAM_STR_KEEPNAMES,
+ CLP_PARAM_STR_SPARSEFACTOR,
+ CLP_PARAM_STR_PRIMALPIVOT,
+ CLP_PARAM_STR_PRESOLVE,
+ CLP_PARAM_STR_CRASH,
+ CLP_PARAM_STR_BIASLU,
+ CLP_PARAM_STR_PERTURBATION,
+ CLP_PARAM_STR_MESSAGES,
+ CLP_PARAM_STR_AUTOSCALE,
+ CLP_PARAM_STR_CHOLESKY,
+ CLP_PARAM_STR_KKT,
+ CLP_PARAM_STR_BARRIERSCALE,
+ CLP_PARAM_STR_GAMMA,
+ CLP_PARAM_STR_CROSSOVER,
+ CLP_PARAM_STR_PFI,
+ CLP_PARAM_STR_INTPRINT,
+ CLP_PARAM_STR_VECTOR,
+ CLP_PARAM_STR_FACTORIZATION,
+ CLP_PARAM_STR_ALLCOMMANDS,
+ CLP_PARAM_STR_TIME_MODE,
+ CLP_PARAM_STR_ABCWANTED,
+ CLP_PARAM_STR_BUFFER_MODE,
+
+ CBC_PARAM_STR_NODESTRATEGY = 251,
+ CBC_PARAM_STR_BRANCHSTRATEGY,
+ CBC_PARAM_STR_CUTSSTRATEGY,
+ CBC_PARAM_STR_HEURISTICSTRATEGY,
+ CBC_PARAM_STR_GOMORYCUTS,
+ CBC_PARAM_STR_PROBINGCUTS,
+ CBC_PARAM_STR_KNAPSACKCUTS,
+ CBC_PARAM_STR_REDSPLITCUTS,
+ CBC_PARAM_STR_ROUNDING,
+ CBC_PARAM_STR_SOLVER,
+ CBC_PARAM_STR_CLIQUECUTS,
+ CBC_PARAM_STR_COSTSTRATEGY,
+ CBC_PARAM_STR_FLOWCUTS,
+ CBC_PARAM_STR_MIXEDCUTS,
+ CBC_PARAM_STR_TWOMIRCUTS,
+ CBC_PARAM_STR_PREPROCESS,
+ CBC_PARAM_STR_FPUMP,
+ CBC_PARAM_STR_GREEDY,
+ CBC_PARAM_STR_COMBINE,
+ CBC_PARAM_STR_PROXIMITY,
+ CBC_PARAM_STR_LOCALTREE,
+ CBC_PARAM_STR_SOS,
+ CBC_PARAM_STR_LANDPCUTS,
+ CBC_PARAM_STR_RINS,
+ CBC_PARAM_STR_RESIDCUTS,
+ CBC_PARAM_STR_RENS,
+ CBC_PARAM_STR_DIVINGS,
+ CBC_PARAM_STR_DIVINGC,
+ CBC_PARAM_STR_DIVINGF,
+ CBC_PARAM_STR_DIVINGG,
+ CBC_PARAM_STR_DIVINGL,
+ CBC_PARAM_STR_DIVINGP,
+ CBC_PARAM_STR_DIVINGV,
+ CBC_PARAM_STR_DINS,
+ CBC_PARAM_STR_PIVOTANDFIX,
+ CBC_PARAM_STR_RANDROUND,
+ CBC_PARAM_STR_NAIVE,
+ CBC_PARAM_STR_ZEROHALFCUTS,
+ CBC_PARAM_STR_CPX,
+ CBC_PARAM_STR_CROSSOVER2,
+ CBC_PARAM_STR_PIVOTANDCOMPLEMENT,
+ CBC_PARAM_STR_VND,
+ CBC_PARAM_STR_LAGOMORYCUTS,
+ CBC_PARAM_STR_LATWOMIRCUTS,
+ CBC_PARAM_STR_REDSPLIT2CUTS,
+ CBC_PARAM_STR_GMICUTS,
+ CBC_PARAM_STR_CUTOFF_CONSTRAINT,
+ CBC_PARAM_STR_DW,
+ CBC_PARAM_STR_ORBITAL,
+
+ CLP_PARAM_ACTION_DIRECTORY = 301,
+ CLP_PARAM_ACTION_DIRSAMPLE,
+ CLP_PARAM_ACTION_DIRNETLIB,
+ CBC_PARAM_ACTION_DIRMIPLIB,
+ CLP_PARAM_ACTION_IMPORT,
+ CLP_PARAM_ACTION_EXPORT,
+ CLP_PARAM_ACTION_RESTORE,
+ CLP_PARAM_ACTION_SAVE,
+ CLP_PARAM_ACTION_DUALSIMPLEX,
+ CLP_PARAM_ACTION_PRIMALSIMPLEX,
+ CLP_PARAM_ACTION_EITHERSIMPLEX,
+ CLP_PARAM_ACTION_MAXIMIZE,
+ CLP_PARAM_ACTION_MINIMIZE,
+ CLP_PARAM_ACTION_EXIT,
+ CLP_PARAM_ACTION_STDIN,
+ CLP_PARAM_ACTION_UNITTEST,
+ CLP_PARAM_ACTION_NETLIB_EITHER,
+ CLP_PARAM_ACTION_NETLIB_DUAL,
+ CLP_PARAM_ACTION_NETLIB_PRIMAL,
+ CLP_PARAM_ACTION_SOLUTION,
+ CLP_PARAM_ACTION_SAVESOL,
+ CLP_PARAM_ACTION_TIGHTEN,
+ CLP_PARAM_ACTION_FAKEBOUND,
+ CLP_PARAM_ACTION_HELP,
+ CLP_PARAM_ACTION_PLUSMINUS,
+ CLP_PARAM_ACTION_NETWORK,
+ CLP_PARAM_ACTION_ALLSLACK,
+ CLP_PARAM_ACTION_REVERSE,
+ CLP_PARAM_ACTION_BARRIER,
+ CLP_PARAM_ACTION_NETLIB_BARRIER,
+ CLP_PARAM_ACTION_NETLIB_TUNE,
+ CLP_PARAM_ACTION_REALLY_SCALE,
+ CLP_PARAM_ACTION_BASISIN,
+ CLP_PARAM_ACTION_BASISOUT,
+ CLP_PARAM_ACTION_SOLVECONTINUOUS,
+ CLP_PARAM_ACTION_CLEARCUTS,
+ CLP_PARAM_ACTION_VERSION,
+ CLP_PARAM_ACTION_STATISTICS,
+ CLP_PARAM_ACTION_DEBUG,
+ CLP_PARAM_ACTION_DUMMY,
+ CLP_PARAM_ACTION_PRINTMASK,
+ CLP_PARAM_ACTION_OUTDUPROWS,
+ CLP_PARAM_ACTION_USERCLP,
+ CLP_PARAM_ACTION_MODELIN,
+ CLP_PARAM_ACTION_CSVSTATISTICS,
+ CLP_PARAM_ACTION_STOREDFILE,
+ CLP_PARAM_ACTION_ENVIRONMENT,
+ CLP_PARAM_ACTION_PARAMETRICS,
+ CLP_PARAM_ACTION_GMPL_SOLUTION,
+ CLP_PARAM_ACTION_RESTORESOL,
+
+ CBC_PARAM_ACTION_BAB = 361,
+ CBC_PARAM_ACTION_MIPLIB,
+ CBC_PARAM_ACTION_STRENGTHEN,
+ CBC_PARAM_ACTION_PRIORITYIN,
+ CBC_PARAM_ACTION_MIPSTART,
+ CBC_PARAM_ACTION_USERCBC,
+ CBC_PARAM_ACTION_DOHEURISTIC,
+ CLP_PARAM_ACTION_NEXTBESTSOLUTION,
+
+ CBC_PARAM_NOTUSED_OSLSTUFF = 401,
+ CBC_PARAM_NOTUSED_CBCSTUFF,
+
+ CBC_PARAM_NOTUSED_INVALID = 1000
+} ;
+#include
+#include
+
+/// Very simple class for setting parameters
+
+class CbcOrClpParam {
+public:
+ /**@name Constructor and destructor */
+ //@{
+ /// Constructors
+ CbcOrClpParam ( );
+ CbcOrClpParam (std::string name, std::string help,
+ double lower, double upper, CbcOrClpParameterType type, int display = 2);
+ CbcOrClpParam (std::string name, std::string help,
+ int lower, int upper, CbcOrClpParameterType type, int display = 2);
+ // Other strings will be added by insert
+ CbcOrClpParam (std::string name, std::string help, std::string firstValue,
+ CbcOrClpParameterType type, int whereUsed = 7, int display = 2);
+ // Action
+ CbcOrClpParam (std::string name, std::string help,
+ CbcOrClpParameterType type, int whereUsed = 7, int display = 2);
+ /// Copy constructor.
+ CbcOrClpParam(const CbcOrClpParam &);
+ /// Assignment operator. This copies the data
+ CbcOrClpParam & operator=(const CbcOrClpParam & rhs);
+ /// Destructor
+ ~CbcOrClpParam ( );
+ //@}
+
+ /**@name stuff */
+ //@{
+ /// Insert string (only valid for keywords)
+ void append(std::string keyWord);
+ /// Adds one help line
+ void addHelp(std::string keyWord);
+ /// Returns name
+ inline std::string name( ) const {
+ return name_;
+ }
+ /// Returns short help
+ inline std::string shortHelp( ) const {
+ return shortHelp_;
+ }
+ /// Sets a double parameter (nonzero code if error)
+ int setDoubleParameter(CbcModel & model, double value) ;
+ /// Sets double parameter and returns printable string and error code
+ const char * setDoubleParameterWithMessage ( CbcModel & model, double value , int & returnCode);
+ /// Gets a double parameter
+ double doubleParameter(CbcModel & model) const;
+ /// Sets a int parameter (nonzero code if error)
+ int setIntParameter(CbcModel & model, int value) ;
+ /// Sets int parameter and returns printable string and error code
+ const char * setIntParameterWithMessage ( CbcModel & model, int value , int & returnCode);
+ /// Gets a int parameter
+ int intParameter(CbcModel & model) const;
+ /// Sets a double parameter (nonzero code if error)
+ int setDoubleParameter(ClpSimplex * model, double value) ;
+ /// Gets a double parameter
+ double doubleParameter(ClpSimplex * model) const;
+ /// Sets double parameter and returns printable string and error code
+ const char * setDoubleParameterWithMessage ( ClpSimplex * model, double value , int & returnCode);
+ /// Sets a int parameter (nonzero code if error)
+ int setIntParameter(ClpSimplex * model, int value) ;
+ /// Sets int parameter and returns printable string and error code
+ const char * setIntParameterWithMessage ( ClpSimplex * model, int value , int & returnCode);
+ /// Gets a int parameter
+ int intParameter(ClpSimplex * model) const;
+ /// Sets a double parameter (nonzero code if error)
+ int setDoubleParameter(OsiSolverInterface * model, double value) ;
+ /// Sets double parameter and returns printable string and error code
+ const char * setDoubleParameterWithMessage ( OsiSolverInterface * model, double value , int & returnCode);
+ /// Gets a double parameter
+ double doubleParameter(OsiSolverInterface * model) const;
+ /// Sets a int parameter (nonzero code if error)
+ int setIntParameter(OsiSolverInterface * model, int value) ;
+ /// Sets int parameter and returns printable string and error code
+ const char * setIntParameterWithMessage ( OsiSolverInterface * model, int value , int & returnCode);
+ /// Gets a int parameter
+ int intParameter(OsiSolverInterface * model) const;
+ /// Checks a double parameter (nonzero code if error)
+ int checkDoubleParameter(double value) const;
+ /// Returns name which could match
+ std::string matchName ( ) const;
+ /// Returns length of name for ptinting
+ int lengthMatchName ( ) const;
+ /// Returns parameter option which matches (-1 if none)
+ int parameterOption ( std::string check ) const;
+ /// Prints parameter options
+ void printOptions ( ) const;
+ /// Returns current parameter option
+ inline std::string currentOption ( ) const {
+ return definedKeyWords_[currentKeyWord_];
+ }
+ /// Sets current parameter option
+ void setCurrentOption ( int value , bool printIt = false);
+ /// Sets current parameter option and returns printable string
+ const char * setCurrentOptionWithMessage ( int value );
+ /// Sets current parameter option using string
+ void setCurrentOption (const std::string value );
+ /// Sets current parameter option using string with message
+ const char * setCurrentOptionWithMessage (const std::string value );
+ /// Returns current parameter option position
+ int currentOptionAsInteger ( ) const ;
+ /** Returns current parameter option position
+ but if fake keyword returns a fake value and sets
+ fakeInteger to true value. If not fake then fakeInteger is -COIN_INT_MAX
+ */
+ int currentOptionAsInteger ( int & fakeInteger ) const;
+ /// Sets int value
+ void setIntValue ( int value );
+ /// Sets int value with message
+ const char * setIntValueWithMessage ( int value );
+ inline int intValue () const {
+ return intValue_;
+ }
+ /// Sets double value
+ void setDoubleValue ( double value );
+ /// Sets double value with message
+ const char * setDoubleValueWithMessage ( double value );
+ inline double doubleValue () const {
+ return doubleValue_;
+ }
+ /// Sets string value
+ void setStringValue ( std::string value );
+ inline std::string stringValue () const {
+ return stringValue_;
+ }
+ /// Returns 1 if matches minimum, 2 if matches less, 0 if not matched
+ int matches (std::string input) const;
+ /// type
+ inline CbcOrClpParameterType type() const {
+ return type_;
+ }
+ /// whether to display
+ inline int displayThis() const {
+ return display_;
+ }
+ /// Set Long help
+ inline void setLonghelp(const std::string help) {
+ longHelp_ = help;
+ }
+ /// Print Long help
+ void printLongHelp() const;
+ /// Print action and string
+ void printString() const;
+ /** 7 if used everywhere,
+ 1 - used by clp
+ 2 - used by cbc
+ 4 - used by ampl
+ */
+ inline int whereUsed() const {
+ return whereUsed_;
+ }
+ /// Gets value of fake keyword
+ inline int fakeKeyWord() const
+ { return fakeKeyWord_;}
+ /// Sets value of fake keyword
+ inline void setFakeKeyWord(int value, int fakeValue)
+ { fakeKeyWord_ = value; fakeValue_ = fakeValue;}
+ /// Sets value of fake keyword to current size of keywords
+ void setFakeKeyWord(int fakeValue);
+
+private:
+ /// gutsOfConstructor
+ void gutsOfConstructor();
+ //@}
+////////////////// data //////////////////
+private:
+
+ /**@name data
+ We might as well throw all type data in - could derive?
+ */
+ //@{
+ // Type see CbcOrClpParameterType
+ CbcOrClpParameterType type_;
+ /// If double == okay
+ double lowerDoubleValue_;
+ double upperDoubleValue_;
+ /// If int == okay
+ int lowerIntValue_;
+ int upperIntValue_;
+ // Length of name
+ unsigned int lengthName_;
+ // Minimum match
+ unsigned int lengthMatch_;
+ /// set of valid strings
+ std::vector definedKeyWords_;
+ /// Name
+ std::string name_;
+ /// Short help
+ std::string shortHelp_;
+ /// Long help
+ std::string longHelp_;
+ /// Action
+ CbcOrClpParameterType action_;
+ /// Current keyWord (if a keyword parameter)
+ int currentKeyWord_;
+ /// Display on ?
+ int display_;
+ /// Integer parameter - current value
+ int intValue_;
+ /// Double parameter - current value
+ double doubleValue_;
+ /// String parameter - current value
+ std::string stringValue_;
+ /** 7 if used everywhere,
+ 1 - used by clp
+ 2 - used by cbc
+ 4 - used by ampl
+ */
+ int whereUsed_;
+ /** If >=0 then integers allowed as a fake keyword
+ So minusnnnn would got to -nnnn in currentKeyword_
+ and plusnnnn would go to fakeKeyword_+nnnn
+ */
+ int fakeKeyWord_;
+ /// Return this as main value if an integer
+ int fakeValue_;
+ //@}
+};
+/// Simple read stuff
+std::string CoinReadNextField();
+
+std::string CoinReadGetCommand(int argc, const char *argv[]);
+std::string CoinReadGetString(int argc, const char *argv[]);
+// valid 0 - okay, 1 bad, 2 not there
+int CoinReadGetIntField(int argc, const char *argv[], int * valid);
+double CoinReadGetDoubleField(int argc, const char *argv[], int * valid);
+void CoinReadPrintit(const char * input);
+void setCbcOrClpPrinting(bool yesNo);
+#define CBCMAXPARAMETERS 250
+/*
+ Subroutine to establish the cbc parameter array. See the description of
+ class CbcOrClpParam for details. Pulled from C..Main() for clarity.
+*/
+void establishParams (int &numberParameters, CbcOrClpParam *const parameters);
+// Given a parameter type - returns its number in list
+int whichParam (CbcOrClpParameterType name,
+ int numberParameters, CbcOrClpParam *const parameters);
+// Dump/restore a solution to file
+void saveSolution(const ClpSimplex * lpSolver, std::string fileName);
+void restoreSolution(ClpSimplex * lpSolver, std::string fileName, int mode);
+#endif /* CbcOrClpParam_H */
diff --git a/thirdparty/windows/include/coin/Cgl012cut.hpp b/thirdparty/windows/include/coin/Cgl012cut.hpp
new file mode 100644
index 0000000..2814b0a
--- /dev/null
+++ b/thirdparty/windows/include/coin/Cgl012cut.hpp
@@ -0,0 +1,464 @@
+// $Id: Cgl012cut.hpp 1149 2013-10-21 18:23:53Z tkr $
+// Copyright (C) 2010, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+/** @file 012cut.h Include file for C coded 0-1/2 separator */
+#ifndef CGL012CUT
+#define CGL012CUT
+#include
+#include
+#include
+
+#define CGL_NEW_SHORT
+#ifndef CGL_NEW_SHORT
+typedef /* arc */
+ struct arc_st
+{
+ int len; /* length of the arc */
+ struct node_st *head; /* head node */
+}
+ arc;
+
+typedef /* node */
+ struct node_st
+{
+ arc *first; /* first outgoing arc */
+ int dist; /* tentative shortest path length */
+ struct node_st *parent; /* parent pointer */
+ struct node_st *next; /* next node in queue */
+ struct node_st *prev; /* previous node in queue */
+ int status; /* status of node */
+ int temp; /* for temporary labels */
+ int index; /* index of the node in the graph */
+} node;
+#endif
+typedef struct
+{
+ int length; // Length of arc
+ int to; // To node
+} cgl_arc;
+
+typedef struct
+{
+ cgl_arc * firstArc; // First outgoing arc
+ int parentNode; // Parent node in shortest path
+ int index; // Which node I am
+ int distanceBack; // Distance back to source
+} cgl_node;
+
+typedef struct
+{
+ int nnodes; // Number of nodes in graph
+ int narcs; // Number of arcs in graph
+ cgl_node * nodes;
+ cgl_arc * arcs;
+} cgl_graph;
+/* #define PRINT */
+/* #define PRINT_CUTS */
+#define REDUCTION
+
+typedef struct {
+int mr; /* number of rows in the ILP matrix */
+int mc; /* number of columns in the ILP matrix */
+int mnz; /* number of nonzero's in the ILP matrix */
+int *mtbeg; /* starting position of each row in arrays mtind and mtval */
+int *mtcnt; /* number of entries of each row in arrays mtind and mtval */
+int *mtind; /* column indices of the nonzero entries of the ILP matrix */
+int *mtval; /* values of the nonzero entries of the ILP matrix */
+int *vlb; /* lower bounds on the variables */
+int *vub; /* upper bounds on the variables */
+int *mrhs; /* right hand sides of the constraints */
+char *msense; /* senses of the constraints: 'L', 'G' or 'E' */
+const double *xstar; /* current optimal solution of the LP relaxation */
+} ilp;
+
+typedef struct {
+int mr; /* number of rows in the parity ILP matrix */
+int mc; /* number of columns in the parity ILP matrix */
+int mnz; /* number of 1's in the parity ILP matrix */
+int *mtbeg; /* starting position of each row in arrays mtind and mtval */
+int *mtcnt; /* number of entries of each row in arrays mtind and mtval */
+int *mtind; /* column indices of the 1's of the parity ILP matrix */
+short int *mrhs; /* right hand side parity of the constraints */
+double *xstar; /* current optimal solution of the LP relaxation */
+double *slack; /* slack of the constraints w.r.t. xstar */
+short int *row_to_delete; /* flag for marking rows not to be considered */
+short int *col_to_delete; /* flag for marking columns not to be considered */
+int *gcd; /* greatest common divisor of each row in the input ILP matrix */
+short int *possible_weak; /* possible weakening types of each column */
+short int *type_even_weak; /* type of even weakening of each column
+ (lower or upper bound weakening) */
+short int *type_odd_weak; /* type of odd weakening of each column
+ (lower or upper bound weakening) */
+double *loss_even_weak; /* loss for the even weakening of each column */
+double *loss_odd_weak; /* loss for the odd weakening of each column */
+double *min_loss_by_weak; /* minimum loss for the weakening of each column */
+} parity_ilp;
+
+typedef struct {
+int nweak; /* number of variables weakened */
+int *var; /* list of variables weakened */
+short int *type; /* type of weakening (lower or upper bound weakening) */
+} info_weak;
+
+typedef struct {
+int endpoint1, endpoint2; /* endpoints of the edge */
+double weight; /* edge weight */
+short int parity; /* edge parity (even or odd) */
+int constr; /* constraint associated with the edge */
+info_weak *weak; /* weakening information */
+} edge;
+
+typedef struct {
+int nnodes; /* number of nodes */
+int nedges; /* number of edges */
+int *nodes; /* indexes of the ILP columns corresponding to the nodes */
+int *ind; /* indexes of the nodes corresponding to the ILP columns */
+edge **even_adj_list; /* pointers to the even edges */
+edge **odd_adj_list; /* pointers to the odd edges */
+} separation_graph;
+
+#ifndef CGL_NEW_SHORT
+typedef struct {
+int nnodes; /* number of nodes */
+int narcs; /* number of arcs */
+node *nodes; /* array of the nodes - see "types_db.h" */
+arc *arcs; /* array of the arcs - see "types_db.h" */
+} auxiliary_graph;
+#else
+typedef struct {
+int nnodes; /* number of nodes */
+int narcs; /* number of arcs */
+cgl_node *nodes; /* array of the nodes - see "types_db.h" */
+cgl_arc *arcs; /* array of the arcs - see "types_db.h" */
+} auxiliary_graph;
+#endif
+
+typedef struct {
+long dist; /* distance from/to root */
+int pred; /* index of the predecessor */
+} short_path_node;
+
+typedef struct {
+double weight; /* overall weight of the cycle */
+int length; /* number of edges in the cycle */
+edge **edge_list; /* list of edges in the cycle */
+} cycle;
+
+typedef struct {
+int cnum; /* overall number of cycles */
+cycle **list; /* pointers to the cycles in the list */
+} cycle_list;
+
+typedef struct {
+int n_of_constr; /* number of constraints combined to get the cut */
+int *constr_list; /* list of the constraints combined */
+short int *in_constr_list; /* flag saying whether a given constraint is
+ in the list of constraints of the cut (IN)
+ or not (OUT) */
+int cnzcnt; /* overall number of nonzero's in the cut */
+int *cind; /* column indices of the nonzero entries of the cut */
+int *cval; /* values of the nonzero entries of the cut */
+int crhs; /* right hand side of the cut */
+char csense; /* sense of the cut: 'L', 'G' or 'E' */
+double violation; /* violation of the cut w.r.t. the current LP solution */
+} cut;
+
+typedef struct {
+int cnum; /* overall number of cuts */
+cut **list; /* pointers to the cuts in the list */
+} cut_list;
+
+typedef struct {
+int n_of_constr; /* number of constraints combined to get the cut */
+int *constr_list; /* list of the constraints combined */
+int code; /* identifier of the cut */
+int n_it_violated; /* number of consecutive iterations (starting from the
+ last and going backward) in which the cut was
+ violated by the LP solution */
+int it_found; /* iteration in which the cut was separated */
+double score; /* score of the cut, used to choose wich cut should be
+ added to the current LP (if any) */
+} pool_cut;
+
+typedef struct {
+int cnum; /* overall number of cuts */
+pool_cut **list; /* pointers to the cuts in the list */
+int *ncod; /* number of cuts with a given code in the pool */
+} pool_cut_list;
+
+typedef struct {
+int *ccoef; /* coefficients of the cut */
+int crhs; /* right hand side of the cut */
+int pool_index; /* index of the cut in the pool */
+double score; /* cut score (to be maximized) */
+} select_cut;
+
+typedef struct {
+int n_it_zero; /* number of consecutive iterations (starting from the
+ last and going backward) in which each variable took
+ the value 0 in the LP solution */
+} log_var;
+/** 012Cut Generator Class
+
+ This class is to make Cgl01cut thread safe etc
+*/
+
+class Cgl012Cut {
+
+public:
+
+ /**@name Generate Cuts */
+ //@{
+int sep_012_cut(
+/*
+ INPUT parameters:
+*/
+int mr, /* number of rows in the ILP matrix */
+int mc, /* number of columns in the ILP matrix */
+int mnz, /* number of nonzero's in the ILP matrix */
+int *mtbeg, /* starting position of each row in arrays mtind and mtval */
+int *mtcnt, /* number of entries of each row in arrays mtind and mtval */
+int *mtind, /* column indices of the nonzero entries of the ILP matrix */
+int *mtval, /* values of the nonzero entries of the ILP matrix */
+int *vlb, /* lower bounds on the variables */
+int *vub, /* upper bounds on the variables */
+int *mrhs, /* right hand sides of the constraints */
+char *msense, /* senses of the constraints: 'L', 'G' or 'E' */
+const double *xstar, /* current optimal solution of the LP relaxation */
+bool aggressive, /* flag asking whether as many cuts as possible are
+ required on output (TRUE) or not (FALSE) */
+/*
+ OUTPUT parameters (the memory for the vectors is allocated INTERNALLY
+ by the procedure: if some memory is already allocated, it is FREED):
+*/
+int *cnum, /* number of violated 0-1/2 cuts identified by the procedure */
+int *cnzcnt, /* overall number of nonzero's in the cuts */
+int **cbeg, /* starting position of each cut in arrays cind and cval */
+int **ccnt, /* number of entries of each cut in arrays cind and cval */
+int **cind, /* column indices of the nonzero entries of the cuts */
+int **cval, /* values of the nonzero entries of the cuts */
+int **crhs, /* right hand sides of the cuts */
+char **csense /* senses of the cuts: 'L', 'G' or 'E' */
+/*
+ NOTE that all the numerical input/output vectors are INTEGER (with
+ the exception of xstar), since the procedure is intended to work
+ with pure ILP's, and that the ILP matrix has to be given on input
+ in ROW format.
+*/
+ );
+void ilp_load(
+ int mr, /* number of rows in the ILP matrix */
+ int mc, /* number of columns in the ILP matrix */
+ int mnz, /* number of nonzero's in the ILP matrix */
+ int *mtbeg, /* starting position of each row in arrays mtind and mtval */
+ int *mtcnt, /* number of entries of each row in arrays mtind and mtval */
+ int *mtind, /* column indices of the nonzero entries of the ILP matrix */
+ int *mtval, /* values of the nonzero entries of the ILP matrix */
+ int *vlb, /* lower bounds on the variables */
+ int *vub, /* upper bounds on the variables */
+ int *mrhs, /* right hand sides of the constraints */
+ char *msense /* senses of the constraints: 'L', 'G' or 'E' */
+ );
+void free_ilp();
+/* alloc_parity_ilp: allocate the memory for the parity ILP data structure */
+
+void alloc_parity_ilp(
+ int mr, /* number of rows in the ILP matrix */
+ int mc, /* number of columns in the ILP matrix */
+ int mnz /* number of nonzero's in the ILP matrix */
+ );
+void free_parity_ilp();
+ void initialize_log_var();
+/* free_log_var */
+ void free_log_var();
+private:
+/* best_weakening: find the best upper/lower bound weakening of a set
+ of variables */
+
+int best_weakening(
+ int n_to_weak, /* number of variables to weaken */
+int *vars_to_weak, /* indices of the variables to weaken */
+short int original_parity, /* original parity of the constraint to weaken */
+double original_slack, /* original slack of the constraint to weaken */
+double *best_even_slack, /* best possible slack of a weakened constraint
+ with even right-hand-side */
+double *best_odd_slack, /* best possible slack of a weakened constraint
+ with odd right-hand-side */
+info_weak **info_even_weak, /* weakening information about the best possible
+ even weakened constraint */
+info_weak **info_odd_weak, /* weakening information about the best possible
+ odd weakened constraint */
+short int only_odd, /* flag which tells whether only an odd weakening is of
+ interest (TRUE) or both weakenings are (FALSE) */
+short int only_viol /* flag which tells whether only an inequality of
+ slack smaller than MAX_SLACK is of interest (TRUE)
+ otherwise (FALSE) */
+ );
+
+/* best_cut: find the coefficients, the rhs and the violation of the
+ best possible cut that can be obtained by weakening a given set of
+ coefficients to even and a rhs to odd, dividing by 2 and rounding */
+
+short int best_cut(
+ int *ccoef, /* vector of the coefficients */
+ int *crhs, /* pointer to rhs value */
+ double *violation, /* violation of the cut */
+ short int update, /* TRUE/FALSE: if TRUE, the new ccoef and crhs are
+ given on output */
+ short int only_viol /* flag which tells whether only an inequality of
+ slack smaller than MAX_SLACK is of interest (TRUE)
+ otherwise (FALSE) */
+ );
+/* get_cut: extract a hopefully violated cut from an odd cycle of the
+ separation graph */
+
+cut *get_cut(
+ cycle *s_cyc /* shortest odd cycles identified in the separation graph */
+ );
+
+/* update_log_var: update the log information for the problem variables */
+ void update_log_var();
+
+/* basic_separation: try to identify violated 0-1/2 cuts by using the
+ original procedure described in Caprara and Fischetti's MP paper */
+
+ cut_list *basic_separation();
+
+/* score_by_moving: compute the score of the best cut obtainable from
+ the current local search solution by inserting/deleting a constraint */
+
+double score_by_moving(
+ int i, /* constraint to be moved */
+ short int itype, /* type of move - ADD or DEL */
+ double thresh /* minimum value of an interesting score */
+ );
+/* modify_current: update the current local search solution by inserting/
+ deleting a constraint */
+
+void modify_current(
+ int i, /* constraint to be moved */
+ short int itype /* type of move - ADD or DEL */
+ );
+
+/* best neighbour: find the cut to be added/deleted from the current
+ solution among those allowed by the tabu rules */
+
+ short int best_neighbour(cut_list *out_cuts /* list of the violated cuts found */);
+
+/* add_tight_constraint: initialize the current cut by adding a tight
+ constraint to it */
+
+ void add_tight_constraint();
+
+/* tabu_012: try to identify violated 0-1/2 cuts by a simple tabu search
+ procedure adapted from that used by Battiti and Protasi for finding
+ large cliques */
+
+ cut_list *tabu_012();
+/* initialize: initialize the data structures for local search */
+
+ void initialize();
+/* restart: perform a restart of the search - IMPORTANT: in the current
+ implementation vector last_moved is not cleared at restart */
+
+ void restart(short int failure /* flag forcing the restart if some trouble occurred */);
+ void print_constr(int i /* constraint to be printed */);
+ void print_parity_ilp();
+
+/* get_parity_ilp: construct an internal data structure containing all the
+ information which can be useful for 0-1/2 cut separation */
+
+ void get_parity_ilp();
+/* initialize_sep_graph: allocate and initialize the data structure
+ to contain the information associated with a separation graph */
+
+ separation_graph *initialize_sep_graph();
+ void print_cut(cut *v_cut);
+/* get_ori_cut_coef: get the coefficients of a cut, before dividing by 2 and
+ rounding, starting from the list of the constraints combined to get
+ the cut */
+
+short int get_ori_cut_coef(
+ int n_of_constr, /* number of constraints combined */
+ int *constr_list, /* list of the constraints combined */
+ int *ccoef, /* cut left hand side coefficients */
+ int *crhs, /* cut right hand side */
+ short int only_viol /* flag which tells whether only an inequality of
+ slack smaller than MAX_SLACK is of interest (TRUE)
+ otherwise (FALSE) */
+ );
+/* define_cut: construct a cut data structure from a vector of
+ coefficients and a right-hand-side */
+
+cut *define_cut(
+ int *ccoef, /* coefficients of the cut */
+ int crhs /* right hand side of the cut */
+ );
+
+/* cut_score: define the score of a (violated) cut */
+
+double cut_score(
+ int *ccoef, /* cut left hand side coefficients */
+ int crhs, /* cut right hand side */
+ double viol, /* cut violation */
+ short int only_viol /* flag which tells whether only an inequality of
+ slack smaller than MAX_SLACK is of interest (TRUE)
+ otherwise (FALSE) */
+ );
+/* get_current_cut: return a cut data type with the information about
+ the current cut of the search procedure */
+
+ cut *get_current_cut();
+/* print_cur_cut: display cur_cut on output */
+
+ void print_cur_cut();
+ void print_cut_list(cut_list *cuts);
+ //@}
+public:
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ Cgl012Cut ();
+
+ /// Copy constructor
+ Cgl012Cut (
+ const Cgl012Cut &);
+
+ /// Assignment operator
+ Cgl012Cut &
+ operator=(
+ const Cgl012Cut& rhs);
+
+ /// Destructor
+ virtual ~Cgl012Cut ();
+ //@}
+
+private:
+
+ // Private member methods
+
+ /**@name Private methods */
+ //@{
+ //@}
+
+
+ /**@name Private member data */
+ //@{
+
+ilp *inp_ilp; /* input ILP data structure */
+parity_ilp *p_ilp; /* parity ILP data structure */
+int iter;
+double gap;
+double maxgap;
+int errorNo;
+int sep_iter; /* number of the current separation iteration */
+log_var **vlog; /* information about the value attained
+ by the variables in the last iterations,
+ used to possibly set to 0 some coefficient
+ > 0 in a cut to be added */
+bool aggr; /* flag saying whether as many cuts as possible are required
+ from the separation procedure (TRUE) or not (FALSE) */
+ //@}
+};
+#endif
diff --git a/thirdparty/windows/include/coin/CglAllDifferent.hpp b/thirdparty/windows/include/coin/CglAllDifferent.hpp
new file mode 100644
index 0000000..ed369d1
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglAllDifferent.hpp
@@ -0,0 +1,115 @@
+// Copyright (C) 2005, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglAllDifferent_H
+#define CglAllDifferent_H
+
+#include
+
+#include "CglCutGenerator.hpp"
+
+/** AllDifferent Cut Generator Class
+ This has a number of sets. All the members in each set are general integer
+ variables which have to be different from all others in the set.
+
+ At present this only generates column cuts
+
+ At present it is very primitive compared to proper CSP implementations
+ */
+class CglAllDifferent : public CglCutGenerator {
+
+public:
+
+
+ /**@name Generate Cuts */
+ //@{
+ /** This fixes (or reduces bounds) on sets of all different variables
+ */
+ virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ //@}
+
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglAllDifferent ();
+
+ /// Useful constructot
+ CglAllDifferent(int numberSets, const int * starts, const int * which);
+
+ /// Copy constructor
+ CglAllDifferent (
+ const CglAllDifferent &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglAllDifferent &
+ operator=(
+ const CglAllDifferent& rhs);
+
+ /// Destructor
+ virtual
+ ~CglAllDifferent ();
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+
+ /// This can be used to refresh any inforamtion
+ virtual void refreshSolver(OsiSolverInterface * solver);
+ /**
+ Returns true if may generate Row cuts in tree (rather than root node).
+ Used so know if matrix will change in tree. Really
+ meant so column cut generators can still be active
+ without worrying code.
+ Default is true
+ */
+ virtual bool mayGenerateRowCutsInTree() const
+ { return false;}
+ //@}
+ /**@name Sets and Gets */
+ //@{
+ /// Set log level
+ inline void setLogLevel(int value)
+ { logLevel_=value;}
+ /// Get log level
+ inline int getLogLevel() const
+ { return logLevel_;}
+ /// Set Maximum number of sets to look at at once
+ inline void setMaxLook(int value)
+ { maxLook_=value;}
+ /// Get Maximum number of sets to look at at once
+ inline int getMaxLook() const
+ { return maxLook_;}
+ //@}
+
+private:
+
+ // Private member methods
+ /**@name */
+ //@{
+ //@}
+
+ // Private member data
+
+ /**@name Private member data */
+ //@{
+ /// Number of sets
+ int numberSets_;
+ /// Total number of variables in all different sets
+ int numberDifferent_;
+ /// Maximum number of sets to look at at once
+ int maxLook_;
+ /// Log level - 0 none, 1 - a bit, 2 - more details
+ int logLevel_;
+ /// Start of each set
+ int * start_;
+ /// Members (0,1,....) not as in original model
+ int * which_;
+ /// Original members
+ int * originalWhich_;
+ //@}
+};
+#endif
diff --git a/thirdparty/windows/include/coin/CglClique.hpp b/thirdparty/windows/include/coin/CglClique.hpp
new file mode 100644
index 0000000..288052d
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglClique.hpp
@@ -0,0 +1,312 @@
+// $Id: CglClique.hpp 1330 2016-01-26 19:35:16Z forrest $
+// Copyright (C) 2000, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef _CglClique_h_
+#define _CglClique_h_
+
+#include "CglCutGenerator.hpp"
+
+//class OsiCuts;
+//class OsiSolverInterface;
+
+class CglClique : public CglCutGenerator {
+
+ friend void CglCliqueUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+public:
+ /// Copy constructor
+ CglClique(const CglClique& rhs);
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglClique& operator=(const CglClique& rhs);
+
+public:
+
+ virtual void
+ generateCuts(const OsiSolverInterface& si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+
+ /**@name Constructors and destructors */
+ //@{
+ /** Default constructor.
+ If the setPacking argument is set to true then CglClique will assume that the
+ problem in the solverinterface passed to the generateCuts() method
+ describes a set packing problem, i.e.,
+ - all variables are binary
+ - the matrix is a 0-1 matrix
+ - all constraints are '= 1' or '<= 1'
+
+ Otherwise the user can use the considerRows() method to set the list of
+ clique rows, that is,
+ - all coeffs corresponding to binary variables at fractional level is 1
+ - all other coeffs are non-negative
+ - the constraint is '= 1' or '<= 1'.
+
+ If the user does not set the list of clique rows then CglClique will
+ start the generateCuts() methods by scanning the matrix for them.
+ Also justOriginalRows can be set to true to limit clique creation
+ */
+ CglClique(bool setPacking = false, bool justOriginalRows = false);
+ /// Destructor
+ virtual ~CglClique() {}
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+
+ void considerRows(const int numRows, const int* rowInd);
+
+public:
+ /** possible choices for selecting the next node in the star clique search
+ */
+ enum scl_next_node_method {
+ SCL_MIN_DEGREE,
+ SCL_MAX_DEGREE,
+ SCL_MAX_XJ_MAX_DEG
+ };
+
+ void setStarCliqueNextNodeMethod(scl_next_node_method method) {
+ scl_next_node_rule = method;
+ }
+
+ void setStarCliqueCandidateLengthThreshold(int maxlen) {
+ scl_candidate_length_threshold = maxlen;
+ }
+ void setRowCliqueCandidateLengthThreshold(int maxlen) {
+ rcl_candidate_length_threshold = maxlen;
+ }
+
+ void setStarCliqueReport(bool yesno = true) { scl_report_result = yesno; }
+ void setRowCliqueReport(bool yesno = true) { rcl_report_result = yesno; }
+
+ void setDoStarClique(bool yesno = true) { do_star_clique = yesno; }
+ void setDoRowClique(bool yesno = true) { do_row_clique = yesno; }
+
+ void setMinViolation(double minviol) { petol = minviol; }
+ double getMinViolation() const { return petol; }
+ /// Maximum number of binaries for looking at all
+ inline void setMaxNumber(int value) { maxNumber_ = value; }
+
+private:
+
+ struct frac_graph ;
+ friend struct frac_graph ;
+
+ /** A node of the fractional graph. There is a node for every variable at
+ fractional level. */
+ struct fnode {
+ /** pointer into all_nbr */
+ int *nbrs;
+ /** 1-x_i-x_j, needed for odd holes, in the same order as the adj list,
+ pointer into all_edgecost */
+ double *edgecosts;
+ /** degree of the node */
+ int degree;
+ /** the fractional value of the variable corresponding to this node */
+ double val;
+ };
+
+ /** A graph corresponding to a fractional solution of an LP. Two nodes are
+ adjacent iff their columns are non-orthogonal. */
+ struct frac_graph {
+ /** # of nodes = # of fractional values in the LP solution */
+ int nodenum;
+ /** # of edges in the graph */
+ int edgenum;
+ /** density= edgenum/(nodenum choose 2) */
+ double density;
+ int min_deg_node;
+ int min_degree;
+ int max_deg_node;
+ int max_degree;
+ /** The array of the nodes in the graph */
+ fnode *nodes;
+ /** The array of all the neighbors. First the indices of the nodes
+ adjacent to node 0 are listed, then those adjacent to node 1, etc. */
+ int *all_nbr;
+ /** The array of the costs of the edges going to the neighbors */
+ double *all_edgecost;
+
+ frac_graph() :
+ nodenum(0), edgenum(0), density(0),
+ min_deg_node(0), min_degree(0), max_deg_node(0), max_degree(0),
+ nodes(0), all_nbr(0), all_edgecost(0) {}
+ };
+
+protected:
+ /** An indicator showing whether the whole matrix in the solverinterface is
+ a set packing problem or not */
+ bool setPacking_;
+ /// True if just look at original rows
+ bool justOriginalRows_;
+ /** pieces of the set packing part of the solverinterface */
+ int sp_numrows;
+ int* sp_orig_row_ind;
+ int sp_numcols;
+ int* sp_orig_col_ind;
+ double* sp_colsol;
+ int* sp_col_start;
+ int* sp_col_ind;
+ int* sp_row_start;
+ int* sp_row_ind;
+
+ /** the intersection graph corresponding to the set packing problem */
+ frac_graph fgraph;
+ /** the node-node incidence matrix of the intersection graph. */
+ bool* node_node;
+
+ /** The primal tolerance in the solverinterface. */
+ double petol;
+ /// Maximum number of binaries for looking at all
+ int maxNumber_;
+
+ /** data for the star clique algorithm */
+
+ /** Parameters */
+ /**@{*/
+ /** whether to do the row clique algorithm or not. */
+ bool do_row_clique;
+ /** whether to do the star clique algorithm or not. */
+ bool do_star_clique;
+
+ /** How the next node to be added to the star clique should be selected */
+ scl_next_node_method scl_next_node_rule;
+ /** In the star clique method the maximal length of the candidate list
+ (those nodes that are in a star, i.e., connected to the center of the
+ star) to allow complete enumeration of maximal cliques. Otherwise a
+ greedy algorithm is used. */
+ int scl_candidate_length_threshold;
+ /** whether to give a detailed statistics on the star clique method */
+ bool scl_report_result;
+
+ /** In the row clique method the maximal length of the candidate list
+ (those nodes that can extend the row clique, i.e., connected to all
+ nodes in the row clique) to allow complete enumeration of maximal
+ cliques. Otherwise a greedy algorithm is used. */
+ int rcl_candidate_length_threshold;
+ /** whether to give a detailed statistics on the row clique method */
+ bool rcl_report_result;
+ /**@}*/
+
+ /** variables/arrays that are used across many methods */
+ /**@{*/
+ /** List of indices that must be in the to be created clique. This is just
+ a pointer, it is never new'd and therefore does not need to be
+ delete[]'d either. */
+ const int* cl_perm_indices;
+ /** The length of cl_perm_indices */
+ int cl_perm_length;
+
+ /** List of indices that should be considered for extending the ones listed
+ in cl_perm_indices. */
+ int* cl_indices;
+ /** The length of cl_indices */
+ int cl_length;
+
+ /** An array of nodes discarded from the candidate list. These are
+ rechecked when a maximal clique is found just to make sure that the
+ clique is really maximal. */
+ int* cl_del_indices;
+ /** The length of cl_del_indices */
+ int cl_del_length;
+
+ /**@}*/
+
+private:
+ /** Scan through the variables and select those that are binary and are at
+ a fractional level. */
+ void selectFractionalBinaries(const OsiSolverInterface& si);
+ /** Scan through the variables and select those that are at a fractional
+ level. We already know that everything is binary. */
+ void selectFractionals(const OsiSolverInterface& si);
+ /** */
+ void selectRowCliques(const OsiSolverInterface& si,int numOriginalRows);
+ /** */
+ void createSetPackingSubMatrix(const OsiSolverInterface& si);
+ /** */
+ void createFractionalGraph();
+ /** */
+ int createNodeNode();
+ /** */
+ void deleteSetPackingSubMatrix();
+ /** */
+ void deleteFractionalGraph();
+ /** */
+ void find_scl(OsiCuts& cs);
+ /** */
+ void find_rcl(OsiCuts& cs);
+ /** */
+ int scl_choose_next_node(const int current_nodenum,
+ const int *current_indices,
+ const int *current_degrees,
+ const double *current_values);
+ /** */
+ void scl_delete_node(const int del_ind, int& current_nodenum,
+ int *current_indices, int *current_degrees,
+ double *current_values);
+ /** */
+ int enumerate_maximal_cliques(int& pos, bool* scl_label, OsiCuts& cs);
+ /** */
+ int greedy_maximal_clique(OsiCuts& cs);
+ /** */
+ void recordClique(const int len, int* indices, OsiCuts& cs);
+};
+//#############################################################################
+/** A function that tests the methods in the CglClique class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging. */
+void CglCliqueUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir);
+/// This works on a fake solver i.e. invented rows
+class CglProbing;
+class CglFakeClique : public CglClique {
+
+public:
+ /// Copy constructor
+ CglFakeClique(const CglFakeClique& rhs);
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglFakeClique& operator=(const CglFakeClique& rhs);
+
+ virtual void
+ generateCuts(const OsiSolverInterface& si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+
+ /**@name Constructors and destructors */
+ //@{
+ /** Default constructor.
+ If the setPacking argument is set to true then CglFakeClique will assume that the
+ problem in the solverinterface passed to the generateCuts() method
+ describes a set packing problem, i.e.,
+ - all variables are binary
+ - the matrix is a 0-1 matrix
+ - all constraints are '= 1' or '<= 1'
+
+ Otherwise the user can use the considerRows() method to set the list of
+ clique rows, that is,
+ - all coeffs corresponding to binary variables at fractional level is 1
+ - all other coeffs are non-negative
+ - the constraint is '= 1' or '<= 1'.
+
+ If the user does not set the list of clique rows then CglFakeClique will
+ start the generateCuts() methods by scanning the matrix for them.
+ */
+ CglFakeClique(OsiSolverInterface * solver=NULL,bool setPacking = false);
+ /// Destructor
+ virtual ~CglFakeClique();
+ /// Assign solver (generator takes over ownership)
+ void assignSolver(OsiSolverInterface * fakeSolver);
+protected:
+ /// fake solver to use
+ OsiSolverInterface * fakeSolver_;
+ /// Probing object
+ CglProbing * probing_;
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglConfig.h b/thirdparty/windows/include/coin/CglConfig.h
new file mode 100644
index 0000000..9291ebd
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglConfig.h
@@ -0,0 +1,19 @@
+/* src/config_cgl.h. Generated by configure. */
+/* src/config_cgl.h.in. */
+
+#ifndef __CONFIG_CGL_H__
+#define __CONFIG_CGL_H__
+
+/* Version number of project */
+#define CGL_VERSION "0.59.8"
+
+/* Major Version number of project */
+#define CGL_VERSION_MAJOR 0
+
+/* Minor Version number of project */
+#define CGL_VERSION_MINOR 59
+
+/* Release Version number of project */
+#define CGL_VERSION_RELEASE 8
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglCutGenerator.hpp b/thirdparty/windows/include/coin/CglCutGenerator.hpp
new file mode 100644
index 0000000..7629140
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglCutGenerator.hpp
@@ -0,0 +1,121 @@
+// Copyright (C) 2000, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglCutGenerator_H
+#define CglCutGenerator_H
+
+#include "OsiCuts.hpp"
+#include "OsiSolverInterface.hpp"
+#include "CglTreeInfo.hpp"
+
+//-------------------------------------------------------------------
+//
+// Abstract base class for generating cuts.
+//
+//-------------------------------------------------------------------
+///
+/** Cut Generator Base Class
+
+This is an abstract base class for generating cuts. A specific cut
+generator will inherit from this class.
+*/
+class CglCutGenerator {
+
+public:
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate cuts for the model data contained in si.
+ The generated cuts are inserted into and returned in the
+ collection of cuts cs.
+ */
+ virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo())=0;
+ //@}
+
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglCutGenerator ();
+
+ /// Copy constructor
+ CglCutGenerator ( const CglCutGenerator &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const = 0;
+
+ /// Assignment operator
+ CglCutGenerator & operator=(const CglCutGenerator& rhs);
+
+ /// Destructor
+ virtual ~CglCutGenerator ();
+
+ /** Create C++ lines to set the generator in the current state.
+ The output must be parsed by the calling code, as each line
+ starts with a key indicating the following:
+ 0: must be kept (for #includes etc)
+ 3: Set to changed (not default) values
+ 4: Set to default values (redundant)
+
+ Keys 1, 2, 5, 6, 7, 8 are defined, but not applicable to
+ cut generators.
+ */
+ virtual std::string generateCpp( FILE * ) {return "";}
+
+ /// This can be used to refresh any information
+ virtual void refreshSolver(OsiSolverInterface * ) {}
+ //@}
+
+ /**@name Gets and Sets */
+ //@{
+ /**
+ Get Aggressiveness - 0 = neutral, 100 is normal root node.
+ Really just a hint to cut generator
+ */
+ inline int getAggressiveness() const
+ { return aggressive_;}
+
+ /**
+ Set Aggressiveness - 0 = neutral, 100 is normal root node.
+ Really just a hint to cut generator
+ */
+ inline void setAggressiveness(int value)
+ { aggressive_=value;}
+ /// Set whether can do global cuts
+ inline void setGlobalCuts(bool trueOrFalse)
+ { canDoGlobalCuts_ = trueOrFalse;}
+ /// Say whether can do global cuts
+ inline bool canDoGlobalCuts() const
+ {return canDoGlobalCuts_;}
+ /**
+ Returns true if may generate Row cuts in tree (rather than root node).
+ Used so know if matrix will change in tree. Really
+ meant so column cut generators can still be active
+ without worrying code.
+ Default is true
+ */
+ virtual bool mayGenerateRowCutsInTree() const;
+ /// Return true if needs optimal basis to do cuts
+ virtual bool needsOptimalBasis() const;
+ /// Return maximum length of cut in tree
+ virtual int maximumLengthOfCutInTree() const
+ { return COIN_INT_MAX;}
+ //@}
+
+ // test this class
+ //static void unitTest();
+
+// private:
+
+ /**
+ Aggressiveness - 0 = neutral, 100 is normal root node.
+ Really just a hint to cut generator
+ */
+ int aggressive_;
+ /// True if can do global cuts i.e. no general integers
+ bool canDoGlobalCuts_;
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglDuplicateRow.hpp b/thirdparty/windows/include/coin/CglDuplicateRow.hpp
new file mode 100644
index 0000000..b40f969
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglDuplicateRow.hpp
@@ -0,0 +1,189 @@
+// $Id: CglDuplicateRow.hpp 1119 2013-04-06 20:24:18Z stefan $
+// Copyright (C) 2004, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglDuplicateRow_H
+#define CglDuplicateRow_H
+
+#include
+
+#include "CglCutGenerator.hpp"
+class CglStored;
+
+/** DuplicateRow Cut Generator Class */
+class CglDuplicateRow : public CglCutGenerator {
+
+public:
+
+
+ /**@name Generate Cuts */
+ //@{
+ /** Fix variables and find duplicate/dominated rows for the model of the
+ solver interface, si.
+
+ This is a very simple minded idea but I (JJF) am using it in a project so thought
+ I might as well add it. It should really be called before first solve and I may
+ modify CBC to allow for that.
+
+ This is designed for problems with few rows and many integer variables where the rhs
+ are <= or == and all coefficients and rhs are small integers.
+
+ If effective rhs is K then we can fix all variables with coefficients > K to their lower bounds
+ (effective rhs just means original with variables with nonzero lower bounds subtracted out).
+
+ If one row is a subset of another and the effective rhs are same we can fix some variables
+ and then the two rows are identical.
+
+ The generator marks identical rows so can be taken out in solve
+ */
+ virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+private:
+ /// Does work for modes 1,2
+ void generateCuts12( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ /// Does work for mode 4
+ void generateCuts4( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ /// Does work for mode 8
+ void generateCuts8( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+public:
+ /** Fix variables and find duplicate/dominated rows for the model of the
+ solver interface, si.
+
+ This is a very simple minded idea but I (JJF) am using it in a project so thought
+ I might as well add it. It should really be called before first solve and I may
+ modify CBC to allow for that.
+
+ This is designed for problems with few rows and many integer variables where the rhs
+ are <= or == and all coefficients and rhs are small integers.
+
+ If effective rhs is K then we can fix all variables with coefficients > K to their lower bounds
+ (effective rhs just means original with variables with nonzero lower bounds subtracted out).
+
+ If one row is a subset of another and the effective rhs are same we can fix some variables
+ and then the two rows are identical.
+
+ This version does deletions and fixings and may return stored cuts for
+ dominated columns
+ */
+ CglStored * outDuplicates( OsiSolverInterface * solver);
+
+ //@}
+
+ /**@name Get information on size of problem */
+ //@{
+ /// Get duplicate row list, -1 means still in, -2 means out (all fixed), k>= means same as row k
+ inline const int * duplicate() const
+ { return duplicate_;}
+ /// Size of dynamic program
+ inline int sizeDynamic() const
+ { return sizeDynamic_;}
+ /// Number of rows in original problem
+ inline int numberOriginalRows() const
+ { return matrix_.getNumRows();}
+ //@}
+
+ /**@name Get information on size of problem */
+ //@{
+ /// logLevel
+ inline int logLevel() const
+ { return logLevel_;}
+ inline void setLogLevel(int value)
+ { logLevel_ = value;}
+ //@}
+
+
+ /**@name We only check for duplicates amongst rows with effective rhs <= this */
+ //@{
+ /// Get
+ inline int maximumRhs() const
+ { return maximumRhs_;}
+ /// Set
+ inline void setMaximumRhs(int value)
+ { maximumRhs_=value;}
+ //@}
+
+ /**@name We only check for dominated amongst groups of columns whose size <= this */
+ //@{
+ /// Get
+ inline int maximumDominated() const
+ { return maximumDominated_;}
+ /// Set
+ inline void setMaximumDominated(int value)
+ { maximumDominated_=value;}
+ //@}
+ /**@name gets and sets */
+ //@{
+ /// Get mode
+ inline int mode() const
+ { return mode_;}
+ /// Set mode
+ inline void setMode(int value)
+ { mode_=value;}
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglDuplicateRow ();
+
+ /// Useful constructor
+ CglDuplicateRow (OsiSolverInterface * solver);
+
+ /// Copy constructor
+ CglDuplicateRow (
+ const CglDuplicateRow & rhs);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglDuplicateRow &
+ operator=(
+ const CglDuplicateRow& rhs);
+
+ /// Destructor
+ virtual
+ ~CglDuplicateRow ();
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+
+ /// This can be used to refresh any information
+ virtual void refreshSolver(OsiSolverInterface * solver);
+ //@}
+
+protected:
+
+
+ // Protected member data
+
+ /**@name Protected member data */
+ //@{
+ /// Matrix
+ CoinPackedMatrix matrix_;
+ /// Matrix by row
+ CoinPackedMatrix matrixByRow_;
+ /// Possible rhs (if 0 then not possible)
+ int * rhs_;
+ /// Marks duplicate rows
+ int * duplicate_;
+ /// To allow for <= rows
+ int * lower_;
+ /// Stored cuts if we found dominance cuts
+ CglStored * storedCuts_;
+ /// Check dominated columns if less than this number of candidates
+ int maximumDominated_;
+ /// Check duplicates if effective rhs <= this
+ int maximumRhs_;
+ /// Size of dynamic program
+ int sizeDynamic_;
+ /// 1 do rows, 2 do columns, 3 do both
+ int mode_;
+ /// Controls print out
+ int logLevel_;
+ //@}
+};
+#endif
diff --git a/thirdparty/windows/include/coin/CglFlowCover.hpp b/thirdparty/windows/include/coin/CglFlowCover.hpp
new file mode 100644
index 0000000..eea070f
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglFlowCover.hpp
@@ -0,0 +1,371 @@
+// $Id: CglFlowCover.hpp 1119 2013-04-06 20:24:18Z stefan $
+//-----------------------------------------------------------------------------
+// name: Cgl Lifted Simple Generalized Flow Cover Cut Generator
+// author: Yan Xu email: yan.xu@sas.com
+// Jeff Linderoth email: jtl3@lehigh.edu
+// Martin Savelsberg email: martin.savelsbergh@isye.gatech.edu
+// date: 05/01/2003
+// comments: please scan this file for '???' and read the comments
+//-----------------------------------------------------------------------------
+// Copyright (C) 2003, Yan Xu, Jeff Linderoth, Martin Savelsberg and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+
+#ifndef CglFlowCover_H
+#define CglFlowCover_H
+
+#include
+
+#include "CoinError.hpp"
+
+#include "CglCutGenerator.hpp"
+
+//=============================================================================
+
+//=============================================================================
+
+/** This enumerative constant describes the various col types.*/
+enum CglFlowColType {
+ /** The column(variable) is a negative binary variable.*/
+ CGLFLOW_COL_BINNEG = -2,
+ /** The column is a negative continous variable.*/
+ CGLFLOW_COL_CONTNEG,
+ /** The column is a positive continous variable.*/
+ CGLFLOW_COL_CONTPOS = 1,
+ /** The column is a positive binary variable.*/
+ CGLFLOW_COL_BINPOS
+};
+
+enum CglFlowColStatus{
+};
+
+/** This enumerative constant describes the various stati of vars in
+ a cut or not.*/
+enum CglFlowColCut{
+ /** The column is NOT in cover.*/
+ CGLFLOW_COL_OUTCUT = 0,
+ /** The column is in cover now. */
+ CGLFLOW_COL_INCUT,
+ /** The column is decided to be in cover. */
+ CGLFLOW_COL_INCUTDONE,
+ /** The column is in L-. */
+ CGLFLOW_COL_INLMIN,
+ /** The column is decided to be in L-. */
+ CGLFLOW_COL_INLMINDONE,
+ /** The column is in L--.*/
+ CGLFLOW_COL_INLMINMIN,
+ /** This enumerative constant describes the various stati of vars in
+ determining the cover.*/
+ /** The column is a prime candidate. */
+ CGLFLOW_COL_PRIME,
+ /** The column is a secondary candidate. */
+ CGLFLOW_COL_SECONDARY
+};
+
+/** This enumerative constant describes the various row types.*/
+enum CglFlowRowType {
+ /** The row type of this row is NOT defined yet.*/
+ CGLFLOW_ROW_UNDEFINED,
+ /** After the row is flipped to 'L', the row has exactly two variables:
+ one is negative binary and the other is continous, and the RHS
+ is zero.*/
+ CGLFLOW_ROW_VARUB,
+ /** After the row is flipped to 'L', the row has exactlytwo variables:
+ one is positive binary and the other is continous, and the RHS
+ is zero.*/
+ CGLFLOW_ROW_VARLB,
+ /** The row sense is 'E', the row has exactly two variables:
+ one is binary and the other is a continous, and the RHS is zero.*/
+ CGLFLOW_ROW_VAREQ,
+ /** Rows can not be classfied into other types and the row sense
+ is NOT 'E'.*/
+ CGLFLOW_ROW_MIXUB,
+ /** Rows can not be classfied into other types and the row sense is 'E'.*/
+ CGLFLOW_ROW_MIXEQ,
+ /** All variables are NOT binary and the row sense is NOT 'E'. */
+ CGLFLOW_ROW_NOBINUB,
+ /** All variables are NOT binary and the row sense is 'E'. */
+ CGLFLOW_ROW_NOBINEQ,
+ /** The row has one binary and 2 or more other types of variables and
+ the row sense is NOT 'E'. */
+ CGLFLOW_ROW_SUMVARUB,
+ /** The row has one binary and 2 or more other types of variables and
+ the row sense is 'E'. */
+ CGLFLOW_ROW_SUMVAREQ,
+ /** All variables are binary. */
+ CGLFLOW_ROW_UNINTERSTED
+};
+
+//=============================================================================
+
+/** Variable upper bound class. */
+class CglFlowVUB
+{
+protected:
+ int varInd_; /** The index of the associated 0-1 variable.*/
+ double upper_; /** The Value of the associated upper bound.*/
+
+public:
+ CglFlowVUB() : varInd_(-1), upper_(-1) {}
+
+ CglFlowVUB(const CglFlowVUB& source) {
+ varInd_= source.varInd_;
+ upper_ = source.upper_;
+ }
+
+ CglFlowVUB& operator=(const CglFlowVUB& rhs) {
+ if (this == &rhs)
+ return *this;
+ varInd_= rhs.varInd_;
+ upper_ = rhs.upper_;
+ return *this;
+ }
+
+ /**@name Query and set functions for associated 0-1 variable index
+ and value.
+ */
+ //@{
+ inline int getVar() const { return varInd_; }
+ inline double getVal() const { return upper_; }
+ inline void setVar(const int v) { varInd_ = v; }
+ inline void setVal(const double v) { upper_ = v; }
+ //@}
+};
+
+//=============================================================================
+
+/** Variable lower bound class, which is the same as vub. */
+typedef CglFlowVUB CglFlowVLB;
+
+/** Overloaded operator<< for printing VUB and VLB.*/
+std::ostream& operator<<( std::ostream& os, const CglFlowVUB &v );
+
+//=============================================================================
+
+/**
+ * Lifed Simple Generalized Flow Cover Cut Generator Class.
+ */
+class CglFlowCover : public CglCutGenerator {
+ friend void CglFlowCoverUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+public:
+
+ /**
+ * Do the following tasks:
+ *
+ * - classify row types
+ *
- indentify vubs and vlbs
+ *
+ * This function is called by
+ * generateCuts(const OsiSolverInterface & si, OsiCuts & cs).
+ */
+ void flowPreprocess(const OsiSolverInterface& si);
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate Lifed Simple Generalized flow cover cuts for the model data
+ contained in si. The generated cuts are inserted into and returned
+ in the collection of cuts cs.
+ */
+ virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ //@}
+
+ /**@name Functions to query and set maximum number of cuts can be
+ generated. */
+ //@{
+ inline int getMaxNumCuts() const { return maxNumCuts_; }
+ inline void setMaxNumCuts(int mc) { maxNumCuts_ = mc; }
+ //@}
+
+ /**@name Functions to query and set the number of cuts have been
+ generated. */
+ //@{
+ static int getNumFlowCuts() { return numFlowCuts_; }
+ static void setNumFlowCuts(int fc) { numFlowCuts_ = fc; }
+ static void incNumFlowCuts(int fc = 1) { numFlowCuts_ += fc; }
+ //@}
+
+ //-------------------------------------------------------------------------
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglFlowCover ();
+
+ /// Copy constructor
+ CglFlowCover (
+ const CglFlowCover &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglFlowCover &
+ operator=(
+ const CglFlowCover& rhs);
+
+ /// Destructor
+ virtual
+ ~CglFlowCover ();
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+ //@}
+
+private:
+ //-------------------------------------------------------------------------
+ // Private member functions
+
+ /** Based a given row, a LP solution and other model data, this function
+ tries to generate a violated lifted simple generalized flow cover.
+ */
+ bool generateOneFlowCut( const OsiSolverInterface & si,
+ const int rowLen,
+ int* ind,
+ double* coef,
+ char sense,
+ double rhs,
+ OsiRowCut& flowCut,
+ double& violation );
+
+
+ /** Transform a row from ">=" to "<=", and vice versa. */
+ void flipRow(int rowLen, double* coef, double& rhs) const;
+
+ /** Transform a row from ">=" to "<=", and vice versa. Have 'sense'. */
+ void flipRow(int rowLen, double* coef, char& sen, double& rhs) const;
+
+ /** Determine the type of a given row. */
+ CglFlowRowType determineOneRowType(const OsiSolverInterface& si,
+ int rowLen, int* ind,
+ double* coef, char sen,
+ double rhs) const;
+ /** Lift functions */
+ void liftMinus(double &movement, /* Output */
+ int t,
+ int r,
+ double z,
+ double dPrimePrime,
+ double lambda,
+ double ml,
+ double *M,
+ double *rho) const;
+
+ bool liftPlus(double &alpha,
+ double &beta,
+ int r,
+ double m_j,
+ double lambda,
+ double y_j,
+ double x_j,
+ double dPrimePrime,
+ double *M) const;
+
+
+ //-------------------------------------------------------------------------
+ //**@name Query and set the row type of a givne row. */
+ //@{
+ inline const CglFlowRowType* getRowTypes() const
+ { return rowTypes_; }
+ inline CglFlowRowType getRowType(const int i) const
+ { return rowTypes_[i]; }
+ /** Set rowtypes, take over the ownership. */
+ inline void setRowTypes(CglFlowRowType* rt)
+ { rowTypes_ = rt; rt = 0; }
+ inline void setRowTypes(const CglFlowRowType rt, const int i) {
+ if (rowTypes_ != 0)
+ rowTypes_[i] = rt;
+ else {
+ std::cout << "ERROR: Should allocate memory for rowType_ before "
+ << "using it " << std::endl;
+ throw CoinError("Forgot to allocate memory for rowType_",
+ "setRowType", "CglFlowCover");
+ }
+ }
+ //@}
+
+ //-------------------------------------------------------------------------
+ //**@name Query and set vubs. */
+ //@{
+ inline const CglFlowVUB* getVubs() const { return vubs_; }
+ inline const CglFlowVUB& getVubs(int i) const { return vubs_[i]; }
+ /** Set CglFlowVUBs,take over the ownership. */
+ inline void setVubs(CglFlowVUB* vubs) { vubs_ = vubs; vubs = 0; }
+ inline void setVubs(const CglFlowVUB& vub, int i) {
+ if (vubs_ != 0)
+ vubs_[i] = vub;
+ else {
+ std::cout << "ERROR: Should allocate memory for vubs_ before "
+ << "using it " << std::endl;
+ throw CoinError("Forgot to allocate memory for vubs_", "setVubs",
+ "CglFlowCover");
+ }
+ }
+ inline void printVubs(std::ostream& os) const {
+ for (int i = 0; i < numCols_; ++i) {
+ os << "ix: " << i << ", " << vubs_[i];
+ }
+ }
+ //@}
+
+ //-------------------------------------------------------------------------
+ //**@name Query and set vlbs. */
+ //@{
+ inline const CglFlowVLB* getVlbs() const { return vlbs_; }
+ inline const CglFlowVLB& getVlbs(int i) const { return vlbs_[i]; }
+ /** Set CglFlowVLBs,take over the ownership. */
+ inline void setVlbs(CglFlowVLB* vlbs) { vlbs_ = vlbs; vlbs = 0; }
+ inline void setVlbs(const CglFlowVLB& vlb, int i) {
+ if (vlbs_ != 0)
+ vlbs_[i] = vlb;
+ else {
+ std::cout << "ERROR: Should allocate memory for vlbs_ before "
+ << "using it " << std::endl;
+ throw CoinError("Forgot to allocate memory for vlbs_", "setVlbs",
+ "CglFlowCover");
+ }
+ }
+ //@}
+
+private:
+ //------------------------------------------------------------------------
+ // Private member data
+
+ /** The maximum number of flow cuts to be generated. Default is 1000. */
+ int maxNumCuts_;
+ /** Tolerance used for numerical purpose. */
+ double EPSILON_;
+ /** The variable upper bound of a flow is not indentified yet.*/
+ int UNDEFINED_;
+ /** Very large number. */
+ double INFTY_;
+ /** If violation of a cut is greater that this number, the cut is useful.*/
+ double TOLERANCE_;
+ /** First time preprocessing */
+ bool firstProcess_;
+ /** The number rows of the problem.*/
+ int numRows_;
+ /** The number columns of the problem.*/
+ int numCols_;
+ /** The number flow cuts found.*/
+ static int numFlowCuts_;
+ /** Indicate whether initial flow preprecessing has been done. */
+ bool doneInitPre_;
+ /** The array of CglFlowVUBs. */
+ CglFlowVUB* vubs_;
+ /** The array of CglFlowVLBs. */
+ CglFlowVLB* vlbs_;
+ /** CglFlowRowType of the rows in model. */
+ CglFlowRowType* rowTypes_;
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglFlowCover class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging. */
+void CglFlowCoverUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglGMI.hpp b/thirdparty/windows/include/coin/CglGMI.hpp
new file mode 100644
index 0000000..240f6ad
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglGMI.hpp
@@ -0,0 +1,364 @@
+// Last edit: 02/05/2013
+//
+// Name: CglGMI.hpp
+// Author: Giacomo Nannicini
+// Singapore University of Technology and Design, Singapore
+// email: nannicini@sutd.edu.sg
+// Date: 11/17/09
+//-----------------------------------------------------------------------------
+// Copyright (C) 2009, Giacomo Nannicini. All Rights Reserved.
+
+#ifndef CglGMI_H
+#define CglGMI_H
+
+#include "CglCutGenerator.hpp"
+#include "CglGMIParam.hpp"
+#include "CoinWarmStartBasis.hpp"
+#include "CoinFactorization.hpp"
+
+/* Enable tracking of rejection of cutting planes. If this is disabled,
+ the cut generator is slightly faster. If defined, it enables proper use
+ of setTrackRejection and related functions. */
+//#define TRACK_REJECT
+
+/* Debug output */
+//#define GMI_TRACE
+
+/* Debug output: print optimal tableau */
+//#define GMI_TRACETAB
+
+/* Print reason for cut rejection, whenever a cut is discarded */
+//#define GMI_TRACE_CLEAN
+
+/** Gomory cut generator with several cleaning procedures, used to test
+ * the numerical safety of the resulting cuts
+ */
+
+class CglGMI : public CglCutGenerator {
+
+ friend void CglGMIUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir);
+public:
+
+ /** Public enum: all possible reasons for cut rejection */
+ enum RejectionType{
+ failureFractionality,
+ failureDynamism,
+ failureViolation,
+ failureSupport,
+ failureScale
+ };
+
+ /**@name generateCuts */
+ //@{
+ /** Generate Gomory Mixed-Integer cuts for the model of the solver
+ interface si.
+
+ Insert the generated cuts into OsiCuts cs.
+
+ Warning: This generator currently works only with the Lp solvers Clp or
+ Cplex9.0 or higher. It requires access to the optimal tableau and
+ optimal basis inverse and makes assumptions on the way slack variables
+ are added by the solver. The Osi implementations for Clp and Cplex
+ verify these assumptions.
+
+ When calling the generator, the solver interface si must contain
+ an optimized problem and information related to the optimal
+ basis must be available through the OsiSolverInterface methods
+ (si->optimalBasisIsAvailable() must return 'true'). It is also
+ essential that the integrality of structural variable i can be
+ obtained using si->isInteger(i).
+
+ */
+ virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+
+ /// Return true if needs optimal basis to do cuts (will return true)
+ virtual bool needsOptimalBasis() const { return true; }
+ //@}
+
+ /**@name Common Methods */
+ //@{
+ // Function for checking equality with user tolerance
+ inline bool areEqual(double x, double y,
+ double epsAbs = 1e-12,
+ double epsRel = 1e-12) {
+ return (fabs((x) - (y)) <=
+ std::max(epsAbs, epsRel * std::max(fabs(x), fabs(y))));
+ }
+
+ // Function for checking is a number is zero
+ inline bool isZero(double x, double epsZero = 1e-20) {
+ return (fabs(x) <= epsZero);
+ }
+
+
+ // Function for checking if a number is integer
+ inline bool isIntegerValue(double x,
+ double intEpsAbs = 1e-9,
+ double intEpsRel = 1e-15) {
+ return (fabs((x) - floor((x)+0.5)) <=
+ std::max(intEpsAbs, intEpsRel * fabs(x)));
+ }
+
+
+ //@}
+
+
+ /**@name Public Methods */
+ //@{
+
+ // Set the parameters to the values of the given CglGMIParam object.
+ void setParam(const CglGMIParam &source);
+ // Return the CglGMIParam object of the generator.
+ inline CglGMIParam getParam() const {return param;}
+ inline CglGMIParam & getParam() {return param;}
+
+ // Compute entries of is_integer.
+ void computeIsInteger();
+
+ /// Print the current simplex tableau
+ void printOptTab(OsiSolverInterface *solver) const;
+
+ /// Set/get tracking of the rejection of cutting planes.
+ /// Note that all rejection related functions will not do anything
+ /// unless the generator is compiled with the define GMI_TRACK_REJECTION
+ void setTrackRejection(bool value);
+ bool getTrackRejection();
+
+ /// Get number of cuts rejected for given reason; see above
+ int getNumberRejectedCuts(RejectionType reason);
+
+ /// Reset counters for cut rejection tracking; see above
+ void resetRejectionCounters();
+
+ /// Get total number of generated cuts since last resetRejectionCounters()
+ int getNumberGeneratedCuts();
+
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglGMI();
+
+ /// Constructor with specified parameters
+ CglGMI(const CglGMIParam ¶m);
+
+ /// Copy constructor
+ CglGMI(const CglGMI &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglGMI & operator=(const CglGMI& rhs);
+
+ /// Destructor
+ virtual ~CglGMI();
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+
+ //@}
+
+private:
+
+ // Private member methods
+
+/**@name Private member methods */
+
+ //@{
+
+ // Method generating the cuts after all CglGMI members are properly set.
+ void generateCuts(OsiCuts & cs);
+
+ /// Compute the fractional part of value, allowing for small error.
+ inline double aboveInteger(double value) const;
+
+ /// Compute the fractionalities involved in the cut, and the cut rhs.
+ /// Returns true if cut is accepted, false if discarded
+ inline bool computeCutFractionality(double varRhs, double& cutRhs);
+
+ /// Compute the cut coefficient on a given variable
+ inline double computeCutCoefficient(double rowElem, int index);
+
+ /// Use multiples of the initial inequalities to cancel out the coefficient
+ /// on a slack variables.
+ inline void eliminateSlack(double cutElem, int cutIndex, double* cut,
+ double& cutRhs, const double *elements,
+ const int *rowStart, const int *indices,
+ const int *rowLength, const double *rhs);
+
+ /// Change the sign of the coefficients of the non basic
+ /// variables at their upper bound.
+ inline void flip(double& rowElem, int rowIndex);
+
+ /// Change the sign of the coefficients of the non basic
+ /// variables at their upper bound and do the translations restoring
+ /// the original bounds. Modify the right hand side
+ /// accordingly. Two functions: one for original variables, one for slacks.
+ inline void unflipOrig(double& rowElem, int rowIndex, double& rowRhs);
+ inline void unflipSlack(double& rowElem, int rowIndex, double& rowRhs,
+ const double* slack_val);
+
+ /// Pack a row of ncol elements
+ inline void packRow(double* row, double* rowElem, int* rowIndex,
+ int& rowNz);
+
+ /// Clean the cutting plane; the cleaning procedure does several things
+ /// like removing small coefficients, scaling, and checks several
+ /// acceptance criteria. If this returns false, the cut should be discarded.
+ /// There are several cleaning procedures available, that can be selected
+ /// via the parameter param.setCLEANING_PROCEDURE(int value)
+ bool cleanCut(double* cutElem, int* cutIndex, int& cutNz,
+ double& cutRhs, const double* xbar);
+
+ /// Cut cleaning procedures: return true if successfull, false if
+ /// cut should be discarded by the caller of if problems encountered
+
+ /// Check the violation
+ bool checkViolation(const double* cutElem, const int* cutIndex,
+ int cutNz, double cutrhs, const double* xbar);
+
+ /// Check the dynamism
+ bool checkDynamism(const double* cutElem, const int* cutIndex,
+ int cutNz);
+
+ /// Check the support
+ bool checkSupport(int cutNz);
+
+ /// Remove small coefficients and adjust the rhs accordingly
+ bool removeSmallCoefficients(double* cutElem, int* cutIndex,
+ int& cutNz, double& cutRhs);
+
+ /// Adjust the rhs by relaxing by a small amount (relative or absolute)
+ void relaxRhs(double& rhs);
+
+ /// Scale the cutting plane in different ways;
+ /// scaling_type possible values:
+ /// 0 : scale to obtain integral cut
+ /// 1 : scale based on norm, to obtain cut norm equal to ncol
+ /// 2 : scale to obtain largest coefficient equal to 1
+ bool scaleCut(double* cutElem, int* cutIndex, int cutNz,
+ double& cutRhs, int scalingType);
+
+ /// Scale the cutting plane in order to generate integral coefficients
+ bool scaleCutIntegral(double* cutElem, int* cutIndex, int cutNz,
+ double& cutRhs);
+
+ /// Compute the nearest rational number; used by scale_row_integral
+ bool nearestRational(double val, double maxdelta, long maxdnom,
+ long& numerator, long& denominator);
+
+ /// Compute the greatest common divisor
+ long computeGcd(long a, long b);
+
+ /// print a vector of integers
+ void printvecINT(const char *vecstr, const int *x, int n) const;
+ /// print a vector of doubles: dense form
+ void printvecDBL(const char *vecstr, const double *x, int n) const;
+ /// print a vector of doubles: sparse form
+ void printvecDBL(const char *vecstr, const double *elem, const int * index,
+ int nz) const;
+
+ /// Recompute the simplex tableau for want of a better accuracy.
+ /// Requires an empty CoinFactorization object to do the computations,
+ /// and two empty (already allocated) arrays which will contain
+ /// the basis indices on exit. Returns 0 if successfull.
+ int factorize(CoinFactorization & factorization,
+ int* colBasisIndex, int* rowBasisIndex);
+
+
+ //@}
+
+
+ // Private member data
+
+/**@name Private member data */
+
+ //@{
+
+ /// Object with CglGMIParam members.
+ CglGMIParam param;
+
+ /// Number of rows ( = number of slack variables) in the current LP.
+ int nrow;
+
+ /// Number of structural variables in the current LP.
+ int ncol;
+
+ /// Lower bounds for structural variables
+ const double *colLower;
+
+ /// Upper bounds for structural variables
+ const double *colUpper;
+
+ /// Lower bounds for constraints
+ const double *rowLower;
+
+ /// Upper bounds for constraints
+ const double *rowUpper;
+
+ /// Righ hand side for constraints (upper bound for ranged constraints).
+ const double *rowRhs;
+
+ /// Characteristic vectors of structural integer variables or continuous
+ /// variables currently fixed to integer values.
+ bool *isInteger;
+
+ /// Current basis status: columns
+ int *cstat;
+
+ /// Current basis status: rows
+ int *rstat;
+
+ /// Pointer on solver. Reset by each call to generateCuts().
+ OsiSolverInterface *solver;
+
+ /// Pointer on point to separate. Reset by each call to generateCuts().
+ const double *xlp;
+
+ /// Pointer on row activity. Reset by each call to generateCuts().
+ const double *rowActivity;
+
+ /// Pointer on matrix of coefficient ordered by rows.
+ /// Reset by each call to generateCuts().
+ const CoinPackedMatrix *byRow;
+
+ /// Pointer on matrix of coefficient ordered by columns.
+ /// Reset by each call to generateCuts().
+ const CoinPackedMatrix *byCol;
+
+ /// Fractionality of the cut and related quantities.
+ double f0;
+ double f0compl;
+ double ratiof0compl;
+
+#if defined(TRACK_REJECT) || defined (TRACK_REJECT_SIMPLE)
+ /// Should we track the reason of each cut rejection?
+ bool trackRejection;
+ /// Number of failures by type
+ int fracFail;
+ int dynFail;
+ int violFail;
+ int suppFail;
+ int smallCoeffFail;
+ int scaleFail;
+ /// Total number of generated cuts
+ int numGeneratedCuts;
+#endif
+
+ //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglGMI class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging. */
+void CglGMIUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglGMIParam.hpp b/thirdparty/windows/include/coin/CglGMIParam.hpp
new file mode 100644
index 0000000..a1aae41
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglGMIParam.hpp
@@ -0,0 +1,313 @@
+// Name: CglGMIParam.hpp
+// Author: Giacomo Nannicini
+// Singapore University of Technology and Design
+// email: nannicini@sutd.edu.sg
+// based on CglRedSplitParam.hpp by Francois Margot
+// Date: 11/17/09
+//-----------------------------------------------------------------------------
+// Copyright (C) 2009, Giacomo Nannicini and others. All Rights Reserved.
+
+#ifndef CglGMIParam_H
+#define CglGMIParam_H
+
+#include "CglParam.hpp"
+
+
+ /**@name CglGMI Parameters */
+ //@{
+
+ /** Class collecting parameters for the GMI cut generator.
+
+ Parameters of the generator are listed below. Modifying the default
+ values for parameters other than the last four might result in
+ invalid cuts.
+
+ - MAXDYN: Maximum ratio between largest and smallest non zero
+ coefficients in a cut. See method setMAXDYN().
+ - EPS_ELIM: Precision for deciding if a coefficient is zero when
+ eliminating slack variables. See method setEPS_ELIM().
+ - MINVIOL: Minimum violation for the current basic solution in
+ a generated cut. See method setMINVIOL().
+ - USE_INTSLACKS: Use integer slacks to generate cuts.
+ (not implemented yet, will be in the future).
+ See method setUSE_INTSLACKS().
+ - AWAY: Look only at basic integer variables whose current value is at
+ least this value away from being integer. See method setAway().
+ - CHECK_DUPLICATES: Should we check for duplicates when adding a cut
+ to the collection? Can be slow.
+ Default 0 - do not check, add cuts anyway.
+ - CLEAN_PROC: Cleaning procedure that should be used. Look below at the
+ enumeration CleaningProcedure for possible values.
+ - INTEGRAL_SCALE_CONT: If we try to scale cut coefficients so that
+ they become integral, do we also scale on
+ continuous variables?
+ Default 0 - do not scale continuous vars.
+ Used only if CLEAN_PROC does integral scaling.
+ - ENFORCE_SCALING: Discard badly scaled cuts, or keep them (unscaled).
+ Default 1 - yes.
+
+ */
+ //@}
+
+class CglGMIParam : public CglParam {
+
+public:
+
+ /**@name Enumerations */
+ enum CleaningProcedure{
+ /* CglLandP procedure I */
+ CP_CGLLANDP1,
+ /* CglLandP procedure II */
+ CP_CGLLANDP2,
+ /* CglRedSplit procedure I */
+ CP_CGLREDSPLIT,
+ /* Only integral cuts, i.e. cuts with integral coefficients */
+ CP_INTEGRAL_CUTS,
+ /* CglLandP procedure I with integral scaling */
+ CP_CGLLANDP1_INT,
+ /* CglLandP procedure I with scaling of the max element to 1 if possible */
+ CP_CGLLANDP1_SCALEMAX,
+ /* CglLandP procedure I with scaling of the rhs to 1 if possible */
+ CP_CGLLANDP1_SCALERHS
+ };
+
+ /**@name Set/get methods */
+
+ //@{
+ /** Aliases for parameter get/set method in the base class CglParam */
+
+ /** Value for Infinity. Default: DBL_MAX */
+ inline void setInfinity(double value) {setINFINIT(value);}
+ inline double getInfinity() const {return INFINIT;}
+
+ /** Epsilon for comparing numbers. Default: 1.0e-6 */
+ inline void setEps(double value) {setEPS(value);}
+ inline double getEps() const {return EPS;}
+
+ /** Epsilon for zeroing out coefficients. Default: 1.0e-5 */
+ inline void setEpsCoeff(double value) {setEPS_COEFF(value);}
+ inline double getEpsCoeff() const {return EPS_COEFF;}
+
+ /** Maximum support of the cutting planes. Default: INT_MAX */
+ inline void setMaxSupport(int value) {setMAX_SUPPORT(value);}
+ inline int getMaxSupport() const {return MAX_SUPPORT;}
+ /** Alias for consistency with our naming scheme */
+ inline void setMaxSupportAbs(int value) {setMAX_SUPPORT(value);}
+ inline int getMaxSupportAbs() const {return MAX_SUPPORT;}
+ inline int getMAX_SUPPORT_ABS() const {return MAX_SUPPORT;}
+
+ /** Set AWAY, the minimum distance from being integer used for selecting
+ rows for cut generation; all rows whose pivot variable should be
+ integer but is more than away from integrality will be selected;
+ Default: 0.005 */
+ virtual void setAway(double value);
+ /** Get value of away */
+ inline double getAway() const {return AWAY;}
+ /// Aliases
+ inline void setAWAY(double value) {setAway(value);}
+ inline double getAWAY() const {return AWAY;}
+
+ /** Set the value of EPS_ELIM, epsilon for values of coefficients when
+ eliminating slack variables;
+ Default: 0 */
+ virtual void setEPS_ELIM(double value);
+ /** Get the value of EPS_ELIM */
+ inline double getEPS_ELIM() const {return EPS_ELIM;}
+ /// Aliases
+ inline void setEpsElim(double value) {setEPS_ELIM(value);}
+ inline double getEpsElim() const {return EPS_ELIM;}
+
+ /** Set EPS_RELAX_ABS */
+ virtual void setEPS_RELAX_ABS(double value);
+ /** Get value of EPS_RELAX_ABS */
+ inline double getEPS_RELAX_ABS() const {return EPS_RELAX_ABS;}
+ /// Aliases
+ inline void setEpsRelaxAbs(double value) {setEPS_RELAX_ABS(value);}
+ inline double getEpsRelaxAbs() const {return EPS_RELAX_ABS;}
+
+ /** Set EPS_RELAX_REL */
+ virtual void setEPS_RELAX_REL(double value);
+ /** Get value of EPS_RELAX_REL */
+ inline double getEPS_RELAX_REL() const {return EPS_RELAX_REL;}
+ /// Aliases
+ inline void setEpsRelaxRel(double value) {setEPS_RELAX_REL(value);}
+ inline double getEpsRelaxRel() const {return EPS_RELAX_REL;}
+
+ // Set the maximum ratio between largest and smallest non zero
+ // coefficients in a cut. Default: 1e6.
+ virtual void setMAXDYN(double value);
+ /** Get the value of MAXDYN */
+ inline double getMAXDYN() const {return MAXDYN;}
+ /// Aliases
+ inline void setMaxDyn(double value) {setMAXDYN(value);}
+ inline double getMaxDyn() const {return MAXDYN;}
+
+ /** Set the value of MINVIOL, the minimum violation for the current
+ basic solution in a generated cut. Default: 1e-7 */
+ virtual void setMINVIOL(double value);
+ /** Get the value of MINVIOL */
+ inline double getMINVIOL() const {return MINVIOL;}
+ /// Aliases
+ inline void setMinViol(double value) {setMINVIOL(value);}
+ inline double getMinViol() const {return MINVIOL;}
+
+ /** Set the value of MAX_SUPPORT_REL, the factor contributing to the
+ maximum support relative to the number of columns. Maximum
+ allowed support is: MAX_SUPPORT_ABS +
+ MAX_SUPPORT_REL*ncols. Default: 0.1 */
+ virtual void setMAX_SUPPORT_REL(double value);
+ /** Get the value of MINVIOL */
+ inline double getMAX_SUPPORT_REL() const {return MAX_SUPPORT_REL;}
+ /// Aliases
+ inline void setMaxSupportRel(double value) {setMAX_SUPPORT_REL(value);}
+ inline double getMaxSupportRel() const {return MAX_SUPPORT_REL;}
+
+ /** Set the value of USE_INTSLACKS. Default: 0 */
+ virtual void setUSE_INTSLACKS(bool value);
+ /** Get the value of USE_INTSLACKS */
+ inline bool getUSE_INTSLACKS() const {return USE_INTSLACKS;}
+ /// Aliases
+ inline void setUseIntSlacks(bool value) {setUSE_INTSLACKS(value);}
+ inline int getUseIntSlacks() const {return USE_INTSLACKS;}
+
+ /** Set the value of CHECK_DUPLICATES. Default: 0 */
+ virtual void setCHECK_DUPLICATES(bool value);
+ /** Get the value of CHECK_DUPLICATES */
+ inline bool getCHECK_DUPLICATES() const {return CHECK_DUPLICATES;}
+ /// Aliases
+ inline void setCheckDuplicates(bool value) {setCHECK_DUPLICATES(value);}
+ inline bool getCheckDuplicates() const {return CHECK_DUPLICATES;}
+
+ /** Set the value of CLEAN_PROC. Default: CP_CGLLANDP1 */
+ virtual void setCLEAN_PROC(CleaningProcedure value);
+ /** Get the value of CLEAN_PROC. */
+ inline CleaningProcedure getCLEAN_PROC() const {return CLEAN_PROC;}
+ /// Aliases
+ inline void setCleanProc(CleaningProcedure value) {setCLEAN_PROC(value);}
+ inline CleaningProcedure getCleaningProcedure() const {return CLEAN_PROC;}
+
+ /** Set the value of INTEGRAL_SCALE_CONT. Default: 0 */
+ virtual void setINTEGRAL_SCALE_CONT(bool value);
+ /** Get the value of INTEGRAL_SCALE_CONT. */
+ inline bool getINTEGRAL_SCALE_CONT() const {return INTEGRAL_SCALE_CONT;}
+ /// Aliases
+ inline void setIntegralScaleCont(bool value) {setINTEGRAL_SCALE_CONT(value);}
+ inline bool getIntegralScaleCont() const {return INTEGRAL_SCALE_CONT;}
+
+ /** Set the value of ENFORCE_SCALING. Default: 1 */
+ virtual void setENFORCE_SCALING(bool value);
+ /** Get the value of ENFORCE_SCALING. */
+ inline bool getENFORCE_SCALING() const {return ENFORCE_SCALING;}
+ /// Aliases
+ inline void setEnforceScaling(bool value) {setENFORCE_SCALING(value);}
+ inline bool getEnforcescaling() const {return ENFORCE_SCALING;}
+
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglGMIParam(double eps = 1e-12,
+ double away = 0.005,
+ double eps_coeff = 1e-11,
+ double eps_elim = 0,
+ double eps_relax_abs = 1e-11,
+ double eps_relax_rel = 1e-13,
+ double max_dyn = 1e6,
+ double min_viol = 1e-4,
+ int max_supp_abs = 1000,
+ double max_supp_rel = 0.1,
+ CleaningProcedure clean_proc = CP_CGLLANDP1,
+ bool use_int_slacks = false,
+ bool check_duplicates = false,
+ bool integral_scale_cont = false,
+ bool enforce_scaling = true);
+
+ /// Constructor from CglParam
+ CglGMIParam(CglParam &source,
+ double away = 0.005,
+ double eps_elim = 1e-12,
+ double eps_relax_abs = 1e-11,
+ double eps_relax_rel = 1e-13,
+ double max_dyn = 1e6,
+ double min_viol = 1e-4,
+ double max_supp_rel = 0.1,
+ CleaningProcedure clean_proc = CP_CGLLANDP1,
+ bool use_int_slacks = false,
+ bool check_duplicates = false,
+ bool integral_scale_cont = false,
+ bool enforce_scaling = true);
+
+ /// Copy constructor
+ CglGMIParam(const CglGMIParam &source);
+
+ /// Clone
+ virtual CglGMIParam* clone() const;
+
+ /// Assignment operator
+ virtual CglGMIParam& operator=(const CglGMIParam &rhs);
+
+ /// Destructor
+ virtual ~CglGMIParam();
+ //@}
+
+protected:
+
+ /**@name Parameters */
+ //@{
+
+ /** Use row only if pivot variable should be integer but is more
+ than AWAY from being integer. */
+ double AWAY;
+
+ /** Epsilon for value of coefficients when eliminating slack variables.
+ Default: 0. */
+ double EPS_ELIM;
+
+ /** Value added to the right hand side of each generated cut to relax it.
+ Default: 1e-11 */
+ double EPS_RELAX_ABS;
+
+ /** For a generated cut with right hand side rhs_val,
+ EPS_RELAX_EPS * fabs(rhs_val) is used to relax the constraint.
+ Default: 1.e-13 */
+ double EPS_RELAX_REL;
+
+ /** Maximum ratio between largest and smallest non zero
+ coefficients in a cut. Default: 1e6. */
+ double MAXDYN;
+
+ /** Minimum violation for the current basic solution in a generated cut.
+ Default: 1e-4. */
+ double MINVIOL;
+
+ /** Maximum support relative to number of columns. Must be between 0
+ and 1. Default: 0. */
+ double MAX_SUPPORT_REL;
+
+ /** Which cleaning procedure should be used? */
+ CleaningProcedure CLEAN_PROC;
+
+ /** Use integer slacks to generate cuts if USE_INTSLACKS = 1. Default: 0. */
+ bool USE_INTSLACKS;
+
+ /** Check for duplicates when adding the cut to the collection? */
+ bool CHECK_DUPLICATES;
+
+ /** Should we try to rescale cut coefficients on continuous variables
+ so that they become integral, or do we only rescale coefficients
+ on integral variables? Used only by cleaning procedure that try
+ the integral scaling. */
+ bool INTEGRAL_SCALE_CONT;
+
+ /** Should we discard badly scaled cuts (according to the scaling
+ procedure in use)? If false, CglGMI::scaleCut always returns
+ true, even though it still scales cuts whenever possible, but
+ not cut is rejected for scaling. Default true. Used only by
+ cleaning procedure that try to scale. */
+ bool ENFORCE_SCALING;
+
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglGomory.hpp b/thirdparty/windows/include/coin/CglGomory.hpp
new file mode 100644
index 0000000..2d7f5c5
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglGomory.hpp
@@ -0,0 +1,204 @@
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglGomory_H
+#define CglGomory_H
+
+#include
+
+#include "CglCutGenerator.hpp"
+
+class CoinWarmStartBasis;
+/** Gomory Cut Generator Class */
+class CglGomory : public CglCutGenerator {
+ friend void CglGomoryUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+public:
+
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate Mixed Integer Gomory cuts for the model of the
+ solver interface, si.
+
+ Insert the generated cuts into OsiCut, cs.
+
+ There is a limit option, which will only generate cuts with
+ less than this number of entries.
+
+ We can also only look at 0-1 variables a certain distance
+ from integer.
+ */
+ virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ /** Generates cuts given matrix and solution etc,
+ returns number of cuts generated */
+ int generateCuts( const OsiRowCutDebugger * debugger,
+ OsiCuts & cs,
+ const CoinPackedMatrix & columnCopy,
+ const CoinPackedMatrix & rowCopy,
+ const double * colsol,
+ const double * colLower, const double * colUpper,
+ const double * rowLower, const double * rowUpper,
+ const char * intVar ,
+ const CoinWarmStartBasis* warm,
+ const CglTreeInfo info = CglTreeInfo());
+ /** Generates cuts given matrix and solution etc,
+ returns number of cuts generated (no row copy passed in) */
+ int generateCuts( const OsiRowCutDebugger * debugger,
+ OsiCuts & cs,
+ const CoinPackedMatrix & columnCopy,
+ const double * colsol,
+ const double * colLower, const double * colUpper,
+ const double * rowLower, const double * rowUpper,
+ const char * intVar ,
+ const CoinWarmStartBasis* warm,
+ const CglTreeInfo info = CglTreeInfo());
+
+ /// Return true if needs optimal basis to do cuts (will return true)
+ virtual bool needsOptimalBasis() const { return true; }
+ //@}
+
+ /**@name Change way Gomory works */
+ //@{
+ /// Pass in a copy of original solver (clone it)
+ void passInOriginalSolver(OsiSolverInterface * solver);
+ /// Returns original solver
+ inline OsiSolverInterface * originalSolver() const
+ { return originalSolver_;}
+ /// Set type - 0 normal, 1 add original matrix one, 2 replace
+ inline void setGomoryType(int type)
+ { gomoryType_=type;}
+ /// Return type
+ inline int gomoryType() const
+ { return gomoryType_;}
+ //@}
+
+ /**@name Change limit on how many variables in cut (default 50) */
+ //@{
+ /// Set
+ void setLimit(int limit);
+ /// Get
+ int getLimit() const;
+ /// Set at root (if
+
+#include "CglCutGenerator.hpp"
+#include "CglTreeInfo.hpp"
+
+/** Knapsack Cover Cut Generator Class */
+class CglKnapsackCover : public CglCutGenerator {
+ friend void CglKnapsackCoverUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+public:
+ /** A method to set which rows should be tested for knapsack covers */
+ void setTestedRowIndices(int num, const int* ind);
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate knapsack cover cuts for the model of the solver interface, si.
+ Insert the generated cuts into OsiCut, cs.
+ */
+ virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglKnapsackCover ();
+
+ /// Copy constructor
+ CglKnapsackCover (
+ const CglKnapsackCover &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglKnapsackCover &
+ operator=(
+ const CglKnapsackCover& rhs);
+
+ /// Destructor
+ virtual
+ ~CglKnapsackCover ();
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+ /// This can be used to refresh any information
+ virtual void refreshSolver(OsiSolverInterface * solver);
+ //@}
+
+
+ /**@name Sets and gets */
+ //@{
+ /// Set limit on number in knapsack
+ inline void setMaxInKnapsack(int value)
+ { if (value>0) maxInKnapsack_ = value;}
+ /// get limit on number in knapsack
+ inline int getMaxInKnapsack() const
+ {return maxInKnapsack_;}
+ /// Switch off expensive cuts
+ inline void switchOffExpensive()
+ { expensiveCuts_=false;}
+ /// Switch on expensive cuts
+ inline void switchOnExpensive()
+ { expensiveCuts_=true;}
+private:
+
+ // Private member methods
+
+
+ /**@name Private methods */
+ //@{
+
+ /** deriveAKnapsack
+ returns 1 if it is able to derive
+ a (canonical) knapsack inequality
+ in binary variables of the form ax<=b
+ from the rowIndex-th row in the model,
+ returns 0 otherwise.
+ */
+ int deriveAKnapsack(
+ const OsiSolverInterface & si,
+ OsiCuts & cs,
+ CoinPackedVector & krow,
+ bool treatAsLRow,
+ double & b,
+ int * complement,
+ double * xstar,
+ int rowIndex,
+ int numberElements,
+ const int * index,
+ const double * element);
+
+ int deriveAKnapsack(
+ const OsiSolverInterface & si,
+ OsiCuts & cs,
+ CoinPackedVector & krow,
+ double & b,
+ int * complement,
+ double * xstar,
+ int rowIndex,
+ const CoinPackedVectorBase & matrixRow);
+
+ /** Find a violated minimal cover from
+ a canonical form knapsack inequality by
+ solving the -most- violated cover problem
+ and postprocess to ensure minimality
+ */
+ int findExactMostViolatedMinCover(
+ int nCols,
+ int row,
+ CoinPackedVector & krow,
+ double b,
+ double * xstar,
+ CoinPackedVector & cover,
+ CoinPackedVector & remainder);
+
+ /** Find the most violate minimum cover by solving the lp-relaxation of the
+ most-violate-min-cover problem
+ */
+ int findLPMostViolatedMinCover(
+ int nCols,
+ int row,
+ CoinPackedVector & krow,
+ double & b,
+ double * xstar,
+ CoinPackedVector & cover,
+ CoinPackedVector & remainder);
+
+/// find a minimum cover by a simple greedy approach
+ int findGreedyCover(
+ int row,
+ CoinPackedVector & krow,
+ double & b,
+ double * xstar,
+ CoinPackedVector & cover,
+ CoinPackedVector & remainder
+ );
+
+ /// lift the cover inequality
+ int liftCoverCut(
+ double & b,
+ int nRowElem,
+ CoinPackedVector & cover,
+ CoinPackedVector & remainder,
+ CoinPackedVector & cut );
+
+ /// sequence-independent lift and uncomplement and add the resulting cut to the cut set
+ int liftAndUncomplementAndAdd(
+ double rowub,
+ CoinPackedVector & krow,
+ double & b,
+ int * complement,
+ int row,
+ CoinPackedVector & cover,
+ CoinPackedVector & remainder,
+ OsiCuts & cs );
+
+ /// sequence-dependent lift, uncomplement and add the resulting cut to the cut set
+void seqLiftAndUncomplementAndAdd(
+ int nCols,
+ double * xstar,
+ int * complement,
+ int row,
+ int nRowElem,
+ double & b,
+ CoinPackedVector & cover, // need not be violated
+ CoinPackedVector & remainder,
+ OsiCuts & cs );
+
+ /// sequence-dependent lift binary variables either up or down, uncomplement and add to the cut set
+void liftUpDownAndUncomplementAndAdd(
+ int nCols,
+ double * xstar,
+ int * complement,
+ int row,
+ int nRowElem,
+ double & b,
+
+ // the following 3 packed vectors partition the krow:
+ CoinPackedVector & fracCover, // vars have frac soln values in lp relaxation
+ // and form cover with the vars atOne
+ CoinPackedVector & atOne, // vars have soln value of 1 in lp relaxation
+ // and together with fracCover form minimal (?) cover.
+ CoinPackedVector & remainder,
+ OsiCuts & cs );
+
+ /// find a cover using a variation of the logic found in OSL (w/o SOS)
+ int findPseudoJohnAndEllisCover (
+ int row,
+ CoinPackedVector & krow,
+ double & b,
+ double * xstar,
+ CoinPackedVector & cover,
+ CoinPackedVector & remainder);
+
+ /// find a cover using the basic logic found in OSL (w/o SOS)
+ int findJohnAndEllisCover (
+ int row,
+ CoinPackedVector & krow,
+ double & b,
+ double * xstar,
+ CoinPackedVector & fracCover,
+ CoinPackedVector & atOnes,
+ CoinPackedVector & remainder);
+
+
+ /** A C-style implementation of the Horowitz-Sahni exact solution
+ procedure for solving knapsack problem.
+
+ (ToDo: implement the more efficient dynamic programming approach)
+
+ (Reference: Martello and Toth, Knapsack Problems, Wiley, 1990, p30.)
+ */
+ int exactSolveKnapsack(
+ int n,
+ double c,
+ double const *pp,
+ double const *ww,
+ double & z,
+ int * x);
+ /// For testing gub stuff
+ int gubifyCut(CoinPackedVector & cut);
+public:
+ /** Creates cliques for use by probing.
+ Only cliques >= minimumSize and < maximumSize created
+ Can also try and extend cliques as a result of probing (root node).
+ Returns number of cliques found.
+ */
+ int createCliques( OsiSolverInterface & si,
+ int minimumSize=2, int maximumSize=100, bool extendCliques=false);
+private:
+ /// Delete all clique information
+ void deleteCliques();
+ //@}
+
+ // Private member data
+
+ /**@name Private member data */
+ //@{
+ /// epsilon
+ double epsilon_;
+ /// Tolerance to use for violation - bigger than epsilon_
+ double epsilon2_;
+ /// 1-epsilon
+ double onetol_;
+ /// Maximum in knapsack
+ int maxInKnapsack_;
+ /** which rows to look at. If specified, only these rows will be considered
+ for generating knapsack covers. Otherwise all rows will be tried */
+ int numRowsToCheck_;
+ int* rowsToCheck_;
+ /// exactKnapsack can be expensive - this switches off some
+ bool expensiveCuts_;
+ /// Cliques
+ /// **** TEMP so can reference from listing
+ const OsiSolverInterface * solver_;
+ int whichRow_;
+ int * complement_;
+ double * elements_;
+ /// Number of cliques
+ int numberCliques_;
+ /// Clique type
+ typedef struct {
+ unsigned int equality:1; // nonzero if clique is ==
+ } CliqueType;
+ CliqueType * cliqueType_;
+ /// Start of each clique
+ int * cliqueStart_;
+ /// Entries for clique
+ CliqueEntry * cliqueEntry_;
+ /** Start of oneFixes cliques for a column in matrix or -1 if not
+ in any clique */
+ int * oneFixStart_;
+ /** Start of zeroFixes cliques for a column in matrix or -1 if not
+ in any clique */
+ int * zeroFixStart_;
+ /// End of fixes for a column
+ int * endFixStart_;
+ /// Clique numbers for one or zero fixes
+ int * whichClique_;
+ /// Number of columns
+ int numberColumns_;
+ /** For each column with nonzero in row copy this gives a clique "number".
+ So first clique mentioned in row is always 0. If no entries for row
+ then no cliques. If sequence > numberColumns then not in clique.
+ */
+ //CliqueEntry * cliqueRow_;
+ /// cliqueRow_ starts for each row
+ //int * cliqueRowStart_;
+ //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglKnapsackCover class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging. */
+void CglKnapsackCoverUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglLandP.hpp b/thirdparty/windows/include/coin/CglLandP.hpp
new file mode 100644
index 0000000..64447e7
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglLandP.hpp
@@ -0,0 +1,306 @@
+// Copyright (C) 2005-2009, Pierre Bonami and others. All Rights Reserved.
+// Author: Pierre Bonami
+// Tepper School of Business
+// Carnegie Mellon University, Pittsburgh, PA 15213
+// Date: 07/21/05
+//
+// $Id: CglLandP.hpp 1122 2013-04-06 20:39:53Z stefan $
+//
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+//---------------------------------------------------------------------------
+#ifndef CglLandP_H
+#define CglLandP_H
+
+#include "CglLandPValidator.hpp"
+#include "CglCutGenerator.hpp"
+#include "CglParam.hpp"
+
+#include
+class CoinWarmStartBasis;
+/** Performs one round of Lift & Project using CglLandPSimplex
+ to build cuts
+*/
+
+namespace LAP
+{
+enum LapMessagesTypes
+{
+ BEGIN_ROUND,
+ END_ROUND,
+ DURING_SEP,
+ CUT_REJECTED,
+ CUT_FAILED,
+ CUT_GAP,
+ LAP_CUT_FAILED_DO_MIG,
+ LAP_MESSAGES_DUMMY_END
+};
+/** Output messages for Cgl */
+class LapMessages : public CoinMessages
+{
+public:
+ /** Constructor */
+ LapMessages( );
+ /** destructor.*/
+ virtual ~LapMessages() {}
+};
+class CglLandPSimplex;
+}
+
+class CglLandP : public CglCutGenerator
+{
+ friend void CglLandPUnitTest(OsiSolverInterface *si, const std::string & mpsDir);
+
+ friend class LAP::CglLandPSimplex;
+ friend class CftCglp;
+
+public:
+
+ enum SelectionRules
+ {
+ mostNegativeRc /** select most negative reduced cost */,
+ bestPivot /** select best possible pivot.*/,
+ initialReducedCosts/** Select only those rows which had initialy a 0 reduced cost.*/
+ };
+
+ enum ExtraCutsMode
+ {
+ none/** Generate no extra cuts.*/,
+ AtOptimalBasis /** Generate cuts from the optimal basis.*/,
+ WhenEnteringBasis /** Generate cuts as soon as a structural enters the basis.*/,
+ AllViolatedMigs/** Generate all violated Mixed integer Gomory cuts in the course of the optimization.*/
+ };
+
+ /** Space where cuts are optimized.*/
+ enum SeparationSpaces
+ {
+ Fractional=0 /** True fractional space.*/,
+ Fractional_rc/** Use fractional space only for computing reduced costs.*/,
+ Full /** Work in full space.*/
+ };
+
+ /** Normalization */
+ enum Normalization
+ {
+ Unweighted = 0,
+ WeightRHS,
+ WeightLHS,
+ WeightBoth
+ };
+
+ enum LHSnorm
+ {
+ L1 = 0,
+ L2,
+ SupportSize,
+ Infinity,
+ Average,
+ Uniform
+ };
+ /** RHS weight in normalization.*/
+ enum RhsWeightType
+ {
+ Fixed = 0 /** 2*initial number of constraints. */,
+ Dynamic /** 2 * current number of constraints. */
+ };
+ /** Class storing parameters.
+ \remark I take all parameters from Ionut's code */
+ class Parameters : public CglParam
+ {
+ public:
+ /** Default constructor (with default values)*/
+ Parameters();
+ /** Copy constructor */
+ Parameters(const Parameters &other);
+ /** Assignment opertator */
+ Parameters & operator=(const Parameters &other);
+ /// @name integer parameters
+ ///@{
+
+ /** Max number of pivots before we generate the cut
+ \default 20 */
+ int pivotLimit;
+ /** Max number of pivots at regular nodes. Put a value if you want it lower than the global pivot limit.
+ \default 100.*/
+ int pivotLimitInTree;
+ /** Maximum number of cuts generated at a given round*/
+ int maxCutPerRound;
+ /** Maximum number of failed pivots before aborting */
+ int failedPivotLimit;
+ /** maximum number of consecutive degenerate pivots
+ \default 0 */
+ int degeneratePivotLimit;
+ /** Maximum number of extra rows to generate per round.*/
+ int extraCutsLimit;
+ ///@}
+ /// @name double parameters
+ ///@{
+ /** Tolerance for small pivots values (should be the same as the solver */
+ double pivotTol;
+ /** A variable have to be at least away from integrity to be generated */
+ double away;
+ /** Total time limit for cut generation.*/
+ double timeLimit;
+ /** Time limit for generating a single cut.*/
+ double singleCutTimeLimit;
+ /** Weight to put in RHS of normalization if static.*/
+ double rhsWeight;
+ ///@}
+
+ /// @name Flags
+ ///@{
+ /** Do we use tableau row or the disjunction (I don't really get that there should be a way to always use the tableau)*/
+ bool useTableauRow;
+ /** Do we apply Egon Balas's Heuristic for modularized cuts */
+ bool modularize;
+ /** Do we strengthen the final cut (always do if modularize is 1) */
+ bool strengthen;
+ /** Wether to limit or not the number of mistaken RC (when perturbation is applied).*/
+ bool countMistakenRc;
+ /** Work in the reduced space (only non-structurals enter the basis) */
+ SeparationSpaces sepSpace;
+ /** Apply perturbation procedure. */
+ bool perturb;
+ /** How to weight normalization.*/
+ Normalization normalization;
+ /** How to weight RHS of normalization.*/
+ RhsWeightType rhsWeightType;
+ /** How to weight LHS of normalization.*/
+ LHSnorm lhs_norm;
+ /** Generate extra constraints from optimal lift-and-project basis.*/
+ ExtraCutsMode generateExtraCuts;
+ /** Which rule to apply for choosing entering and leaving variables.*/
+ SelectionRules pivotSelection;
+ ///@}
+ };
+
+
+ /** Constructor for the class*/
+ CglLandP(const CglLandP::Parameters ¶ms = CglLandP::Parameters(),
+ const LAP::Validator &validator = LAP::Validator());
+ /** Destructor */
+ ~CglLandP();
+ /** Copy constructor */
+ CglLandP(const CglLandP &source);
+ /** Assignment operator */
+ CglLandP& operator=(const CglLandP &rhs);
+ /** Clone function */
+ CglCutGenerator * clone() const;
+
+ /**@name Generate Cuts */
+ //@{
+
+ virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+
+ //@}
+
+ virtual bool needsOptimalBasis() const
+ {
+ return true;
+ }
+
+ LAP::Validator & validator()
+ {
+ return validator_;
+ }
+ /** set level of log for cut generation procedure :
+
+ - for none
+ - for log at begin and end of procedure + at some time interval
+ - for log at every cut generated
+
+ */
+ void setLogLevel(int level)
+ {
+ handler_->setLogLevel(level);
+ }
+
+ class NoBasisError : public CoinError
+ {
+ public:
+ NoBasisError(): CoinError("No basis available","LandP","") {}
+ };
+
+ class SimplexInterfaceError : public CoinError
+ {
+ public:
+ SimplexInterfaceError(): CoinError("Invalid conversion to simplex interface", "CglLandP","CglLandP") {}
+ };
+ Parameters & parameter()
+ {
+ return params_;
+ }
+private:
+
+
+ void scanExtraCuts(OsiCuts& cs, const double * colsol) const;
+
+ Parameters params_;
+
+ /** Some informations that will be changed by the pivots and that we want to keep*/
+ struct CachedData
+ {
+ CachedData(int nBasics = 0 , int nNonBasics = 0);
+ CachedData(const CachedData & source);
+
+ CachedData& operator=(const CachedData &source);
+ /** Get the data from a problem */
+ void getData(const OsiSolverInterface &si);
+
+ void clean();
+
+ ~CachedData();
+ /** Indices of basic variables in starting basis (ordered if variable basics_[i] s basic in row i)*/
+ int * basics_;
+ /** Indices of non-basic variables */
+ int *nonBasics_;
+ /** number of basics variables */
+ int nBasics_;
+ /** number of non-basics */
+ int nNonBasics_;
+ /** Optimal basis */
+ CoinWarmStartBasis * basis_;
+ /** Stores the value of the solution to cut */
+ double * colsol_;
+ /** Stores the values of the slacks */
+ double * slacks_;
+ /** Stores wheter slacks are integer constrained */
+ bool * integers_;
+ /** Solver before pivots */
+ OsiSolverInterface * solver_;
+ };
+ /** Retrieve sorted integer variables which are fractional in the solution.
+ Return the number of variables.*/
+ int getSortedFractionals(CoinPackedVector &xFrac,
+ const CachedData & data,
+ const CglLandP::Parameters& params) const;
+ /** Retrieve sorted integer variables which are fractional in the solution.
+ Return the number of variables.*/
+ void getSortedFractionalIndices(std::vector& indices,
+ const CachedData &data,
+ const CglLandP::Parameters & params) const;
+ /** Cached informations about problem.*/
+ CachedData cached_;
+ /** message handler */
+ CoinMessageHandler * handler_;
+ /** messages */
+ CoinMessages messages_;
+ /** cut validator */
+ LAP::Validator validator_;
+ /** number of rows in the original problems. */
+ int numrows_;
+ /** number of columns in the original problems. */
+ int numcols_;
+ /** Original lower bounds for the problem (for lifting cuts).*/
+ double * originalColLower_;
+ /** Original upper bounds for the problem (for lifting cuts).*/
+ double * originalColUpper_;
+ /** Flag to say if cuts can be lifted.*/
+ bool canLift_;
+ /** Store some extra cut which could be cheaply generated but do not cut current incumbent.*/
+ OsiCuts extraCuts_;
+};
+void CglLandPUnitTest(OsiSolverInterface *si, const std::string & mpsDir);
+
+#endif
+
diff --git a/thirdparty/windows/include/coin/CglLandPValidator.hpp b/thirdparty/windows/include/coin/CglLandPValidator.hpp
new file mode 100644
index 0000000..b9e363d
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglLandPValidator.hpp
@@ -0,0 +1,130 @@
+// Copyright (C) 2005-2009, Pierre Bonami and others. All Rights Reserved.
+// Author: Pierre Bonami
+// Tepper School of Business
+// Carnegie Mellon University, Pittsburgh, PA 15213
+// Date: 11/22/05
+//
+// $Id: CglLandPValidator.hpp 1302 2015-08-14 15:48:32Z stefan $
+//
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+//---------------------------------------------------------------------------
+
+#ifndef CglLandPValidator_H
+#define CglLandPValidator_H
+#include "OsiSolverInterface.hpp"
+#include "CglParam.hpp"
+#include
+
+/** constants describing rejection codes*/
+//[5] = {"Accepted", "violation too small", "small coefficient too small", "big dynamic","too dense"}
+
+
+namespace LAP
+{
+
+/** Class to validate or reject a cut */
+class Validator
+{
+public:
+ /** Reasons for rejecting a cut */
+ enum RejectionsReasons
+ {
+ NoneAccepted=0 /**Cut was accepted*/,
+ SmallViolation /** Violation of the cut is too small */,
+ SmallCoefficient /** There is a small coefficient we can not get rid off.*/,
+ BigDynamic /** Dynamic of coefficinet is too important. */,
+ DenseCut/**cut is too dense */,
+ EmptyCut/**After cleaning cut has become empty*/,
+ DummyEnd/** dummy*/
+ };
+
+ /** Constructor with default values */
+ Validator(double maxFillIn = 1.,
+ double maxRatio = 1e8,
+ double minViolation = 0,
+ bool scale = false,
+ double rhsScale = 1);
+
+ /** Clean an OsiCut */
+ int cleanCut(OsiRowCut & aCut, const double * solCut,const OsiSolverInterface &si, const CglParam & par,
+ const double * colLower, const double * colUpper);
+ /** Clean an OsiCut by another method */
+ int cleanCut2(OsiRowCut & aCut, const double * solCut, const OsiSolverInterface &si, const CglParam & par,
+ const double * colLower, const double * colUpper);
+ /** Call the cut cleaner */
+ int operator()(OsiRowCut & aCut, const double * solCut,const OsiSolverInterface &si, const CglParam & par,
+ const double * colLower, const double * colUpper)
+ {
+ return cleanCut(aCut, solCut, si, par, colLower, colUpper);
+ }
+ /** @name set functions */
+ /** @{ */
+ void setMaxFillIn(double value)
+ {
+ maxFillIn_ = value;
+ }
+ void setMaxRatio(double value)
+ {
+ maxRatio_ = value;
+ }
+ void setMinViolation(double value)
+ {
+ minViolation_ = value;
+ }
+
+ void setRhsScale(double v)
+ {
+ rhsScale_ = v;
+ }
+ /** @} */
+ /** @name get functions */
+ /** @{ */
+ double getMaxFillIn()
+ {
+ return maxFillIn_;
+ }
+ double getMaxRatio()
+ {
+ return maxRatio_;
+ }
+ double getMinViolation()
+ {
+ return minViolation_;
+ }
+ /** @} */
+
+ const char* failureString(RejectionsReasons code) const
+ {
+ return rejections_[static_cast (code)];
+ }
+ const char* failureString(int code) const
+ {
+ return rejections_[ code];
+ }
+ int numRejected(RejectionsReasons code)const
+ {
+ return numRejected_[static_cast (code)];
+ }
+ int numRejected(int code)const
+ {
+ return numRejected_[ code];
+ }
+private:
+ /** max percentage of given formulation fillIn should be accepted for cut fillin.*/
+ double maxFillIn_;
+ /** max ratio between smallest and biggest coefficient */
+ double maxRatio_;
+ /** minimum violation for accepting a cut */
+ double minViolation_;
+ /** Do we do scaling? */
+ bool scale_;
+ /** Scale of right-hand-side.*/
+ double rhsScale_;
+ /** Strings explaining reason for rejections */
+ static const char* rejections_[DummyEnd];
+ /** Number of cut rejected for each of the reasons.*/
+ std::vector numRejected_;
+};
+
+}/* Ends namespace LAP.*/
+#endif
diff --git a/thirdparty/windows/include/coin/CglLiftAndProject.hpp b/thirdparty/windows/include/coin/CglLiftAndProject.hpp
new file mode 100644
index 0000000..364ba5a
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglLiftAndProject.hpp
@@ -0,0 +1,104 @@
+// Copyright (C) 2000, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglLiftAndProject_H
+#define CglLiftAndProject_H
+
+#include
+
+#include "CglCutGenerator.hpp"
+
+/** Lift And Project Cut Generator Class */
+class CglLiftAndProject : public CglCutGenerator {
+ friend void CglLiftAndProjectUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+public:
+ /**@name Generate Cuts */
+ //@{
+ /** Generate lift-and-project cuts for the
+ model of the solver interface, si.
+ Insert the generated cuts into OsiCut, cs.
+ */
+ virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+
+ /** Get the normalization : Either beta=+1 or beta=-1.
+ */
+
+ double getBeta() const {
+ return beta_;
+ }
+
+ /** Set the normalization : Either beta=+1 or beta=-1.
+ Default value is 1.
+ */
+ void setBeta(int oneOrMinusOne){
+ if (oneOrMinusOne==1 || oneOrMinusOne==-1){
+ beta_= static_cast(oneOrMinusOne);
+ }
+ else {
+ throw CoinError("Unallowable value. Beta must be 1 or -1",
+ "cutGeneration","CglLiftAndProject");
+ }
+ }
+
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglLiftAndProject ();
+
+ /// Copy constructor
+ CglLiftAndProject (
+ const CglLiftAndProject &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglLiftAndProject &
+ operator=(
+ const CglLiftAndProject& rhs);
+
+ /// Destructor
+ virtual
+ ~CglLiftAndProject ();
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+ //@}
+
+private:
+
+ // Private member methods
+
+ /**@name Private methods */
+ //@{
+
+ //@}
+
+ // Private member data
+
+ /**@name Private member data */
+ //@{
+ /// The normalization is beta_=1 or beta_=-1
+ double beta_;
+ /// epsilon
+ double epsilon_;
+ /// 1-epsilon
+ double onetol_;
+ //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglLiftAndProject class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging. */
+void CglLiftAndProjectUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglMessage.hpp b/thirdparty/windows/include/coin/CglMessage.hpp
new file mode 100644
index 0000000..5f080e8
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglMessage.hpp
@@ -0,0 +1,50 @@
+// $Id: CglMessage.hpp 1105 2013-03-19 12:43:52Z forrest $
+// Copyright (C) 2005, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglMessage_H
+#define CglMessage_H
+
+
+#include "CoinPragma.hpp"
+
+// This deals with Cgl messages (as against Osi messages etc)
+
+#include "CoinMessageHandler.hpp"
+enum CGL_Message
+{
+ CGL_INFEASIBLE,
+ CGL_CLIQUES,
+ CGL_FIXED,
+ CGL_PROCESS_STATS,
+ CGL_SLACKS,
+ CGL_PROCESS_STATS2,
+ CGL_PROCESS_SOS1,
+ CGL_PROCESS_SOS2,
+ CGL_UNBOUNDED,
+ CGL_ELEMENTS_CHANGED1,
+ CGL_ELEMENTS_CHANGED2,
+ CGL_MADE_INTEGER,
+ CGL_ADDED_INTEGERS,
+ CGL_POST_INFEASIBLE,
+ CGL_POST_CHANGED,
+ CGL_GENERAL,
+ CGL_DUMMY_END
+};
+
+/** This deals with Cgl messages (as against Osi messages etc)
+ */
+class CglMessage : public CoinMessages {
+
+public:
+
+ /**@name Constructors etc */
+ //@{
+ /** Constructor */
+ CglMessage(Language language=us_en);
+ //@}
+
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglMixedIntegerRounding.hpp b/thirdparty/windows/include/coin/CglMixedIntegerRounding.hpp
new file mode 100644
index 0000000..10580cb
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglMixedIntegerRounding.hpp
@@ -0,0 +1,429 @@
+// LAST EDIT:
+//-----------------------------------------------------------------------------
+// name: Mixed Integer Rounding Cut Generator
+// authors: Joao Goncalves (jog7@lehigh.edu)
+// Laszlo Ladanyi (ladanyi@us.ibm.com)
+// date: August 11, 2004
+//-----------------------------------------------------------------------------
+// Copyright (C) 2004, International Business Machines Corporation and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+
+#ifndef CglMixedIntegerRounding_H
+#define CglMixedIntegerRounding_H
+
+#include
+#include
+//#include
+
+#include "CoinError.hpp"
+
+#include "CglCutGenerator.hpp"
+
+//=============================================================================
+
+#ifndef CGL_DEBUG
+#define CGL_DEBUG 0
+#endif
+
+//=============================================================================
+
+// Class to store variable upper bounds (VUB)
+class CglMixIntRoundVUB
+{
+ // Variable upper bounds have the form x_j <= a y_j, where x_j is
+ // a continuous variable and y_j is an integer variable
+
+protected:
+ int var_; // The index of y_j
+ double val_; // The value of a
+
+public:
+ // Default constructor
+ CglMixIntRoundVUB() : var_(-1), val_(-1) {}
+
+ // Copy constructor
+ CglMixIntRoundVUB(const CglMixIntRoundVUB& source) {
+ var_ = source.var_;
+ val_ = source.val_;
+ }
+
+ // Assignment operator
+ CglMixIntRoundVUB& operator=(const CglMixIntRoundVUB& rhs) {
+ if (this != &rhs) {
+ var_ = rhs.var_;
+ val_ = rhs.val_;
+ }
+ return *this;
+ }
+
+ // Destructor
+ ~CglMixIntRoundVUB() {}
+
+ // Query and set functions
+ int getVar() const { return var_; }
+ double getVal() const { return val_; }
+ void setVar(const int v) { var_ = v; }
+ void setVal(const double v) { val_ = v; }
+};
+
+//=============================================================================
+
+// Class to store variable lower bounds (VLB).
+// It is the same as the class to store variable upper bounds
+typedef CglMixIntRoundVUB CglMixIntRoundVLB;
+
+//=============================================================================
+
+/** Mixed Integer Rounding Cut Generator Class */
+
+// Reference:
+// Hugues Marchand and Laurence A. Wolsey
+// Aggregation and Mixed Integer Rounding to Solve MIPs
+// Operations Research, 49(3), May-June 2001.
+// Also published as CORE Dicusion Paper 9839, June 1998.
+
+class CglMixedIntegerRounding : public CglCutGenerator {
+
+ friend void CglMixedIntegerRoundingUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir);
+
+
+private:
+ //---------------------------------------------------------------------------
+ // Enumeration constants that describe the various types of rows
+ enum RowType {
+ // The row type of this row is NOT defined yet.
+ ROW_UNDEFINED,
+ /** After the row is flipped to 'L', the row has exactly two variables:
+ one is negative binary and the other is a continous,
+ and the RHS is zero.*/
+ ROW_VARUB,
+ /** After the row is flipped to 'L', the row has exactly two variables:
+ one is positive binary and the other is a continous,
+ and the RHS is zero.*/
+ ROW_VARLB,
+ /** The row sense is 'E', the row has exactly two variables:
+ one is binary and the other is a continous, and the RHS is zero.*/
+ ROW_VAREQ,
+ // The row contains continuous and integer variables;
+ // the total number of variables is at least 2
+ ROW_MIX,
+ // The row contains only continuous variables
+ ROW_CONT,
+ // The row contains only integer variables
+ ROW_INT,
+ // The row contains other types of rows
+ ROW_OTHER
+ };
+
+
+public:
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate Mixed Integer Rounding cuts for the model data
+ contained in si. The generated cuts are inserted
+ in the collection of cuts cs.
+ */
+ virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ //@}
+
+ //---------------------------------------------------------------------------
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglMixedIntegerRounding ();
+
+ /// Alternate Constructor
+ CglMixedIntegerRounding (const int maxaggr,
+ const bool multiply,
+ const int criterion,
+ const int preproc = -1);
+
+ /// Copy constructor
+ CglMixedIntegerRounding (
+ const CglMixedIntegerRounding &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglMixedIntegerRounding &
+ operator=(
+ const CglMixedIntegerRounding& rhs);
+
+ /// Destructor
+ virtual
+ ~CglMixedIntegerRounding ();
+ /// This can be used to refresh any inforamtion
+ virtual void refreshSolver(OsiSolverInterface * solver);
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+ //@}
+
+ //---------------------------------------------------------------------------
+ /**@name Set and get methods */
+ //@{
+ /// Set MAXAGGR_
+ inline void setMAXAGGR_ (int maxaggr) {
+ if (maxaggr > 0) {
+ MAXAGGR_ = maxaggr;
+ }
+ else {
+ throw CoinError("Unallowable value. maxaggr must be > 0",
+ "gutsOfConstruct","CglMixedIntegerRounding");
+ }
+ }
+
+ /// Get MAXAGGR_
+ inline int getMAXAGGR_ () const { return MAXAGGR_; }
+
+ /// Set MULTIPLY_
+ inline void setMULTIPLY_ (bool multiply) { MULTIPLY_ = multiply; }
+
+ /// Get MULTIPLY_
+ inline bool getMULTIPLY_ () const { return MULTIPLY_; }
+
+ /// Set CRITERION_
+ inline void setCRITERION_ (int criterion) {
+ if ((criterion >= 1) && (criterion <= 3)) {
+ CRITERION_ = criterion;
+ }
+ else {
+ throw CoinError("Unallowable value. criterion must be 1, 2 or 3",
+ "gutsOfConstruct","CglMixedIntegerRounding");
+ }
+ }
+
+ /// Get CRITERION_
+ inline int getCRITERION_ () const { return CRITERION_; }
+
+
+ /// Set doPreproc
+ void setDoPreproc(int value);
+ /// Get doPreproc
+ bool getDoPreproc() const;
+
+ //@}
+
+private:
+ //--------------------------------------------------------------------------
+ // Private member methods
+
+ // Construct
+ void gutsOfConstruct (const int maxaggr,
+ const bool multiply,
+ const int criterion,
+ const int preproc);
+
+ // Delete
+ void gutsOfDelete();
+
+ // Copy
+ void gutsOfCopy (const CglMixedIntegerRounding& rhs);
+
+ // Do preprocessing.
+ // It determines the type of each row. It also identifies the variable
+ // upper bounds and variable lower bounds.
+ // It may change sense and RHS for ranged rows
+ void mixIntRoundPreprocess(const OsiSolverInterface& si);
+
+ // Determine the type of a given row.
+ RowType determineRowType(const OsiSolverInterface& si,
+ const int rowLen, const int* ind,
+ const double* coef, const char sense,
+ const double rhs) const;
+
+ // Generate MIR cuts
+ void generateMirCuts( const OsiSolverInterface& si,
+ const double* xlp,
+ const double* colUpperBound,
+ const double* colLowerBound,
+ const CoinPackedMatrix& matrixByRow,
+ const double* LHS,
+ const double* coefByRow,
+ const int* colInds,
+ const int* rowStarts,
+ const int* rowLengths,
+ //const CoinPackedMatrix& matrixByCol,
+ const double* coefByCol,
+ const int* rowInds,
+ const int* colStarts,
+ const int* colLengths,
+ OsiCuts& cs ) const;
+
+ // Copy row selected to CoinPackedVector
+ void copyRowSelected( const int iAggregate,
+ const int rowSelected,
+ std::set& setRowsAggregated,
+ int* listRowsAggregated,
+ double* xlpExtra,
+ const char sen,
+ const double rhs,
+ const double lhs,
+ const CoinPackedMatrix& matrixByRow,
+ CoinPackedVector& rowToAggregate,
+ double& rhsToAggregate) const;
+
+ // Select a row to aggregate
+ bool selectRowToAggregate( const OsiSolverInterface& si,
+ const CoinPackedVector& rowAggregated,
+ const double* colUpperBound,
+ const double* colLowerBound,
+ const std::set& setRowsAggregated,
+ const double* xlp, const double* coefByCol,
+ const int* rowInds, const int* colStarts,
+ const int* colLengths,
+ int& rowSelected,
+ int& colSelected ) const;
+
+ // Aggregation heuristic.
+ // Combines one or more rows of the original matrix
+ void aggregateRow( const int colSelected,
+ CoinPackedVector& rowToAggregate, double rhs,
+ CoinPackedVector& rowAggregated,
+ double& rhsAggregated ) const;
+
+ // Choose the bound substitution based on the criteria defined by the user
+ inline bool isLowerSubst(const double inf,
+ const double aj,
+ const double xlp,
+ const double LB,
+ const double UB) const;
+
+ // Bound substitution heuristic
+ bool boundSubstitution( const OsiSolverInterface& si,
+ const CoinPackedVector& rowAggregated,
+ const double* xlp,
+ const double* xlpExtra,
+ const double* colUpperBound,
+ const double* colLowerBound,
+ CoinPackedVector& mixedKnapsack,
+ double& rhsMixedKnapsack, double& sStar,
+ CoinPackedVector& contVariablesInS ) const;
+
+ // c-MIR separation heuristic
+ bool cMirSeparation ( const OsiSolverInterface& si,
+ const CoinPackedMatrix& matrixByRow,
+ const CoinPackedVector& rowAggregated,
+ const int* listRowsAggregated,
+ const char* sense, const double* RHS,
+ //const double* coefByRow,
+ //const int* colInds, const int* rowStarts,
+ //const int* rowLengths,
+ const double* xlp, const double sStar,
+ const double* colUpperBound,
+ const double* colLowerBound,
+ const CoinPackedVector& mixedKnapsack,
+ const double& rhsMixedKnapsack,
+ const CoinPackedVector& contVariablesInS,
+ OsiRowCut& flowCut ) const;
+
+ // function to create one c-MIR inequality
+ void cMirInequality( const int numInt,
+ const double delta,
+ const double numeratorBeta,
+ const int *knapsackIndices,
+ const double* knapsackElements,
+ const double* xlp,
+ const double sStar,
+ const double* colUpperBound,
+ const std::set& setC,
+ CoinPackedVector& cMIR,
+ double& rhscMIR,
+ double& sCoef,
+ double& violation) const;
+
+ // function to compute G
+ inline double functionG( const double d, const double f ) const;
+
+ // function to print statistics (used only in debug mode)
+ void printStats(
+ std::ofstream & fout,
+ const bool hasCut,
+ const OsiSolverInterface& si,
+ const CoinPackedVector& rowAggregated,
+ const double& rhsAggregated, const double* xlp,
+ const double* xlpExtra,
+ const int* listRowsAggregated,
+ const int* listColsSelected,
+ const int level,
+ const double* colUpperBound,
+ const double* colLowerBound ) const;
+
+
+private:
+ //---------------------------------------------------------------------------
+ // Private member data
+
+ // Maximum number of rows to aggregate
+ int MAXAGGR_;
+ // Flag that indicates if an aggregated row is also multiplied by -1
+ bool MULTIPLY_;
+ // The criterion to use in the bound substitution
+ int CRITERION_;
+ // Tolerance used for numerical purposes
+ double EPSILON_;
+ /// There is no variable upper bound or variable lower bound defined
+ int UNDEFINED_;
+ // If violation of a cut is greater that this number, the cut is accepted
+ double TOLERANCE_;
+ /** Controls the preprocessing of the matrix to identify rows suitable for
+ cut generation.
+ - -1: preprocess according to solver settings;
+
- 0: Do preprocessing only if it has not yet been done;
+
- 1: Do preprocessing.
+
+ Default value: -1 **/
+ int doPreproc_;
+ // The number of rows of the problem.
+ int numRows_;
+ // The number columns of the problem.
+ int numCols_;
+ // Indicates whether preprocessing has been done.
+ bool doneInitPre_;
+ // The array of CglMixIntRoundVUBs.
+ CglMixIntRoundVUB* vubs_;
+ // The array of CglMixIntRoundVLBs.
+ CglMixIntRoundVLB* vlbs_;
+ // Array with the row types of the rows in the model.
+ RowType* rowTypes_;
+ // The indices of the rows of the initial matrix
+ int* indRows_;
+ // The number of rows of type ROW_MIX
+ int numRowMix_;
+ // The indices of the rows of type ROW_MIX
+ int* indRowMix_;
+ // The number of rows of type ROW_CONT
+ int numRowCont_;
+ // The indices of the rows of type ROW_CONT
+ int* indRowCont_;
+ // The number of rows of type ROW_INT
+ int numRowInt_;
+ // The indices of the rows of type ROW_INT
+ int* indRowInt_;
+ // The number of rows of type ROW_CONT that have at least one variable
+ // with variable upper or lower bound
+ int numRowContVB_;
+ // The indices of the rows of type ROW_CONT that have at least one variable
+ // with variable upper or lower bound
+ int* indRowContVB_;
+ // Sense of rows (modified if ranges)
+ char * sense_;
+ // RHS of rows (modified if ranges)
+ double * RHS_;
+
+};
+
+//#############################################################################
+// A function that tests the methods in the CglMixedIntegerRounding class. The
+// only reason for it not to be a member method is that this way it doesn't
+// have to be compiled into the library. And that's a gain, because the
+// library should be compiled with optimization on, but this method should be
+// compiled with debugging.
+void CglMixedIntegerRoundingUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir);
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglMixedIntegerRounding2.hpp b/thirdparty/windows/include/coin/CglMixedIntegerRounding2.hpp
new file mode 100644
index 0000000..abf2530
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglMixedIntegerRounding2.hpp
@@ -0,0 +1,427 @@
+// LAST EDIT:
+//-----------------------------------------------------------------------------
+// name: Mixed Integer Rounding Cut Generator
+// authors: Joao Goncalves (jog7@lehigh.edu)
+// Laszlo Ladanyi (ladanyi@us.ibm.com)
+// date: August 11, 2004
+//-----------------------------------------------------------------------------
+// Copyright (C) 2004, International Business Machines Corporation and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+
+#ifndef CglMixedIntegerRounding2_H
+#define CglMixedIntegerRounding2_H
+
+#include
+#include
+//#include
+
+#include "CoinError.hpp"
+
+#include "CglCutGenerator.hpp"
+#include "CoinIndexedVector.hpp"
+
+//=============================================================================
+
+#ifndef CGL_DEBUG
+#define CGL_DEBUG 0
+#endif
+
+//=============================================================================
+
+// Class to store variable upper bounds (VUB)
+class CglMixIntRoundVUB2
+{
+ // Variable upper bounds have the form x_j <= a y_j, where x_j is
+ // a continuous variable and y_j is an integer variable
+
+protected:
+ int var_; // The index of y_j
+ double val_; // The value of a
+
+public:
+ // Default constructor
+ CglMixIntRoundVUB2() : var_(-1), val_(-1) {}
+
+ // Copy constructor
+ CglMixIntRoundVUB2(const CglMixIntRoundVUB2& source) {
+ var_ = source.var_;
+ val_ = source.val_;
+ }
+
+ // Assignment operator
+ CglMixIntRoundVUB2& operator=(const CglMixIntRoundVUB2& rhs) {
+ if (this != &rhs) {
+ var_ = rhs.var_;
+ val_ = rhs.val_;
+ }
+ return *this;
+ }
+
+ // Destructor
+ ~CglMixIntRoundVUB2() {}
+
+ // Query and set functions
+ int getVar() const { return var_; }
+ double getVal() const { return val_; }
+ void setVar(const int v) { var_ = v; }
+ void setVal(const double v) { val_ = v; }
+};
+
+//=============================================================================
+
+// Class to store variable lower bounds (VLB).
+// It is the same as the class to store variable upper bounds
+typedef CglMixIntRoundVUB2 CglMixIntRoundVLB2;
+
+//=============================================================================
+
+/** Mixed Integer Rounding Cut Generator Class */
+
+// Reference:
+// Hugues Marchand and Laurence A. Wolsey
+// Aggregation and Mixed Integer Rounding to Solve MIPs
+// Operations Research, 49(3), May-June 2001.
+// Also published as CORE Dicusion Paper 9839, June 1998.
+
+class CglMixedIntegerRounding2 : public CglCutGenerator {
+
+ friend void CglMixedIntegerRounding2UnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir);
+
+
+private:
+ //---------------------------------------------------------------------------
+ // Enumeration constants that describe the various types of rows
+ enum RowType {
+ // The row type of this row is NOT defined yet.
+ ROW_UNDEFINED,
+ /** After the row is flipped to 'L', the row has exactly two variables:
+ one is negative binary and the other is a continous,
+ and the RHS is zero.*/
+ ROW_VARUB,
+ /** After the row is flipped to 'L', the row has exactly two variables:
+ one is positive binary and the other is a continous,
+ and the RHS is zero.*/
+ ROW_VARLB,
+ /** The row sense is 'E', the row has exactly two variables:
+ one is binary and the other is a continous, and the RHS is zero.*/
+ ROW_VAREQ,
+ // The row contains continuous and integer variables;
+ // the total number of variables is at least 2
+ ROW_MIX,
+ // The row contains only continuous variables
+ ROW_CONT,
+ // The row contains only integer variables
+ ROW_INT,
+ // The row contains other types of rows
+ ROW_OTHER
+ };
+
+
+public:
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate Mixed Integer Rounding cuts for the model data
+ contained in si. The generated cuts are inserted
+ in the collection of cuts cs.
+ */
+ virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ //@}
+
+ //---------------------------------------------------------------------------
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglMixedIntegerRounding2 ();
+
+ /// Alternate Constructor
+ CglMixedIntegerRounding2 (const int maxaggr,
+ const bool multiply,
+ const int criterion,
+ const int preproc = -1);
+
+ /// Copy constructor
+ CglMixedIntegerRounding2 (
+ const CglMixedIntegerRounding2 &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglMixedIntegerRounding2 &
+ operator=(
+ const CglMixedIntegerRounding2& rhs);
+
+ /// Destructor
+ virtual
+ ~CglMixedIntegerRounding2 ();
+ /// This can be used to refresh any inforamtion
+ virtual void refreshSolver(OsiSolverInterface * solver);
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+ //@}
+
+ //---------------------------------------------------------------------------
+ /**@name Set and get methods */
+ //@{
+ /// Set MAXAGGR_
+ inline void setMAXAGGR_ (int maxaggr) {
+ if (maxaggr > 0) {
+ MAXAGGR_ = maxaggr;
+ }
+ else {
+ throw CoinError("Unallowable value. maxaggr must be > 0",
+ "gutsOfConstruct","CglMixedIntegerRounding2");
+ }
+ }
+
+ /// Get MAXAGGR_
+ inline int getMAXAGGR_ () const { return MAXAGGR_; }
+
+ /// Set MULTIPLY_
+ inline void setMULTIPLY_ (bool multiply) { MULTIPLY_ = multiply; }
+
+ /// Get MULTIPLY_
+ inline bool getMULTIPLY_ () const { return MULTIPLY_; }
+
+ /// Set CRITERION_
+ inline void setCRITERION_ (int criterion) {
+ if ((criterion >= 1) && (criterion <= 3)) {
+ CRITERION_ = criterion;
+ }
+ else {
+ throw CoinError("Unallowable value. criterion must be 1, 2 or 3",
+ "gutsOfConstruct","CglMixedIntegerRounding2");
+ }
+ }
+
+ /// Get CRITERION_
+ inline int getCRITERION_ () const { return CRITERION_; }
+
+ /// Set doPreproc
+ void setDoPreproc(int value);
+ /// Get doPreproc
+ bool getDoPreproc() const;
+ //@}
+
+private:
+ //--------------------------------------------------------------------------
+ // Private member methods
+
+ // Construct
+ void gutsOfConstruct ( const int maxaggr,
+ const bool multiply,
+ const int criterion,
+ const int preproc);
+
+ // Delete
+ void gutsOfDelete();
+
+ // Copy
+ void gutsOfCopy (const CglMixedIntegerRounding2& rhs);
+
+ // Do preprocessing.
+ // It determines the type of each row. It also identifies the variable
+ // upper bounds and variable lower bounds.
+ // It may change sense and RHS for ranged rows
+ void mixIntRoundPreprocess(const OsiSolverInterface& si);
+
+ // Determine the type of a given row.
+ RowType determineRowType(//const OsiSolverInterface& si,
+ const int rowLen, const int* ind,
+ const double* coef, const char sense,
+ const double rhs) const;
+
+ // Generate MIR cuts
+ void generateMirCuts( const OsiSolverInterface& si,
+ const double* xlp,
+ const double* colUpperBound,
+ const double* colLowerBound,
+ const CoinPackedMatrix& matrixByRow,
+ const double* LHS,
+ //const double* coefByRow,
+ //const int* colInds,
+ //const int* rowStarts,
+ //const CoinPackedMatrix& matrixByCol,
+ const double* coefByCol,
+ const int* rowInds,
+ const int* colStarts,
+ OsiCuts& cs ) const;
+
+ // Copy row selected to CoinIndexedVector
+ void copyRowSelected( const int iAggregate,
+ const int rowSelected,
+ CoinIndexedVector& setRowsAggregated,
+ int* listRowsAggregated,
+ double* xlpExtra,
+ const char sen,
+ const double rhs,
+ const double lhs,
+ const CoinPackedMatrix& matrixByRow,
+ CoinIndexedVector& rowToAggregate,
+ double& rhsToAggregate) const;
+
+ // Select a row to aggregate
+ bool selectRowToAggregate( //const OsiSolverInterface& si,
+ const CoinIndexedVector& rowAggregated,
+ const double* colUpperBound,
+ const double* colLowerBound,
+ const CoinIndexedVector& setRowsAggregated,
+ const double* xlp, const double* coefByCol,
+ const int* rowInds, const int* colStarts,
+ int& rowSelected,
+ int& colSelected ) const;
+
+ // Aggregation heuristic.
+ // Combines one or more rows of the original matrix
+ void aggregateRow( const int colSelected,
+ CoinIndexedVector& rowToAggregate, double rhs,
+ CoinIndexedVector& rowAggregated,
+ double& rhsAggregated ) const;
+
+ // Choose the bound substitution based on the criteria defined by the user
+ inline bool isLowerSubst(const double inf,
+ const double aj,
+ const double xlp,
+ const double LB,
+ const double UB) const;
+
+ // Bound substitution heuristic
+ bool boundSubstitution( const OsiSolverInterface& si,
+ const CoinIndexedVector& rowAggregated,
+ const double* xlp,
+ const double* xlpExtra,
+ const double* colUpperBound,
+ const double* colLowerBound,
+ CoinIndexedVector& mixedKnapsack,
+ double& rhsMixedKnapsack, double& sStar,
+ CoinIndexedVector& contVariablesInS ) const;
+
+ // c-MIR separation heuristic
+ bool cMirSeparation ( const OsiSolverInterface& si,
+ const CoinPackedMatrix& matrixByRow,
+ const CoinIndexedVector& rowAggregated,
+ const int* listRowsAggregated,
+ const char* sense, const double* RHS,
+ //const double* coefByRow,
+ //const int* colInds, const int* rowStarts,
+ const double* xlp, const double sStar,
+ const double* colUpperBound,
+ const double* colLowerBound,
+ const CoinIndexedVector& mixedKnapsack,
+ const double& rhsMixedKnapsack,
+ const CoinIndexedVector& contVariablesInS,
+ CoinIndexedVector * workVector,
+ OsiRowCut& flowCut ) const;
+
+ // function to create one c-MIR inequality
+ void cMirInequality( const int numInt,
+ const double delta,
+ const double numeratorBeta,
+ const int *knapsackIndices,
+ const double* knapsackElements,
+ const double* xlp,
+ const double sStar,
+ const double* colUpperBound,
+ const CoinIndexedVector& setC,
+ CoinIndexedVector& cMIR,
+ double& rhscMIR,
+ double& sCoef,
+ double& violation) const;
+
+ // function to compute G
+ inline double functionG( const double d, const double f ) const;
+
+ // function to print statistics (used only in debug mode)
+ void printStats(
+ std::ofstream & fout,
+ const bool hasCut,
+ const OsiSolverInterface& si,
+ const CoinIndexedVector& rowAggregated,
+ const double& rhsAggregated, const double* xlp,
+ const double* xlpExtra,
+ const int* listRowsAggregated,
+ const int* listColsSelected,
+ const int level,
+ const double* colUpperBound,
+ const double* colLowerBound ) const;
+
+
+private:
+ //---------------------------------------------------------------------------
+ // Private member data
+
+ // Maximum number of rows to aggregate
+ int MAXAGGR_;
+ // Flag that indicates if an aggregated row is also multiplied by -1
+ bool MULTIPLY_;
+ // The criterion to use in the bound substitution
+ int CRITERION_;
+ // Tolerance used for numerical purposes
+ double EPSILON_;
+ /// There is no variable upper bound or variable lower bound defined
+ int UNDEFINED_;
+ // If violation of a cut is greater that this number, the cut is accepted
+ double TOLERANCE_;
+ /** Controls the preprocessing of the matrix to identify rows suitable for
+ cut generation.
+ - -1: preprocess according to solver settings;
+
- 0: Do preprocessing only if it has not yet been done;
+
- 1: Do preprocessing.
+
+ Default value: -1 **/
+ int doPreproc_;
+ // The number of rows of the problem.
+ int numRows_;
+ // The number columns of the problem.
+ int numCols_;
+ // Indicates whether preprocessing has been done.
+ bool doneInitPre_;
+ // The array of CglMixIntRoundVUB2s.
+ CglMixIntRoundVUB2* vubs_;
+ // The array of CglMixIntRoundVLB2s.
+ CglMixIntRoundVLB2* vlbs_;
+ // Array with the row types of the rows in the model.
+ RowType* rowTypes_;
+ // The indices of the rows of the initial matrix
+ int* indRows_;
+ // The number of rows of type ROW_MIX
+ int numRowMix_;
+ // The indices of the rows of type ROW_MIX
+ int* indRowMix_;
+ // The number of rows of type ROW_CONT
+ int numRowCont_;
+ // The indices of the rows of type ROW_CONT
+ int* indRowCont_;
+ // The number of rows of type ROW_INT
+ int numRowInt_;
+ // The indices of the rows of type ROW_INT
+ int* indRowInt_;
+ // The number of rows of type ROW_CONT that have at least one variable
+ // with variable upper or lower bound
+ int numRowContVB_;
+ // The indices of the rows of type ROW_CONT that have at least one variable
+ // with variable upper or lower bound
+ int* indRowContVB_;
+ // If integer - for speed
+ char * integerType_;
+ // Sense of rows (modified if ranges)
+ char * sense_;
+ // RHS of rows (modified if ranges)
+ double * RHS_;
+
+};
+
+//#############################################################################
+// A function that tests the methods in the CglMixedIntegerRounding2 class. The
+// only reason for it not to be a member method is that this way it doesn't
+// have to be compiled into the library. And that's a gain, because the
+// library should be compiled with optimization on, but this method should be
+// compiled with debugging.
+void CglMixedIntegerRounding2UnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir);
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglOddHole.hpp b/thirdparty/windows/include/coin/CglOddHole.hpp
new file mode 100644
index 0000000..3b80caa
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglOddHole.hpp
@@ -0,0 +1,160 @@
+// $Id: CglOddHole.hpp 1119 2013-04-06 20:24:18Z stefan $
+// Copyright (C) 2000, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglOddHole_H
+#define CglOddHole_H
+
+#include
+
+#include "CglCutGenerator.hpp"
+
+/** Odd Hole Cut Generator Class */
+class CglOddHole : public CglCutGenerator {
+ friend void CglOddHoleUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+public:
+
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate odd hole cuts for the model of the solver interface, si.
+ This looks at all rows of type sum x(i) <= 1 (or == 1) (x 0-1)
+ and sees if there is an odd cycle cut. See Grotschel, Lovasz
+ and Schrijver (1988) for method.
+ This is then lifted by using the corresponding Chvatal cut i.e.
+ Take all rows in cycle and add them together. RHS will be odd so
+ weaken all odd coefficients so 1.0 goes to 0.0 etc - then
+ constraint is sum even(j)*x(j) <= odd which can be replaced by
+ sum (even(j)/2)*x(j) <= (odd-1.0)/2.
+ A similar cut can be generated for sum x(i) >= 1.
+
+ Insert the generated cuts into OsiCut, cs.
+
+ This is only done for rows with unsatisfied 0-1 variables. If there
+ are many of these it will be slow. Improvements would do a
+ randomized subset and also speed up shortest path algorithm used.
+
+ */
+ virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ //@}
+
+ /**@name Create Row List */
+ //@{
+ /// Create a list of rows which might yield cuts
+ /// this is to speed up process
+ /// The possible parameter is a list to cut down search
+ void createRowList( const OsiSolverInterface & si,
+ const int * possible=NULL);
+ /// This version passes in a list - 1 marks possible
+ void createRowList(int numberRows, const int * whichRow);
+ //@}
+
+ /**@name Create Clique List */
+ //@{
+ /// Create a list of extra row cliques which may not be in matrix
+ /// At present these are classical cliques
+ void createCliqueList(int numberCliques, const int * cliqueStart,
+ const int * cliqueMember);
+ //@}
+
+ /**@name Number Possibilities */
+ //@{
+ /// Returns how many rows might give odd hole cuts
+ int numberPossible();
+ //@}
+ /**@name Gets and Sets */
+ //@{
+ /// Minimum violation
+ double getMinimumViolation() const;
+ void setMinimumViolation(double value);
+ /// Minimum violation per entry
+ double getMinimumViolationPer() const;
+ void setMinimumViolationPer(double value);
+ /// Maximum number of entries in a cut
+ int getMaximumEntries() const;
+ void setMaximumEntries(int value);
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglOddHole ();
+
+ /// Copy constructor
+ CglOddHole (
+ const CglOddHole &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglOddHole &
+ operator=(
+ const CglOddHole& rhs);
+
+ /// Destructor
+ virtual
+ ~CglOddHole ();
+
+ /// This can be used to refresh any inforamtion
+ virtual void refreshSolver(OsiSolverInterface * solver);
+ //@}
+
+private:
+
+ // Private member methods
+
+
+ /**@name Private methods */
+ //@{
+ /// Generate cuts from matrix copy and solution
+ /// If packed true then <=1 rows, otherwise >=1 rows.
+ void generateCuts(const OsiRowCutDebugger * debugger,
+ const CoinPackedMatrix & rowCopy,
+ const double * solution, const double * dj,
+ OsiCuts & cs, const int * suitableRow,
+ const int * fixedColumn,const CglTreeInfo info,
+ bool packed);
+ //@}
+
+ // Private member data
+
+ /**@name Private member data */
+ //@{
+ /// list of suitableRows
+ int * suitableRows_;
+ /// start of each clique
+ int * startClique_;
+ /// clique members
+ int * member_;
+ /// epsilon
+ double epsilon_;
+ /// 1-epsilon
+ double onetol_;
+ /// Minimum violation
+ double minimumViolation_;
+ /// Minimum violation per entry
+ double minimumViolationPer_;
+ /// Maximum number of entries in a cut
+ int maximumEntries_;
+ /// number of rows when suitability tested
+ int numberRows_;
+ /// number of cliques
+ int numberCliques_;
+ //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglOddHole class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging. */
+void CglOddHoleUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglParam.hpp b/thirdparty/windows/include/coin/CglParam.hpp
new file mode 100644
index 0000000..4463ef5
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglParam.hpp
@@ -0,0 +1,93 @@
+// Name: CglParam.hpp
+// Author: Francois Margot
+// Tepper School of Business
+// Carnegie Mellon University, Pittsburgh, PA 15213
+// email: fmargot@andrew.cmu.edu
+// Date: 11/24/06
+//
+// $Id: CglParam.hpp 1122 2013-04-06 20:39:53Z stefan $
+//
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+//-----------------------------------------------------------------------------
+// Copyright (C) 2006, Francois Margot and others. All Rights Reserved.
+
+#ifndef CglParam_H
+#define CglParam_H
+#include "CglConfig.h"
+#include "CoinFinite.hpp"
+/** Class collecting parameters for all cut generators. Each generator
+ may have a derived class to add parameters. Each generator might
+ also set different default values for the parameters in CglParam. */
+
+class CglParam {
+
+public:
+
+ /**@name Public Set/get methods */
+ //@{
+
+ /** Set INFINIT */
+ virtual void setINFINIT(const double inf);
+ /** Get value of INFINIT */
+ inline double getINFINIT() const {return INFINIT;}
+
+ /** Set EPS */
+ virtual void setEPS(const double eps);
+ /** Get value of EPS */
+ inline double getEPS() const {return EPS;}
+
+ /** Set EPS_COEFF */
+ virtual void setEPS_COEFF(const double eps_c);
+ /** Get value of EPS_COEFF */
+ inline double getEPS_COEFF() const {return EPS_COEFF;}
+
+ /** Set MAX_SUPPORT */
+ virtual void setMAX_SUPPORT(const int max_s);
+ /** Get value of MAX_SUPPORT */
+ inline int getMAX_SUPPORT() const {return MAX_SUPPORT;}
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglParam(const double inf = COIN_DBL_MAX, const double eps = 1e-6,
+ const double eps_c = 1e-5, const int max_s = COIN_INT_MAX);
+
+ /// Copy constructor
+ CglParam(const CglParam&);
+
+ /// Clone
+ virtual CglParam* clone() const;
+
+ /// Assignment operator
+ CglParam& operator=(const CglParam &rhs);
+
+ /// Destructor
+ virtual ~CglParam();
+ //@}
+
+protected:
+
+ // Protected member data
+
+ /**@name Protected member data */
+
+ //@{
+ // Value for infinity. Default: COIN_DBL_MAX.
+ double INFINIT;
+
+ // EPSILON for double comparisons. Default: 1e-6.
+ double EPS;
+
+ // Returned cuts do not have coefficients with absolute value smaller
+ // than EPS_COEFF. Default: 1e-5.
+ double EPS_COEFF;
+
+ /** Maximum number of non zero coefficients in a generated cut;
+ Default: COIN_INT_MAX */
+ int MAX_SUPPORT;
+ //@}
+
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglPreProcess.hpp b/thirdparty/windows/include/coin/CglPreProcess.hpp
new file mode 100644
index 0000000..65c04ca
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglPreProcess.hpp
@@ -0,0 +1,492 @@
+// Copyright (C) 2005, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglPreProcess_H
+#define CglPreProcess_H
+
+#include
+#include
+
+#include "CoinMessageHandler.hpp"
+#include "OsiSolverInterface.hpp"
+#include "CglStored.hpp"
+#include "OsiPresolve.hpp"
+#include "CglCutGenerator.hpp"
+
+//#############################################################################
+
+/** Class for preProcessing and postProcessing.
+
+ While cuts can be added at any time in the tree, some cuts are actually just
+ stronger versions of existing constraints. In this case they can replace those
+ constraints rather than being added as new constraints. This is awkward in the
+ tree but reasonable at the root node.
+
+ This is a general process class which uses other cut generators to strengthen
+ constraints, establish that constraints are redundant, fix variables and
+ find relationships such as x + y == 1.
+
+ Presolve will also be done.
+
+ If row names existed they may be replaced by R0000000 etc
+
+*/
+
+class CglPreProcess {
+
+public:
+
+ ///@name Main methods
+ //@{
+ /** preProcess problem - returning new problem.
+ If makeEquality true then <= cliques converted to ==.
+ Presolve will be done numberPasses times.
+
+ Returns NULL if infeasible
+
+ This version uses default strategy. For more control copy and edit
+ code from this function i.e. call preProcessNonDefault
+ */
+ OsiSolverInterface * preProcess(OsiSolverInterface & model,
+ bool makeEquality=false, int numberPasses=5);
+ /** preProcess problem - returning new problem.
+ If makeEquality true then <= cliques converted to ==.
+ Presolve will be done numberPasses times.
+
+ Returns NULL if infeasible
+
+ This version assumes user has added cut generators to CglPreProcess object
+ before calling it. As an example use coding in preProcess
+ If makeEquality is 1 add slacks to get cliques,
+ if 2 add slacks to get sos (but only if looks plausible) and keep sos info
+ */
+ OsiSolverInterface * preProcessNonDefault(OsiSolverInterface & model,
+ int makeEquality=0, int numberPasses=5,
+ int tuning=0);
+ /// Creates solution in original model
+ void postProcess(OsiSolverInterface &model
+ ,bool deleteStuff=true);
+ /** Tightens primal bounds to make dual and branch and cutfaster. Unless
+ fixed or integral, bounds are slightly looser than they could be.
+ Returns non-zero if problem infeasible
+ Fudge for branch and bound - put bounds on columns of factor *
+ largest value (at continuous) - should improve stability
+ in branch and bound on infeasible branches (0.0 is off)
+ */
+ int tightenPrimalBounds(OsiSolverInterface & model,double factor=0.0);
+ /** Fix some of problem - returning new problem.
+ Uses reduced costs.
+ Optional signed character array
+ 1 always keep, -1 always discard, 0 use djs
+
+ */
+ OsiSolverInterface * someFixed(OsiSolverInterface & model,
+ double fractionToKeep=0.25,
+ bool fixContinuousAsWell=false,
+ char * keep=NULL) const;
+ /** Replace cliques by more maximal cliques
+ Returns NULL if rows not reduced by greater than cliquesNeeded*rows
+
+ */
+ OsiSolverInterface * cliqueIt(OsiSolverInterface & model,
+ double cliquesNeeded=0.0) const;
+ /// If we have a cutoff - fix variables
+ int reducedCostFix(OsiSolverInterface & model);
+ //@}
+
+ //---------------------------------------------------------------------------
+
+ /**@name Parameter set/get methods
+
+ The set methods return true if the parameter was set to the given value,
+ false if the value of the parameter is out of range.
+
+ The get methods return the value of the parameter.
+
+ */
+ //@{
+ /** Set cutoff bound on the objective function.
+
+ When using strict comparison, the bound is adjusted by a tolerance to
+ avoid accidentally cutting off the optimal solution.
+ */
+ void setCutoff(double value) ;
+
+ /// Get the cutoff bound on the objective function - always as minimize
+ double getCutoff() const;
+ /// The original solver associated with this model.
+ inline OsiSolverInterface * originalModel() const
+ { return originalModel_;}
+ /// Solver after making clique equalities (may == original)
+ inline OsiSolverInterface * startModel() const
+ { return startModel_;}
+ /// Copies of solver at various stages after presolve
+ inline OsiSolverInterface * modelAtPass(int iPass) const
+ { if (iPass>=0&&iPass=0&&iPass=0&&iPass
+
+#include "CglCutGenerator.hpp"
+ /** Only useful type of disaggregation is most normal
+ For now just done for 0-1 variables
+ Can be used for building cliques
+ */
+ typedef struct {
+ //unsigned int zeroOne:1; // nonzero if affected variable is 0-1
+ //unsigned int whenAtUB:1; // nonzero if fixing happens when this variable at 1
+ //unsigned int affectedToUB:1; // nonzero if affected variable fixed to UB
+ //unsigned int affected:29; // If 0-1 then 0-1 sequence, otherwise true
+ unsigned int affected;
+ } disaggregationAction;
+
+/** Probing Cut Generator Class */
+class CglProbing : public CglCutGenerator {
+ friend void CglProbingUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+public:
+
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate probing/disaggregation cuts for the model of the
+ solver interface, si.
+
+ This is a simplification of probing ideas put into OSL about
+ ten years ago. The only known documentation is a copy of a
+ talk handout - we think Robin Lougee-Heimer has a copy!
+
+ For selected integer variables (e.g. unsatisfied ones) the effect of
+ setting them up or down is investigated. Setting a variable up
+ may in turn set other variables (continuous as well as integer).
+ There are various possible results:
+
+ 1) It is shown that problem is infeasible (this may also be
+ because objective function or reduced costs show worse than
+ best solution). If the other way is feasible we can generate
+ a column cut (and continue probing), if not feasible we can
+ say problem infeasible.
+
+ 2) If both ways are feasible, it can happen that x to 0 implies y to 1
+ ** and x to 1 implies y to 1 (again a column cut). More common
+ is that x to 0 implies y to 1 and x to 1 implies y to 0 so we could
+ substitute for y which might lead later to more powerful cuts.
+ ** This is not done in this code as there is no mechanism for
+ returning information.
+
+ 3) When x to 1 a constraint went slack by c. We can tighten the
+ constraint ax + .... <= b (where a may be zero) to
+ (a+c)x + .... <= b. If this cut is violated then it is
+ generated.
+
+ 4) Similarly we can generate implied disaggregation cuts
+
+ Note - differences to cuts in OSL.
+
+ a) OSL had structures intended to make this faster.
+ b) The "chaining" in 2) was done
+ c) Row cuts modified original constraint rather than adding cut
+ b) This code can cope with general integer variables.
+
+ Insert the generated cuts into OsiCut, cs.
+
+ If a "snapshot" of a matrix exists then this will be used.
+ Presumably this will give global cuts and will be faster.
+ No check is done to see if cuts will be global.
+
+ Otherwise use current matrix.
+
+ Both row cuts and column cuts may be returned
+
+ The mode options are:
+ 0) Only unsatisfied integer variables will be looked at.
+ If no information exists for that variable then
+ probing will be done so as a by-product you "may" get a fixing
+ or infeasibility. This will be fast and is only available
+ if a snapshot exists (otherwise as 1).
+ The bounds in the snapshot are the ones used.
+ 1) Look at unsatisfied integer variables, using current bounds.
+ Probing will be done on all looked at.
+ 2) Look at all integer variables, using current bounds.
+ Probing will be done on all
+
+ ** If generateCutsAndModify is used then new relaxed
+ row bounds and tightened column bounds are generated
+ Returns number of infeasibilities
+ */
+ virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ int generateCutsAndModify( const OsiSolverInterface & si, OsiCuts & cs,
+ CglTreeInfo * info);
+ //@}
+
+ /**@name snapshot etc */
+ //@{
+ /** Create a copy of matrix which is to be used
+ this is to speed up process and to give global cuts
+ Can give an array with 1 set to select, 0 to ignore
+ column bounds are tightened
+ If array given then values of 1 will be set to 0 if redundant.
+ Objective may be added as constraint
+ Returns 1 if infeasible otherwise 0
+ */
+ int snapshot ( const OsiSolverInterface & si,
+ char * possible=NULL,
+ bool withObjective=true);
+ /// Deletes snapshot
+ void deleteSnapshot ( );
+ /** Creates cliques for use by probing.
+ Only cliques >= minimumSize and < maximumSize created
+ Can also try and extend cliques as a result of probing (root node).
+ Returns number of cliques found.
+ */
+ int createCliques( OsiSolverInterface & si,
+ int minimumSize=2, int maximumSize=100);
+ /// Delete all clique information
+ void deleteCliques();
+ /** Create a fake model by adding cliques
+ if type&4 then delete rest of model first,
+ if 1 then add proper cliques, 2 add fake cliques */
+ OsiSolverInterface * cliqueModel(const OsiSolverInterface * model,
+ int type);
+ //@}
+
+ /**@name Get tighter column bounds */
+ //@{
+ /// Lower
+ const double * tightLower() const;
+ /// Upper
+ const double * tightUpper() const;
+ /// Array which says tighten continuous
+ const char * tightenBounds() const
+ { return tightenBounds_;}
+ //@}
+
+ /**@name Get possible freed up row bounds - only valid after mode==3 */
+ //@{
+ /// Lower
+ const double * relaxedRowLower() const;
+ /// Upper
+ const double * relaxedRowUpper() const;
+ //@}
+
+ /**@name Change mode */
+ //@{
+ /// Set
+ void setMode(int mode);
+ /// Get
+ int getMode() const;
+ //@}
+
+ /**@name Change maxima */
+ //@{
+ /// Set maximum number of passes per node
+ void setMaxPass(int value);
+ /// Get maximum number of passes per node
+ int getMaxPass() const;
+ /// Set log level - 0 none, 1 - a bit, 2 - more details
+ void setLogLevel(int value);
+ /// Get log level
+ int getLogLevel() const;
+ /// Set maximum number of unsatisfied variables to look at
+ void setMaxProbe(int value);
+ /// Get maximum number of unsatisfied variables to look at
+ int getMaxProbe() const;
+ /// Set maximum number of variables to look at in one probe
+ void setMaxLook(int value);
+ /// Get maximum number of variables to look at in one probe
+ int getMaxLook() const;
+ /// Set maximum number of elements in row for it to be considered
+ void setMaxElements(int value);
+ /// Get maximum number of elements in row for it to be considered
+ int getMaxElements() const;
+ /// Set maximum number of passes per node (root node)
+ void setMaxPassRoot(int value);
+ /// Get maximum number of passes per node (root node)
+ int getMaxPassRoot() const;
+ /// Set maximum number of unsatisfied variables to look at (root node)
+ void setMaxProbeRoot(int value);
+ /// Get maximum number of unsatisfied variables to look at (root node)
+ int getMaxProbeRoot() const;
+ /// Set maximum number of variables to look at in one probe (root node)
+ void setMaxLookRoot(int value);
+ /// Get maximum number of variables to look at in one probe (root node)
+ int getMaxLookRoot() const;
+ /// Set maximum number of elements in row for it to be considered (root node)
+ void setMaxElementsRoot(int value);
+ /// Get maximum number of elements in row for it to be considered (root node)
+ int getMaxElementsRoot() const;
+ /**
+ Returns true if may generate Row cuts in tree (rather than root node).
+ Used so know if matrix will change in tree. Really
+ meant so column cut generators can still be active
+ without worrying code.
+ Default is true
+ */
+ virtual bool mayGenerateRowCutsInTree() const;
+ //@}
+
+ /**@name Get information back from probing */
+ //@{
+ /// Number looked at this time
+ inline int numberThisTime() const
+ { return numberThisTime_;}
+ /// Which ones looked at this time
+ inline const int * lookedAt() const
+ { return lookedAt_;}
+ //@}
+
+ /**@name Stop or restart row cuts (otherwise just fixing from probing) */
+ //@{
+ /// Set
+ /// 0 no cuts, 1 just disaggregation type, 2 coefficient ( 3 both)
+ void setRowCuts(int type);
+ /// Get
+ int rowCuts() const;
+ //@}
+ /// Clique type
+ typedef struct {
+ unsigned int equality:1; // nonzero if clique is ==
+ } CliqueType;
+
+ /**@name Information on cliques */
+ //@{
+ /// Number of cliques
+ inline int numberCliques() const
+ { return numberCliques_;}
+ /// Clique type
+ inline CliqueType * cliqueType() const
+ { return cliqueType_;}
+ /// Start of each clique
+ inline int * cliqueStart() const
+ { return cliqueStart_;}
+ /// Entries for clique
+ inline CliqueEntry * cliqueEntry() const
+ { return cliqueEntry_;}
+ //@}
+
+ /**@name Whether use objective as constraint */
+ //@{
+ /** Set
+ 0 don't
+ 1 do
+ -1 don't even think about it
+ */
+ void setUsingObjective(int yesNo);
+ /// Get
+ int getUsingObjective() const;
+ //@}
+
+ /**@name Mark which continuous variables are to be tightened */
+ //@{
+ /// Mark variables to be tightened
+ void tightenThese(const OsiSolverInterface & solver, int number, const int * which);
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglProbing ();
+
+ /// Copy constructor
+ CglProbing (
+ const CglProbing &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglProbing &
+ operator=(
+ const CglProbing& rhs);
+
+ /// Destructor
+ virtual
+ ~CglProbing ();
+
+ /// This can be used to refresh any inforamtion
+ virtual void refreshSolver(OsiSolverInterface * solver);
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+ //@}
+
+private:
+
+ // Private member methods
+ /**@name probe */
+ //@{
+ /// Does probing and adding cuts (without cliques and mode_!=0)
+ int probe( const OsiSolverInterface & si,
+ const OsiRowCutDebugger * debugger,
+ OsiCuts & cs,
+ double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
+ CoinPackedMatrix *columnCopy,const CoinBigIndex * rowStartPos,
+ const int * realRow, const double * rowLower, const double * rowUpper,
+ const char * intVar, double * minR, double * maxR, int * markR,
+ CglTreeInfo * info);
+ /// Does probing and adding cuts (with cliques)
+ int probeCliques( const OsiSolverInterface & si,
+ const OsiRowCutDebugger * debugger,
+ OsiCuts & cs,
+ double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
+ CoinPackedMatrix *columnCopy, const int * realRow,
+ double * rowLower, double * rowUpper,
+ char * intVar, double * minR, double * maxR, int * markR,
+ CglTreeInfo * info);
+ /// Does probing and adding cuts for clique slacks
+ int probeSlacks( const OsiSolverInterface & si,
+ const OsiRowCutDebugger * debugger,
+ OsiCuts & cs,
+ double * colLower, double * colUpper, CoinPackedMatrix *rowCopy,
+ CoinPackedMatrix *columnCopy,
+ double * rowLower, double * rowUpper,
+ char * intVar, double * minR, double * maxR,int * markR,
+ CglTreeInfo * info);
+ /** Does most of work of generateCuts
+ Returns number of infeasibilities */
+ int gutsOfGenerateCuts( const OsiSolverInterface & si,
+ OsiCuts & cs,
+ double * rowLower, double * rowUpper,
+ double * colLower, double * colUpper,
+ CglTreeInfo * info);
+ /// Sets up clique information for each row
+ void setupRowCliqueInformation(const OsiSolverInterface & si);
+ /** This tightens column bounds (and can declare infeasibility)
+ It may also declare rows to be redundant */
+ int tighten(double *colLower, double * colUpper,
+ const int *column, const double *rowElements,
+ const CoinBigIndex *rowStart,const CoinBigIndex * rowStartPos,
+ const int * rowLength,
+ double *rowLower, double *rowUpper,
+ int nRows,int nCols,char * intVar,int maxpass,
+ double tolerance);
+ /// This just sets minima and maxima on rows
+ void tighten2(double *colLower, double * colUpper,
+ const int *column, const double *rowElements,
+ const CoinBigIndex *rowStart,
+ const int * rowLength,
+ double *rowLower, double *rowUpper,
+ double * minR, double * maxR, int * markR,
+ int nRows);
+ //@}
+
+ // Private member data
+
+ struct disaggregation_struct_tag ;
+ friend struct CglProbing::disaggregation_struct_tag ;
+
+ /**@name Private member data */
+ //@{
+ /// Row copy (only if snapshot)
+ CoinPackedMatrix * rowCopy_;
+ /// Column copy (only if snapshot)
+ CoinPackedMatrix * columnCopy_;
+ /// Lower bounds on rows
+ double * rowLower_;
+ /// Upper bounds on rows
+ double * rowUpper_;
+ /// Lower bounds on columns
+ double * colLower_;
+ /// Upper bounds on columns
+ double * colUpper_;
+ /// Number of rows in snapshot (or when cliqueRow stuff computed)
+ int numberRows_;
+ /// Number of columns in problem ( must == current)
+ int numberColumns_;
+ /// Tolerance to see if infeasible
+ double primalTolerance_;
+ /** Mode - 0 lazy using snapshot, 1 just unsatisfied, 2 all.
+ 16 bit set if want to extend cliques at root node
+ */
+ int mode_;
+ /** Row cuts flag
+ 0 no cuts, 1 just disaggregation type, 2 coefficient ( 3 both), 4 just column cuts
+ -n as +n but just fixes variables unless at root
+ */
+ int rowCuts_;
+ /// Maximum number of passes to do in probing
+ int maxPass_;
+ /// Log level - 0 none, 1 - a bit, 2 - more details
+ int logLevel_;
+ /// Maximum number of unsatisfied variables to probe
+ int maxProbe_;
+ /// Maximum number of variables to look at in one probe
+ int maxStack_;
+ /// Maximum number of elements in row for scan
+ int maxElements_;
+ /// Maximum number of passes to do in probing at root
+ int maxPassRoot_;
+ /// Maximum number of unsatisfied variables to probe at root
+ int maxProbeRoot_;
+ /// Maximum number of variables to look at in one probe at root
+ int maxStackRoot_;
+ /// Maximum number of elements in row for scan at root
+ int maxElementsRoot_;
+ /// Whether to include objective as constraint
+ int usingObjective_;
+ /// Number of integer variables
+ int numberIntegers_;
+ /// Number of 0-1 integer variables
+ int number01Integers_;
+ /// Number looked at this time
+ int numberThisTime_;
+ /// Total number of times called
+ int totalTimesCalled_;
+ /// Which ones looked at this time
+ int * lookedAt_;
+ /// Disaggregation cuts and for building cliques
+ typedef struct disaggregation_struct_tag {
+ int sequence; // integer variable
+ // index will be NULL if no probing done yet
+ int length; // length of newValue
+ disaggregationAction * index; // columns whose bounds will be changed
+ } disaggregation;
+ disaggregation * cutVector_;
+ /// Cliques
+ /// Number of cliques
+ int numberCliques_;
+ /// Clique type
+ CliqueType * cliqueType_;
+ /// Start of each clique
+ int * cliqueStart_;
+ /// Entries for clique
+ CliqueEntry * cliqueEntry_;
+ /** Start of oneFixes cliques for a column in matrix or -1 if not
+ in any clique */
+ int * oneFixStart_;
+ /** Start of zeroFixes cliques for a column in matrix or -1 if not
+ in any clique */
+ int * zeroFixStart_;
+ /// End of fixes for a column
+ int * endFixStart_;
+ /// Clique numbers for one or zero fixes
+ int * whichClique_;
+ /** For each column with nonzero in row copy this gives a clique "number".
+ So first clique mentioned in row is always 0. If no entries for row
+ then no cliques. If sequence > numberColumns then not in clique.
+ */
+ CliqueEntry * cliqueRow_;
+ /// cliqueRow_ starts for each row
+ int * cliqueRowStart_;
+ /// If not null and [i] !=0 then also tighten even if continuous
+ char * tightenBounds_;
+ //@}
+};
+inline int affectedInDisaggregation(const disaggregationAction & dis)
+{ return dis.affected&0x1fffffff;}
+inline void setAffectedInDisaggregation(disaggregationAction & dis,
+ int affected)
+{ dis.affected = affected|(dis.affected&0xe0000000);}
+#ifdef NDEBUG
+inline bool zeroOneInDisaggregation(const disaggregationAction & )
+{ return true;}
+#else
+inline bool zeroOneInDisaggregation(const disaggregationAction & dis)
+//{ return (dis.affected&0x80000000)!=0;}
+{ assert ((dis.affected&0x80000000)!=0); return true;}
+#endif
+inline void setZeroOneInDisaggregation(disaggregationAction & dis,bool zeroOne)
+{ dis.affected = (zeroOne ? 0x80000000 : 0)|(dis.affected&0x7fffffff);}
+inline bool whenAtUBInDisaggregation(const disaggregationAction & dis)
+{ return (dis.affected&0x40000000)!=0;}
+inline void setWhenAtUBInDisaggregation(disaggregationAction & dis,bool whenAtUB)
+{ dis.affected = (whenAtUB ? 0x40000000 : 0)|(dis.affected&0xbfffffff);}
+inline bool affectedToUBInDisaggregation(const disaggregationAction & dis)
+{ return (dis.affected&0x20000000)!=0;}
+inline void setAffectedToUBInDisaggregation(disaggregationAction & dis,bool affectedToUB)
+{ dis.affected = (affectedToUB ? 0x20000000 : 0)|(dis.affected&0xdfffffff);}
+
+//#############################################################################
+/** A function that tests the methods in the CglProbing class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging. */
+void CglProbingUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+/// This just uses implication info
+class CglImplication : public CglCutGenerator {
+
+public:
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate cuts from implication table
+ Insert generated cuts into the cut set cs.
+ */
+ virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglImplication ();
+
+ /// Constructor with info
+ CglImplication (CglTreeProbingInfo * info);
+
+ /// Copy constructor
+ CglImplication (
+ const CglImplication &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglImplication &
+ operator=(
+ const CglImplication& rhs);
+
+ /// Destructor
+ virtual
+ ~CglImplication ();
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+ //@}
+ /**@name Set implication */
+ //@{
+ /// Set implication
+ inline void setProbingInfo(CglTreeProbingInfo * info)
+ { probingInfo_=info;}
+ //@}
+
+private:
+ /**@name Private member data */
+ //@{
+ /// Pointer to tree probing info
+ CglTreeProbingInfo * probingInfo_;
+ //@}
+};
+#endif
diff --git a/thirdparty/windows/include/coin/CglRedSplit.hpp b/thirdparty/windows/include/coin/CglRedSplit.hpp
new file mode 100644
index 0000000..1265b1d
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglRedSplit.hpp
@@ -0,0 +1,448 @@
+// Last edit: 4/20/07
+//
+// Name: CglRedSplit.hpp
+// Author: Francois Margot
+// Tepper School of Business
+// Carnegie Mellon University, Pittsburgh, PA 15213
+// email: fmargot@andrew.cmu.edu
+// Date: 2/6/05
+//
+// $Id: CglRedSplit.hpp 1119 2013-04-06 20:24:18Z stefan $
+//-----------------------------------------------------------------------------
+// Copyright (C) 2005, Francois Margot and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglRedSplit_H
+#define CglRedSplit_H
+
+#include "CglCutGenerator.hpp"
+#include "CglRedSplitParam.hpp"
+
+/** Gomory Reduce-and-Split Cut Generator Class; See method generateCuts().
+ Based on the paper by K. Anderson, G. Cornuejols, Yanjun Li,
+ "Reduce-and-Split Cuts: Improving the Performance of Mixed Integer
+ Gomory Cuts", Management Science 51 (2005). */
+
+class CglRedSplit : public CglCutGenerator {
+
+ friend void CglRedSplitUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir);
+public:
+ /**@name generateCuts */
+ //@{
+ /** Generate Reduce-and-Split Mixed Integer Gomory cuts
+ for the model of the solver interface si.
+
+ Insert the generated cuts into OsiCuts cs.
+
+ Warning: This generator currently works only with the Lp solvers Clp or
+ Cplex9.0 or higher. It requires access to the optimal tableau and
+ optimal basis inverse and makes assumptions on the way slack variables
+ are added by the solver. The Osi implementations for Clp and Cplex
+ verify these assumptions.
+
+ When calling the generator, the solver interface si
+ must contain an optimized
+ problem and information related to the optimal basis must be available
+ through the OsiSolverInterface methods (si->optimalBasisIsAvailable()
+ must return 'true'). It is also essential that the integrality of
+ structural variable i can be obtained using si->isInteger(i).
+
+ Reduce-and-Split cuts are variants of Gomory cuts: Starting from
+ the current optimal tableau, linear combinations of the rows of
+ the current optimal simplex tableau are used for generating Gomory
+ cuts. The choice of the linear combinations is driven by the objective
+ of reducing the coefficients of the non basic continuous variables
+ in the resulting row.
+ Note that this generator might not be able to generate cuts for some
+ solutions violating integrality constraints.
+
+ */
+ virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+
+ /// Return true if needs optimal basis to do cuts (will return true)
+ virtual bool needsOptimalBasis() const;
+ //@}
+
+
+ /**@name Public Methods */
+ //@{
+
+ // Set the parameters to the values of the given CglRedSplitParam object.
+ void setParam(const CglRedSplitParam &source);
+ // Return the CglRedSplitParam object of the generator.
+ inline CglRedSplitParam getParam() const {return param;}
+
+ // Compute entries of low_is_lub and up_is_lub.
+ void compute_is_lub();
+
+ // Compute entries of is_integer.
+ void compute_is_integer();
+
+ /// Set given_optsol to the given optimal solution given_sol.
+ /// If given_optsol is set using this method,
+ /// the code will stop as soon as
+ /// a generated cut is violated by the given solution; exclusively
+ /// for debugging purposes.
+ void set_given_optsol(const double *given_sol, const int card_sol);
+
+ /// Print some of the data members
+ void print() const;
+
+ /// Print the current simplex tableau
+ void printOptTab(OsiSolverInterface *solver) const;
+
+ //@}
+
+ /**@name Public Methods (soon to be obsolete)*/
+ //@{
+ //************************************************************
+ // TO BE REMOVED
+ /** Set limit, the maximum number of non zero coefficients in generated cut;
+ Default: 50 */
+ void setLimit(int limit);
+ /** Get value of limit */
+ int getLimit() const;
+
+ /** Set away, the minimum distance from being integer used for selecting
+ rows for cut generation; all rows whose pivot variable should be
+ integer but is more than away from integrality will be selected;
+ Default: 0.05 */
+ void setAway(double value);
+ /// Get value of away
+ double getAway() const;
+ /** Set the value of LUB, value considered large for the absolute value of
+ a lower or upper bound on a variable;
+ Default: 1000 */
+ void setLUB(double value);
+ /** Get the value of LUB */
+ double getLUB() const;
+
+ /** Set the value of EPS, epsilon for double computations;
+ Default: 1e-7 */
+ void setEPS(double value);
+ /** Get the value of EPS */
+ double getEPS() const;
+
+ /** Set the value of EPS_COEFF, epsilon for values of coefficients;
+ Default: 1e-8 */
+ void setEPS_COEFF(double value);
+ /** Get the value of EPS_COEFF */
+ double getEPS_COEFF() const;
+
+ /** Set the value of EPS_COEFF_LUB, epsilon for values of coefficients for
+ variables with absolute value of lower or upper bound larger than LUB;
+ Default: 1e-13 */
+ void setEPS_COEFF_LUB(double value);
+ /** Get the value of EPS_COEFF_LUB */
+ double getEPS_COEFF_LUB() const;
+
+ /** Set the value of EPS_RELAX, value used for relaxing the right hand side
+ of each generated cut;
+ Default: 1e-8 */
+ void setEPS_RELAX(double value);
+ /** Get the value of EPS_RELAX */
+ double getEPS_RELAX() const;
+
+ /** Set the value of normIsZero, the threshold for considering a norm to be
+ 0; Default: 1e-5 */
+ void setNormIsZero(double value);
+ /** Get the value of normIsZero */
+ double getNormIsZero() const;
+
+ /** Set the value of minReduc, threshold for relative norm improvement for
+ performing a reduction; Default: 0.05 */
+ void setMinReduc(double value);
+ /// Get the value of minReduc
+ double getMinReduc() const;
+
+ /** Set the maximum allowed value for (mTab * mTab * CoinMax(mTab, nTab)) where
+ mTab is the number of rows used in the combinations and nTab is the
+ number of continuous non basic variables. The work of the generator is
+ proportional to (mTab * mTab * CoinMax(mTab, nTab)). Reducing the value of
+ maxTab makes the generator faster, but weaker. Default: 1e7. */
+ void setMaxTab(double value);
+ /// Get the value of maxTab
+ double getMaxTab() const;
+ // END TO BE REMOVED
+ //************************************************************
+
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglRedSplit();
+
+ /// Constructor with specified parameters
+ CglRedSplit(const CglRedSplitParam &RS_param);
+
+ /// Copy constructor
+ CglRedSplit (const CglRedSplit &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglRedSplit &
+ operator=(
+ const CglRedSplit& rhs);
+
+ /// Destructor
+ virtual
+ ~CglRedSplit ();
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+ //@}
+
+private:
+
+ // Private member methods
+
+/**@name Private member methods */
+
+ //@{
+
+ // Method generating the cuts after all CglRedSplit members are properly set.
+ void generateCuts(OsiCuts & cs);
+
+ /// Compute the fractional part of value, allowing for small error.
+ inline double rs_above_integer(double value);
+
+ /// Perform row r1 of pi := row r1 of pi - step * row r2 of pi.
+ void update_pi_mat(int r1, int r2, int step);
+
+ /// Perform row r1 of tab := row r1 of tab - step * row r2 of tab.
+ void update_redTab(int r1, int r2, int step);
+
+ /// Find optimal integer step for changing row r1 by adding to it a
+ /// multiple of another row r2.
+ void find_step(int r1, int r2, int *step,
+ double *reduc, double *norm);
+
+ /// Test if an ordered pair of rows yields a reduction. Perform the
+ /// reduction if it is acceptable.
+ int test_pair(int r1, int r2, double *norm);
+
+ /// Reduce rows of contNonBasicTab.
+ void reduce_contNonBasicTab();
+
+ /// Generate a row of the current LP tableau.
+ void generate_row(int index_row, double *row);
+
+ /// Generate a mixed integer Chvatal-Gomory cut, when all non basic
+ /// variables are non negative and at their lower bound.
+ int generate_cgcut(double *row, double *rhs);
+
+ /// Generate a mixed integer Chvatal-Gomory cut, when all non basic
+ /// variables are non negative and at their lower bound (different formula)
+ int generate_cgcut_2(int basic_ind, double *row, double *rhs);
+
+ /// Use multiples of the initial inequalities to cancel out the coefficients
+ /// of the slack variables.
+ void eliminate_slacks(double *row,
+ const double *elements,
+ const int *start,
+ const int *indices,
+ const int *rowLength,
+ const double *rhs, double *rowrhs);
+
+ /// Change the sign of the coefficients of the continuous non basic
+ /// variables at their upper bound.
+ void flip(double *row);
+
+ /// Change the sign of the coefficients of the continuous non basic
+ /// variables at their upper bound and do the translations restoring
+ /// the original bounds. Modify the right hand side
+ /// accordingly.
+ void unflip(double *row, double *rowrhs, double *slack_val);
+
+ /// Return the scale factor for the row.
+ /// Compute max_coeff: maximum absolute value of the coefficients.
+ /// Compute min_coeff: minimum absolute value of the coefficients
+ /// larger than EPS_COEFF.
+ /// Return -1 if max_coeff < EPS_COEFF or if max_coeff/min_coeff > MAXDYN
+ /// or MAXDYN_LUB (depending if the row has a non zero coeff. for a variable
+ /// with large lower/upper bound) */.
+ double row_scale_factor(double *row);
+
+ /// Generate the packed cut from the row representation.
+ int generate_packed_row(const double *xlp, double *row,
+ int *rowind, double *rowelem,
+ int *card_row, double & rhs);
+
+ /// Check that the generated cuts do not cut a given optimal solution.
+ void check_optsol(const int calling_place,
+ const double *xlp, const double *slack_val,
+ const int do_flip);
+
+ /// Check that the generated cuts do not cut a given optimal solution.
+ void check_optsol(const int calling_place,
+ const double *xlp, const double *slack_val,
+ const double *ck_row, const double ck_rhs,
+ const int cut_number, const int do_flip);
+
+ // Check that two vectors are different.
+ bool rs_are_different_vectors(const int *vect1,
+ const int *vect2,
+ const int dim);
+
+ // Check that two vectors are different.
+ bool rs_are_different_vectors(const double *vect1,
+ const double *vect2,
+ const int dim);
+
+ // Check that two matrices are different.
+ bool rs_are_different_matrices(const CoinPackedMatrix *mat1,
+ const CoinPackedMatrix *mat2,
+ const int nmaj,
+ const int nmin);
+ //@}
+
+
+ // Private member data
+
+/**@name Private member data */
+
+ //@{
+
+ /// Object with CglRedSplitParam members.
+ CglRedSplitParam param;
+
+ /// Number of rows ( = number of slack variables) in the current LP.
+ int nrow;
+
+ /// Number of structural variables in the current LP.
+ int ncol;
+
+ /// Lower bounds for structural variables
+ const double *colLower;
+
+ /// Upper bounds for structural variables
+ const double *colUpper;
+
+ /// Lower bounds for constraints
+ const double *rowLower;
+
+ /// Upper bounds for constraints
+ const double *rowUpper;
+
+ /// Righ hand side for constraints (upper bound for ranged constraints).
+ const double *rowRhs;
+
+ /// Number of integer basic structural variables that are fractional in the
+ /// current lp solution (at least param.away_ from being integer).
+ int card_intBasicVar_frac;
+
+ /// Number of integer non basic structural variables in the
+ /// current lp solution.
+ int card_intNonBasicVar;
+
+ /// Number of continuous non basic variables (structural or slack) in the
+ /// current lp solution.
+ int card_contNonBasicVar;
+
+ /// Number of non basic variables (structural or slack) at their
+ /// upper bound in the current lp solution.
+ int card_nonBasicAtUpper;
+
+ /// Number of non basic variables (structural or slack) at their
+ /// lower bound in the current lp solution.
+ int card_nonBasicAtLower;
+
+ /// Characteristic vector for integer basic structural variables
+ /// with non integer value in the current lp solution.
+ int *cv_intBasicVar_frac;
+
+ /// List of integer structural basic variables
+ /// (in order of pivot in selected rows for cut generation).
+ int *intBasicVar_frac;
+
+ /// List of integer structural non basic variables.
+ int *intNonBasicVar;
+
+ /// List of continuous non basic variables (structural or slack).
+ // slacks are considered continuous (no harm if this is not the case).
+ int *contNonBasicVar;
+
+ /// List of non basic variables (structural or slack) at their
+ /// upper bound.
+ int *nonBasicAtUpper;
+
+ /// List of non basic variables (structural or slack) at their lower
+ /// bound.
+ int *nonBasicAtLower;
+
+ /// Number of rows in the reduced tableau (= card_intBasicVar_frac).
+ int mTab;
+
+ /// Number of columns in the reduced tableau (= card_contNonBasicVar)
+ int nTab;
+
+ /// Tableau of multipliers used to alter the rows used in generation.
+ /// Dimensions: mTab by mTab. Initially, pi_mat is the identity matrix.
+ int **pi_mat;
+
+ /// Current tableau for continuous non basic variables (structural or slack).
+ /// Only rows used for generation.
+ /// Dimensions: mTab by nTab.
+ double **contNonBasicTab;
+
+ /// Current tableau for integer non basic structural variables.
+ /// Only rows used for generation.
+ // Dimensions: mTab by card_intNonBasicVar.
+ double **intNonBasicTab;
+
+ /// Right hand side of the tableau.
+ /// Only rows used for generation.
+ double *rhsTab ;
+
+ /// Given optimal solution that should not be cut; only for debug.
+ const double *given_optsol;
+
+ /// Number of entries in given_optsol.
+ int card_given_optsol;
+
+ /// Characteristic vectors of structural integer variables or continuous
+ /// variables currently fixed to integer values.
+ int *is_integer;
+
+ /// Characteristic vector of the structural variables whose lower bound
+ /// in absolute value is larger than LUB.
+ int *low_is_lub;
+
+ /// Characteristic vector of the structural variables whose upper bound
+ /// in absolute value is larger than LUB.
+ int *up_is_lub;
+
+ /// Pointer on solver. Reset by each call to generateCuts().
+ OsiSolverInterface *solver;
+
+ /// Pointer on point to separate. Reset by each call to generateCuts().
+ const double *xlp;
+
+ /// Pointer on row activity. Reset by each call to generateCuts().
+ const double *rowActivity;
+
+ /// Pointer on column type. Reset by each call to generateCuts().
+ const char *colType;
+
+ /// Pointer on matrix of coefficient ordered by rows.
+ /// Reset by each call to generateCuts().
+ const CoinPackedMatrix *byRow;
+
+ //@}
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglRedSplit class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging. */
+void CglRedSplitUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglRedSplit2.hpp b/thirdparty/windows/include/coin/CglRedSplit2.hpp
new file mode 100644
index 0000000..c66e1ca
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglRedSplit2.hpp
@@ -0,0 +1,494 @@
+// Last edit: 04/03/10
+//
+// Name: CglRedSplit2.hpp
+// Author: Giacomo Nannicini
+// Singapore University of Technology and Design
+// Singapore
+// email: nannicini@sutd.edu.sg
+// based on CglRedSplit by Francois Margot
+// Date: 03/09/09
+//-----------------------------------------------------------------------------
+// Copyright (C) 2010, Giacomo Nannicini and others. All Rights Reserved.
+
+#ifndef CglRedSplit2_H
+#define CglRedSplit2_H
+
+#include "CglCutGenerator.hpp"
+#include "CglRedSplit2Param.hpp"
+#include "CoinWarmStartBasis.hpp"
+#include "CoinHelperFunctions.hpp"
+#include "CoinTime.hpp"
+
+/** Reduce-and-Split Cut Generator Class; See method generateCuts().
+ Based on the papers "Practical strategies for generating rank-1
+ split cuts in mixed-integer linear programming" by G. Cornuejols
+ and G. Nannicini, published on Mathematical Programming
+ Computation, and "Combining Lift-and-Project and Reduce-and-Split"
+ by E. Balas, G. Cornuejols, T. Kis and G. Nannicini, published on
+ INFORMS Journal on Computing. Part of this code is based on
+ CglRedSplit by F. Margot. */
+
+class CglRedSplit2 : public CglCutGenerator {
+
+ friend void CglRedSplit2UnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir);
+public:
+ /**@name generateCuts */
+ //@{
+ /** Generate Reduce-and-Split Mixed Integer Gomory cuts
+ for the model of the solver interface si.
+
+ Insert the generated cuts into OsiCuts cs.
+
+ This generator currently works only with the Lp solvers Clp or
+ Cplex9.0 or higher. It requires access to the optimal tableau
+ and optimal basis inverse and makes assumptions on the way slack
+ variables are added by the solver. The Osi implementations for
+ Clp and Cplex verify these assumptions.
+
+ When calling the generator, the solver interface si must contain
+ an optimized problem and information related to the optimal
+ basis must be available through the OsiSolverInterface methods
+ (si->optimalBasisIsAvailable() must return 'true'). It is also
+ essential that the integrality of structural variable i can be
+ obtained using si->isInteger(i).
+
+ Reduce-and-Split cuts are a class of split cuts. We compute
+ linear combinations of the rows of the simplex tableau, trying
+ to reduce some of the coefficients on the nonbasic continuous
+ columns. We have a large number of heuristics to choose which
+ coefficients should be reduced, and by using which rows. The
+ paper explains everything in detail.
+
+ Note that this generator can potentially generate a huge number
+ of cuts, depending on how it is parametered. Default parameters
+ should be good for most situations; if you want to go heavy on
+ split cuts, use more row selection strategies or a different
+ number of rows in the linear combinations. Again, look at the
+ paper for details. If you want to generate a small number of
+ cuts, default parameters are not the best choice.
+
+ A combination of Reduce-and-Split with Lift & Project is
+ described in the paper "Combining Lift-and-Project and
+ Reduce-and-Split". The Reduce-and-Split code for the
+ implementation used in that paper is included here.
+
+ This generator does not generate the same cuts as CglRedSplit,
+ therefore both generators can be used in conjunction.
+
+ */
+
+ virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+
+ /// Return true if needs optimal basis to do cuts (will return true)
+ virtual bool needsOptimalBasis() const;
+
+ // Generate the row multipliers computed by Reduce-and-Split from the
+ // given OsiSolverInterface. The multipliers are written in lambda;
+ // lambda should be of size nrow*maxNumMultipliers. We generate at most
+ // maxNumMultipliers m-vectors of row multipliers, and return the number
+ // of m-vectors that were generated.
+ // If the caller wants to know which variables are basic in each row
+ // (same order as lambda), basicVariables should be non-NULL (size nrow).
+ // This method can also generate the cuts corresponding to the multipliers
+ // returned; it suffices to pass non-NULL OsiCuts.
+ // This method is not needed by the typical user; however, it is useful
+ // in the context of generating Lift & Project cuts.
+ int generateMultipliers(const OsiSolverInterface& si, int* lambda,
+ int maxNumMultipliers, int* basicVariables = NULL,
+ OsiCuts* cs = NULL);
+
+ // Try to improve a Lift & Project cut, by employing the
+ // Reduce-and-Split procedure. We start from a row of a L&P tableau,
+ // and generate a cut trying to reduce the coefficients on the
+ // nonbasic variables. Note that this L&P tableau will in general
+ // have nonbasic variables which are nonzero in the point that we
+ // want to cut off, so we should be careful. Arguments:
+ // OsiSolverInterface which contains the simplex tableau, initial
+ // row from which the cut is derived, row rhs, row number of the
+ // source row (if it is in the simplex tableau; otherwise, a
+ // negative number; needed to avoid using duplicate rows), point
+ // that we want to cut off (note: this is NOT a basic solution for
+ // the OsiSolverInterace!), list of variables which are basic in
+ // xbar but are nonbasic in the OsiSolverInterface. The computed cut
+ // is written in OsiRowCut* cs. Finally, if a starting disjunction
+ // is provided in the vector lambda (of size ncols, i.e. a
+ // disjunction on the structural variables), the disjunction is
+ // modified according to the cut which is produced.
+ int tiltLandPcut(const OsiSolverInterface* si, double* row,
+ double rowRhs, int rownumber, const double* xbar,
+ const int* newnonbasics, OsiRowCut* cs, int* lambda = NULL);
+
+ //@}
+
+
+ /**@name Public Methods */
+ //@{
+
+ // Set the parameters to the values of the given CglRedSplit2Param object.
+ void setParam(const CglRedSplit2Param &source);
+ // Return the CglRedSplit2Param object of the generator.
+ inline CglRedSplit2Param& getParam() {return param;}
+
+ /// Print some of the data members; used for debugging
+ void print() const;
+
+ /// Print the current simplex tableau
+ void printOptTab(OsiSolverInterface *solver) const;
+
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglRedSplit2();
+
+ /// Constructor with specified parameters
+ CglRedSplit2(const CglRedSplit2Param &RS_param);
+
+ /// Copy constructor
+ CglRedSplit2(const CglRedSplit2 &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglRedSplit2 & operator=(const CglRedSplit2& rhs);
+
+ /// Destructor
+ virtual ~CglRedSplit2 ();
+
+ //@}
+
+private:
+
+ // Private member methods
+
+/**@name Private member methods */
+
+ //@{
+
+ // Method generating the cuts after all CglRedSplit2 members are
+ // properly set. This does the actual work. Returns the number of
+ // generated cuts (or multipliers).
+ // Will generate cuts if cs != NULL, and will generate multipliers
+ // if lambda != NULL.
+ int generateCuts(OsiCuts* cs, int maxNumCuts, int* lambda = NULL);
+
+ /// Compute the fractional part of value, allowing for small error.
+ inline double rs_above_integer(const double value) const;
+
+ /// Fill workNonBasicTab, depending on the column selection strategy.
+ /// Accepts a list of variables indices that should be ignored; by
+ /// default, this list is empty (it is only used by Lift & Project).
+ /// The list ignore_list contains -1 as the last element.
+ /// Note that the implementation of the ignore_list is not very efficient
+ /// if the list is long, so it should be used only if its short.
+ void fill_workNonBasicTab(CglRedSplit2Param::ColumnSelectionStrategy
+ strategy, const int* ignore_list = NULL);
+
+ /// Fill workNonBasicTab, alternate version for Lift & Project: also
+ /// reduces columns which are now nonbasic but are basic in xbar.
+ /// This function should be called only when CglRedSplit2 is used in
+ /// conjunction with CglLandP to generate L&P+RS cuts.
+ void fill_workNonBasicTab(const int* newnonbasics, const double* xbar,
+ CglRedSplit2Param::ColumnScalingStrategy scaling);
+
+ /// Reduce rows of workNonBasicTab, i.e. compute integral linear
+ /// combinations of the rows in order to reduce row coefficients on
+ /// workNonBasicTab
+ void reduce_workNonBasicTab(int numRows,
+ CglRedSplit2Param::RowSelectionStrategy
+ rowSelectionStrategy,
+ int maxIterations);
+
+ /// Generate a linear combination of the rows of the current LP
+ /// tableau, using the row multipliers stored in the matrix pi_mat
+ /// on the row of index index_row
+ void generate_row(int index_row, double *row);
+
+ /// Generate a mixed integer Gomory cut, when all non basic
+ /// variables are non negative and at their lower bound.
+ int generate_cgcut(double *row, double *rhs);
+
+ /// Use multiples of the initial inequalities to cancel out the coefficients
+ /// of the slack variables.
+ void eliminate_slacks(double *row,
+ const double *elements,
+ const int *start,
+ const int *indices,
+ const int *rowLength,
+ const double *rhs, double *rowrhs);
+
+ /// Change the sign of the coefficients of the continuous non basic
+ /// variables at their upper bound.
+ void flip(double *row);
+
+ /// Change the sign of the coefficients of the continuous non basic
+ /// variables at their upper bound and do the translations restoring
+ /// the original bounds. Modify the right hand side
+ /// accordingly.
+ void unflip(double *row, double *rowrhs);
+
+ /// Returns 1 if the row has acceptable max/min coeff ratio.
+ /// Compute max_coeff: maximum absolute value of the coefficients.
+ /// Compute min_coeff: minimum absolute value of the coefficients
+ /// larger than EPS_COEFF.
+ /// Return 0 if max_coeff/min_coeff > MAXDYN.
+ int check_dynamism(double *row);
+
+ /// Generate the packed cut from the row representation.
+ int generate_packed_row(const double *xlp, double *row,
+ int *rowind, double *rowelem,
+ int *card_row, double & rhs);
+
+ // Compute entries of is_integer.
+ void compute_is_integer();
+
+ // Check that two vectors are different.
+ bool rs_are_different_vectors(const int *vect1,
+ const int *vect2,
+ const int dim);
+
+ // allocate matrix of integers
+ void rs_allocmatINT(int ***v, int m, int n);
+ // deallocate matrix of integers
+ void rs_deallocmatINT(int ***v, int m);
+ // allocate matrix of doubles
+ void rs_allocmatDBL(double ***v, int m, int n);
+ // deallocate matrix of doubles
+ void rs_deallocmatDBL(double ***v, int m);
+ // print a vector of integers
+ void rs_printvecINT(const char *vecstr, const int *x, int n) const;
+ // print a vector of doubles
+ void rs_printvecDBL(const char *vecstr, const double *x, int n) const;
+ // print a matrix of integers
+ void rs_printmatINT(const char *vecstr, const int * const *x, int m, int n) const;
+ // print a matrix of doubles
+ void rs_printmatDBL(const char *vecstr, const double * const *x, int m, int n) const;
+ // dot product
+ double rs_dotProd(const double *u, const double *v, int dim) const;
+ double rs_dotProd(const int *u, const double *v, int dim) const;
+ // From Numerical Recipes in C: LU decomposition
+ int ludcmp(double **a, int n, int *indx, double *d, double* vv) const;
+ // from Numerical Recipes in C: backward substitution
+ void lubksb(double **a, int n, int *indx, double *b) const;
+
+ // Check if the linear combination given by listOfRows with given multipliers
+ // improves the norm of row #rowindex; note: multipliers are rounded!
+ // Returns the difference with respect to the old norm (if negative there is
+ // an improvement, if positive norm increases)
+ double compute_norm_change(double oldnorm, const int* listOfRows,
+ int numElemList, const double* multipliers) const;
+
+ // Compute the list of rows that should be used to reduce row #rowIndex
+ int get_list_rows_reduction(int rowIndex, int numRowsReduction,
+ int* list, const double* norm,
+ CglRedSplit2Param::RowSelectionStrategy
+ rowSelectionStrategy) const;
+
+ // Sorts the rows by increasing number of nonzeroes with respect to a given
+ // row (rowIndex), on the nonbasic variables (whichTab == 0 means only
+ // integer, whichTab == 1 means only workTab, whichTab == 2 means both).
+ // The array for sorting must be allocated (and deleted) by caller.
+ // Corresponds to BRS1 in the paper.
+ int sort_rows_by_nonzeroes(struct sortElement* array, int rowIndex,
+ int maxRows, int whichTab) const;
+
+ // Greedy variant of the previous function; slower but typically
+ // more effective. Corresponds to BRS2 in the paper.
+ int sort_rows_by_nonzeroes_greedy(struct sortElement* array, int rowIndex,
+ int maxRows, int whichTab) const;
+
+ // Sorts the rows by decreasing absolute value of the cosine of the
+ // angle with respect to a given row (rowIndex), on the nonbasic
+ // variables (whichTab == 0 means only integer, whichTab == 1 means
+ // only workTab, whichTab == 2 means both). The array for sorting
+ // must be allocated (and deleted) by caller. Very effective
+ // strategy in practice. Corresponds to BRS3 in the paper.
+ int sort_rows_by_cosine(struct sortElement* array, int rowIndex,
+ int maxRows, int whichTab) const;
+
+ // Did we hit the time limit?
+ inline bool checkTime() const{
+ if ((CoinCpuTime() - startTime) < param.getTimeLimit()){
+ return true;
+ }
+ return false;
+ }
+
+ //@}
+
+
+ // Private member data
+
+ /**@name Private member data */
+
+ //@{
+
+ /// Object with CglRedSplit2Param members.
+ CglRedSplit2Param param;
+
+ /// Number of rows ( = number of slack variables) in the current LP.
+ int nrow;
+
+ /// Number of structural variables in the current LP.
+ int ncol;
+
+ /// Number of rows which have been reduced
+ int numRedRows;
+
+ /// Lower bounds for structural variables
+ const double *colLower;
+
+ /// Upper bounds for structural variables
+ const double *colUpper;
+
+ /// Lower bounds for constraints
+ const double *rowLower;
+
+ /// Upper bounds for constraints
+ const double *rowUpper;
+
+ /// Righ hand side for constraints (upper bound for ranged constraints).
+ const double *rowRhs;
+
+ /// Reduced costs for columns
+ const double *reducedCost;
+
+ /// Row price
+ const double *rowPrice;
+
+ /// Objective coefficients
+ const double* objective;
+
+ /// Number of integer basic structural variables
+ int card_intBasicVar;
+
+ /// Number of integer basic structural variables that are fractional in the
+ /// current lp solution (at least param.away_ from being integer).
+ int card_intBasicVar_frac;
+
+ /// Number of integer non basic structural variables in the
+ /// current lp solution.
+ int card_intNonBasicVar;
+
+ /// Number of continuous non basic variables (structural or slack) in the
+ /// current lp solution.
+ int card_contNonBasicVar;
+
+ /// Number of continuous non basic variables (structural or slack) in the
+ /// current working set for coefficient reduction
+ int card_workNonBasicVar;
+
+ /// Number of non basic variables (structural or slack) at their
+ /// upper bound in the current lp solution.
+ int card_nonBasicAtUpper;
+
+ /// Number of non basic variables (structural or slack) at their
+ /// lower bound in the current lp solution.
+ int card_nonBasicAtLower;
+
+ /// Characteristic vector for integer basic structural variables
+ int *cv_intBasicVar;
+
+ /// Characteristic vector for integer basic structural variables
+ /// with non integer value in the current lp solution.
+ int *cv_intBasicVar_frac;
+
+ /// Characteristic vector for rows of the tableau selected for reduction
+ /// with non integer value in the current lp solution
+ int *cv_fracRowsTab;
+
+ /// List of integer structural basic variables
+ /// (in order of pivot in selected rows for cut generation).
+ int *intBasicVar;
+
+ /// List of integer structural basic variables with fractional value
+ /// (in order of pivot in selected rows for cut generation).
+ int *intBasicVar_frac;
+
+ /// List of integer structural non basic variables.
+ int *intNonBasicVar;
+
+ /// List of continuous non basic variables (structural or slack).
+ // slacks are considered continuous (no harm if this is not the case).
+ int *contNonBasicVar;
+
+ /// List of non basic variables (structural or slack) at their
+ /// upper bound.
+ int *nonBasicAtUpper;
+
+ /// List of non basic variables (structural or slack) at their lower
+ /// bound.
+ int *nonBasicAtLower;
+
+ /// Number of rows in the reduced tableau (= card_intBasicVar).
+ int mTab;
+
+ /// Number of columns in the reduced tableau (= card_contNonBasicVar)
+ int nTab;
+
+ /// Tableau of multipliers used to alter the rows used in generation.
+ /// Dimensions: mTab by mTab. Initially, pi_mat is the identity matrix.
+ int **pi_mat;
+
+ /// Simplex tableau for continuous non basic variables (structural or slack).
+ /// Only rows used for generation.
+ /// Dimensions: mTab by card_contNonBasicVar.
+ double **contNonBasicTab;
+
+ /// Current tableau for continuous non basic variables (structural or slack).
+ /// Only columns used for coefficient reduction.
+ /// Dimensions: mTab by card_workNonBasicVar.
+ double **workNonBasicTab;
+
+ /// Simplex tableau for integer non basic structural variables.
+ /// Only rows used for generation.
+ // Dimensions: mTab by card_intNonBasicVar.
+ double **intNonBasicTab;
+
+ /// Right hand side of the tableau.
+ /// Only rows used for generation.
+ double *rhsTab;
+
+ /// Norm of rows in workNonBasicTab; needed for faster computations
+ double *norm;
+
+ /// Characteristic vectors of structural integer variables or continuous
+ /// variables currently fixed to integer values.
+ int *is_integer;
+
+ /// Pointer on solver. Reset by each call to generateCuts().
+ OsiSolverInterface *solver;
+
+ /// Pointer on point to separate. Reset by each call to generateCuts().
+ const double *xlp;
+
+ /// Pointer on row activity. Reset by each call to generateCuts().
+ const double *rowActivity;
+
+ /// Pointer on matrix of coefficient ordered by rows.
+ /// Reset by each call to generateCuts().
+ const CoinPackedMatrix *byRow;
+
+ /// Time at which cut computations began.
+ /// Reset by each call to generateCuts().
+ double startTime;
+
+ //@}
+};
+
+//#############################################################################
+/** A function that tests some of the methods in the CglRedSplit2
+ class. The only reason for it not to be a member method is that
+ this way it doesn't have to be compiled into the library. And
+ that's a gain, because the library should be compiled with
+ optimization on, but this method should be compiled with
+ debugging. */
+void CglRedSplit2UnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglRedSplit2Param.hpp b/thirdparty/windows/include/coin/CglRedSplit2Param.hpp
new file mode 100644
index 0000000..369c676
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglRedSplit2Param.hpp
@@ -0,0 +1,495 @@
+// Name: CglRedSplit2Param.hpp
+// Author: Giacomo Nannicini
+// Singapore University of Technology and Design
+// Singapore
+// email: nannicini@sutd.edu.sg
+// Date: 03/09/09
+//-----------------------------------------------------------------------------
+// Copyright (C) 2010, Giacomo Nannicini and others. All Rights Reserved.
+
+#ifndef CglRedSplit2Param_H
+#define CglRedSplit2Param_H
+
+#include "CglParam.hpp"
+#include
+
+ /**@name CglRedSplit2 Parameters */
+ //@{
+
+ /** Class collecting parameters the Reduced-and-split cut generator.
+
+ An important thing to note is that the cut generator allows for
+ the selection of a number of strategies that can be combined
+ together. By default, a selection that typically yields a good
+ compromise between speed and cut strenght is made. The selection
+ can be changed by resetting the default choices (see the
+ functions whose name starts with "reset") or by setting the
+ parameter use_default_strategies to false in the
+ constructors. After this, the chosen strategies can be added to
+ the list by using the functions whose name starts with
+ "add". All strategies will be combined together: if we choose 3
+ row selection strategies, 2 column selection strategies, and 2
+ possible numbers of rows, we end up with a total of 3*2*2
+ combinations.
+
+ For a detailed explanation of the parameters and their meaning,
+ see the paper by Cornuejols and Nannicini: "Practical strategies
+ for generating rank-1 split cuts in mixed-integer linear
+ programming", on Mathematical Programming Computation.
+
+ Parameters of the generator are listed below.
+
+ - MAXDYN: Maximum ratio between largest and smallest non zero
+ coefficients in a cut. See method setMAXDYN().
+ - EPS_ELIM: Precision for deciding if a coefficient is zero when
+ eliminating slack variables. See method setEPS_ELIM().
+ - MINVIOL: Minimum violation for the current basic solution in
+ a generated cut. See method setMINVIOL().
+ - EPS_RELAX_ABS: Absolute relaxation of cut rhs.
+ - EPS_RELAX_REL: Relative relaxation of cut rhs.
+ - MAX_SUPP_ABS: Maximum cut support (absolute).
+ - MAX_SUPP_REL: Maximum cut support (relative): the formula to
+ compute maximum cut support is
+ MAX_SUPP_ABS + ncol*MAX_SUPP_REL.
+ - USE_INTSLACKS: Use integer slacks to generate cuts. (not implemented).
+ See method setUSE_INTSLACKS().
+ - normIsZero: Norm of a vector is considered zero if smaller than
+ this value. See method setNormIsZero().
+ - minNormReduction: a cut is generated if the new norm of the row on the
+ continuous nonbasics is reduced by at least
+ this factor (relative reduction).
+ - away: Look only at basic integer variables whose current value
+ is at least this value from being integer. See method setAway().
+ - maxSumMultipliers: maximum sum (in absolute value) of row multipliers
+ - normalization: normalization factor for the norm of lambda in the
+ coefficient reduction algorithm (convex min problem)
+ - numRowsReduction: Maximum number of rows in the linear system for
+ norm reduction.
+ - columnSelectionStrategy: parameter to select which columns should be
+ used for coefficient reduction.
+ - rowSelectionStrategy: parameter to select which rows should be
+ used for coefficient reduction.
+ - timeLimit: Time limit (in seconds) for cut generation.
+ - maxNumCuts: Maximum number of cuts that can be returned at each pass;
+ we could generate more cuts than this number (see below)
+ - maxNumComputedCuts: Maximum number of cuts that can be computed
+ by the generator at each pass
+ - maxNonzeroesTab : Rows of the simplex tableau with more than
+ this number of nonzeroes will not be
+ considered for reduction. Only works if
+ RS_FAST_* are defined in CglRedSplit2.
+ - skipGomory: Skip traditional Gomory cuts, i.e. GMI cuts arising from
+ a single row of the tableau (instead of a combination).
+ Default is 1 (true), because we assume that they are
+ generated by a traditional Gomory generator anyway.
+ */
+ //@}
+
+class CglRedSplit2Param : public CglParam {
+
+public:
+ /** Enumerations for parameters */
+
+ /** Row selection strategies; same names as in the paper */
+ enum RowSelectionStrategy{
+ /* Pick rows that introduce the fewest nonzeroes on integer nonbasics */
+ RS1,
+ /* Pick rows that introduce the fewest nonzeroes on the set of working
+ continuous nonbasics */
+ RS2,
+ /* Pick rows that introduce the fewest nonzeroes on both integer and
+ working continuous nonbasics */
+ RS3,
+ /* Same as RS0 but with greedy algorithm */
+ RS4,
+ /* Same as RS1 but with greedy algorithm */
+ RS5,
+ /* Same as RS2 but with greedy algorithm */
+ RS6,
+ /* Pick rows with smallest angle in the space of integer and working
+ continuous nonbasics */
+ RS7,
+ /* Pick rows with smallest angle in the space of working
+ continuous nonbasics */
+ RS8,
+ /* Use all strategies */
+ RS_ALL,
+ /* Use best ones - that is, RS8 and RS7 */
+ RS_BEST
+ };
+
+ /** Column selection strategies; again, look them up in the paper. */
+ enum ColumnSelectionStrategy{
+ /* C-3P */
+ CS1, CS2, CS3,
+ /* C-5P */
+ CS4, CS5, CS6, CS7, CS8,
+ /* I-2P-2/3 */
+ CS9, CS10,
+ /* I-2P-4/5 */
+ CS11, CS12,
+ /* I-2P-1/2 */
+ CS13, CS14,
+ /* I-3P */
+ CS15, CS16, CS17,
+ /* I-4P */
+ CS18, CS19, CS20, CS21,
+ /* Use all strategies up to this point */
+ CS_ALL,
+ /* Use best strategies (same effect as CS_ALL, because it turns out that
+ using all strategies is the best thing to do) */
+ CS_BEST,
+ /* Optimize over all continuous nonbasic columns; this does not give
+ good results, but we use it for testing Lift & Project + RedSplit */
+ CS_ALLCONT,
+ /* Lift & Project specific strategy: only select variables which
+ are nonbasic in the tableau but are basic in the point to cut
+ off. This strategy cannot be used outside L&P. It is not very
+ effective even with L&P, but is left here for testing.*/
+ CS_LAP_NONBASICS
+ };
+
+ /** Scaling strategies for new nonbasic columns for Lift & Project;
+ * "factor" is the value of columnScalingBoundLAP_ */
+ enum ColumnScalingStrategy{
+ /* No scaling */
+ SC_NONE,
+ /* Multiply by |xbar[i]| where xbar[i] is the value of the
+ corresponding component of the point that we want to cut off */
+ SC_LINEAR,
+ /* Multiply by min(factor,|xbar[i]|) */
+ SC_LINEAR_BOUNDED,
+ /* Multiply by min(factor,log(|xbar[i]|)) */
+ SC_LOG_BOUNDED,
+ /* Multiply all new nonbasics by factor */
+ SC_UNIFORM,
+ /* Multiply only nonzero coefficients by factor */
+ SC_UNIFORM_NZ
+ };
+
+ /**@name Set/get methods */
+ //@{
+ /** Set away, the minimum distance from being integer used for selecting
+ rows for cut generation; all rows whose pivot variable should be
+ integer but is more than away from integrality will be selected;
+ Default: 0.005 */
+ virtual void setAway(double value);
+ /// Get value of away
+ inline double getAway() const {return away_;}
+
+ /** Set the value of EPS_ELIM, epsilon for values of coefficients when
+ eliminating slack variables;
+ Default: 0.0 */
+ void setEPS_ELIM(double value);
+ /** Get the value of EPS_ELIM */
+ double getEPS_ELIM() const {return EPS_ELIM;}
+
+ /** Set EPS_RELAX_ABS */
+ virtual void setEPS_RELAX_ABS(double eps_ra);
+ /** Get value of EPS_RELAX_ABS */
+ inline double getEPS_RELAX_ABS() const {return EPS_RELAX_ABS;}
+
+ /** Set EPS_RELAX_REL */
+ virtual void setEPS_RELAX_REL(double eps_rr);
+ /** Get value of EPS_RELAX_REL */
+ inline double getEPS_RELAX_REL() const {return EPS_RELAX_REL;}
+
+ // Set the maximum ratio between largest and smallest non zero
+ // coefficients in a cut. Default: 1e6.
+ virtual void setMAXDYN(double value);
+ /** Get the value of MAXDYN */
+ inline double getMAXDYN() const {return MAXDYN;}
+
+ /** Set the value of MINVIOL, the minimum violation for the current
+ basic solution in a generated cut. Default: 1e-3 */
+ virtual void setMINVIOL(double value);
+ /** Get the value of MINVIOL */
+ inline double getMINVIOL() const {return MINVIOL;}
+
+ /** Maximum absolute support of the cutting planes. Default: INT_MAX.
+ Aliases for consistency with our naming scheme. */
+ inline void setMAX_SUPP_ABS(int value) {setMAX_SUPPORT(value);}
+ inline int getMAX_SUPP_ABS() const {return MAX_SUPPORT;}
+
+ /** Maximum relative support of the cutting planes. Default: 0.0.
+ The maximum support is MAX_SUPP_ABS + MAX_SUPPREL*ncols. */
+ inline void setMAX_SUPP_REL(double value);
+ inline double getMAX_SUPP_REL() const {return MAX_SUPP_REL;}
+
+ /** Set the value of USE_INTSLACKS. Default: 0 */
+ virtual void setUSE_INTSLACKS(int value);
+ /** Get the value of USE_INTSLACKS */
+ inline int getUSE_INTSLACKS() const {return USE_INTSLACKS;}
+
+ /** Set the value of normIsZero, the threshold for considering a norm to be
+ 0; Default: 1e-5 */
+ virtual void setNormIsZero(double value);
+ /** Get the value of normIsZero */
+ inline double getNormIsZero() const {return normIsZero_;}
+
+ /** Set the value of minNormReduction; Default: 0.1 */
+ virtual void setMinNormReduction(double value);
+ /** Get the value of normIsZero */
+ inline double getMinNormReduction() const {return minNormReduction_;}
+
+ /** Set the value of maxSumMultipliers; Default: 10 */
+ virtual void setMaxSumMultipliers(int value);
+ /** Get the value of maxSumMultipliers */
+ inline int getMaxSumMultipliers() const {return maxSumMultipliers_;}
+
+ /** Set the value of normalization; Default: 0.0001 */
+ virtual void setNormalization(double value);
+ /** Get the value of normalization */
+ inline double getNormalization() const {return normalization_;}
+
+ /** Set the value of numRowsReduction, max number of rows that are used
+ * for each row reduction step. In particular, the linear system will
+ * involve a numRowsReduction*numRowsReduction matrix */
+ virtual void addNumRowsReduction(int value);
+ /// get the value
+ inline std::vector getNumRowsReduction() const {return numRowsReduction_;}
+ /// reset
+ inline void resetNumRowsReduction() {numRowsReduction_.clear();}
+
+ /** Add the value of columnSelectionStrategy */
+ virtual void addColumnSelectionStrategy(ColumnSelectionStrategy value);
+ /// get the value
+ inline std::vector getColumnSelectionStrategy() const {return columnSelectionStrategy_;}
+ /// reset
+ inline void resetColumnSelectionStrategy(){columnSelectionStrategy_.clear();}
+
+ /** Set the value for rowSelectionStrategy, which changes the way we choose
+ * the rows for the reduction step */
+ virtual void addRowSelectionStrategy(RowSelectionStrategy value);
+ /// get the value
+ inline std::vector getRowSelectionStrategy() const {return rowSelectionStrategy_;};
+ /// reset
+ inline void resetRowSelectionStrategy() {rowSelectionStrategy_.clear();}
+
+ /** Set the value of numRowsReductionLAP, max number of rows that are used
+ * for each row reduction step during Lift & Project.
+ * In particular, the linear system will involve a
+ * numRowsReduction*numRowsReduction matrix */
+ virtual void addNumRowsReductionLAP(int value);
+ /// get the value
+ inline std::vector getNumRowsReductionLAP() const {return numRowsReductionLAP_;}
+ /// reset
+ inline void resetNumRowsReductionLAP() {numRowsReductionLAP_.clear();}
+
+ /** Add the value of columnSelectionStrategyLAP */
+ virtual void addColumnSelectionStrategyLAP(ColumnSelectionStrategy value);
+ /// get the value
+ inline std::vector getColumnSelectionStrategyLAP() const {return columnSelectionStrategyLAP_;}
+ /// reset
+ inline void resetColumnSelectionStrategyLAP(){columnSelectionStrategyLAP_.clear();}
+
+ /** Set the value for rowSelectionStrategyLAP, which changes the way we
+ * choose the rows for the reduction step */
+ virtual void addRowSelectionStrategyLAP(RowSelectionStrategy value);
+ /// get the value
+ inline std::vector getRowSelectionStrategyLAP() const {return rowSelectionStrategyLAP_;};
+ /// reset
+ inline void resetRowSelectionStrategyLAP() {rowSelectionStrategyLAP_.clear();}
+
+ /** Set the value for columnScalingStrategyLAP, which sets the way nonbasic
+ * columns that are basic in the fractional point to cut off are scaled */
+ virtual void setColumnScalingStrategyLAP(ColumnScalingStrategy value);
+ /// get the value
+ inline ColumnScalingStrategy getColumnScalingStrategyLAP() const {return columnScalingStrategyLAP_; };
+
+ /** Set the value for the bound in the column scaling factor */
+ virtual void setColumnScalingBoundLAP(double value);
+ /// get the value
+ inline double getColumnScalingBoundLAP() const {return columnScalingBoundLAP_;};
+
+ /** Set the value of the time limit for cut generation (in seconds) */
+ virtual void setTimeLimit(double value);
+ /// get the value
+ inline double getTimeLimit() const {return timeLimit_;}
+
+ /** Set the value for the maximum number of cuts that can be returned */
+ virtual void setMaxNumCuts(int value);
+ /// get the value
+ inline int getMaxNumCuts() const {return maxNumCuts_;}
+
+ /** Set the value for the maximum number of cuts that can be computed */
+ virtual void setMaxNumComputedCuts(int value);
+ /// get the value
+ inline int getMaxNumComputedCuts() const {return maxNumComputedCuts_;}
+
+ /** Set the value for the maximum number of nonzeroes in a row of
+ * the simplex tableau for the row to be considered */
+ virtual void setMaxNonzeroesTab(int value);
+ /// get the value
+ inline int getMaxNonzeroesTab() const {return maxNonzeroesTab_;}
+
+ /** Set the value of skipGomory: should we skip simple Gomory cuts,
+ * i.e. GMI cuts derived from a single row of the simple tableau?
+ * This is 1 (true) by default: we only generate cuts from linear
+ * combinations of at least two rows. */
+ virtual void setSkipGomory(int value);
+ /// get the value
+ inline int getSkipGomory() const {return skipGomory_;}
+
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor. If use_default_strategies is true, we add
+ /// to the list of strategies the default ones. If is false, the
+ /// list of strategies is left empty (must be populated before usage!).
+ CglRedSplit2Param(bool use_default_strategies = true,
+ double eps = 1e-12,
+ double eps_coeff = 1e-11,
+ double eps_elim = 0.0,
+ double eps_relax_abs = 1e-11,
+ double eps_relax_rel = 1e-13,
+ double max_dyn = 1e6,
+ double min_viol = 1e-3,
+ int max_supp_abs = 1000,
+ double max_supp_rel = 0.1,
+ int use_int_slacks = 0,
+ double norm_zero = 1e-5,
+ double minNormReduction = 0.1,
+ int maxSumMultipliers = 10,
+ double normalization = 0.0001,
+ double away = 0.005,
+ double timeLimit = 60,
+ int maxNumCuts = 10000,
+ int maxNumComputedCuts = 10000,
+ int maxNonzeroesTab = 1000,
+ double columnScalingBoundLAP = 5.0,
+ int skipGomory = 1);
+
+ /// Constructor from CglParam. If use_default_strategies is true, we
+ /// add to the list of strategies the default ones. If is false, the
+ /// list of strategies is left empty (must be populated before
+ /// usage!).
+ CglRedSplit2Param(const CglParam &source,
+ bool use_default_strategies = true,
+ double eps_elim = 0.0,
+ double eps_relax_abs = 1e-11,
+ double eps_relax_rel = 1e-13,
+ double max_dyn = 1e6,
+ double min_viol = 1e-3,
+ double max_supp_rel = 0.1,
+ int use_int_slacks = 0,
+ double norm_zero = 1e-5,
+ double minNormReduction = 0.1,
+ int maxSumMultipliers = 10,
+ double normalization = 0.0001,
+ double away = 0.005,
+ double timeLimit = 60,
+ int maxNumCuts = 10000,
+ int maxNumComputedCuts = 10000,
+ int maxNonzeroesTab = 1000,
+ double columnScalingBoundLAP = 5.0,
+ int skipGomory = 1);
+
+ /// Copy constructor
+ CglRedSplit2Param(const CglRedSplit2Param &source);
+
+ /// Clone
+ virtual CglRedSplit2Param* clone() const;
+
+ /// Assignment operator
+ virtual CglRedSplit2Param& operator=(const CglRedSplit2Param &rhs);
+
+ /// Destructor
+ virtual ~CglRedSplit2Param();
+ //@}
+
+protected:
+
+ /**@name Parameters */
+ //@{
+
+ /** Epsilon for value of coefficients when eliminating slack variables.
+ Default: 0.0. */
+ double EPS_ELIM;
+
+ /** Value added to the right hand side of each generated cut to relax it.
+ Default: 1e-11 */
+ double EPS_RELAX_ABS;
+
+ /** For a generated cut with right hand side rhs_val,
+ EPS_RELAX_EPS * fabs(rhs_val) is used to relax the constraint.
+ Default: 1e-13 */
+ double EPS_RELAX_REL;
+
+ // Maximum ratio between largest and smallest non zero
+ // coefficients in a cut. Default: 1e6.
+ double MAXDYN;
+
+ /// Minimum violation for the current basic solution in a generated cut.
+ /// Default: 1e-3.
+ double MINVIOL;
+
+ /// Maximum support - relative part of the formula
+ double MAX_SUPP_REL;
+
+ /// Use integer slacks to generate cuts if USE_INTSLACKS = 1. Default: 0.
+ int USE_INTSLACKS;
+
+ /// Norm of a vector is considered zero if smaller than normIsZero;
+ /// Default: 1e-5.
+ double normIsZero_;
+
+ /// Minimum reduction to accept a new row.
+ double minNormReduction_;
+
+ /// Maximum sum of the vector of row multipliers to generate a cut
+ int maxSumMultipliers_;
+
+ /// Normalization factor for the norm of lambda in the quadratic
+ /// minimization problem that is solved during the coefficient reduction step
+ double normalization_;
+
+ /// Use row only if pivot variable should be integer but is more
+ /// than away_ from being integer. Default: 0.005
+ double away_;
+
+ /// Maximum number of rows to use for the reduction of a given row.
+ std::vector numRowsReduction_;
+
+ /// Column selection method
+ std::vector columnSelectionStrategy_;
+
+ /// Row selection method
+ std::vector rowSelectionStrategy_;
+
+ /// Maximum number of rows to use for the reduction during Lift & Project
+ std::vector numRowsReductionLAP_;
+
+ /// Column selection method for Lift & Project
+ std::vector columnSelectionStrategyLAP_;
+
+ /// Row selection method for Lift & Project
+ std::vector rowSelectionStrategyLAP_;
+
+ /// Column scaling strategy for the nonbasics columns that were basic in
+ /// the point that we want to cut off (Lift & Project only)
+ ColumnScalingStrategy columnScalingStrategyLAP_;
+
+ /// Minimum value for column scaling (Lift & Project only)
+ double columnScalingBoundLAP_;
+
+ /// Time limit
+ double timeLimit_;
+
+ /// Maximum number of returned cuts
+ int maxNumCuts_;
+
+ /// Maximum number of computed cuts
+ int maxNumComputedCuts_;
+
+ /// Maximum number of nonzeroes in tableau row for reduction
+ int maxNonzeroesTab_;
+
+ /// Skip simple Gomory cuts
+ int skipGomory_;
+
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglRedSplitParam.hpp b/thirdparty/windows/include/coin/CglRedSplitParam.hpp
new file mode 100644
index 0000000..2601fb2
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglRedSplitParam.hpp
@@ -0,0 +1,272 @@
+// Name: CglRedSplitParam.hpp
+// Author: Francois Margot
+// Tepper School of Business
+// Carnegie Mellon University, Pittsburgh, PA 15213
+// email: fmargot@andrew.cmu.edu
+// Date: 11/24/06
+//
+// $Id: CglRedSplitParam.hpp 1122 2013-04-06 20:39:53Z stefan $
+//-----------------------------------------------------------------------------
+// Copyright (C) 2006, Francois Margot and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglRedSplitParam_H
+#define CglRedSplitParam_H
+
+#include "CglParam.hpp"
+
+
+ /**@name CglRedSplit Parameters */
+ //@{
+
+ /** Class collecting parameters the Reduced-and-split cut generator.
+
+ Parameters of the generator are listed below. Modifying the default
+ values for parameters other than the last four might result in
+ invalid cuts.
+
+ - LUB: Value considered large for the absolute value of a lower or upper
+ bound on a variable. See method setLUB().
+ - MAXDYN: Maximum ratio between largest and smallest non zero
+ coefficients in a cut. See method setMAXDYN().
+ - MAXDYN_LUB: Maximum ratio between largest and smallest non zero
+ coefficients in a cut involving structural variables with
+ lower or upper bound in absolute value larger than LUB.
+ Should logically be larger or equal to MAXDYN.
+ See method setMAXDYN_LUB().
+ - EPS_ELIM: Precision for deciding if a coefficient is zero when
+ eliminating slack variables. See method setEPS_ELIM().
+ - EPS_COEFF_LUB: Precision for deciding if a coefficient of a
+ generated cut is zero when the corresponding
+ variable has a lower or upper bound larger than
+ LUB in absolute value. See method setEPS_COEFF_LUB().
+ - MINVIOL: Minimum violation for the current basic solution in
+ a generated cut. See method setMINVIOL().
+ - USE_INTSLACKS: Use integer slacks to generate cuts. (not implemented).
+ See method setUSE_INTSLACKS().
+ - USE_CG2: Use alternative formula to generate a mixed integer Gomory
+ cut (see methods CglRedSPlit::generate_cgcut()
+ and CglRedSPlit::generate_cgcut_2()). See method setUSE_CG2().
+ - normIsZero: Norm of a vector is considered zero if smaller than
+ this value. See method setNormIsZero().
+ - minReduc: Reduction is performed only if the norm of the vector is
+ reduced by this fraction. See method setMinReduc().
+ - away: Look only at basic integer variables whose current value
+ is at least this value from being integer. See method setAway().
+ - maxTab: Controls the number of rows selected for the generation. See
+ method setMaxTab().
+ */
+ //@}
+
+class CglRedSplitParam : public CglParam {
+
+public:
+
+ /**@name Set/get methods */
+ //@{
+ /** Set away, the minimum distance from being integer used for selecting
+ rows for cut generation; all rows whose pivot variable should be
+ integer but is more than away from integrality will be selected;
+ Default: 0.05 */
+ virtual void setAway(const double value);
+ /// Get value of away
+ inline double getAway() const {return away_;}
+
+ /** Set the value of LUB, value considered large for the absolute value of
+ a lower or upper bound on a variable;
+ Default: 1000 */
+ virtual void setLUB(const double value);
+ /** Get the value of LUB */
+ inline double getLUB() const {return LUB;}
+
+ /** Set the value of EPS_ELIM, epsilon for values of coefficients when
+ eliminating slack variables;
+ Default: 1e-12 */
+ void setEPS_ELIM(const double value);
+ /** Get the value of EPS_ELIM */
+ double getEPS_ELIM() const {return EPS_ELIM;}
+
+ /** Set EPS_RELAX_ABS */
+ virtual void setEPS_RELAX_ABS(const double eps_ra);
+ /** Get value of EPS_RELAX_ABS */
+ inline double getEPS_RELAX_ABS() const {return EPS_RELAX_ABS;}
+
+ /** Set EPS_RELAX_REL */
+ virtual void setEPS_RELAX_REL(const double eps_rr);
+ /** Get value of EPS_RELAX_REL */
+ inline double getEPS_RELAX_REL() const {return EPS_RELAX_REL;}
+
+ // Set the maximum ratio between largest and smallest non zero
+ // coefficients in a cut. Default: 1e8.
+ virtual void setMAXDYN(double value);
+ /** Get the value of MAXDYN */
+ inline double getMAXDYN() const {return MAXDYN_LUB;}
+
+ // Set the maximum ratio between largest and smallest non zero
+ // coefficient in a cut involving structural variables with
+ // lower or upper bound in absolute value larger than LUB.
+ // Should logically be larger or equal to MAXDYN. Default: 1e13.
+ virtual void setMAXDYN_LUB(double value);
+ /** Get the value of MAXDYN_LUB */
+ inline double getMAXDYN_LUB() const {return MAXDYN_LUB;}
+
+ /** Set the value of EPS_COEFF_LUB, epsilon for values of coefficients for
+ variables with absolute value of lower or upper bound larger than LUB;
+ Default: 1e-13 */
+ virtual void setEPS_COEFF_LUB(const double value);
+ /** Get the value of EPS_COEFF_LUB */
+ inline double getEPS_COEFF_LUB() const {return EPS_COEFF_LUB;}
+
+ /** Set the value of MINVIOL, the minimum violation for the current
+ basic solution in a generated cut. Default: 1e-7 */
+ virtual void setMINVIOL(double value);
+ /** Get the value of MINVIOL */
+ inline double getMINVIOL() const {return MINVIOL;}
+
+ /** Set the value of USE_INTSLACKS. Default: 0 */
+ virtual void setUSE_INTSLACKS(int value);
+ /** Get the value of USE_INTSLACKS */
+ inline int getUSE_INTSLACKS() const {return USE_INTSLACKS;}
+
+ /** Set the value of USE_CG2. Default: 0 */
+ virtual void setUSE_CG2(int value);
+ /** Get the value of USE_CG2 */
+ inline int getUSE_CG2() const {return USE_CG2;}
+
+ /** Set the value of normIsZero, the threshold for considering a norm to be
+ 0; Default: 1e-5 */
+ virtual void setNormIsZero(const double value);
+ /** Get the value of normIsZero */
+ inline double getNormIsZero() const {return normIsZero;}
+
+ /** Set the value of minReduc, threshold for relative norm improvement for
+ performing a reduction; Default: 0.05 */
+ virtual void setMinReduc(const double value);
+ /// Get the value of minReduc
+ inline double getMinReduc() const {return minReduc;}
+
+ /** Set the maximum allowed value for (mTab * mTab * CoinMax(mTab, nTab)) where
+ mTab is the number of rows used in the combinations and nTab is the
+ number of continuous non basic variables. The work of the generator is
+ proportional to (mTab * mTab * CoinMax(mTab, nTab)). Reducing the value of
+ maxTab makes the generator faster, but weaker. Default: 1e7. */
+ virtual void setMaxTab(const double value);
+ /// Get the value of maxTab
+ inline double getMaxTab() const {return maxTab_;}
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglRedSplitParam(const double lub = 1000.0,
+ const double eps_elim = 1e-12,
+ const double eps_relax_abs = 1e-8,
+ const double eps_relax_rel = 0.0,
+ const double max_dyn = 1e8,
+ const double max_dyn_lub = 1e13,
+ const double eps_coeff_lub = 1e-13,
+ const double min_viol = 1e-7,
+ const int use_int_slacks = 0,
+ const int use_cg2 = 0,
+ const double norm_zero = 1e-5,
+ const double min_reduc = 0.05,
+ const double away = 0.05,
+ const double max_tab = 1e7);
+
+ /// Constructor from CglParam
+ CglRedSplitParam(const CglParam &source,
+ const double lub = 1000.0,
+ const double eps_elim = 1e-12,
+ const double eps_relax_abs = 1e-8,
+ const double eps_relax_rel = 0.0,
+ const double max_dyn = 1e8,
+ const double max_dyn_lub = 1e13,
+ const double eps_coeff_lub = 1e-13,
+ const double min_viol = 1e-7,
+ const int use_int_slacks = 0,
+ const int use_cg2 = 0,
+ const double norm_zero = 1e-5,
+ const double min_reduc = 0.05,
+ const double away = 0.05,
+ const double max_tab = 1e7);
+
+ /// Copy constructor
+ CglRedSplitParam(const CglRedSplitParam &source);
+
+ /// Clone
+ virtual CglRedSplitParam* clone() const;
+
+ /// Assignment operator
+ virtual CglRedSplitParam& operator=(const CglRedSplitParam &rhs);
+
+ /// Destructor
+ virtual ~CglRedSplitParam();
+ //@}
+
+protected:
+
+ /**@name Parameters */
+ //@{
+
+ /** Value considered large for the absolute value of lower or upper
+ bound on a variable. Default: 1000. */
+ double LUB;
+
+ /** Epsilon for value of coefficients when eliminating slack variables.
+ Default: 1e-12. */
+ double EPS_ELIM;
+
+ /** Value added to the right hand side of each generated cut to relax it.
+ Default: 1e-8 */
+ double EPS_RELAX_ABS;
+
+ /** For a generated cut with right hand side rhs_val,
+ EPS_RELAX_EPS * fabs(rhs_val) is used to relax the constraint.
+ Default: 0 */
+ double EPS_RELAX_REL;
+
+ // Maximum ratio between largest and smallest non zero
+ // coefficients in a cut. Default: 1e8.
+ double MAXDYN;
+
+ // Maximum ratio between largest and smallest non zero
+ // coefficients in a cut involving structural variables with
+ // lower or upper bound in absolute value larger than LUB.
+ // Should logically be larger or equal to MAXDYN. Default: 1e13.
+ double MAXDYN_LUB;
+
+ /// Epsilon for value of coefficients for variables with absolute value of
+ /// lower or upper bound larger than LUB. Default: 1e-13.
+ double EPS_COEFF_LUB;
+
+ /// Minimum violation for the current basic solution in a generated cut.
+ /// Default: 1e-7.
+ double MINVIOL;
+
+ /// Use integer slacks to generate cuts if USE_INTSLACKS = 1. Default: 0.
+ int USE_INTSLACKS;
+
+ /// Use second way to generate a mixed integer Gomory cut
+ /// (see methods generate_cgcut()) and generate_cgcut_2()). Default: 0.
+ int USE_CG2;
+
+ /// Norm of a vector is considered zero if smaller than normIsZero;
+ /// Default: 1e-5.
+ double normIsZero;
+
+ /// Minimum reduction in percent that must be achieved by a potential
+ /// reduction step in order to be performed; Between 0 and 1, default: 0.05.
+ double minReduc;
+
+ /// Use row only if pivot variable should be integer but is more
+ /// than away_ from being integer.
+ double away_;
+
+ /// Maximum value for (mTab * mTab * CoinMax(mTab, nTab)). See method
+ /// setMaxTab().
+ double maxTab_;
+
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglResidualCapacity.hpp b/thirdparty/windows/include/coin/CglResidualCapacity.hpp
new file mode 100644
index 0000000..1e26e46
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglResidualCapacity.hpp
@@ -0,0 +1,240 @@
+// LAST EDIT:
+//-----------------------------------------------------------------------------
+// Implementation of Residual Capacity Inequalities
+// Francisco Barahona (barahon@us.ibm.com)
+//
+// date: May 18, 2006
+//-----------------------------------------------------------------------------
+// Copyright (C) 2004, International Business Machines Corporation and others.
+// All Rights Reserved.
+// This code is published under the Eclipse Public License.
+
+#ifndef CglResidualCapacity_H
+#define CglResidualCapacity_H
+
+#include
+#include
+//#include
+
+#include "CoinError.hpp"
+
+#include "CglCutGenerator.hpp"
+
+//=============================================================================
+
+#ifndef CGL_DEBUG
+#define CGL_DEBUG 0
+#endif
+
+//=============================================================================
+
+
+
+
+//=============================================================================
+
+/** Residual Capacity Inequalities Cut Generator Class
+
+ References:
+ T Magnanti, P Mirchandani, R Vachani,
+ "The convex hull of two core capacitated network design problems,"
+ Math Programming 60 (1993), 233-250.
+
+ A Atamturk, D Rajan,
+ "On splittable and unsplittable flow capacitated network design
+ arc-set polyhedra," Math Programming 92 (2002), 315-333. **/
+
+class CglResidualCapacity : public CglCutGenerator {
+
+ friend void CglResidualCapacityUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+
+private:
+ //---------------------------------------------------------------------------
+ // Enumeration constants that describe the various types of rows
+ enum RowType {
+ /** row of the type a_1 c_1 + + a_k c_k - d z_1 - - d z_p <= b,
+ where c_i are continuous variables and z_j are integer variables
+ */
+ ROW_L,
+ /** row of the type -a_1 c_1 - - a_k c_k + d z_1 + + d z_p >= b,
+ where c_i are continuous variables and z_j are integer variables
+ */
+ ROW_G,
+ /** equation that can be treated as ROW_L and ROW_G
+ */
+ ROW_BOTH,
+ /** Other types of rows
+ */
+ ROW_OTHER
+ };
+
+
+public:
+ /**@name Get and Set Parameters */
+ //@{
+ /// Set Epsilon
+ void setEpsilon(double value);
+ /// Get Epsilon
+ double getEpsilon() const;
+ /// Set Tolerance
+ void setTolerance(double value);
+ /// Get Tolerance
+ double getTolerance() const;
+ /// Set doPreproc
+ void setDoPreproc(int value);
+ /// Get doPreproc
+ bool getDoPreproc() const;
+ //@}
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate Residual Capacity cuts for the model data
+ contained in si. The generated cuts are inserted
+ in the collection of cuts cs.
+ */
+ virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ //@}
+
+ //---------------------------------------------------------------------------
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglResidualCapacity ();
+
+ /// Alternate Constructor
+ CglResidualCapacity ( const double tolerance );
+
+ /// Copy constructor
+ CglResidualCapacity (
+ const CglResidualCapacity &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglResidualCapacity &
+ operator=(
+ const CglResidualCapacity& rhs);
+
+ /// Destructor
+ virtual
+ ~CglResidualCapacity ();
+ /// This is to refresh preprocessing
+ virtual void refreshPrep();
+ //@}
+
+
+
+private:
+ //--------------------------------------------------------------------------
+ // Private member methods
+
+ // Construct
+ void gutsOfConstruct ( const double tolerance);
+
+ // Delete
+ void gutsOfDelete();
+
+ // Copy
+ void gutsOfCopy (const CglResidualCapacity& rhs);
+
+ // Do preprocessing.
+ // It determines the type of each row.
+ // It may change sense and RHS for ranged rows
+ void resCapPreprocess(const OsiSolverInterface& si);
+
+ // Determine the type of a given row.
+ RowType determineRowType(const OsiSolverInterface& si,
+ const int rowLen, const int* ind,
+ const double* coef, const char sense,
+ const double rhs,
+ const double* colLowerBound,
+ const double* colUpperBound) const;
+ // helps the function above
+ bool treatAsLessThan(const OsiSolverInterface& si,
+ const int rowLen, const int* ind,
+ const double* coef,
+ const double rhs,
+ const double* colLowerBound,
+ const double* colUpperBound) const;
+
+ // Generate Residual Capacity cuts
+ void generateResCapCuts( const OsiSolverInterface& si,
+ const double* xlp,
+ const double* colUpperBound,
+ const double* colLowerBound,
+ const CoinPackedMatrix& matrixByRow,
+ const double* LHS,
+ const double* coefByRow,
+ const int* colInds,
+ const int* rowStarts,
+ const int* rowLengths,
+ OsiCuts& cs ) const;
+
+
+ // Residual Capacity separation
+ bool resCapSeparation(const OsiSolverInterface& si,
+ const int rowLen, const int* ind,
+ const double* coef,
+ const double rhs,
+ const double *xlp,
+ const double* colUpperBound,
+ const double* colLowerBound,
+ OsiRowCut& resCapCut) const;
+
+
+
+private:
+ //---------------------------------------------------------------------------
+ // Private member data
+ /** Tolerance used for numerical purposes, default value: 1.e-6 **/
+ double EPSILON_;
+ /** If violation of a cut is greater that this number,
+ the cut is accepted, default value: 1.e-4 **/
+ double TOLERANCE_;
+ /** Controls the preprocessing of the matrix to identify rows suitable for
+ cut generation.
+ - -1: preprocess according to solver settings;
+
- 0: Do preprocessing only if it has not yet been done;
+
- 1: Do preprocessing.
+
+ Default value: -1 **/
+ int doPreproc_;
+ // The number of rows of the problem.
+ int numRows_;
+ // The number columns of the problem.
+ int numCols_;
+ // Indicates whether preprocessing has been done.
+ bool doneInitPre_;
+ // Array with the row types of the rows in the model.
+ RowType* rowTypes_;
+ // The indices of the rows of the initial matrix
+ int* indRows_;
+ // Sense of rows (modified if ranges)
+ char * sense_;
+ // RHS of rows (modified if ranges)
+ double * RHS_;
+ // The number of rows of type ROW_L
+ int numRowL_;
+ // The indices of the rows of type ROW_L
+ int* indRowL_;
+ // The number of rows of type ROW_G
+ int numRowG_;
+ // The indices of the rows of type ROW_G
+ int* indRowG_;
+};
+
+//#############################################################################
+/** A function that tests the methods in the CglResidualCapacity class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging. */
+void CglResidualCapacityUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir);
+
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglSimpleRounding.hpp b/thirdparty/windows/include/coin/CglSimpleRounding.hpp
new file mode 100644
index 0000000..b93c8bf
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglSimpleRounding.hpp
@@ -0,0 +1,174 @@
+// $Id: CglSimpleRounding.hpp 1149 2013-10-21 18:23:53Z tkr $
+// Copyright (C) 2000, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglSimpleRounding_H
+#define CglSimpleRounding_H
+
+#include
+
+#include "CglCutGenerator.hpp"
+#include "CoinPackedMatrix.hpp"
+
+/** Simple Rounding Cut Generator Class
+
+ This class generates simple rounding cuts via the following method:
+ For each contraint,
+ attempt to derive a <= inequality in all integer variables
+ by netting out any continuous variables.
+ Divide the resulting integer inequality through by
+ the greatest common denomimator (gcd) of the lhs coefficients.
+ Round down the rhs.
+
+ Warning: Use with careful attention to data precision.
+
+ (Reference: Nemhauser and Wolsey, Integer and Combinatorial Optimization, 1988, pg 211.)
+*/
+
+class CglSimpleRounding : public CglCutGenerator {
+ friend void CglSimpleRoundingUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+public:
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate simple rounding cuts for the model accessed through the solver interface.
+ Insert generated cuts into the cut set cs.
+ */
+ virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglSimpleRounding ();
+
+ /// Copy constructor
+ CglSimpleRounding (
+ const CglSimpleRounding &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglSimpleRounding &
+ operator=(
+ const CglSimpleRounding& rhs);
+
+ /// Destructor
+ virtual
+ ~CglSimpleRounding ();
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+ //@}
+
+private:
+
+ // Private member methods
+
+ /**@name Private methods */
+ //@{
+
+ /// Derive a <= inequality in integer variables from the rowIndex-th constraint
+ bool deriveAnIntegerRow(
+ const OsiSolverInterface & si,
+ int rowIndex,
+ const CoinShallowPackedVector & matrixRow,
+ CoinPackedVector & irow,
+ double & b,
+ bool * negative) const;
+
+
+ /** Given a vector of doubles, x, with size elements and a positive tolerance,
+ dataTol, this method returns the smallest power of 10 needed so that
+ x[i]*10**power "is integer" for all i=0,...,size-1.
+
+ ** change of definition of dataTol so that it refers to original
+ data, not to scaled data as that seems to lead to problems.
+
+ So if xScaled is x[i]*10**power and xInt is rounded(xScaled)
+ then fabs(xScaled-xInt) <= dataTol*10**power. This means that
+ dataTol should be smaller - say 1.0e-12 rather tahn 1.0e-8
+
+ Returns -number of times overflowed if the power is so big that it will
+ cause overflow (i.e. integer stored will be bigger than 2**31).
+ Test in cut generator.
+ */
+ int power10ToMakeDoubleAnInt(
+ int size, // the length of the vector x
+ const double * x,
+ double dataTol ) const; // the precision of the data, i.e. the positive
+ // epsilon, which is equivalent to zero
+
+ /**@name Greatest common denominators methods */
+ //@{
+ /// Returns the greatest common denominator of two positive integers, a and b.
+ inline int gcd(int a, int b) const;
+
+ /** Returns the greatest common denominator of a vector of
+ positive integers, vi, of length n.
+ */
+ inline int gcdv(int n, const int * const vi) const;
+ //@}
+
+ //@}
+
+ /**@name Private member data */
+ //@{
+ /// A value within an epsilon_ neighborhood of 0 is considered to be 0.
+ double epsilon_;
+ //@}
+};
+
+
+//-------------------------------------------------------------------
+// Returns the greatest common denominator of two
+// positive integers, a and b, found using Euclid's algorithm
+//-------------------------------------------------------------------
+int
+CglSimpleRounding::gcd(int a, int b) const
+{
+ if(a > b) {
+ // Swap a and b
+ int temp = a;
+ a = b;
+ b = temp;
+ }
+ int remainder = b % a;
+ if (remainder == 0) return a;
+ else return gcd(remainder,a);
+}
+
+//-------------------------------------------------------------------
+// Returns the greatest common denominator of a vector of
+// positive integers, vi, of length n.
+//-------------------------------------------------------------------
+int
+CglSimpleRounding::gcdv(int n, const int* const vi) const
+{
+ if (n==0)
+ abort();
+
+ if (n==1)
+ return vi[0];
+
+ int retval=gcd(vi[0], vi[1]);
+ for (int i=2; i
+
+#include "CglCutGenerator.hpp"
+
+class CoinWarmStartBasis;
+class CglTreeProbingInfo;
+/** Stored Cut Generator Class */
+class CglStored : public CglCutGenerator {
+
+public:
+
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate Mixed Integer Stored cuts for the model of the
+ solver interface, si.
+
+ Insert the generated cuts into OsiCut, cs.
+
+ This generator just looks at previously stored cuts
+ and inserts any that are violated by enough
+ */
+ virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ //@}
+
+ /**@name Change criterion on whether to include cut.
+ Violations of more than this will be added to current cut list
+ (default 1.0e-5) */
+ //@{
+ /// Set
+ inline void setRequiredViolation(double value)
+ { requiredViolation_=value;}
+ /// Get
+ inline double getRequiredViolation() const
+ { return requiredViolation_;}
+ /// Takes over ownership of probing info
+ inline void setProbingInfo(CglTreeProbingInfo * info)
+ { probingInfo_ = info;}
+ //@}
+
+ /**@name Cut stuff */
+ //@{
+ /// Add cuts
+ void addCut(const OsiCuts & cs);
+ /// Add a row cut
+ void addCut(const OsiRowCut & cut);
+ /// Add a row cut from a packed vector
+ void addCut(double lb, double ub, const CoinPackedVector & vector);
+ /// Add a row cut from elements
+ void addCut(double lb, double ub, int size, const int * colIndices, const double * elements);
+ inline int sizeRowCuts() const
+ { return cuts_.sizeRowCuts();}
+ const OsiRowCut * rowCutPointer(int index) const
+ { return cuts_.rowCutPtr(index);}
+ /// Save stuff
+ void saveStuff(double bestObjective, const double * bestSolution,
+ const double * lower, const double * upper);
+ /// Best solution (or NULL)
+ inline const double * bestSolution() const
+ { return bestSolution_;}
+ /// Best objective
+ double bestObjective() const;
+ /// Tight lower bounds
+ const double * tightLower() const
+ { return bounds_;}
+ /// Tight upper bounds
+ const double * tightUpper() const
+ { return bounds_+numberColumns_;}
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglStored (int numberColumns=0);
+
+ /// Copy constructor
+ CglStored (const CglStored & rhs);
+
+ /// Constructor from file
+ CglStored (const char * fileName);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglStored &
+ operator=(const CglStored& rhs);
+
+ /// Destructor
+ virtual
+ ~CglStored ();
+ //@}
+
+protected:
+
+ // Protected member methods
+
+ // Protected member data
+
+ /**@name Protected member data */
+ //@{
+ /// Only add if more than this requiredViolation
+ double requiredViolation_;
+ /// Pointer to probing information
+ CglTreeProbingInfo * probingInfo_;
+ /// Cuts
+ OsiCuts cuts_;
+ /// Number of columns in model
+ int numberColumns_;
+ /// Best solution (objective at end)
+ double * bestSolution_;
+ /// Tight bounds
+ double * bounds_;
+ //@}
+};
+#endif
diff --git a/thirdparty/windows/include/coin/CglTreeInfo.hpp b/thirdparty/windows/include/coin/CglTreeInfo.hpp
new file mode 100644
index 0000000..4f85aca
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglTreeInfo.hpp
@@ -0,0 +1,180 @@
+// $Id: CglTreeInfo.hpp 1201 2014-03-07 17:24:04Z forrest $
+// Copyright (C) 2000, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglTreeInfo_H
+#define CglTreeInfo_H
+
+#include "OsiCuts.hpp"
+#include "OsiSolverInterface.hpp"
+#include "CoinHelperFunctions.hpp"
+class CglStored;
+/** Information about where the cut generator is invoked from. */
+
+class CglTreeInfo {
+public:
+ /// The level of the search tree node
+ int level;
+ /** How many times the cut generator was already invoked in this search tree
+ node */
+ int pass;
+ /** The number of rows in the original formulation. Some generators may not
+ want to consider already generated rows when generating new ones. */
+ int formulation_rows;
+ /** Options
+ 1 - treat costed integers as important
+ 2 - switch off some stuff as variables semi-integer
+ 4 - set global cut flag if at root node
+ 8 - set global cut flag if at root node and first pass
+ 16 - set global cut flag and make cuts globally valid
+ 32 - last round of cuts did nothing - maybe be more aggressive
+ 64 - in preprocessing stage
+ 128 - looks like solution
+ 256 - want alternate cuts
+ 512 - in sub tree (i.e. parent model)
+ 1024 - in must call again mode or after everything mode
+ */
+ int options;
+ /// Set true if in tree (to avoid ambiguity at first branch)
+ bool inTree;
+ /** Replacement array. Before Branch and Cut it may be beneficial to strengthen rows
+ rather than adding cuts. If this array is not NULL then the cut generator can
+ place a pointer to the stronger cut in this array which is number of rows in size.
+
+ A null (i.e. zero elements and free rhs) cut indicates that the row is useless
+ and can be removed.
+
+ The calling function can then replace those rows.
+ */
+ OsiRowCut ** strengthenRow;
+ /// Optional pointer to thread specific random number generator
+ CoinThreadRandom * randomNumberGenerator;
+ /// Default constructor
+ CglTreeInfo ();
+
+ /// Copy constructor
+ CglTreeInfo (
+ const CglTreeInfo &);
+ /// Clone
+ virtual CglTreeInfo * clone() const;
+
+ /// Assignment operator
+ CglTreeInfo &
+ operator=(
+ const CglTreeInfo& rhs);
+
+ /// Destructor
+ virtual
+ ~CglTreeInfo ();
+ /// Take action if cut generator can fix a variable (toValue -1 for down, +1 for up)
+ virtual bool fixes(int , int , int ,bool) {return false;}
+ /** Initalizes fixing arrays etc - returns >0 if we want to save info
+ 0 if we don't and -1 if is to be used */
+ virtual int initializeFixing(const OsiSolverInterface * ) {return 0;}
+
+};
+
+/** Derived class to pick up probing info. */
+typedef struct {
+ //unsigned int oneFixed:1; // nonzero if variable to 1 fixes all
+ //unsigned int sequence:31; // variable (in matrix) (but also see cliqueRow_)
+ unsigned int fixes;
+} CliqueEntry;
+
+class CglTreeProbingInfo : public CglTreeInfo {
+public:
+ /// Default constructor
+ CglTreeProbingInfo ();
+ /// Constructor from model
+ CglTreeProbingInfo (const OsiSolverInterface * model);
+
+ /// Copy constructor
+ CglTreeProbingInfo (
+ const CglTreeProbingInfo &);
+ /// Clone
+ virtual CglTreeInfo * clone() const;
+
+ /// Assignment operator
+ CglTreeProbingInfo &
+ operator=(
+ const CglTreeProbingInfo& rhs);
+
+ /// Destructor
+ virtual
+ ~CglTreeProbingInfo ();
+ OsiSolverInterface * analyze(const OsiSolverInterface & si, int createSolver=0,
+ int numberExtraCliques=0,const int * starts=NULL,
+ const CliqueEntry * entries=NULL,const char * type=NULL);
+ /** Take action if cut generator can fix a variable
+ (toValue -1 for down, +1 for up)
+ Returns true if still room, false if not */
+ virtual bool fixes(int variable, int toValue, int fixedVariable,bool fixedToLower);
+ /** Initalizes fixing arrays etc - returns >0 if we want to save info
+ 0 if we don't and -1 if is to be used */
+ virtual int initializeFixing(const OsiSolverInterface * model) ;
+ /// Fix entries in a solver using implications
+ int fixColumns(OsiSolverInterface & si) const;
+ /// Fix entries in a solver using implications for one variable
+ int fixColumns(int iColumn, int value, OsiSolverInterface & si) const;
+ /// Packs down entries
+ int packDown();
+ /// Generate cuts from implications
+ void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info) const;
+ /// Entries for fixing variables
+ inline CliqueEntry * fixEntries()
+ { convert(); return fixEntry_;}
+ /// Starts of integer variable going to zero
+ inline int * toZero()
+ { convert(); return toZero_;}
+ /// Starts of integer variable going to one
+ inline int * toOne()
+ { convert(); return toOne_;}
+ /// List of 0-1 integer variables
+ inline int * integerVariable() const
+ { return integerVariable_;}
+ /// Backward look up
+ inline int * backward() const
+ { return backward_;}
+ /// Number of variables
+ inline int numberVariables() const
+ { return numberVariables_;}
+ /// Number of 0-1 variables
+ inline int numberIntegers() const
+ { return numberIntegers_;}
+private:
+ /// Converts to ordered
+ void convert();
+protected:
+ /// Entries for fixing variables
+ CliqueEntry * fixEntry_;
+ /// Starts of integer variable going to zero
+ int * toZero_;
+ /// Starts of integer variable going to one
+ int * toOne_;
+ /// List of 0-1 integer variables
+ int * integerVariable_;
+ /// Backward look up
+ int * backward_;
+ /// Entries for fixing variable when collecting
+ int * fixingEntry_;
+ /// Number of variables
+ int numberVariables_;
+ /// Number of 0-1 variables
+ int numberIntegers_;
+ /// Maximum number in fixEntry_
+ int maximumEntries_;
+ /// Number entries in fixingEntry_ (and fixEntry_) or -2 if correct style
+ int numberEntries_;
+};
+inline int sequenceInCliqueEntry(const CliqueEntry & cEntry)
+{ return cEntry.fixes&0x7fffffff;}
+inline void setSequenceInCliqueEntry(CliqueEntry & cEntry,int sequence)
+{ cEntry.fixes = sequence|(cEntry.fixes&0x80000000);}
+inline bool oneFixesInCliqueEntry(const CliqueEntry & cEntry)
+{ return (cEntry.fixes&0x80000000)!=0;}
+inline void setOneFixesInCliqueEntry(CliqueEntry & cEntry,bool oneFixes)
+{ cEntry.fixes = (oneFixes ? 0x80000000 : 0)|(cEntry.fixes&0x7fffffff);}
+
+#endif
diff --git a/thirdparty/windows/include/coin/CglTwomir.hpp b/thirdparty/windows/include/coin/CglTwomir.hpp
new file mode 100644
index 0000000..ba00380
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglTwomir.hpp
@@ -0,0 +1,565 @@
+// $Id: CglTwomir.hpp 1119 2013-04-06 20:24:18Z stefan $
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef CglTwomir_H
+#define CglTwomir_H
+#include
+
+#include "CglCutGenerator.hpp"
+#include "CoinFactorization.hpp"
+
+typedef struct
+{
+
+ int nz; /* current length of arrays index[] and coeff[] */
+ int max_nz; /* max length of arrays index[] and coeff[] */
+ double *coeff; /* coefficient of each variable in the constraint */
+ int *index; /* index of the variable (value in 0 ... nrow+ncol) */
+ double rhs; /* rhs of the constraint */
+ char sense; /* ?? is it necessary */
+
+} DGG_constraint_t;
+
+typedef struct{
+ int n;
+ DGG_constraint_t **c;
+ int *ctype;
+ double *alpha;
+} DGG_list_t;
+
+/******************** BASIS INFORMATION ADTs **********************************/
+typedef struct{
+ int q_min;
+ int q_max;
+ int t_min;
+ int t_max;
+ int a_max;
+ int max_elements;
+} cutParams;
+
+typedef struct
+{
+ double gomory_threshold; /* factional variable must be this away from int */
+ int ncol, /* number of columns in LP */
+ nrow, /* number of constaints in LP */
+ ninteger; /* number of integer variables in LP */
+
+ int nbasic_col, /* number of basic columns in the LP */
+ nbasic_row; /* number of basic rows in the LP */
+
+ /* the following arrays are all of size (ncol+nrow) */
+ int *info; /* description of each variable (see below) */
+ double *lb; /* specifies the lower bound (if any) of each variable */
+ double *ub; /* specifies the upper bound (if any) of each variable */
+ double *x; /* current solution */
+ double *rc; /* current reduced cost */
+ double *opt_x;
+
+ cutParams cparams;
+} DGG_data_t;
+
+/* the following macros allow us to decode the info of the DGG_data
+ type. The encoding is as follows,
+ bit 1 : if the variable is basic or not (non-basic).
+ bit 2 : if the variable is integer or or not (rational).
+ bit 3 : if the variable is structural or not (artifical).
+ bit 4 : if the variable is non-basic and at its upper bound
+ (else if non-basic at lower bound). */
+
+#define DGG_isBasic(data,idx) ((data->info[idx])&1)
+#define DGG_isInteger(data,idx) ((data->info[idx] >> 1)&1)
+#define DGG_isStructural(data,idx) ((data->info[idx] >> 2)&1)
+#define DGG_isEqualityConstraint(data,idx) ((data->info[idx] >> 3)&1)
+#define DGG_isNonBasicAtUB(data,idx) ((data->info[idx] >> 4)&1)
+#define DGG_isNonBasicAtLB(data,idx) ((data->info[idx] >> 5)&1)
+#define DGG_isConstraintBoundedAbove(data,idx) ((data->info[idx] >> 6)&1)
+#define DGG_isConstraintBoundedBelow(data,idx) ((data->info[idx] >> 7)&1)
+
+#define DGG_setIsBasic(data,idx) ((data->info[idx]) |= 1)
+#define DGG_setIsInteger(data,idx) ((data->info[idx]) |= (1<<1))
+#define DGG_setIsStructural(data,idx) ((data->info[idx]) |= (1<<2))
+#define DGG_setEqualityConstraint(data,idx) ((data->info[idx]) |= (1<<3))
+#define DGG_setIsNonBasicAtUB(data,idx) ((data->info[idx]) |= (1<<4))
+#define DGG_setIsNonBasicAtLB(data,idx) ((data->info[idx]) |= (1<<5))
+#define DGG_setIsConstraintBoundedAbove(data,idx) ((data->info[idx]) |= (1<<6))
+#define DGG_setIsConstraintBoundedBelow(data,idx) ((data->info[idx]) |= (1<<7))
+
+class CoinWarmStartBasis;
+/** Twostep MIR Cut Generator Class */
+class CglTwomir : public CglCutGenerator {
+
+ friend void CglTwomirUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+
+public:
+
+ /// Problem name
+ std::string probname_;
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate Two step MIR cuts either from the tableau rows or from the
+ formulation rows
+ */
+ virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ /// Return true if needs optimal basis to do cuts (will return true)
+ virtual bool needsOptimalBasis() const;
+
+ /**@name Change criterion on which scalings to use (default = 1,1,1,1) */
+ //@{
+ /// Set
+ void setMirScale (int tmin, int tmax) {t_min_ = tmin; t_max_ = tmax;}
+ void setTwomirScale (int qmin, int qmax) {q_min_ = qmin; q_max_ = qmax;}
+ void setAMax (int a) {a_max_ = a;}
+ void setMaxElements (int n) {max_elements_ = n;}
+ void setMaxElementsRoot (int n) {max_elements_root_ = n;}
+ void setCutTypes (bool mir, bool twomir, bool tab, bool form)
+ { do_mir_ = mir; do_2mir_ = twomir; do_tab_ = tab; do_form_ = form;}
+ void setFormulationRows (int n) {form_nrows_ = n;}
+
+ /// Get
+ int getTmin() const {return t_min_;}
+ int getTmax() const {return t_max_;}
+ int getQmin() const {return q_min_;}
+ int getQmax() const {return q_max_;}
+ int getAmax() const {return a_max_;}
+ int getMaxElements() const {return max_elements_;}
+ int getMaxElementsRoot() const {return max_elements_root_;}
+ int getIfMir() const { return do_mir_;}
+ int getIfTwomir() const { return do_2mir_;}
+ int getIfTableau() const { return do_tab_;}
+ int getIfFormulation() const { return do_form_;}
+ //@}
+
+ /**@name Change criterion on which variables to look at. All ones
+ more than "away" away from integrality will be investigated
+ (default 0.05) */
+ //@{
+ /// Set away
+ void setAway(double value);
+ /// Get away
+ double getAway() const;
+ /// Set away at root
+ void setAwayAtRoot(double value);
+ /// Get away at root
+ double getAwayAtRoot() const;
+ /// Return maximum length of cut in tree
+ virtual int maximumLengthOfCutInTree() const
+ { return max_elements_;}
+ //@}
+
+ /**@name Change way TwoMir works */
+ //@{
+ /// Pass in a copy of original solver (clone it)
+ void passInOriginalSolver(OsiSolverInterface * solver);
+ /// Returns original solver
+ inline OsiSolverInterface * originalSolver() const
+ { return originalSolver_;}
+ /// Set type - 0 normal, 1 add original matrix one, 2 replace
+ inline void setTwomirType(int type)
+ { twomirType_=type;}
+ /// Return type
+ inline int twomirType() const
+ { return twomirType_;}
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglTwomir ();
+
+ /// Copy constructor
+ CglTwomir (const CglTwomir &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglTwomir & operator=(const CglTwomir& rhs);
+
+ /// Destructor
+ virtual ~CglTwomir ();
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+ /// This can be used to refresh any inforamtion
+ virtual void refreshSolver(OsiSolverInterface * solver);
+ //@}
+
+private:
+ // Private member data
+ /**@name Private member data */
+ //@{
+ /// Threadsafe random number generator
+ CoinThreadRandom randomNumberGenerator_;
+ /// Original solver
+ OsiSolverInterface * originalSolver_;
+ /// Only investigate if more than this away from integrality
+ double away_;
+ /// Only investigate if more than this away from integrality (at root)
+ double awayAtRoot_;
+ /// Type - 0 normal, 1 add original matrix one, 2 replace
+ int twomirType_;
+ bool do_mir_;
+ bool do_2mir_;
+ bool do_tab_;
+ bool do_form_;
+
+ int t_min_; /// t_min - first value of t to use for tMIR inequalities
+ int t_max_; /// t_max - last value of t to use for tMIR inequalities
+ int q_min_; /// q_min - first value of t to use for 2-Step tMIR inequalities
+ int q_max_; /// q_max - last value of t to use for 2-Step tMIR inequalities
+ int a_max_; /// a_max - maximum value of bhat/alpha
+ int max_elements_; /// Maximum number of elements in cut
+ int max_elements_root_; /// Maximum number of elements in cut at root
+ int form_nrows_; //number of rows on which formulation cuts will be generated
+ //@}
+};
+
+//#############################################################################
+
+/*
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+*/
+
+/******************** DEBUG DEFINITIONS ***************************************/
+
+#define DGG_DEBUG_DGG 1
+#define DGG_TRACE_ERRORS 0
+#define DGG_DISPLAY 0
+#define DGG_AUTO_CHECK_CUT_OFF_OPTIMAL 1
+
+/******************** CONFIGURATION DEFAULTS **********************************/
+
+#define DGG_DEFAULT_METHOD 2
+#define DGG_DEFAULT_TMIN 1
+#define DGG_DEFAULT_TMAX 1
+#define DGG_DEFAULT_TAUMIN 2
+#define DGG_DEFAULT_TAUMAX 6
+#define DGG_DEFAULT_MAX_CUTS 500
+#define DGG_DEFAULT_IMPROVEMENT_THRESH 0.001
+#define DGG_DEFAULT_NBELOW_THRESH INT_MAX
+#define DGG_DEFAULT_NROOT_ROUNDS 2
+#define DGG_DEFAULT_NEGATIVE_SCALED_TWOSTEPS 0
+#define DGG_DEFAULT_ALPHA_RULE 0
+#define DGG_DEFAULT_CUT_INC 250
+#define DGG_DEFAULT_CUT_FORM 0
+#define DGG_DEFAULT_NICEFY 0
+#define DGG_DEFAULT_ONLY_DELAYED 0
+#define DGG_DEFAULT_DELAYED_FREQ 9999999
+#define DGG_DEFAULT_LPROWS_FREQ 9999999
+#define DGG_DEFAULT_WHICH_FORMULATION_CUTS 2
+
+/******************** SOLVER CONFIGURATION DEFINITIONS ************************/
+
+#define DGG_OSI 0
+#define DGG_CPX 1
+#define DGG_QSO 2
+
+/* determines the solver to be used */
+#define DGG_SOLVER DGG_OSI
+
+/* adds checking routines to make sure solver works as expected */
+#define DGG_DEBUG_SOLVER 0
+
+/* turn off screen output from solver */
+#define DGG_SOLVER_SCREEN_FLAG 0
+
+/******************** CUT DEFINITIONS *****************************************/
+
+/* internal names for cut types */
+#define DGG_TMIR_CUT 1
+#define DGG_2STEP_CUT 2
+
+/* internal names for alpha-selection rules */
+#define DGG_ALPHA_MIN_SUM 0
+#define DGG_ALPHA_RANDOM_01 1
+#define DGG_ALPHA_RANDOM_COEFF 2
+#define DGG_ALPHA_ALL 3
+#define DGG_ALPHA_MAX_STEEP 5
+
+/******************** PRECISION & NUMERICAL ISSUES DEFINITIONS ****************/
+
+/* how steep a cut must be before adding it to the lp */
+#define DGG_MIN_STEEPNESS 1.0e-4
+#define DGG_MAX_L2NORM 1.0e7
+
+/* 0 = min steepness, 1 = max norm */
+#define DGG_NORM_CRITERIA 1
+
+/* internal representation of +infinity */
+#define UB_MAX DBL_MAX
+
+/* used to define how fractional a basic-integer variable must be
+ before choosing to use it to generate a TMIR cut on.
+ OSI's default is 1.0e-7 */
+#define DGG_GOMORY_THRESH 0.005
+
+#define DGG_RHS_THRESH 0.005
+
+/* used for comparing variables to their upper bounds.
+ OSI's default is 1.0e-7.
+ We set it to 1.0e6 because e-7 seems too sensitive.
+ In fact, with e-7 the problem dsbmip.mps complains. */
+#define DGG_BOUND_THRESH 1.0e-6
+
+/* used for comparing the lhs (activity) value of a tableau row
+ with the rhs. This is only used for debugging purposes. */
+#define DGG_EQUALITY_THRESH 1.0e-5
+
+/* used for comparing a variable's lower bound to 0.0
+ and determining if we need to shift the variable */
+#define DGG_SHIFT_THRESH 1.0e-6
+
+/* used for determing how far from an integer is still an integer.
+ This value is used for comparing coefficients to integers.
+ OSI's default is 1.0e-10. */
+#define DGG_INTEGRALITY_THRESH 1.0e-10
+
+/* the min value that a coeff can have in the tableau row
+ before being set to zero. */
+#define CBC_CHECK_CUT
+#ifndef CBC_CHECK_CUT
+#define DGG_MIN_TABLEAU_COEFFICIENT 1.0e-8
+#else
+#define DGG_MIN_TABLEAU_COEFFICIENT 1.0e-12
+#endif
+
+/* smallest value rho is allowed to have for a simple 2-step MIR
+ (ie: not an extended two-step MIR) */
+#define DGG_MIN_RHO 1.0e-7
+#define DGG_MIN_ALPHA 1.0e-7
+
+/* when a slack is null: used to check if a cut is satisfied or not. */
+#define DGG_NULL_SLACK 1.0e-5
+
+/* nicefy constants */
+#define DGG_NICEFY_MIN_ABSVALUE 1.0e-13
+#define DGG_NICEFY_MIN_FIX 1.0e-7
+#define DGG_NICEFY_MAX_PADDING 1.0e-6
+#define DGG_NICEFY_MAX_RATIO 1.0e9
+
+
+/******************** ERROR-CATCHING MACROS ***********************************/
+#if DGG_TRACE_ERRORS > 0
+
+#define __DGG_PRINT_LOC__(F) fprintf(((F==0)?stdout:F), " in %s (%s:%d)\n", __func__, __FILE__, __LINE__)
+
+#define DGG_THROW(A,REST...) {\
+ fprintf(stdout, ##REST); \
+ __DGG_PRINT_LOC__(stdout); \
+ return (A);}
+
+#define DGG_IF_EXIT(A,B,REST...) {\
+ if(A) {\
+ fprintf(stdout, ##REST); \
+ __DGG_PRINT_LOC__(stdout); \
+ exit(B);}}
+
+#define DGG_CHECKRVAL(A,B) {\
+ if(A) {\
+ __DGG_PRINT_LOC__(stdout); \
+ return B; } }
+
+#define DGG_CHECKRVAL1(A,B) {\
+ if(A) {\
+ __DGG_PRINT_LOC__(stdout); \
+ rval = B; goto CLEANUP; } }
+
+#define DGG_WARNING(A, REST...) {\
+ if(A) {\
+ fprintf(stdout, ##REST); \
+ __DGG_PRINT_LOC__(stdout); \
+ }}
+
+#define DGG_TEST(A,B,REST...) {\
+ if(A) DGG_THROW(B,##REST) }
+
+#define DGG_TEST2(A,B,C,REST) {DGG_TEST(A,B,C,REST) }
+#define DGG_TEST3(A,B,C,D,REST) {DGG_TEST(A,B,C,D,REST) }
+
+#else
+
+#define DGG_IF_EXIT(A,B,REST) {if(A) {fprintf(stdout, REST);exit(B);}}
+
+#define DGG_THROW(A,B) return(A)
+
+#define DGG_CHECKRVAL(A,B) { if(A) return(B); }
+#define DGG_CHECKRVAL1(A,B){ if(A) { rval = B; goto CLEANUP; } }
+
+#define DGG_TEST(A,B,REST) { if(A) return(B);}
+#define DGG_TEST2(A,B,REST,C) { DGG_TEST(A,B,REST) }
+#define DGG_TEST3(A,B,REST,C,D) { DGG_TEST(A,B,REST) }
+
+#endif
+
+/******************** SIMPLE MACROS AND FUNCTIONS *****************************/
+
+#define DGG_MIN(a,b) ( (ab)?a:b )
+#define KREM(vht,alpha,tau) (DGG_MIN( ceil(vht / alpha), tau ) - 1)
+#define LMIN(vht, d, bht) (DGG_MIN( floor(d*bht/bht), d))
+#define ABOV(v) (v - floor(v))
+#define QINT(vht,bht,tau) ( (int)floor( (vht*(tau-1))/bht ) )
+#define V2I(bht,tau,i) ( ((i+1)*bht / tau) )
+
+int DGG_is_even(double vht, double bht, int tau, int q);
+double frac_part(double value);
+int DGG_is_a_multiple_of_b(double a, double b);
+
+
+/* free function for DGG_data_t. Frees internal arrays and data structure */
+int DGG_freeData( DGG_data_t *data );
+
+/******************** CONSTRAINT ADTs *****************************************/
+DGG_constraint_t* DGG_newConstraint(int max_arrays);
+void DGG_freeConstraint(DGG_constraint_t *c);
+DGG_constraint_t *DGG_copyConstraint(DGG_constraint_t *c);
+void DGG_scaleConstraint(DGG_constraint_t *c, int t);
+
+/******************** CONFIGURATION *******************************************/
+void DGG_list_init (DGG_list_t *l);
+int DGG_list_addcut (DGG_list_t *l, DGG_constraint_t *cut, int ctype, double alpha);
+void DGG_list_delcut (DGG_list_t *l, int i);
+void DGG_list_free(DGG_list_t *l);
+
+/******************* SOLVER SPECIFIC METHODS **********************************/
+DGG_data_t *DGG_getData(const void *solver_ptr);
+
+/******************* CONSTRAINT MANIPULATION **********************************/
+
+/* DGG_transformConstraint: manipulates a constraint in the following way:
+
+packs everything in output
+
+1 - variables at their upper bounds are substituted for their
+complements. This is done by adjusting the coefficients and
+the right hand side (simple substitution).
+
+2 - variables with non-zero lower bounds are shifted. */
+
+int DGG_transformConstraint( DGG_data_t *data,
+ double **x_out,
+ double **rc_out,
+ char **isint_out,
+ DGG_constraint_t *constraint );
+
+/* DGG_unTransformConstraint :
+
+1 - Undoes step (1) of DGG_transformConstraint
+2 - Undoes step (2) of DGG_transformConstraint */
+
+int DGG_unTransformConstraint( DGG_data_t *data,
+ DGG_constraint_t *constraint );
+
+/* substitutes each slack variable by the structural variables which
+ define it. This function, hence, changes the constraint 'cut'. */
+
+int DGG_substituteSlacks( const void *solver_ptr,
+ DGG_data_t *data,
+ DGG_constraint_t *cut );
+
+int DGG_nicefyConstraint( const void *solver_ptr,
+ DGG_data_t *data,
+ DGG_constraint_t *cut);
+
+/******************* CUT GENERATION *******************************************/
+int DGG_getFormulaConstraint( int row_idx,
+ const void *solver_ptr,
+ DGG_data_t *data,
+ DGG_constraint_t* row );
+
+int DGG_getTableauConstraint( int index,
+ const void *solver_ptr,
+ DGG_data_t *data,
+ DGG_constraint_t* tabrow,
+ const int * colIsBasic,
+ const int * rowIsBasic,
+ CoinFactorization & factorization,
+ int mode );
+
+DGG_constraint_t* DGG_getSlackExpression(const void *solver_ptr, DGG_data_t* data, int row_index);
+
+ int DGG_generateTabRowCuts( DGG_list_t *list,
+ DGG_data_t *data,
+ const void *solver_ptr );
+
+ int DGG_generateFormulationCuts( DGG_list_t *list,
+ DGG_data_t *data,
+ const void *solver_ptr,
+ int nrows,
+ CoinThreadRandom & generator);
+
+
+ int DGG_generateFormulationCutsFromBase( DGG_constraint_t *base,
+ double slack,
+ DGG_list_t *list,
+ DGG_data_t *data,
+ const void *solver_ptr,
+ CoinThreadRandom & generator);
+
+ int DGG_generateCutsFromBase( DGG_constraint_t *base,
+ DGG_list_t *list,
+ DGG_data_t *data,
+ const void *solver_ptr );
+
+int DGG_buildMir( char *isint,
+ DGG_constraint_t *base,
+ DGG_constraint_t **cut_out );
+
+int DGG_build2step( double alpha,
+ char *isint,
+ DGG_constraint_t *base,
+ DGG_constraint_t **cut_out );
+
+ int DGG_addMirToList ( DGG_constraint_t *base,
+ char *isint,
+ double *x,
+ DGG_list_t *list,
+ DGG_data_t *data,
+ DGG_constraint_t *orig_base );
+
+ int DGG_add2stepToList ( DGG_constraint_t *base,
+ char *isint,
+ double *x,
+ double *rc,
+ DGG_list_t *list,
+ DGG_data_t *data,
+ DGG_constraint_t *orig_base );
+
+/******************* CUT INFORMATION ******************************************/
+
+double DGG_cutLHS(DGG_constraint_t *c, double *x);
+int DGG_isCutDesirable(DGG_constraint_t *c, DGG_data_t *d);
+
+/******************* TEST / DEBUGGING ROUTINES ********************************/
+
+int DGG_isConstraintViolated(DGG_data_t *d, DGG_constraint_t *c);
+
+int DGG_isBaseTrivial(DGG_data_t *d, DGG_constraint_t* c);
+int DGG_is2stepValid(double alpha, double bht);
+
+int DGG_cutsOffPoint(double *x, DGG_constraint_t *cut);
+
+//#############################################################################
+/** A function that tests the methods in the CglTwomir class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging. */
+void CglTwomirUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir);
+
+
+#endif
+
+
diff --git a/thirdparty/windows/include/coin/CglZeroHalf.hpp b/thirdparty/windows/include/coin/CglZeroHalf.hpp
new file mode 100644
index 0000000..929269a
--- /dev/null
+++ b/thirdparty/windows/include/coin/CglZeroHalf.hpp
@@ -0,0 +1,133 @@
+// $Id: CglZeroHalf.hpp 1122 2013-04-06 20:39:53Z stefan $
+// Copyright (C) 2010, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+#ifndef CglZeroHalf_H
+#define CglZeroHalf_H
+
+#include
+
+#include "CglCutGenerator.hpp"
+#include "CoinPackedMatrix.hpp"
+#include "Cgl012cut.hpp"
+
+/** Zero Half Cut Generator Class
+
+ This class generates zero half cuts via the following method:
+
+ See -
+
+G. Andreello, A. Caprara, M. Fischetti,
+ “Embedding Cuts in a Branch and Cut Framework: a Computational Study
+ with {0,1/2}-Cuts”, INFORMS Journal on Computing 19(2), 229-238, 2007.
+
+*/
+
+class CglZeroHalf : public CglCutGenerator {
+ friend void CglZeroHalfUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+public:
+
+ /**@name Generate Cuts */
+ //@{
+ /** Generate zero half cuts for the model accessed through the solver interface.
+ Insert generated cuts into the cut set cs.
+ */
+ virtual void generateCuts( const OsiSolverInterface & si, OsiCuts & cs,
+ const CglTreeInfo info = CglTreeInfo());
+ //@}
+
+ /**@name Sets and Gets */
+ //@{
+ /// Get flags
+ inline int getFlags() const
+ { return flags_;}
+ /// Set flags
+ inline void setFlags(int value)
+ { flags_ = value;}
+ //@}
+
+ /**@name Constructors and destructors */
+ //@{
+ /// Default constructor
+ CglZeroHalf ();
+
+ /// Copy constructor
+ CglZeroHalf (
+ const CglZeroHalf &);
+
+ /// Clone
+ virtual CglCutGenerator * clone() const;
+
+ /// Assignment operator
+ CglZeroHalf &
+ operator=(
+ const CglZeroHalf& rhs);
+
+ /// Destructor
+ virtual
+ ~CglZeroHalf ();
+ /// Create C++ lines to get to current state
+ virtual std::string generateCpp( FILE * fp);
+ /// This can be used to refresh any information
+ virtual void refreshSolver(OsiSolverInterface * solver);
+ //@}
+
+private:
+
+ // Private member methods
+
+ /**@name Private methods */
+ //@{
+ //@}
+
+
+ /**@name Private member data */
+ //@{
+ /// number of rows in the ILP matrix
+ int mr_;
+ /// number of columns in the ILP matrix
+ int mc_;
+ /// number of nonzero's in the ILP matrix
+ int mnz_;
+ /// starting position of each row in arrays mtind and mtval
+ int *mtbeg_;
+ /// number of entries of each row in arrays mtind and mtval
+ int *mtcnt_;
+ /// column indices of the nonzero entries of the ILP matrix
+ int *mtind_;
+ /// values of the nonzero entries of the ILP matrix
+ int *mtval_;
+ /// lower bounds on the variables
+ int *vlb_;
+ /// upper bounds on the variables
+ int *vub_;
+ /// right hand sides of the constraints
+ int *mrhs_;
+ /// senses of the constraints: 'L', 'G' or 'E'
+ char *msense_;
+ /// Cgl012Cut object to make thread safe
+ Cgl012Cut cutInfo_;
+ /** Flags
+ 1 bit - global cuts
+ */
+ int flags_;
+ //@}
+};
+/// A simple Dijkstra shortest path - make better later
+#ifndef CGL_NEW_SHORT
+void cglShortestPath(cgl_graph * graph, int source, int maximumLength);
+#else
+void cglShortestPath(auxiliary_graph * graph, int source, int maximumLength);
+#endif
+//#############################################################################
+/** A function that tests the methods in the CglZeroHalf class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging. */
+void CglZeroHalfUnitTest(const OsiSolverInterface * siP,
+ const std::string mpdDir );
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpCholeskyBase.hpp b/thirdparty/windows/include/coin/ClpCholeskyBase.hpp
new file mode 100644
index 0000000..815af01
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpCholeskyBase.hpp
@@ -0,0 +1,294 @@
+/* $Id: ClpCholeskyBase.hpp 1722 2011-04-17 09:58:37Z stefan $ */
+// Copyright (C) 2003, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpCholeskyBase_H
+#define ClpCholeskyBase_H
+
+#include "CoinPragma.hpp"
+#include "CoinTypes.hpp"
+//#define CLP_LONG_CHOLESKY 0
+#ifndef CLP_LONG_CHOLESKY
+#define CLP_LONG_CHOLESKY 0
+#endif
+/* valid combinations are
+ CLP_LONG_CHOLESKY 0 and COIN_LONG_WORK 0
+ CLP_LONG_CHOLESKY 1 and COIN_LONG_WORK 1
+ CLP_LONG_CHOLESKY 2 and COIN_LONG_WORK 1
+*/
+#if COIN_LONG_WORK==0
+#if CLP_LONG_CHOLESKY>0
+#define CHOLESKY_BAD_COMBINATION
+#endif
+#else
+#if CLP_LONG_CHOLESKY==0
+#define CHOLESKY_BAD_COMBINATION
+#endif
+#endif
+#ifdef CHOLESKY_BAD_COMBINATION
+# warning("Bad combination of CLP_LONG_CHOLESKY and COIN_BIG_DOUBLE/COIN_LONG_WORK");
+"Bad combination of CLP_LONG_CHOLESKY and COIN_LONG_WORK"
+#endif
+#if CLP_LONG_CHOLESKY>1
+typedef long double longDouble;
+#define CHOL_SMALL_VALUE 1.0e-15
+#elif CLP_LONG_CHOLESKY==1
+typedef double longDouble;
+#define CHOL_SMALL_VALUE 1.0e-11
+#else
+typedef double longDouble;
+#define CHOL_SMALL_VALUE 1.0e-11
+#endif
+class ClpInterior;
+class ClpCholeskyDense;
+class ClpMatrixBase;
+
+/** Base class for Clp Cholesky factorization
+ Will do better factorization. very crude ordering
+
+ Derived classes may be using more sophisticated methods
+*/
+
+class ClpCholeskyBase {
+
+public:
+ /**@name Virtual methods that the derived classes may provide */
+ //@{
+ /** Orders rows and saves pointer to matrix.and model.
+ returns non-zero if not enough memory.
+ You can use preOrder to set up ADAT
+ If using default symbolic etc then must set sizeFactor_ to
+ size of input matrix to order (and to symbolic).
+ Also just permute_ and permuteInverse_ should be created */
+ virtual int order(ClpInterior * model);
+ /** Does Symbolic factorization given permutation.
+ This is called immediately after order. If user provides this then
+ user must provide factorize and solve. Otherwise the default factorization is used
+ returns non-zero if not enough memory */
+ virtual int symbolic();
+ /** Factorize - filling in rowsDropped and returning number dropped.
+ If return code negative then out of memory */
+ virtual int factorize(const CoinWorkDouble * diagonal, int * rowsDropped) ;
+ /** Uses factorization to solve. */
+ virtual void solve (CoinWorkDouble * region) ;
+ /** Uses factorization to solve. - given as if KKT.
+ region1 is rows+columns, region2 is rows */
+ virtual void solveKKT (CoinWorkDouble * region1, CoinWorkDouble * region2, const CoinWorkDouble * diagonal,
+ CoinWorkDouble diagonalScaleFactor);
+private:
+ /// AMD ordering
+ int orderAMD();
+public:
+ //@}
+
+ /**@name Gets */
+ //@{
+ /// status. Returns status
+ inline int status() const {
+ return status_;
+ }
+ /// numberRowsDropped. Number of rows gone
+ inline int numberRowsDropped() const {
+ return numberRowsDropped_;
+ }
+ /// reset numberRowsDropped and rowsDropped.
+ void resetRowsDropped();
+ /// rowsDropped - which rows are gone
+ inline char * rowsDropped() const {
+ return rowsDropped_;
+ }
+ /// choleskyCondition.
+ inline double choleskyCondition() const {
+ return choleskyCondition_;
+ }
+ /// goDense i.e. use dense factoriaztion if > this (default 0.7).
+ inline double goDense() const {
+ return goDense_;
+ }
+ /// goDense i.e. use dense factoriaztion if > this (default 0.7).
+ inline void setGoDense(double value) {
+ goDense_ = value;
+ }
+ /// rank. Returns rank
+ inline int rank() const {
+ return numberRows_ - numberRowsDropped_;
+ }
+ /// Return number of rows
+ inline int numberRows() const {
+ return numberRows_;
+ }
+ /// Return size
+ inline CoinBigIndex size() const {
+ return sizeFactor_;
+ }
+ /// Return sparseFactor
+ inline longDouble * sparseFactor() const {
+ return sparseFactor_;
+ }
+ /// Return diagonal
+ inline longDouble * diagonal() const {
+ return diagonal_;
+ }
+ /// Return workDouble
+ inline longDouble * workDouble() const {
+ return workDouble_;
+ }
+ /// If KKT on
+ inline bool kkt() const {
+ return doKKT_;
+ }
+ /// Set KKT
+ inline void setKKT(bool yesNo) {
+ doKKT_ = yesNo;
+ }
+ /// Set integer parameter
+ inline void setIntegerParameter(int i, int value) {
+ integerParameters_[i] = value;
+ }
+ /// get integer parameter
+ inline int getIntegerParameter(int i) {
+ return integerParameters_[i];
+ }
+ /// Set double parameter
+ inline void setDoubleParameter(int i, double value) {
+ doubleParameters_[i] = value;
+ }
+ /// get double parameter
+ inline double getDoubleParameter(int i) {
+ return doubleParameters_[i];
+ }
+ //@}
+
+
+public:
+
+ /**@name Constructors, destructor
+ */
+ //@{
+ /** Constructor which has dense columns activated.
+ Default is off. */
+ ClpCholeskyBase(int denseThreshold = -1);
+ /** Destructor (has to be public) */
+ virtual ~ClpCholeskyBase();
+ /// Copy
+ ClpCholeskyBase(const ClpCholeskyBase&);
+ /// Assignment
+ ClpCholeskyBase& operator=(const ClpCholeskyBase&);
+ //@}
+ //@{
+ ///@name Other
+ /// Clone
+ virtual ClpCholeskyBase * clone() const;
+
+ /// Returns type
+ inline int type() const {
+ if (doKKT_) return 100;
+ else return type_;
+ }
+protected:
+ /// Sets type
+ inline void setType(int type) {
+ type_ = type;
+ }
+ /// model.
+ inline void setModel(ClpInterior * model) {
+ model_ = model;
+ }
+ //@}
+
+ /**@name Symbolic, factor and solve */
+ //@{
+ /** Symbolic1 - works out size without clever stuff.
+ Uses upper triangular as much easier.
+ Returns size
+ */
+ int symbolic1(const CoinBigIndex * Astart, const int * Arow);
+ /** Symbolic2 - Fills in indices
+ Uses lower triangular so can do cliques etc
+ */
+ void symbolic2(const CoinBigIndex * Astart, const int * Arow);
+ /** Factorize - filling in rowsDropped and returning number dropped
+ in integerParam.
+ */
+ void factorizePart2(int * rowsDropped) ;
+ /** solve - 1 just first half, 2 just second half - 3 both.
+ If 1 and 2 then diagonal has sqrt of inverse otherwise inverse
+ */
+ void solve(CoinWorkDouble * region, int type);
+ /// Forms ADAT - returns nonzero if not enough memory
+ int preOrder(bool lowerTriangular, bool includeDiagonal, bool doKKT);
+ /// Updates dense part (broken out for profiling)
+ void updateDense(longDouble * d, /*longDouble * work,*/ int * first);
+ //@}
+
+protected:
+ /**@name Data members
+ The data members are protected to allow access for derived classes. */
+ //@{
+ /// type (may be useful) if > 20 do KKT
+ int type_;
+ /// Doing full KKT (only used if default symbolic and factorization)
+ bool doKKT_;
+ /// Go dense at this fraction
+ double goDense_;
+ /// choleskyCondition.
+ double choleskyCondition_;
+ /// model.
+ ClpInterior * model_;
+ /// numberTrials. Number of trials before rejection
+ int numberTrials_;
+ /// numberRows. Number of Rows in factorization
+ int numberRows_;
+ /// status. Status of factorization
+ int status_;
+ /// rowsDropped
+ char * rowsDropped_;
+ /// permute inverse.
+ int * permuteInverse_;
+ /// main permute.
+ int * permute_;
+ /// numberRowsDropped. Number of rows gone
+ int numberRowsDropped_;
+ /// sparseFactor.
+ longDouble * sparseFactor_;
+ /// choleskyStart - element starts
+ CoinBigIndex * choleskyStart_;
+ /// choleskyRow (can be shorter than sparsefactor)
+ int * choleskyRow_;
+ /// Index starts
+ CoinBigIndex * indexStart_;
+ /// Diagonal
+ longDouble * diagonal_;
+ /// double work array
+ longDouble * workDouble_;
+ /// link array
+ int * link_;
+ // Integer work array
+ CoinBigIndex * workInteger_;
+ // Clique information
+ int * clique_;
+ /// sizeFactor.
+ CoinBigIndex sizeFactor_;
+ /// Size of index array
+ CoinBigIndex sizeIndex_;
+ /// First dense row
+ int firstDense_;
+ /// integerParameters
+ int integerParameters_[64];
+ /// doubleParameters;
+ double doubleParameters_[64];
+ /// Row copy of matrix
+ ClpMatrixBase * rowCopy_;
+ /// Dense indicators
+ char * whichDense_;
+ /// Dense columns (updated)
+ longDouble * denseColumn_;
+ /// Dense cholesky
+ ClpCholeskyDense * dense_;
+ /// Dense threshold (for taking out of Cholesky)
+ int denseThreshold_;
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpCholeskyDense.hpp b/thirdparty/windows/include/coin/ClpCholeskyDense.hpp
new file mode 100644
index 0000000..d8428b6
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpCholeskyDense.hpp
@@ -0,0 +1,162 @@
+/* $Id: ClpCholeskyDense.hpp 1910 2013-01-27 02:00:13Z stefan $ */
+/*
+ Copyright (C) 2003, International Business Machines Corporation
+ and others. All Rights Reserved.
+
+ This code is licensed under the terms of the Eclipse Public License (EPL).
+*/
+#ifndef ClpCholeskyDense_H
+#define ClpCholeskyDense_H
+
+#include "ClpCholeskyBase.hpp"
+class ClpMatrixBase;
+
+class ClpCholeskyDense : public ClpCholeskyBase {
+
+public:
+ /**@name Virtual methods that the derived classes provides */
+ /**@{*/
+ /** Orders rows and saves pointer to matrix.and model.
+ Returns non-zero if not enough memory */
+ virtual int order(ClpInterior * model) ;
+ /** Does Symbolic factorization given permutation.
+ This is called immediately after order. If user provides this then
+ user must provide factorize and solve. Otherwise the default factorization is used
+ returns non-zero if not enough memory */
+ virtual int symbolic();
+ /** Factorize - filling in rowsDropped and returning number dropped.
+ If return code negative then out of memory */
+ virtual int factorize(const CoinWorkDouble * diagonal, int * rowsDropped) ;
+ /** Uses factorization to solve. */
+ virtual void solve (CoinWorkDouble * region) ;
+ /**@}*/
+
+ /**@name Non virtual methods for ClpCholeskyDense */
+ /**@{*/
+ /** Reserves space.
+ If factor not NULL then just uses passed space
+ Returns non-zero if not enough memory */
+ int reserveSpace(const ClpCholeskyBase * factor, int numberRows) ;
+ /** Returns space needed */
+ CoinBigIndex space( int numberRows) const;
+ /** part 2 of Factorize - filling in rowsDropped */
+ void factorizePart2(int * rowsDropped) ;
+ /** part 2 of Factorize - filling in rowsDropped - blocked */
+ void factorizePart3(int * rowsDropped) ;
+ /** Forward part of solve */
+ void solveF1(longDouble * a, int n, CoinWorkDouble * region);
+ void solveF2(longDouble * a, int n, CoinWorkDouble * region, CoinWorkDouble * region2);
+ /** Backward part of solve */
+ void solveB1(longDouble * a, int n, CoinWorkDouble * region);
+ void solveB2(longDouble * a, int n, CoinWorkDouble * region, CoinWorkDouble * region2);
+ int bNumber(const longDouble * array, int &, int&);
+ /** A */
+ inline longDouble * aMatrix() const {
+ return sparseFactor_;
+ }
+ /** Diagonal */
+ inline longDouble * diagonal() const {
+ return diagonal_;
+ }
+ /**@}*/
+
+
+ /**@name Constructors, destructor */
+ /**@{*/
+ /** Default constructor. */
+ ClpCholeskyDense();
+ /** Destructor */
+ virtual ~ClpCholeskyDense();
+ /** Copy */
+ ClpCholeskyDense(const ClpCholeskyDense&);
+ /** Assignment */
+ ClpCholeskyDense& operator=(const ClpCholeskyDense&);
+ /** Clone */
+ virtual ClpCholeskyBase * clone() const ;
+ /**@}*/
+
+
+private:
+ /**@name Data members */
+ /**@{*/
+ /** Just borrowing space */
+ bool borrowSpace_;
+ /**@}*/
+};
+
+/* structure for C */
+typedef struct {
+ longDouble * diagonal_;
+ longDouble * a;
+ longDouble * work;
+ int * rowsDropped;
+ double doubleParameters_[1]; /* corresponds to 10 */
+ int integerParameters_[2]; /* corresponds to 34, nThreads */
+ int n;
+ int numberBlocks;
+} ClpCholeskyDenseC;
+
+extern "C" {
+ void ClpCholeskySpawn(void *);
+}
+/**Non leaf recursive factor */
+void
+ClpCholeskyCfactor(ClpCholeskyDenseC * thisStruct,
+ longDouble * a, int n, int numberBlocks,
+ longDouble * diagonal, longDouble * work, int * rowsDropped);
+
+/**Non leaf recursive triangle rectangle update */
+void
+ClpCholeskyCtriRec(ClpCholeskyDenseC * thisStruct,
+ longDouble * aTri, int nThis,
+ longDouble * aUnder, longDouble * diagonal,
+ longDouble * work,
+ int nLeft, int iBlock, int jBlock,
+ int numberBlocks);
+/**Non leaf recursive rectangle triangle update */
+void
+ClpCholeskyCrecTri(ClpCholeskyDenseC * thisStruct,
+ longDouble * aUnder, int nTri, int nDo,
+ int iBlock, int jBlock, longDouble * aTri,
+ longDouble * diagonal, longDouble * work,
+ int numberBlocks);
+/** Non leaf recursive rectangle rectangle update,
+ nUnder is number of rows in iBlock,
+ nUnderK is number of rows in kBlock
+*/
+void
+ClpCholeskyCrecRec(ClpCholeskyDenseC * thisStruct,
+ longDouble * above, int nUnder, int nUnderK,
+ int nDo, longDouble * aUnder, longDouble *aOther,
+ longDouble * work,
+ int iBlock, int jBlock,
+ int numberBlocks);
+/**Leaf recursive factor */
+void
+ClpCholeskyCfactorLeaf(ClpCholeskyDenseC * thisStruct,
+ longDouble * a, int n,
+ longDouble * diagonal, longDouble * work,
+ int * rowsDropped);
+/**Leaf recursive triangle rectangle update */
+void
+ClpCholeskyCtriRecLeaf(/*ClpCholeskyDenseC * thisStruct,*/
+ longDouble * aTri, longDouble * aUnder,
+ longDouble * diagonal, longDouble * work,
+ int nUnder);
+/**Leaf recursive rectangle triangle update */
+void
+ClpCholeskyCrecTriLeaf(/*ClpCholeskyDenseC * thisStruct, */
+ longDouble * aUnder, longDouble * aTri,
+ /*longDouble * diagonal,*/ longDouble * work, int nUnder);
+/** Leaf recursive rectangle rectangle update,
+ nUnder is number of rows in iBlock,
+ nUnderK is number of rows in kBlock
+*/
+void
+ClpCholeskyCrecRecLeaf(/*ClpCholeskyDenseC * thisStruct, */
+ const longDouble * COIN_RESTRICT above,
+ const longDouble * COIN_RESTRICT aUnder,
+ longDouble * COIN_RESTRICT aOther,
+ const longDouble * COIN_RESTRICT work,
+ int nUnder);
+#endif
diff --git a/thirdparty/windows/include/coin/ClpConfig.h b/thirdparty/windows/include/coin/ClpConfig.h
new file mode 100644
index 0000000..2e3620f
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpConfig.h
@@ -0,0 +1,17 @@
+/* src/config_clp.h. Generated by configure. */
+/* src/config_clp.h.in. */
+
+/* Define to 1, 2, 3, or 4 if Aboca should be build. */
+/* #undef CLP_HAS_ABC */
+
+/* Version number of project */
+#define CLP_VERSION "1.16.10"
+
+/* Major Version number of project */
+#define CLP_VERSION_MAJOR 1
+
+/* Minor Version number of project */
+#define CLP_VERSION_MINOR 16
+
+/* Release Version number of project */
+#define CLP_VERSION_RELEASE 10
diff --git a/thirdparty/windows/include/coin/ClpConstraint.hpp b/thirdparty/windows/include/coin/ClpConstraint.hpp
new file mode 100644
index 0000000..be43bb8
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpConstraint.hpp
@@ -0,0 +1,125 @@
+/* $Id: ClpConstraint.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// Copyright (C) 2007, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpConstraint_H
+#define ClpConstraint_H
+
+
+//#############################################################################
+class ClpSimplex;
+class ClpModel;
+
+/** Constraint Abstract Base Class
+
+Abstract Base Class for describing a constraint or objective function
+
+*/
+class ClpConstraint {
+
+public:
+
+ ///@name Stuff
+ //@{
+
+ /** Fills gradient. If Linear then solution may be NULL,
+ also returns true value of function and offset so we can use x not deltaX in constraint
+ If refresh is false then uses last solution
+ Uses model for scaling
+ Returns non-zero if gradient undefined at current solution
+ */
+ virtual int gradient(const ClpSimplex * model,
+ const double * solution,
+ double * gradient,
+ double & functionValue ,
+ double & offset,
+ bool useScaling = false,
+ bool refresh = true) const = 0;
+ /// Constraint function value
+ virtual double functionValue (const ClpSimplex * model,
+ const double * solution,
+ bool useScaling = false,
+ bool refresh = true) const ;
+ /// Resize constraint
+ virtual void resize(int newNumberColumns) = 0;
+ /// Delete columns in constraint
+ virtual void deleteSome(int numberToDelete, const int * which) = 0;
+ /// Scale constraint
+ virtual void reallyScale(const double * columnScale) = 0;
+ /** Given a zeroed array sets nonlinear columns to 1.
+ Returns number of nonlinear columns
+ */
+ virtual int markNonlinear(char * which) const = 0;
+ /** Given a zeroed array sets possible nonzero coefficients to 1.
+ Returns number of nonzeros
+ */
+ virtual int markNonzero(char * which) const = 0;
+ //@}
+
+
+ ///@name Constructors and destructors
+ //@{
+ /// Default Constructor
+ ClpConstraint();
+
+ /// Copy constructor
+ ClpConstraint(const ClpConstraint &);
+
+ /// Assignment operator
+ ClpConstraint & operator=(const ClpConstraint& rhs);
+
+ /// Destructor
+ virtual ~ClpConstraint ();
+
+ /// Clone
+ virtual ClpConstraint * clone() const = 0;
+
+ //@}
+
+ ///@name Other
+ //@{
+ /// Returns type, 0 linear, 1 nonlinear
+ inline int type() {
+ return type_;
+ }
+ /// Row number (-1 is objective)
+ inline int rowNumber() const {
+ return rowNumber_;
+ }
+
+ /// Number of possible coefficients in gradient
+ virtual int numberCoefficients() const = 0;
+
+ /// Stored constraint function value
+ inline double functionValue () const {
+ return functionValue_;
+ }
+
+ /// Constraint offset
+ inline double offset () const {
+ return offset_;
+ }
+ /// Say we have new primal solution - so may need to recompute
+ virtual void newXValues() {}
+ //@}
+
+ //---------------------------------------------------------------------------
+
+protected:
+ ///@name Protected member data
+ //@{
+ /// Gradient at last evaluation
+ mutable double * lastGradient_;
+ /// Value of non-linear part of constraint
+ mutable double functionValue_;
+ /// Value of offset for constraint
+ mutable double offset_;
+ /// Type of constraint - linear is 1
+ int type_;
+ /// Row number (-1 is objective)
+ int rowNumber_;
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpConstraintLinear.hpp b/thirdparty/windows/include/coin/ClpConstraintLinear.hpp
new file mode 100644
index 0000000..fd0a4da
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpConstraintLinear.hpp
@@ -0,0 +1,110 @@
+/* $Id: ClpConstraintLinear.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// Copyright (C) 2007, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpConstraintLinear_H
+#define ClpConstraintLinear_H
+
+#include "ClpConstraint.hpp"
+
+//#############################################################################
+
+/** Linear Constraint Class
+
+*/
+
+class ClpConstraintLinear : public ClpConstraint {
+
+public:
+
+ ///@name Stuff
+ //@{
+
+
+ /** Fills gradient. If Linear then solution may be NULL,
+ also returns true value of function and offset so we can use x not deltaX in constraint
+ If refresh is false then uses last solution
+ Uses model for scaling
+ Returns non-zero if gradient udefined at current solution
+ */
+ virtual int gradient(const ClpSimplex * model,
+ const double * solution,
+ double * gradient,
+ double & functionValue ,
+ double & offset,
+ bool useScaling = false,
+ bool refresh = true) const ;
+ /// Resize constraint
+ virtual void resize(int newNumberColumns) ;
+ /// Delete columns in constraint
+ virtual void deleteSome(int numberToDelete, const int * which) ;
+ /// Scale constraint
+ virtual void reallyScale(const double * columnScale) ;
+ /** Given a zeroed array sets nonlinear columns to 1.
+ Returns number of nonlinear columns
+ */
+ virtual int markNonlinear(char * which) const ;
+ /** Given a zeroed array sets possible nonzero coefficients to 1.
+ Returns number of nonzeros
+ */
+ virtual int markNonzero(char * which) const;
+ //@}
+
+
+ ///@name Constructors and destructors
+ //@{
+ /// Default Constructor
+ ClpConstraintLinear();
+
+ /// Constructor from constraint
+ ClpConstraintLinear(int row, int numberCoefficients, int numberColumns,
+ const int * column, const double * element);
+
+ /** Copy constructor .
+ */
+ ClpConstraintLinear(const ClpConstraintLinear & rhs);
+
+ /// Assignment operator
+ ClpConstraintLinear & operator=(const ClpConstraintLinear& rhs);
+
+ /// Destructor
+ virtual ~ClpConstraintLinear ();
+
+ /// Clone
+ virtual ClpConstraint * clone() const;
+ //@}
+ ///@name Gets and sets
+ //@{
+ /// Number of coefficients
+ virtual int numberCoefficients() const;
+ /// Number of columns in linear constraint
+ inline int numberColumns() const {
+ return numberColumns_;
+ }
+ /// Columns
+ inline const int * column() const {
+ return column_;
+ }
+ /// Coefficients
+ inline const double * coefficient() const {
+ return coefficient_;
+ }
+ //@}
+
+ //---------------------------------------------------------------------------
+
+private:
+ ///@name Private member data
+ /// Column
+ int * column_;
+ /// Coefficients
+ double * coefficient_;
+ /// Useful to have number of columns about
+ int numberColumns_;
+ /// Number of coefficients
+ int numberCoefficients_;
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpConstraintQuadratic.hpp b/thirdparty/windows/include/coin/ClpConstraintQuadratic.hpp
new file mode 100644
index 0000000..2eff6cc
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpConstraintQuadratic.hpp
@@ -0,0 +1,119 @@
+/* $Id: ClpConstraintQuadratic.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// Copyright (C) 2007, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpConstraintQuadratic_H
+#define ClpConstraintQuadratic_H
+
+#include "ClpConstraint.hpp"
+
+//#############################################################################
+
+/** Quadratic Constraint Class
+
+*/
+
+class ClpConstraintQuadratic : public ClpConstraint {
+
+public:
+
+ ///@name Stuff
+ //@{
+
+
+ /** Fills gradient. If Quadratic then solution may be NULL,
+ also returns true value of function and offset so we can use x not deltaX in constraint
+ If refresh is false then uses last solution
+ Uses model for scaling
+ Returns non-zero if gradient udefined at current solution
+ */
+ virtual int gradient(const ClpSimplex * model,
+ const double * solution,
+ double * gradient,
+ double & functionValue ,
+ double & offset,
+ bool useScaling = false,
+ bool refresh = true) const ;
+ /// Resize constraint
+ virtual void resize(int newNumberColumns) ;
+ /// Delete columns in constraint
+ virtual void deleteSome(int numberToDelete, const int * which) ;
+ /// Scale constraint
+ virtual void reallyScale(const double * columnScale) ;
+ /** Given a zeroed array sets nonquadratic columns to 1.
+ Returns number of nonquadratic columns
+ */
+ virtual int markNonlinear(char * which) const ;
+ /** Given a zeroed array sets possible nonzero coefficients to 1.
+ Returns number of nonzeros
+ */
+ virtual int markNonzero(char * which) const;
+ //@}
+
+
+ ///@name Constructors and destructors
+ //@{
+ /// Default Constructor
+ ClpConstraintQuadratic();
+
+ /// Constructor from quadratic
+ ClpConstraintQuadratic(int row, int numberQuadraticColumns, int numberColumns,
+ const CoinBigIndex * start,
+ const int * column, const double * element);
+
+ /** Copy constructor .
+ */
+ ClpConstraintQuadratic(const ClpConstraintQuadratic & rhs);
+
+ /// Assignment operator
+ ClpConstraintQuadratic & operator=(const ClpConstraintQuadratic& rhs);
+
+ /// Destructor
+ virtual ~ClpConstraintQuadratic ();
+
+ /// Clone
+ virtual ClpConstraint * clone() const;
+ //@}
+ ///@name Gets and sets
+ //@{
+ /// Number of coefficients
+ virtual int numberCoefficients() const;
+ /// Number of columns in constraint
+ inline int numberColumns() const {
+ return numberColumns_;
+ }
+ /// Column starts
+ inline CoinBigIndex * start() const {
+ return start_;
+ }
+ /// Columns
+ inline const int * column() const {
+ return column_;
+ }
+ /// Coefficients
+ inline const double * coefficient() const {
+ return coefficient_;
+ }
+ //@}
+
+ //---------------------------------------------------------------------------
+
+private:
+ ///@name Private member data
+ /// Column starts
+ CoinBigIndex * start_;
+ /// Column (if -1 then linear coefficient)
+ int * column_;
+ /// Coefficients
+ double * coefficient_;
+ /// Useful to have number of columns about
+ int numberColumns_;
+ /// Number of coefficients in gradient
+ int numberCoefficients_;
+ /// Number of quadratic columns
+ int numberQuadraticColumns_;
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpDualRowDantzig.hpp b/thirdparty/windows/include/coin/ClpDualRowDantzig.hpp
new file mode 100644
index 0000000..73b42b3
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpDualRowDantzig.hpp
@@ -0,0 +1,71 @@
+/* $Id: ClpDualRowDantzig.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpDualRowDantzig_H
+#define ClpDualRowDantzig_H
+
+#include "ClpDualRowPivot.hpp"
+
+//#############################################################################
+
+/** Dual Row Pivot Dantzig Algorithm Class
+
+This is simplest choice - choose largest infeasibility
+
+*/
+
+class ClpDualRowDantzig : public ClpDualRowPivot {
+
+public:
+
+ ///@name Algorithmic methods
+ //@{
+
+ /// Returns pivot row, -1 if none
+ virtual int pivotRow();
+
+ /** Updates weights and returns pivot alpha.
+ Also does FT update */
+ virtual double updateWeights(CoinIndexedVector * input,
+ CoinIndexedVector * spare,
+ CoinIndexedVector * spare2,
+ CoinIndexedVector * updatedColumn);
+ /** Updates primal solution (and maybe list of candidates)
+ Uses input vector which it deletes
+ Computes change in objective function
+ */
+ virtual void updatePrimalSolution(CoinIndexedVector * input,
+ double theta,
+ double & changeInObjective);
+ //@}
+
+
+ ///@name Constructors and destructors
+ //@{
+ /// Default Constructor
+ ClpDualRowDantzig();
+
+ /// Copy constructor
+ ClpDualRowDantzig(const ClpDualRowDantzig &);
+
+ /// Assignment operator
+ ClpDualRowDantzig & operator=(const ClpDualRowDantzig& rhs);
+
+ /// Destructor
+ virtual ~ClpDualRowDantzig ();
+
+ /// Clone
+ virtual ClpDualRowPivot * clone(bool copyData = true) const;
+
+ //@}
+
+ //---------------------------------------------------------------------------
+
+private:
+ ///@name Private member data
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpDualRowPivot.hpp b/thirdparty/windows/include/coin/ClpDualRowPivot.hpp
new file mode 100644
index 0000000..f1f57a6
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpDualRowPivot.hpp
@@ -0,0 +1,129 @@
+/* $Id: ClpDualRowPivot.hpp 2070 2014-11-18 11:12:54Z forrest $ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpDualRowPivot_H
+#define ClpDualRowPivot_H
+
+class ClpSimplex;
+class CoinIndexedVector;
+
+//#############################################################################
+
+/** Dual Row Pivot Abstract Base Class
+
+Abstract Base Class for describing an interface to an algorithm
+to choose row pivot in dual simplex algorithm. For some algorithms
+e.g. Dantzig choice then some functions may be null.
+
+*/
+
+class ClpDualRowPivot {
+
+public:
+
+ ///@name Algorithmic methods
+ //@{
+
+ /// Returns pivot row, -1 if none
+ virtual int pivotRow() = 0;
+
+ /** Updates weights and returns pivot alpha.
+ Also does FT update */
+ virtual double updateWeights(CoinIndexedVector * input,
+ CoinIndexedVector * spare,
+ CoinIndexedVector * spare2,
+ CoinIndexedVector * updatedColumn) = 0;
+
+ /** Updates primal solution (and maybe list of candidates)
+ Uses input vector which it deletes
+ Computes change in objective function
+ Would be faster if we kept basic regions, but on other hand it
+ means everything is always in sync
+ */
+ /* FIXME: this was pure virtul (=0). Why? */
+ virtual void updatePrimalSolution(CoinIndexedVector * input,
+ double theta,
+ double & changeInObjective) = 0;
+ /** Saves any weights round factorization as pivot rows may change
+ Will be empty unless steepest edge (will save model)
+ May also recompute infeasibility stuff
+ 1) before factorization
+ 2) after good factorization (if weights empty may initialize)
+ 3) after something happened but no factorization
+ (e.g. check for infeasible)
+ 4) as 2 but restore weights from previous snapshot
+ 5) for strong branching - initialize to 1 , infeasibilities
+ 6) scale back
+ 7) for strong branching - initialize full weights , infeasibilities
+ */
+ virtual void saveWeights(ClpSimplex * model, int mode);
+ /// checks accuracy and may re-initialize (may be empty)
+ virtual void checkAccuracy();
+ /// Gets rid of last update (may be empty)
+ virtual void unrollWeights();
+ /// Gets rid of all arrays (may be empty)
+ virtual void clearArrays();
+ /// Returns true if would not find any row
+ virtual bool looksOptimal() const {
+ return false;
+ }
+ /// Called when maximum pivots changes
+ virtual void maximumPivotsChanged() {}
+ //@}
+
+
+ ///@name Constructors and destructors
+ //@{
+ /// Default Constructor
+ ClpDualRowPivot();
+
+ /// Copy constructor
+ ClpDualRowPivot(const ClpDualRowPivot &);
+
+ /// Assignment operator
+ ClpDualRowPivot & operator=(const ClpDualRowPivot& rhs);
+
+ /// Destructor
+ virtual ~ClpDualRowPivot ();
+
+ /// Clone
+ virtual ClpDualRowPivot * clone(bool copyData = true) const = 0;
+
+ //@}
+
+ ///@name Other
+ //@{
+ /// Returns model
+ inline ClpSimplex * model() {
+ return model_;
+ }
+
+ /// Sets model (normally to NULL)
+ inline void setModel(ClpSimplex * newmodel) {
+ model_ = newmodel;
+ }
+
+ /// Returns type (above 63 is extra information)
+ inline int type() {
+ return type_;
+ }
+
+ //@}
+
+ //---------------------------------------------------------------------------
+
+protected:
+ ///@name Protected member data
+ //@{
+ /// Pointer to model
+ ClpSimplex * model_;
+ /// Type of row pivot algorithm
+ int type_;
+ //@}
+};
+#ifndef CLP_DUAL_COLUMN_MULTIPLIER
+//#define CLP_DUAL_COLUMN_MULTIPLIER 0.99999
+#endif
+#endif
diff --git a/thirdparty/windows/include/coin/ClpDualRowSteepest.hpp b/thirdparty/windows/include/coin/ClpDualRowSteepest.hpp
new file mode 100644
index 0000000..7e2cc62
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpDualRowSteepest.hpp
@@ -0,0 +1,153 @@
+/* $Id: ClpDualRowSteepest.hpp 2070 2014-11-18 11:12:54Z forrest $ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpDualRowSteepest_H
+#define ClpDualRowSteepest_H
+
+#include "ClpDualRowPivot.hpp"
+class CoinIndexedVector;
+
+
+//#############################################################################
+
+/** Dual Row Pivot Steepest Edge Algorithm Class
+
+See Forrest-Goldfarb paper for algorithm
+
+*/
+
+class ClpDualRowSteepest : public ClpDualRowPivot {
+
+public:
+
+ ///@name Algorithmic methods
+ //@{
+
+ /// Returns pivot row, -1 if none
+ virtual int pivotRow();
+
+ /** Updates weights and returns pivot alpha.
+ Also does FT update */
+ virtual double updateWeights(CoinIndexedVector * input,
+ CoinIndexedVector * spare,
+ CoinIndexedVector * spare2,
+ CoinIndexedVector * updatedColumn);
+
+ /** Updates primal solution (and maybe list of candidates)
+ Uses input vector which it deletes
+ Computes change in objective function
+ */
+ virtual void updatePrimalSolution(CoinIndexedVector * input,
+ double theta,
+ double & changeInObjective);
+
+ /** Saves any weights round factorization as pivot rows may change
+ Save model
+ May also recompute infeasibility stuff
+ 1) before factorization
+ 2) after good factorization (if weights empty may initialize)
+ 3) after something happened but no factorization
+ (e.g. check for infeasible)
+ 4) as 2 but restore weights from previous snapshot
+ 5) for strong branching - initialize (uninitialized) , infeasibilities
+ */
+ virtual void saveWeights(ClpSimplex * model, int mode);
+ /// Pass in saved weights
+ void passInSavedWeights(const CoinIndexedVector * saved);
+ /// Get saved weights
+ inline CoinIndexedVector * savedWeights()
+ { return savedWeights_;}
+ /// Gets rid of last update
+ virtual void unrollWeights();
+ /// Gets rid of all arrays
+ virtual void clearArrays();
+ /// Returns true if would not find any row
+ virtual bool looksOptimal() const;
+ /// Called when maximum pivots changes
+ virtual void maximumPivotsChanged();
+ //@}
+
+ /** enums for persistence
+ */
+ enum Persistence {
+ normal = 0x00, // create (if necessary) and destroy
+ keep = 0x01 // create (if necessary) and leave
+ };
+
+ ///@name Constructors and destructors
+ //@{
+ /** Default Constructor
+ 0 is uninitialized, 1 full, 2 is partial uninitialized,
+ 3 starts as 2 but may switch to 1.
+ By partial is meant that the weights are updated as normal
+ but only part of the infeasible basic variables are scanned.
+ This can be faster on very easy problems.
+ */
+ ClpDualRowSteepest(int mode = 3);
+
+ /// Copy constructor
+ ClpDualRowSteepest(const ClpDualRowSteepest &);
+
+ /// Assignment operator
+ ClpDualRowSteepest & operator=(const ClpDualRowSteepest& rhs);
+
+ /// Fill most values
+ void fill(const ClpDualRowSteepest& rhs);
+
+ /// Destructor
+ virtual ~ClpDualRowSteepest ();
+
+ /// Clone
+ virtual ClpDualRowPivot * clone(bool copyData = true) const;
+
+ //@}
+ /**@name gets and sets */
+ //@{
+ /// Mode
+ inline int mode() const {
+ return mode_;
+ }
+ /// Set mode
+ inline void setMode(int mode) {
+ mode_ = mode;
+ }
+ /// Set/ get persistence
+ inline void setPersistence(Persistence life) {
+ persistence_ = life;
+ }
+ inline Persistence persistence() const {
+ return persistence_ ;
+ }
+//@}
+
+ //---------------------------------------------------------------------------
+
+private:
+ ///@name Private member data
+ /** Status
+ 0) Normal
+ -1) Needs initialization
+ 1) Weights are stored by sequence number
+ */
+ int state_;
+ /** If 0 then we are using uninitialized weights, 1 then full,
+ if 2 then uninitialized partial, 3 switchable */
+ int mode_;
+ /// Life of weights
+ Persistence persistence_;
+ /// weight array
+ double * weights_;
+ /// square of infeasibility array (just for infeasible rows)
+ CoinIndexedVector * infeasible_;
+ /// alternate weight array (so we can unroll)
+ CoinIndexedVector * alternateWeights_;
+ /// save weight array (so we can use checkpoint)
+ CoinIndexedVector * savedWeights_;
+ /// Dubious weights
+ int * dubiousWeights_;
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpDummyMatrix.hpp b/thirdparty/windows/include/coin/ClpDummyMatrix.hpp
new file mode 100644
index 0000000..1b4a2d4
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpDummyMatrix.hpp
@@ -0,0 +1,183 @@
+/* $Id: ClpDummyMatrix.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// Copyright (C) 2003, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpDummyMatrix_H
+#define ClpDummyMatrix_H
+
+
+#include "CoinPragma.hpp"
+
+#include "ClpMatrixBase.hpp"
+
+/** This implements a dummy matrix as derived from ClpMatrixBase.
+ This is so you can do ClpPdco but may come in useful elsewhere.
+ It just has dimensions but no data
+*/
+
+
+class ClpDummyMatrix : public ClpMatrixBase {
+
+public:
+ /**@name Useful methods */
+ //@{
+ /// Return a complete CoinPackedMatrix
+ virtual CoinPackedMatrix * getPackedMatrix() const;
+ /** Whether the packed matrix is column major ordered or not. */
+ virtual bool isColOrdered() const {
+ return true;
+ }
+ /** Number of entries in the packed matrix. */
+ virtual CoinBigIndex getNumElements() const {
+ return numberElements_;
+ }
+ /** Number of columns. */
+ virtual int getNumCols() const {
+ return numberColumns_;
+ }
+ /** Number of rows. */
+ virtual int getNumRows() const {
+ return numberRows_;
+ }
+
+ /** A vector containing the elements in the packed matrix. Note that there
+ might be gaps in this list, entries that do not belong to any
+ major-dimension vector. To get the actual elements one should look at
+ this vector together with vectorStarts and vectorLengths. */
+ virtual const double * getElements() const;
+ /** A vector containing the minor indices of the elements in the packed
+ matrix. Note that there might be gaps in this list, entries that do not
+ belong to any major-dimension vector. To get the actual elements one
+ should look at this vector together with vectorStarts and
+ vectorLengths. */
+ virtual const int * getIndices() const;
+
+ virtual const CoinBigIndex * getVectorStarts() const;
+ /** The lengths of the major-dimension vectors. */
+ virtual const int * getVectorLengths() const;
+
+ /** Delete the columns whose indices are listed in indDel. */
+ virtual void deleteCols(const int numDel, const int * indDel);
+ /** Delete the rows whose indices are listed in indDel. */
+ virtual void deleteRows(const int numDel, const int * indDel);
+ /** Returns a new matrix in reverse order without gaps */
+ virtual ClpMatrixBase * reverseOrderedCopy() const;
+ /// Returns number of elements in column part of basis
+ virtual CoinBigIndex countBasis(const int * whichColumn,
+ int & numberColumnBasic);
+ /// Fills in column part of basis
+ virtual void fillBasis(ClpSimplex * model,
+ const int * whichColumn,
+ int & numberColumnBasic,
+ int * row, int * start,
+ int * rowCount, int * columnCount,
+ CoinFactorizationDouble * element);
+ /** Unpacks a column into an CoinIndexedvector
+ */
+ virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
+ int column) const ;
+ /** Unpacks a column into an CoinIndexedvector
+ ** in packed foramt
+ Note that model is NOT const. Bounds and objective could
+ be modified if doing column generation (just for this variable) */
+ virtual void unpackPacked(ClpSimplex * model,
+ CoinIndexedVector * rowArray,
+ int column) const;
+ /** Adds multiple of a column into an CoinIndexedvector
+ You can use quickAdd to add to vector */
+ virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
+ int column, double multiplier) const ;
+ /** Adds multiple of a column into an array */
+ virtual void add(const ClpSimplex * model, double * array,
+ int column, double multiplier) const;
+ /// Allow any parts of a created CoinMatrix to be deleted
+ /// Allow any parts of a created CoinPackedMatrix to be deleted
+ virtual void releasePackedMatrix() const {}
+ //@}
+
+ /**@name Matrix times vector methods */
+ //@{
+ /** Return y + A * scalar *x in y.
+ @pre x must be of size numColumns()
+ @pre y must be of size numRows() */
+ virtual void times(double scalar,
+ const double * x, double * y) const;
+ /// And for scaling
+ virtual void times(double scalar,
+ const double * x, double * y,
+ const double * rowScale,
+ const double * columnScale) const;
+ /** Return y + x * scalar * A in y.
+ @pre x must be of size numRows()
+ @pre y must be of size numColumns() */
+ virtual void transposeTimes(double scalar,
+ const double * x, double * y) const;
+ /// And for scaling
+ virtual void transposeTimes(double scalar,
+ const double * x, double * y,
+ const double * rowScale,
+ const double * columnScale) const;
+
+ using ClpMatrixBase::transposeTimes ;
+ /** Return x * scalar * A + y in z.
+ Can use y as temporary array (will be empty at end)
+ Note - If x packed mode - then z packed mode */
+ virtual void transposeTimes(const ClpSimplex * model, double scalar,
+ const CoinIndexedVector * x,
+ CoinIndexedVector * y,
+ CoinIndexedVector * z) const;
+ /** Return x *A in z but
+ just for indices in y.
+ Note - If x packed mode - then z packed mode
+ Squashes small elements and knows about ClpSimplex */
+ virtual void subsetTransposeTimes(const ClpSimplex * model,
+ const CoinIndexedVector * x,
+ const CoinIndexedVector * y,
+ CoinIndexedVector * z) const;
+ //@}
+
+ /**@name Other */
+ //@{
+ //@}
+
+
+ /**@name Constructors, destructor */
+ //@{
+ /** Default constructor. */
+ ClpDummyMatrix();
+ /// Constructor with data
+ ClpDummyMatrix(int numberColumns, int numberRows,
+ int numberElements);
+ /** Destructor */
+ virtual ~ClpDummyMatrix();
+ //@}
+
+ /**@name Copy method */
+ //@{
+ /** The copy constructor. */
+ ClpDummyMatrix(const ClpDummyMatrix&);
+ /** The copy constructor from an CoinDummyMatrix. */
+ ClpDummyMatrix(const CoinPackedMatrix&);
+
+ ClpDummyMatrix& operator=(const ClpDummyMatrix&);
+ /// Clone
+ virtual ClpMatrixBase * clone() const ;
+ //@}
+
+
+protected:
+ /**@name Data members
+ The data members are protected to allow access for derived classes. */
+ //@{
+ /// Number of rows
+ int numberRows_;
+ /// Number of columns
+ int numberColumns_;
+ /// Number of elements
+ int numberElements_;
+
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpDynamicExampleMatrix.hpp b/thirdparty/windows/include/coin/ClpDynamicExampleMatrix.hpp
new file mode 100644
index 0000000..81fe5ba
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpDynamicExampleMatrix.hpp
@@ -0,0 +1,186 @@
+/* $Id: ClpDynamicExampleMatrix.hpp 1936 2013-04-09 10:29:27Z forrest $ */
+// Copyright (C) 2004, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpDynamicExampleMatrix_H
+#define ClpDynamicExampleMatrix_H
+
+
+#include "CoinPragma.hpp"
+
+#include "ClpDynamicMatrix.hpp"
+class ClpSimplex;
+/** This implements a dynamic matrix when we have a limit on the number of
+ "interesting rows". This version inherits from ClpDynamicMatrix and knows that
+ the real matrix is gub. This acts just like ClpDynamicMatrix but generates columns.
+ This "generates" columns by choosing from stored set. It is maent as a starting point
+ as to how you could use shortest path to generate columns.
+
+ So it has its own copy of all data needed. It populates ClpDynamicWatrix with enough
+ to allow for gub keys and active variables. In turn ClpDynamicMatrix populates
+ a CoinPackedMatrix with active columns and rows.
+
+ As there is one copy here and one in ClpDynamicmatrix these names end in Gen_
+
+ It is obviously more efficient to just use ClpDynamicMatrix but the ideas is to
+ show how much code a user would have to write.
+
+ This does not work very well with bounds
+
+*/
+
+class ClpDynamicExampleMatrix : public ClpDynamicMatrix {
+
+public:
+ /**@name Main functions provided */
+ //@{
+ /// Partial pricing
+ virtual void partialPricing(ClpSimplex * model, double start, double end,
+ int & bestSequence, int & numberWanted);
+
+ /** Creates a variable. This is called after partial pricing and will modify matrix.
+ Will update bestSequence.
+ */
+ virtual void createVariable(ClpSimplex * model, int & bestSequence);
+ /** If addColumn forces compression then this allows descendant to know what to do.
+ If >= then entry stayed in, if -1 then entry went out to lower bound.of zero.
+ Entries at upper bound (really nonzero) never go out (at present).
+ */
+ virtual void packDown(const int * in, int numberToPack);
+ //@}
+
+
+
+ /**@name Constructors, destructor */
+ //@{
+ /** Default constructor. */
+ ClpDynamicExampleMatrix();
+ /** This is the real constructor.
+ It assumes factorization frequency will not be changed.
+ This resizes model !!!!
+ The contents of original matrix in model will be taken over and original matrix
+ will be sanitized so can be deleted (to avoid a very small memory leak)
+ */
+ ClpDynamicExampleMatrix(ClpSimplex * model, int numberSets,
+ int numberColumns, const int * starts,
+ const double * lower, const double * upper,
+ const int * startColumn, const int * row,
+ const double * element, const double * cost,
+ const double * columnLower = NULL, const double * columnUpper = NULL,
+ const unsigned char * status = NULL,
+ const unsigned char * dynamicStatus = NULL,
+ int numberIds = 0, const int *ids = NULL);
+#if 0
+ /// This constructor just takes over ownership (except for lower, upper)
+ ClpDynamicExampleMatrix(ClpSimplex * model, int numberSets,
+ int numberColumns, int * starts,
+ const double * lower, const double * upper,
+ int * startColumn, int * row,
+ double * element, double * cost,
+ double * columnLower = NULL, double * columnUpper = NULL,
+ const unsigned char * status = NULL,
+ const unsigned char * dynamicStatus = NULL,
+ int numberIds = 0, const int *ids = NULL);
+#endif
+ /** Destructor */
+ virtual ~ClpDynamicExampleMatrix();
+ //@}
+
+ /**@name Copy method */
+ //@{
+ /** The copy constructor. */
+ ClpDynamicExampleMatrix(const ClpDynamicExampleMatrix&);
+ ClpDynamicExampleMatrix& operator=(const ClpDynamicExampleMatrix&);
+ /// Clone
+ virtual ClpMatrixBase * clone() const ;
+ //@}
+ /**@name gets and sets */
+ //@{
+ /// Starts of each column
+ inline CoinBigIndex * startColumnGen() const {
+ return startColumnGen_;
+ }
+ /// rows
+ inline int * rowGen() const {
+ return rowGen_;
+ }
+ /// elements
+ inline double * elementGen() const {
+ return elementGen_;
+ }
+ /// costs
+ inline double * costGen() const {
+ return costGen_;
+ }
+ /// full starts
+ inline int * fullStartGen() const {
+ return fullStartGen_;
+ }
+ /// ids in next level matrix
+ inline int * idGen() const {
+ return idGen_;
+ }
+ /// Optional lower bounds on columns
+ inline double * columnLowerGen() const {
+ return columnLowerGen_;
+ }
+ /// Optional upper bounds on columns
+ inline double * columnUpperGen() const {
+ return columnUpperGen_;
+ }
+ /// size
+ inline int numberColumns() const {
+ return numberColumns_;
+ }
+ inline void setDynamicStatusGen(int sequence, DynamicStatus status) {
+ unsigned char & st_byte = dynamicStatusGen_[sequence];
+ st_byte = static_cast(st_byte & ~7);
+ st_byte = static_cast(st_byte | status);
+ }
+ inline DynamicStatus getDynamicStatusGen(int sequence) const {
+ return static_cast (dynamicStatusGen_[sequence] & 7);
+ }
+ /// Whether flagged
+ inline bool flaggedGen(int i) const {
+ return (dynamicStatusGen_[i] & 8) != 0;
+ }
+ inline void setFlaggedGen(int i) {
+ dynamicStatusGen_[i] = static_cast(dynamicStatusGen_[i] | 8);
+ }
+ inline void unsetFlagged(int i) {
+ dynamicStatusGen_[i] = static_cast(dynamicStatusGen_[i] & ~8);
+ }
+ //@}
+
+
+protected:
+ /**@name Data members
+ The data members are protected to allow access for derived classes. */
+ //@{
+ /// size
+ int numberColumns_;
+ /// Starts of each column
+ CoinBigIndex * startColumnGen_;
+ /// rows
+ int * rowGen_;
+ /// elements
+ double * elementGen_;
+ /// costs
+ double * costGen_;
+ /// start of each set
+ int * fullStartGen_;
+ /// for status and which bound
+ unsigned char * dynamicStatusGen_;
+ /** identifier for each variable up one level (startColumn_, etc). This is
+ of length maximumGubColumns_. For this version it is just sequence number
+ at this level */
+ int * idGen_;
+ /// Optional lower bounds on columns
+ double * columnLowerGen_;
+ /// Optional upper bounds on columns
+ double * columnUpperGen_;
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpDynamicMatrix.hpp b/thirdparty/windows/include/coin/ClpDynamicMatrix.hpp
new file mode 100644
index 0000000..da4e144
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpDynamicMatrix.hpp
@@ -0,0 +1,381 @@
+/* $Id: ClpDynamicMatrix.hpp 1755 2011-06-28 18:24:31Z lou $ */
+// Copyright (C) 2004, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpDynamicMatrix_H
+#define ClpDynamicMatrix_H
+
+
+#include "CoinPragma.hpp"
+
+#include "ClpPackedMatrix.hpp"
+class ClpSimplex;
+/** This implements a dynamic matrix when we have a limit on the number of
+ "interesting rows". This version inherits from ClpPackedMatrix and knows that
+ the real matrix is gub. A later version could use shortest path to generate columns.
+
+*/
+
+class ClpDynamicMatrix : public ClpPackedMatrix {
+
+public:
+ /// enums for status of various sorts
+ enum DynamicStatus {
+ soloKey = 0x00,
+ inSmall = 0x01,
+ atUpperBound = 0x02,
+ atLowerBound = 0x03
+ };
+ /**@name Main functions provided */
+ //@{
+ /// Partial pricing
+ virtual void partialPricing(ClpSimplex * model, double start, double end,
+ int & bestSequence, int & numberWanted);
+
+ /**
+ update information for a pivot (and effective rhs)
+ */
+ virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
+ /** Returns effective RHS offset if it is being used. This is used for long problems
+ or big dynamic or anywhere where going through full columns is
+ expensive. This may re-compute */
+ virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
+ bool check = false);
+
+ using ClpPackedMatrix::times ;
+ /** Return y + A * scalar *x in y.
+ @pre x must be of size numColumns()
+ @pre y must be of size numRows() */
+ virtual void times(double scalar,
+ const double * x, double * y) const;
+ /// Modifies rhs offset
+ void modifyOffset(int sequence, double amount);
+ /// Gets key value when none in small
+ double keyValue(int iSet) const;
+ /**
+ mode=0 - Set up before "updateTranspose" and "transposeTimes" for duals using extended
+ updates array (and may use other if dual values pass)
+ mode=1 - Update dual solution after "transposeTimes" using extended rows.
+ mode=2 - Compute all djs and compute key dual infeasibilities
+ mode=3 - Report on key dual infeasibilities
+ mode=4 - Modify before updateTranspose in partial pricing
+ */
+ virtual void dualExpanded(ClpSimplex * model, CoinIndexedVector * array,
+ double * other, int mode);
+ /**
+ mode=0 - Create list of non-key basics in pivotVariable_ using
+ number as numberBasic in and out
+ mode=1 - Set all key variables as basic
+ mode=2 - return number extra rows needed, number gives maximum number basic
+ mode=3 - before replaceColumn
+ mode=4 - return 1 if can do primal, 2 if dual, 3 if both
+ mode=5 - save any status stuff (when in good state)
+ mode=6 - restore status stuff
+ mode=7 - flag given variable (normally sequenceIn)
+ mode=8 - unflag all variables
+ mode=9 - synchronize costs
+ mode=10 - return 1 if there may be changing bounds on variable (column generation)
+ mode=11 - make sure set is clean (used when a variable rejected - but not flagged)
+ mode=12 - after factorize but before permute stuff
+ mode=13 - at end of simplex to delete stuff
+ */
+ virtual int generalExpanded(ClpSimplex * model, int mode, int & number);
+ /** Purely for column generation and similar ideas. Allows
+ matrix and any bounds or costs to be updated (sensibly).
+ Returns non-zero if any changes.
+ */
+ virtual int refresh(ClpSimplex * model);
+ /** Creates a variable. This is called after partial pricing and will modify matrix.
+ Will update bestSequence.
+ */
+ virtual void createVariable(ClpSimplex * model, int & bestSequence);
+ /// Returns reduced cost of a variable
+ virtual double reducedCost( ClpSimplex * model, int sequence) const;
+ /// Does gub crash
+ void gubCrash();
+ /// Writes out model (without names)
+ void writeMps(const char * name);
+ /// Populates initial matrix from dynamic status
+ void initialProblem();
+ /** Adds in a column to gub structure (called from descendant) and returns sequence */
+ int addColumn(int numberEntries, const int * row, const double * element,
+ double cost, double lower, double upper, int iSet,
+ DynamicStatus status);
+ /** If addColumn forces compression then this allows descendant to know what to do.
+ If >=0 then entry stayed in, if -1 then entry went out to lower bound.of zero.
+ Entries at upper bound (really nonzero) never go out (at present).
+ */
+ virtual void packDown(const int * , int ) {}
+ /// Gets lower bound (to simplify coding)
+ inline double columnLower(int sequence) const {
+ if (columnLower_) return columnLower_[sequence];
+ else return 0.0;
+ }
+ /// Gets upper bound (to simplify coding)
+ inline double columnUpper(int sequence) const {
+ if (columnUpper_) return columnUpper_[sequence];
+ else return COIN_DBL_MAX;
+ }
+
+ //@}
+
+
+
+ /**@name Constructors, destructor */
+ //@{
+ /** Default constructor. */
+ ClpDynamicMatrix();
+ /** This is the real constructor.
+ It assumes factorization frequency will not be changed.
+ This resizes model !!!!
+ The contents of original matrix in model will be taken over and original matrix
+ will be sanitized so can be deleted (to avoid a very small memory leak)
+ */
+ ClpDynamicMatrix(ClpSimplex * model, int numberSets,
+ int numberColumns, const int * starts,
+ const double * lower, const double * upper,
+ const CoinBigIndex * startColumn, const int * row,
+ const double * element, const double * cost,
+ const double * columnLower = NULL, const double * columnUpper = NULL,
+ const unsigned char * status = NULL,
+ const unsigned char * dynamicStatus = NULL);
+
+ /** Destructor */
+ virtual ~ClpDynamicMatrix();
+ //@}
+
+ /**@name Copy method */
+ //@{
+ /** The copy constructor. */
+ ClpDynamicMatrix(const ClpDynamicMatrix&);
+ /** The copy constructor from an CoinPackedMatrix. */
+ ClpDynamicMatrix(const CoinPackedMatrix&);
+
+ ClpDynamicMatrix& operator=(const ClpDynamicMatrix&);
+ /// Clone
+ virtual ClpMatrixBase * clone() const ;
+ //@}
+ /**@name gets and sets */
+ //@{
+ /// Status of row slacks
+ inline ClpSimplex::Status getStatus(int sequence) const {
+ return static_cast (status_[sequence] & 7);
+ }
+ inline void setStatus(int sequence, ClpSimplex::Status status) {
+ unsigned char & st_byte = status_[sequence];
+ st_byte = static_cast(st_byte & ~7);
+ st_byte = static_cast(st_byte | status);
+ }
+ /// Whether flagged slack
+ inline bool flaggedSlack(int i) const {
+ return (status_[i] & 8) != 0;
+ }
+ inline void setFlaggedSlack(int i) {
+ status_[i] = static_cast(status_[i] | 8);
+ }
+ inline void unsetFlaggedSlack(int i) {
+ status_[i] = static_cast(status_[i] & ~8);
+ }
+ /// Number of sets (dynamic rows)
+ inline int numberSets() const {
+ return numberSets_;
+ }
+ /// Number of possible gub variables
+ inline int numberGubEntries() const
+ { return startSet_[numberSets_];}
+ /// Sets
+ inline int * startSets() const
+ { return startSet_;}
+ /// Whether flagged
+ inline bool flagged(int i) const {
+ return (dynamicStatus_[i] & 8) != 0;
+ }
+ inline void setFlagged(int i) {
+ dynamicStatus_[i] = static_cast(dynamicStatus_[i] | 8);
+ }
+ inline void unsetFlagged(int i) {
+ dynamicStatus_[i] = static_cast(dynamicStatus_[i] & ~8);
+ }
+ inline void setDynamicStatus(int sequence, DynamicStatus status) {
+ unsigned char & st_byte = dynamicStatus_[sequence];
+ st_byte = static_cast(st_byte & ~7);
+ st_byte = static_cast(st_byte | status);
+ }
+ inline DynamicStatus getDynamicStatus(int sequence) const {
+ return static_cast (dynamicStatus_[sequence] & 7);
+ }
+ /// Saved value of objective offset
+ inline double objectiveOffset() const {
+ return objectiveOffset_;
+ }
+ /// Starts of each column
+ inline CoinBigIndex * startColumn() const {
+ return startColumn_;
+ }
+ /// rows
+ inline int * row() const {
+ return row_;
+ }
+ /// elements
+ inline double * element() const {
+ return element_;
+ }
+ /// costs
+ inline double * cost() const {
+ return cost_;
+ }
+ /// ids of active columns (just index here)
+ inline int * id() const {
+ return id_;
+ }
+ /// Optional lower bounds on columns
+ inline double * columnLower() const {
+ return columnLower_;
+ }
+ /// Optional upper bounds on columns
+ inline double * columnUpper() const {
+ return columnUpper_;
+ }
+ /// Lower bounds on sets
+ inline double * lowerSet() const {
+ return lowerSet_;
+ }
+ /// Upper bounds on sets
+ inline double * upperSet() const {
+ return upperSet_;
+ }
+ /// size
+ inline int numberGubColumns() const {
+ return numberGubColumns_;
+ }
+ /// first free
+ inline int firstAvailable() const {
+ return firstAvailable_;
+ }
+ /// first dynamic
+ inline int firstDynamic() const {
+ return firstDynamic_;
+ }
+ /// number of columns in dynamic model
+ inline int lastDynamic() const {
+ return lastDynamic_;
+ }
+ /// number of rows in original model
+ inline int numberStaticRows() const {
+ return numberStaticRows_;
+ }
+ /// size of working matrix (max)
+ inline int numberElements() const {
+ return numberElements_;
+ }
+ inline int * keyVariable() const {
+ return keyVariable_;
+ }
+ /// Switches off dj checking each factorization (for BIG models)
+ void switchOffCheck();
+ /// Status region for gub slacks
+ inline unsigned char * gubRowStatus() const {
+ return status_;
+ }
+ /// Status region for gub variables
+ inline unsigned char * dynamicStatus() const {
+ return dynamicStatus_;
+ }
+ /// Returns which set a variable is in
+ int whichSet (int sequence) const;
+ //@}
+
+
+protected:
+ /**@name Data members
+ The data members are protected to allow access for derived classes. */
+ //@{
+ /// Sum of dual infeasibilities
+ double sumDualInfeasibilities_;
+ /// Sum of primal infeasibilities
+ double sumPrimalInfeasibilities_;
+ /// Sum of Dual infeasibilities using tolerance based on error in duals
+ double sumOfRelaxedDualInfeasibilities_;
+ /// Sum of Primal infeasibilities using tolerance based on error in primals
+ double sumOfRelaxedPrimalInfeasibilities_;
+ /// Saved best dual on gub row in pricing
+ double savedBestGubDual_;
+ /// Saved best set in pricing
+ int savedBestSet_;
+ /// Backward pointer to pivot row !!!
+ int * backToPivotRow_;
+ /// Key variable of set (only accurate if none in small problem)
+ mutable int * keyVariable_;
+ /// Backward pointer to extra row
+ int * toIndex_;
+ // Reverse pointer from index to set
+ int * fromIndex_;
+ /// Number of sets (dynamic rows)
+ int numberSets_;
+ /// Number of active sets
+ int numberActiveSets_;
+ /// Saved value of objective offset
+ double objectiveOffset_;
+ /// Lower bounds on sets
+ double * lowerSet_;
+ /// Upper bounds on sets
+ double * upperSet_;
+ /// Status of slack on set
+ unsigned char * status_;
+ /// Pointer back to model
+ ClpSimplex * model_;
+ /// first free
+ int firstAvailable_;
+ /// first free when iteration started
+ int firstAvailableBefore_;
+ /// first dynamic
+ int firstDynamic_;
+ /// number of columns in dynamic model
+ int lastDynamic_;
+ /// number of rows in original model
+ int numberStaticRows_;
+ /// size of working matrix (max)
+ int numberElements_;
+ /// Number of dual infeasibilities
+ int numberDualInfeasibilities_;
+ /// Number of primal infeasibilities
+ int numberPrimalInfeasibilities_;
+ /** If pricing will declare victory (i.e. no check every factorization).
+ -1 - always check
+ 0 - don't check
+ 1 - in don't check mode but looks optimal
+ */
+ int noCheck_;
+ /// Infeasibility weight when last full pass done
+ double infeasibilityWeight_;
+ /// size
+ int numberGubColumns_;
+ /// current maximum number of columns (then compress)
+ int maximumGubColumns_;
+ /// current maximum number of elemnts (then compress)
+ int maximumElements_;
+ /// Start of each set
+ int * startSet_;
+ /// next in chain
+ int * next_;
+ /// Starts of each column
+ CoinBigIndex * startColumn_;
+ /// rows
+ int * row_;
+ /// elements
+ double * element_;
+ /// costs
+ double * cost_;
+ /// ids of active columns (just index here)
+ int * id_;
+ /// for status and which bound
+ unsigned char * dynamicStatus_;
+ /// Optional lower bounds on columns
+ double * columnLower_;
+ /// Optional upper bounds on columns
+ double * columnUpper_;
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpEventHandler.hpp b/thirdparty/windows/include/coin/ClpEventHandler.hpp
new file mode 100644
index 0000000..aeed324
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpEventHandler.hpp
@@ -0,0 +1,187 @@
+/* $Id: ClpEventHandler.hpp 2156 2015-08-07 14:51:42Z forrest $ */
+// Copyright (C) 2004, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpEventHandler_H
+#define ClpEventHandler_H
+
+#include "ClpSimplex.hpp"
+/** Base class for Clp event handling
+
+This is just here to allow for event handling. By event I mean a Clp event
+e.g. end of values pass.
+
+One use would be to let a user handle a system event e.g. Control-C. This could be done
+by deriving a class MyEventHandler which knows about such events. If one occurs
+MyEventHandler::event() could clear event status and return 3 (stopped).
+
+Clp would then return to user code.
+
+As it is called every iteration this should be fine grained enough.
+
+User can derive and construct from CbcModel - not pretty
+
+*/
+
+class ClpEventHandler {
+
+public:
+ /** enums for what sort of event.
+
+ These will also be returned in ClpModel::secondaryStatus() as int
+ */
+ enum Event {
+ endOfIteration = 100, // used to set secondary status
+ endOfFactorization, // after gutsOfSolution etc
+ endOfValuesPass,
+ node, // for Cbc
+ treeStatus, // for Cbc
+ solution, // for Cbc
+ theta, // hit in parametrics
+ pivotRow, // used to choose pivot row
+ presolveStart, // ClpSolve presolve start
+ presolveSize, // sees if ClpSolve presolve too big or too small
+ presolveInfeasible, // ClpSolve presolve infeasible
+ presolveBeforeSolve, // ClpSolve presolve before solve
+ presolveAfterFirstSolve, // ClpSolve presolve after solve
+ presolveAfterSolve, // ClpSolve presolve after solve
+ presolveEnd, // ClpSolve presolve end
+ goodFactorization, // before gutsOfSolution
+ complicatedPivotIn, // in modifyCoefficients
+ noCandidateInPrimal, // tentative end
+ looksEndInPrimal, // About to declare victory (or defeat)
+ endInPrimal, // Victory (or defeat)
+ beforeStatusOfProblemInPrimal,
+ startOfStatusOfProblemInPrimal,
+ complicatedPivotOut, // in modifyCoefficients
+ noCandidateInDual, // tentative end
+ looksEndInDual, // About to declare victory (or defeat)
+ endInDual, // Victory (or defeat)
+ beforeStatusOfProblemInDual,
+ startOfStatusOfProblemInDual,
+ startOfIterationInDual,
+ updateDualsInDual,
+ endOfCreateRim,
+ slightlyInfeasible,
+ modifyMatrixInMiniPresolve,
+ moreMiniPresolve,
+ modifyMatrixInMiniPostsolve,
+ startOfCrossover, // in Idiot
+ noTheta // At end (because no pivot)
+ };
+ /**@name Virtual method that the derived classes should provide.
+ The base class instance does nothing and as event() is only useful method
+ it would not be very useful NOT providing one!
+ */
+ //@{
+ /** This can do whatever it likes. If return code -1 then carries on
+ if 0 sets ClpModel::status() to 5 (stopped by event) and will return to user.
+ At present if <-1 carries on and if >0 acts as if 0 - this may change.
+ For ClpSolve 2 -> too big return status of -2 and -> too small 3
+ */
+ virtual int event(Event whichEvent);
+ /** This can do whatever it likes. Return code -1 means no action.
+ This passes in something
+ */
+ virtual int eventWithInfo(Event whichEvent, void * info) ;
+ //@}
+
+
+ /**@name Constructors, destructor */
+
+ //@{
+ /** Default constructor. */
+ ClpEventHandler(ClpSimplex * model = NULL);
+ /** Destructor */
+ virtual ~ClpEventHandler();
+ // Copy
+ ClpEventHandler(const ClpEventHandler&);
+ // Assignment
+ ClpEventHandler& operator=(const ClpEventHandler&);
+ /// Clone
+ virtual ClpEventHandler * clone() const;
+
+ //@}
+
+ /**@name Sets/gets */
+
+ //@{
+ /** set model. */
+ void setSimplex(ClpSimplex * model);
+ /// Get model
+ inline ClpSimplex * simplex() const {
+ return model_;
+ }
+ //@}
+
+
+protected:
+ /**@name Data members
+ The data members are protected to allow access for derived classes. */
+ //@{
+ /// Pointer to simplex
+ ClpSimplex * model_;
+ //@}
+};
+/** Base class for Clp disaster handling
+
+This is here to allow for disaster handling. By disaster I mean that Clp
+would otherwise give up
+
+*/
+
+class ClpDisasterHandler {
+
+public:
+ /**@name Virtual methods that the derived classe should provide.
+ */
+ //@{
+ /// Into simplex
+ virtual void intoSimplex() = 0;
+ /// Checks if disaster
+ virtual bool check() const = 0;
+ /// saves information for next attempt
+ virtual void saveInfo() = 0;
+ /// Type of disaster 0 can fix, 1 abort
+ virtual int typeOfDisaster();
+ //@}
+
+
+ /**@name Constructors, destructor */
+
+ //@{
+ /** Default constructor. */
+ ClpDisasterHandler(ClpSimplex * model = NULL);
+ /** Destructor */
+ virtual ~ClpDisasterHandler();
+ // Copy
+ ClpDisasterHandler(const ClpDisasterHandler&);
+ // Assignment
+ ClpDisasterHandler& operator=(const ClpDisasterHandler&);
+ /// Clone
+ virtual ClpDisasterHandler * clone() const = 0;
+
+ //@}
+
+ /**@name Sets/gets */
+
+ //@{
+ /** set model. */
+ void setSimplex(ClpSimplex * model);
+ /// Get model
+ inline ClpSimplex * simplex() const {
+ return model_;
+ }
+ //@}
+
+
+protected:
+ /**@name Data members
+ The data members are protected to allow access for derived classes. */
+ //@{
+ /// Pointer to simplex
+ ClpSimplex * model_;
+ //@}
+};
+#endif
diff --git a/thirdparty/windows/include/coin/ClpFactorization.hpp b/thirdparty/windows/include/coin/ClpFactorization.hpp
new file mode 100644
index 0000000..dda8ff7
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpFactorization.hpp
@@ -0,0 +1,432 @@
+/* $Id: ClpFactorization.hpp 2078 2015-01-05 12:39:49Z forrest $ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpFactorization_H
+#define ClpFactorization_H
+
+
+#include "CoinPragma.hpp"
+
+#include "CoinFactorization.hpp"
+class ClpMatrixBase;
+class ClpSimplex;
+class ClpNetworkBasis;
+class CoinOtherFactorization;
+#ifndef CLP_MULTIPLE_FACTORIZATIONS
+#define CLP_MULTIPLE_FACTORIZATIONS 4
+#endif
+#ifdef CLP_MULTIPLE_FACTORIZATIONS
+#include "CoinDenseFactorization.hpp"
+#include "ClpSimplex.hpp"
+#endif
+#ifndef COIN_FAST_CODE
+#define COIN_FAST_CODE
+#endif
+#ifndef CLP_FACTORIZATION_NEW_TIMING
+#define CLP_FACTORIZATION_NEW_TIMING 1
+#endif
+
+/** This just implements CoinFactorization when an ClpMatrixBase object
+ is passed. If a network then has a dummy CoinFactorization and
+ a genuine ClpNetworkBasis object
+*/
+class ClpFactorization
+#ifndef CLP_MULTIPLE_FACTORIZATIONS
+ : public CoinFactorization
+#endif
+{
+
+ //friend class CoinFactorization;
+
+public:
+ /**@name factorization */
+ //@{
+ /** When part of LP - given by basic variables.
+ Actually does factorization.
+ Arrays passed in have non negative value to say basic.
+ If status is okay, basic variables have pivot row - this is only needed
+ if increasingRows_ >1.
+ Allows scaling
+ If status is singular, then basic variables have pivot row
+ and ones thrown out have -1
+ returns 0 -okay, -1 singular, -2 too many in basis, -99 memory */
+ int factorize (ClpSimplex * model, int solveType, bool valuesPass);
+ //@}
+
+
+ /**@name Constructors, destructor */
+ //@{
+ /** Default constructor. */
+ ClpFactorization();
+ /** Destructor */
+ ~ClpFactorization();
+ //@}
+
+ /**@name Copy method */
+ //@{
+ /** The copy constructor from an CoinFactorization. */
+ ClpFactorization(const CoinFactorization&);
+ /** The copy constructor. */
+ ClpFactorization(const ClpFactorization&, int denseIfSmaller = 0);
+#ifdef CLP_MULTIPLE_FACTORIZATIONS
+ /** The copy constructor from an CoinOtherFactorization. */
+ ClpFactorization(const CoinOtherFactorization&);
+#endif
+ ClpFactorization& operator=(const ClpFactorization&);
+ //@}
+
+ /* **** below here is so can use networkish basis */
+ /**@name rank one updates which do exist */
+ //@{
+
+ /** Replaces one Column to basis,
+ returns 0=OK, 1=Probably OK, 2=singular, 3=no room
+ If checkBeforeModifying is true will do all accuracy checks
+ before modifying factorization. Whether to set this depends on
+ speed considerations. You could just do this on first iteration
+ after factorization and thereafter re-factorize
+ partial update already in U */
+ int replaceColumn ( const ClpSimplex * model,
+ CoinIndexedVector * regionSparse,
+ CoinIndexedVector * tableauColumn,
+ int pivotRow,
+ double pivotCheck ,
+ bool checkBeforeModifying = false,
+ double acceptablePivot = 1.0e-8);
+ //@}
+
+ /**@name various uses of factorization (return code number elements)
+ which user may want to know about */
+ //@{
+ /** Updates one column (FTRAN) from region2
+ Tries to do FT update
+ number returned is negative if no room
+ region1 starts as zero and is zero at end */
+ int updateColumnFT ( CoinIndexedVector * regionSparse,
+ CoinIndexedVector * regionSparse2);
+ /** Updates one column (FTRAN) from region2
+ region1 starts as zero and is zero at end */
+ int updateColumn ( CoinIndexedVector * regionSparse,
+ CoinIndexedVector * regionSparse2,
+ bool noPermute = false) const;
+ /** Updates one column (FTRAN) from region2
+ Tries to do FT update
+ number returned is negative if no room.
+ Also updates region3
+ region1 starts as zero and is zero at end */
+ int updateTwoColumnsFT ( CoinIndexedVector * regionSparse1,
+ CoinIndexedVector * regionSparse2,
+ CoinIndexedVector * regionSparse3,
+ bool noPermuteRegion3 = false) ;
+ /// For debug (no statistics update)
+ int updateColumnForDebug ( CoinIndexedVector * regionSparse,
+ CoinIndexedVector * regionSparse2,
+ bool noPermute = false) const;
+ /** Updates one column (BTRAN) from region2
+ region1 starts as zero and is zero at end */
+ int updateColumnTranspose ( CoinIndexedVector * regionSparse,
+ CoinIndexedVector * regionSparse2) const;
+ //@}
+#ifdef CLP_MULTIPLE_FACTORIZATIONS
+ /**@name Lifted from CoinFactorization */
+ //@{
+ /// Total number of elements in factorization
+ inline int numberElements ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->numberElements();
+ else return coinFactorizationB_->numberElements() ;
+ }
+ /// Returns address of permute region
+ inline int *permute ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->permute();
+ else return coinFactorizationB_->permute() ;
+ }
+ /// Returns address of pivotColumn region (also used for permuting)
+ inline int *pivotColumn ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->pivotColumn();
+ else return coinFactorizationB_->permute() ;
+ }
+ /// Maximum number of pivots between factorizations
+ inline int maximumPivots ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->maximumPivots();
+ else return coinFactorizationB_->maximumPivots() ;
+ }
+ /// Set maximum number of pivots between factorizations
+ inline void maximumPivots ( int value) {
+ if (coinFactorizationA_) coinFactorizationA_->maximumPivots(value);
+ else coinFactorizationB_->maximumPivots(value);
+ }
+ /// Returns number of pivots since factorization
+ inline int pivots ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->pivots();
+ else return coinFactorizationB_->pivots() ;
+ }
+ /// Whether larger areas needed
+ inline double areaFactor ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->areaFactor();
+ else return 0.0 ;
+ }
+ /// Set whether larger areas needed
+ inline void areaFactor ( double value) {
+ if (coinFactorizationA_) coinFactorizationA_->areaFactor(value);
+ }
+ /// Zero tolerance
+ inline double zeroTolerance ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->zeroTolerance();
+ else return coinFactorizationB_->zeroTolerance() ;
+ }
+ /// Set zero tolerance
+ inline void zeroTolerance ( double value) {
+ if (coinFactorizationA_) coinFactorizationA_->zeroTolerance(value);
+ else coinFactorizationB_->zeroTolerance(value);
+ }
+ /// Set tolerances to safer of existing and given
+ void saferTolerances ( double zeroTolerance, double pivotTolerance);
+ /** get sparse threshold */
+ inline int sparseThreshold ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->sparseThreshold();
+ else return 0 ;
+ }
+ /** Set sparse threshold */
+ inline void sparseThreshold ( int value) {
+ if (coinFactorizationA_) coinFactorizationA_->sparseThreshold(value);
+ }
+ /// Returns status
+ inline int status ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->status();
+ else return coinFactorizationB_->status() ;
+ }
+ /// Sets status
+ inline void setStatus ( int value) {
+ if (coinFactorizationA_) coinFactorizationA_->setStatus(value);
+ else coinFactorizationB_->setStatus(value) ;
+ }
+ /// Returns number of dense rows
+ inline int numberDense() const {
+ if (coinFactorizationA_) return coinFactorizationA_->numberDense();
+ else return 0 ;
+ }
+#if 1
+ /// Returns number in U area
+ inline CoinBigIndex numberElementsU ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->numberElementsU();
+ else return -1 ;
+ }
+ /// Returns number in L area
+ inline CoinBigIndex numberElementsL ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->numberElementsL();
+ else return -1 ;
+ }
+ /// Returns number in R area
+ inline CoinBigIndex numberElementsR ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->numberElementsR();
+ else return 0 ;
+ }
+#endif
+ bool timeToRefactorize() const;
+#if CLP_FACTORIZATION_NEW_TIMING>1
+ void statsRefactor(char when) const;
+#endif
+ /// Level of detail of messages
+ inline int messageLevel ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->messageLevel();
+ else return 1 ;
+ }
+ /// Set level of detail of messages
+ inline void messageLevel ( int value) {
+ if (coinFactorizationA_) coinFactorizationA_->messageLevel(value);
+ }
+ /// Get rid of all memory
+ inline void clearArrays() {
+ if (coinFactorizationA_)
+ coinFactorizationA_->clearArrays();
+ else if (coinFactorizationB_)
+ coinFactorizationB_->clearArrays();
+ }
+ /// Number of Rows after factorization
+ inline int numberRows ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->numberRows();
+ else return coinFactorizationB_->numberRows() ;
+ }
+ /// Gets dense threshold
+ inline int denseThreshold() const {
+ if (coinFactorizationA_) return coinFactorizationA_->denseThreshold();
+ else return 0 ;
+ }
+ /// Sets dense threshold
+ inline void setDenseThreshold(int value) {
+ if (coinFactorizationA_) coinFactorizationA_->setDenseThreshold(value);
+ }
+ /// Pivot tolerance
+ inline double pivotTolerance ( ) const {
+ if (coinFactorizationA_) return coinFactorizationA_->pivotTolerance();
+ else if (coinFactorizationB_) return coinFactorizationB_->pivotTolerance();
+ return 1.0e-8 ;
+ }
+ /// Set pivot tolerance
+ inline void pivotTolerance ( double value) {
+ if (coinFactorizationA_) coinFactorizationA_->pivotTolerance(value);
+ else if (coinFactorizationB_) coinFactorizationB_->pivotTolerance(value);
+ }
+ /// Allows change of pivot accuracy check 1.0 == none >1.0 relaxed
+ inline void relaxAccuracyCheck(double value) {
+ if (coinFactorizationA_) coinFactorizationA_->relaxAccuracyCheck(value);
+ }
+ /** Array persistence flag
+ If 0 then as now (delete/new)
+ 1 then only do arrays if bigger needed
+ 2 as 1 but give a bit extra if bigger needed
+ */
+ inline int persistenceFlag() const {
+ if (coinFactorizationA_) return coinFactorizationA_->persistenceFlag();
+ else return 0 ;
+ }
+ inline void setPersistenceFlag(int value) {
+ if (coinFactorizationA_) coinFactorizationA_->setPersistenceFlag(value);
+ }
+ /// Delete all stuff (leaves as after CoinFactorization())
+ inline void almostDestructor() {
+ if (coinFactorizationA_)
+ coinFactorizationA_->almostDestructor();
+ else if (coinFactorizationB_)
+ coinFactorizationB_->clearArrays();
+ }
+ /// Returns areaFactor but adjusted for dense
+ inline double adjustedAreaFactor() const {
+ if (coinFactorizationA_) return coinFactorizationA_->adjustedAreaFactor();
+ else return 0.0 ;
+ }
+ inline void setBiasLU(int value) {
+ if (coinFactorizationA_) coinFactorizationA_->setBiasLU(value);
+ }
+ /// true if Forrest Tomlin update, false if PFI
+ inline void setForrestTomlin(bool value) {
+ if (coinFactorizationA_) coinFactorizationA_->setForrestTomlin(value);
+ }
+ /// Sets default values
+ inline void setDefaultValues() {
+ if (coinFactorizationA_) {
+ // row activities have negative sign
+#ifndef COIN_FAST_CODE
+ coinFactorizationA_->slackValue(-1.0);
+#endif
+ coinFactorizationA_->zeroTolerance(1.0e-13);
+ }
+ }
+ /// If nonzero force use of 1,dense 2,small 3,osl
+ void forceOtherFactorization(int which);
+ /// Get switch to osl if number rows <= this
+ inline int goOslThreshold() const {
+ return goOslThreshold_;
+ }
+ /// Set switch to osl if number rows <= this
+ inline void setGoOslThreshold(int value) {
+ goOslThreshold_ = value;
+ }
+ /// Get switch to dense if number rows <= this
+ inline int goDenseThreshold() const {
+ return goDenseThreshold_;
+ }
+ /// Set switch to dense if number rows <= this
+ inline void setGoDenseThreshold(int value) {
+ goDenseThreshold_ = value;
+ }
+ /// Get switch to small if number rows <= this
+ inline int goSmallThreshold() const {
+ return goSmallThreshold_;
+ }
+ /// Set switch to small if number rows <= this
+ inline void setGoSmallThreshold(int value) {
+ goSmallThreshold_ = value;
+ }
+ /// Go over to dense or small code if small enough
+ void goDenseOrSmall(int numberRows) ;
+ /// Sets factorization
+ void setFactorization(ClpFactorization & factorization);
+ /// Return 1 if dense code
+ inline int isDenseOrSmall() const {
+ return coinFactorizationB_ ? 1 : 0;
+ }
+#else
+ inline bool timeToRefactorize() const {
+ return (pivots() * 3 > maximumPivots() * 2 &&
+ numberElementsR() * 3 > (numberElementsL() + numberElementsU()) * 2 + 1000 &&
+ !numberDense());
+ }
+ /// Sets default values
+ inline void setDefaultValues() {
+ // row activities have negative sign
+#ifndef COIN_FAST_CODE
+ slackValue(-1.0);
+#endif
+ zeroTolerance(1.0e-13);
+ }
+ /// Go over to dense code
+ inline void goDense() {}
+#endif
+ //@}
+
+ /**@name other stuff */
+ //@{
+ /** makes a row copy of L for speed and to allow very sparse problems */
+ void goSparse();
+ /// Cleans up i.e. gets rid of network basis
+ void cleanUp();
+ /// Says whether to redo pivot order
+ bool needToReorder() const;
+#ifndef SLIM_CLP
+ /// Says if a network basis
+ inline bool networkBasis() const {
+ return (networkBasis_ != NULL);
+ }
+#else
+ /// Says if a network basis
+ inline bool networkBasis() const {
+ return false;
+ }
+#endif
+ /// Fills weighted row list
+ void getWeights(int * weights) const;
+ //@}
+
+////////////////// data //////////////////
+private:
+
+ /**@name data */
+ //@{
+ /// Pointer to network basis
+#ifndef SLIM_CLP
+ ClpNetworkBasis * networkBasis_;
+#endif
+#ifdef CLP_MULTIPLE_FACTORIZATIONS
+ /// Pointer to CoinFactorization
+ CoinFactorization * coinFactorizationA_;
+ /// Pointer to CoinOtherFactorization
+ CoinOtherFactorization * coinFactorizationB_;
+#ifdef CLP_REUSE_ETAS
+ /// Pointer to model
+ ClpSimplex * model_;
+#endif
+ /// If nonzero force use of 1,dense 2,small 3,osl
+ int forceB_;
+ /// Switch to osl if number rows <= this
+ int goOslThreshold_;
+ /// Switch to small if number rows <= this
+ int goSmallThreshold_;
+ /// Switch to dense if number rows <= this
+ int goDenseThreshold_;
+#endif
+#ifdef CLP_FACTORIZATION_NEW_TIMING
+ /// For guessing when to re-factorize
+ mutable double shortestAverage_;
+ mutable double totalInR_;
+ mutable double totalInIncreasingU_;
+ mutable int endLengthU_;
+ mutable int lastNumberPivots_;
+ mutable int effectiveStartNumberU_;
+#endif
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpGubDynamicMatrix.hpp b/thirdparty/windows/include/coin/ClpGubDynamicMatrix.hpp
new file mode 100644
index 0000000..2d13e6d
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpGubDynamicMatrix.hpp
@@ -0,0 +1,247 @@
+/* $Id: ClpGubDynamicMatrix.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// Copyright (C) 2003, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpGubDynamicMatrix_H
+#define ClpGubDynamicMatrix_H
+
+
+#include "CoinPragma.hpp"
+
+#include "ClpGubMatrix.hpp"
+/** This implements Gub rows plus a ClpPackedMatrix.
+ This a dynamic version which stores the gub part and dynamically creates matrix.
+ All bounds are assumed to be zero and infinity
+
+ This is just a simple example for real column generation
+*/
+
+class ClpGubDynamicMatrix : public ClpGubMatrix {
+
+public:
+ /**@name Main functions provided */
+ //@{
+ /// Partial pricing
+ virtual void partialPricing(ClpSimplex * model, double start, double end,
+ int & bestSequence, int & numberWanted);
+ /** This is local to Gub to allow synchronization:
+ mode=0 when status of basis is good
+ mode=1 when variable is flagged
+ mode=2 when all variables unflagged (returns number flagged)
+ mode=3 just reset costs (primal)
+ mode=4 correct number of dual infeasibilities
+ mode=5 return 4 if time to re-factorize
+ mode=8 - make sure set is clean
+ mode=9 - adjust lower, upper on set by incoming
+ */
+ virtual int synchronize(ClpSimplex * model, int mode);
+ /// Sets up an effective RHS and does gub crash if needed
+ virtual void useEffectiveRhs(ClpSimplex * model, bool cheapest = true);
+ /**
+ update information for a pivot (and effective rhs)
+ */
+ virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
+ /// Add a new variable to a set
+ void insertNonBasic(int sequence, int iSet);
+ /** Returns effective RHS offset if it is being used. This is used for long problems
+ or big gub or anywhere where going through full columns is
+ expensive. This may re-compute */
+ virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
+ bool check = false);
+
+ using ClpPackedMatrix::times ;
+ /** Return y + A * scalar *x in y.
+ @pre x must be of size numColumns()
+ @pre y must be of size numRows() */
+ virtual void times(double scalar,
+ const double * x, double * y) const;
+ /** Just for debug
+ Returns sum and number of primal infeasibilities. Recomputes keys
+ */
+ virtual int checkFeasible(ClpSimplex * model, double & sum) const;
+ /// Cleans data after setWarmStart
+ void cleanData(ClpSimplex * model);
+ //@}
+
+
+
+ /**@name Constructors, destructor */
+ //@{
+ /** Default constructor. */
+ ClpGubDynamicMatrix();
+ /** Destructor */
+ virtual ~ClpGubDynamicMatrix();
+ //@}
+
+ /**@name Copy method */
+ //@{
+ /** The copy constructor. */
+ ClpGubDynamicMatrix(const ClpGubDynamicMatrix&);
+ /** This is the real constructor.
+ It assumes factorization frequency will not be changed.
+ This resizes model !!!!
+ */
+ ClpGubDynamicMatrix(ClpSimplex * model, int numberSets,
+ int numberColumns, const int * starts,
+ const double * lower, const double * upper,
+ const int * startColumn, const int * row,
+ const double * element, const double * cost,
+ const double * lowerColumn = NULL, const double * upperColumn = NULL,
+ const unsigned char * status = NULL);
+
+ ClpGubDynamicMatrix& operator=(const ClpGubDynamicMatrix&);
+ /// Clone
+ virtual ClpMatrixBase * clone() const ;
+ //@}
+ /**@name gets and sets */
+ //@{
+ /// enums for status of various sorts
+ enum DynamicStatus {
+ inSmall = 0x01,
+ atUpperBound = 0x02,
+ atLowerBound = 0x03
+ };
+ /// Whether flagged
+ inline bool flagged(int i) const {
+ return (dynamicStatus_[i] & 8) != 0;
+ }
+ inline void setFlagged(int i) {
+ dynamicStatus_[i] = static_cast(dynamicStatus_[i] | 8);
+ }
+ inline void unsetFlagged(int i) {
+ dynamicStatus_[i] = static_cast(dynamicStatus_[i] & ~8);
+ }
+ inline void setDynamicStatus(int sequence, DynamicStatus status) {
+ unsigned char & st_byte = dynamicStatus_[sequence];
+ st_byte = static_cast(st_byte & ~7);
+ st_byte = static_cast(st_byte | status);
+ }
+ inline DynamicStatus getDynamicStatus(int sequence) const {
+ return static_cast (dynamicStatus_[sequence] & 7);
+ }
+ /// Saved value of objective offset
+ inline double objectiveOffset() const {
+ return objectiveOffset_;
+ }
+ /// Starts of each column
+ inline CoinBigIndex * startColumn() const {
+ return startColumn_;
+ }
+ /// rows
+ inline int * row() const {
+ return row_;
+ }
+ /// elements
+ inline double * element() const {
+ return element_;
+ }
+ /// costs
+ inline double * cost() const {
+ return cost_;
+ }
+ /// full starts
+ inline int * fullStart() const {
+ return fullStart_;
+ }
+ /// ids of active columns (just index here)
+ inline int * id() const {
+ return id_;
+ }
+ /// Optional lower bounds on columns
+ inline double * lowerColumn() const {
+ return lowerColumn_;
+ }
+ /// Optional upper bounds on columns
+ inline double * upperColumn() const {
+ return upperColumn_;
+ }
+ /// Optional true lower bounds on sets
+ inline double * lowerSet() const {
+ return lowerSet_;
+ }
+ /// Optional true upper bounds on sets
+ inline double * upperSet() const {
+ return upperSet_;
+ }
+ /// size
+ inline int numberGubColumns() const {
+ return numberGubColumns_;
+ }
+ /// first free
+ inline int firstAvailable() const {
+ return firstAvailable_;
+ }
+ /// set first free
+ inline void setFirstAvailable(int value) {
+ firstAvailable_ = value;
+ }
+ /// first dynamic
+ inline int firstDynamic() const {
+ return firstDynamic_;
+ }
+ /// number of columns in dynamic model
+ inline int lastDynamic() const {
+ return lastDynamic_;
+ }
+ /// size of working matrix (max)
+ inline int numberElements() const {
+ return numberElements_;
+ }
+ /// Status region for gub slacks
+ inline unsigned char * gubRowStatus() const {
+ return status_;
+ }
+ /// Status region for gub variables
+ inline unsigned char * dynamicStatus() const {
+ return dynamicStatus_;
+ }
+ /// Returns which set a variable is in
+ int whichSet (int sequence) const;
+ //@}
+
+
+protected:
+ /**@name Data members
+ The data members are protected to allow access for derived classes. */
+ //@{
+ /// Saved value of objective offset
+ double objectiveOffset_;
+ /// Starts of each column
+ CoinBigIndex * startColumn_;
+ /// rows
+ int * row_;
+ /// elements
+ double * element_;
+ /// costs
+ double * cost_;
+ /// full starts
+ int * fullStart_;
+ /// ids of active columns (just index here)
+ int * id_;
+ /// for status and which bound
+ unsigned char * dynamicStatus_;
+ /// Optional lower bounds on columns
+ double * lowerColumn_;
+ /// Optional upper bounds on columns
+ double * upperColumn_;
+ /// Optional true lower bounds on sets
+ double * lowerSet_;
+ /// Optional true upper bounds on sets
+ double * upperSet_;
+ /// size
+ int numberGubColumns_;
+ /// first free
+ int firstAvailable_;
+ /// saved first free
+ int savedFirstAvailable_;
+ /// first dynamic
+ int firstDynamic_;
+ /// number of columns in dynamic model
+ int lastDynamic_;
+ /// size of working matrix (max)
+ int numberElements_;
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpGubMatrix.hpp b/thirdparty/windows/include/coin/ClpGubMatrix.hpp
new file mode 100644
index 0000000..26c3f62
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpGubMatrix.hpp
@@ -0,0 +1,358 @@
+/* $Id: ClpGubMatrix.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// Copyright (C) 2003, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpGubMatrix_H
+#define ClpGubMatrix_H
+
+
+#include "CoinPragma.hpp"
+
+#include "ClpPackedMatrix.hpp"
+class ClpSimplex;
+/** This implements Gub rows plus a ClpPackedMatrix.
+
+ There will be a version using ClpPlusMinusOne matrix but
+ there is no point doing one with ClpNetworkMatrix (although
+ an embedded network is attractive).
+
+*/
+
+class ClpGubMatrix : public ClpPackedMatrix {
+
+public:
+ /**@name Main functions provided */
+ //@{
+ /** Returns a new matrix in reverse order without gaps (GUB wants NULL) */
+ virtual ClpMatrixBase * reverseOrderedCopy() const;
+ /// Returns number of elements in column part of basis
+ virtual CoinBigIndex countBasis(const int * whichColumn,
+ int & numberColumnBasic);
+ /// Fills in column part of basis
+ virtual void fillBasis(ClpSimplex * model,
+ const int * whichColumn,
+ int & numberColumnBasic,
+ int * row, int * start,
+ int * rowCount, int * columnCount,
+ CoinFactorizationDouble * element);
+ /** Unpacks a column into an CoinIndexedvector
+ */
+ virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
+ int column) const ;
+ /** Unpacks a column into an CoinIndexedvector
+ ** in packed foramt
+ Note that model is NOT const. Bounds and objective could
+ be modified if doing column generation (just for this variable) */
+ virtual void unpackPacked(ClpSimplex * model,
+ CoinIndexedVector * rowArray,
+ int column) const;
+ /** Adds multiple of a column into an CoinIndexedvector
+ You can use quickAdd to add to vector */
+ virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
+ int column, double multiplier) const ;
+ /** Adds multiple of a column into an array */
+ virtual void add(const ClpSimplex * model, double * array,
+ int column, double multiplier) const;
+ /// Partial pricing
+ virtual void partialPricing(ClpSimplex * model, double start, double end,
+ int & bestSequence, int & numberWanted);
+ /// Returns number of hidden rows e.g. gub
+ virtual int hiddenRows() const;
+ //@}
+
+ /**@name Matrix times vector methods */
+ //@{
+
+ using ClpPackedMatrix::transposeTimes ;
+ /** Return x * scalar * A + y in z.
+ Can use y as temporary array (will be empty at end)
+ Note - If x packed mode - then z packed mode
+ Squashes small elements and knows about ClpSimplex */
+ virtual void transposeTimes(const ClpSimplex * model, double scalar,
+ const CoinIndexedVector * x,
+ CoinIndexedVector * y,
+ CoinIndexedVector * z) const;
+ /** Return x * scalar * A + y in z.
+ Can use y as temporary array (will be empty at end)
+ Note - If x packed mode - then z packed mode
+ Squashes small elements and knows about ClpSimplex.
+ This version uses row copy*/
+ virtual void transposeTimesByRow(const ClpSimplex * model, double scalar,
+ const CoinIndexedVector * x,
+ CoinIndexedVector * y,
+ CoinIndexedVector * z) const;
+ /** Return x *A in z but
+ just for indices in y.
+ Note - z always packed mode */
+ virtual void subsetTransposeTimes(const ClpSimplex * model,
+ const CoinIndexedVector * x,
+ const CoinIndexedVector * y,
+ CoinIndexedVector * z) const;
+ /** expands an updated column to allow for extra rows which the main
+ solver does not know about and returns number added if mode 0.
+ If mode 1 deletes extra entries
+
+ This active in Gub
+ */
+ virtual int extendUpdated(ClpSimplex * model, CoinIndexedVector * update, int mode);
+ /**
+ mode=0 - Set up before "update" and "times" for primal solution using extended rows
+ mode=1 - Cleanup primal solution after "times" using extended rows.
+ mode=2 - Check (or report on) primal infeasibilities
+ */
+ virtual void primalExpanded(ClpSimplex * model, int mode);
+ /**
+ mode=0 - Set up before "updateTranspose" and "transposeTimes" for duals using extended
+ updates array (and may use other if dual values pass)
+ mode=1 - Update dual solution after "transposeTimes" using extended rows.
+ mode=2 - Compute all djs and compute key dual infeasibilities
+ mode=3 - Report on key dual infeasibilities
+ mode=4 - Modify before updateTranspose in partial pricing
+ */
+ virtual void dualExpanded(ClpSimplex * model, CoinIndexedVector * array,
+ double * other, int mode);
+ /**
+ mode=0 - Create list of non-key basics in pivotVariable_ using
+ number as numberBasic in and out
+ mode=1 - Set all key variables as basic
+ mode=2 - return number extra rows needed, number gives maximum number basic
+ mode=3 - before replaceColumn
+ mode=4 - return 1 if can do primal, 2 if dual, 3 if both
+ mode=5 - save any status stuff (when in good state)
+ mode=6 - restore status stuff
+ mode=7 - flag given variable (normally sequenceIn)
+ mode=8 - unflag all variables
+ mode=9 - synchronize costs
+ mode=10 - return 1 if there may be changing bounds on variable (column generation)
+ mode=11 - make sure set is clean (used when a variable rejected - but not flagged)
+ mode=12 - after factorize but before permute stuff
+ mode=13 - at end of simplex to delete stuff
+ */
+ virtual int generalExpanded(ClpSimplex * model, int mode, int & number);
+ /**
+ update information for a pivot (and effective rhs)
+ */
+ virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
+ /// Sets up an effective RHS and does gub crash if needed
+ virtual void useEffectiveRhs(ClpSimplex * model, bool cheapest = true);
+ /** Returns effective RHS offset if it is being used. This is used for long problems
+ or big gub or anywhere where going through full columns is
+ expensive. This may re-compute */
+ virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
+ bool check = false);
+ /** This is local to Gub to allow synchronization:
+ mode=0 when status of basis is good
+ mode=1 when variable is flagged
+ mode=2 when all variables unflagged (returns number flagged)
+ mode=3 just reset costs (primal)
+ mode=4 correct number of dual infeasibilities
+ mode=5 return 4 if time to re-factorize
+ mode=6 - return 1 if there may be changing bounds on variable (column generation)
+ mode=7 - do extra restores for column generation
+ mode=8 - make sure set is clean
+ mode=9 - adjust lower, upper on set by incoming
+ */
+ virtual int synchronize(ClpSimplex * model, int mode);
+ /// Correct sequence in and out to give true value
+ virtual void correctSequence(const ClpSimplex * model, int & sequenceIn, int & sequenceOut) ;
+ //@}
+
+
+
+ /**@name Constructors, destructor */
+ //@{
+ /** Default constructor. */
+ ClpGubMatrix();
+ /** Destructor */
+ virtual ~ClpGubMatrix();
+ //@}
+
+ /**@name Copy method */
+ //@{
+ /** The copy constructor. */
+ ClpGubMatrix(const ClpGubMatrix&);
+ /** The copy constructor from an CoinPackedMatrix. */
+ ClpGubMatrix(const CoinPackedMatrix&);
+ /** Subset constructor (without gaps). Duplicates are allowed
+ and order is as given */
+ ClpGubMatrix (const ClpGubMatrix & wholeModel,
+ int numberRows, const int * whichRows,
+ int numberColumns, const int * whichColumns);
+ ClpGubMatrix (const CoinPackedMatrix & wholeModel,
+ int numberRows, const int * whichRows,
+ int numberColumns, const int * whichColumns);
+
+ /** This takes over ownership (for space reasons) */
+ ClpGubMatrix(CoinPackedMatrix * matrix);
+
+ /** This takes over ownership (for space reasons) and is the
+ real constructor*/
+ ClpGubMatrix(ClpPackedMatrix * matrix, int numberSets,
+ const int * start, const int * end,
+ const double * lower, const double * upper,
+ const unsigned char * status = NULL);
+
+ ClpGubMatrix& operator=(const ClpGubMatrix&);
+ /// Clone
+ virtual ClpMatrixBase * clone() const ;
+ /** Subset clone (without gaps). Duplicates are allowed
+ and order is as given */
+ virtual ClpMatrixBase * subsetClone (
+ int numberRows, const int * whichRows,
+ int numberColumns, const int * whichColumns) const ;
+ /** redoes next_ for a set. */
+ void redoSet(ClpSimplex * model, int newKey, int oldKey, int iSet);
+ //@}
+ /**@name gets and sets */
+ //@{
+ /// Status
+ inline ClpSimplex::Status getStatus(int sequence) const {
+ return static_cast (status_[sequence] & 7);
+ }
+ inline void setStatus(int sequence, ClpSimplex::Status status) {
+ unsigned char & st_byte = status_[sequence];
+ st_byte = static_cast(st_byte & ~7);
+ st_byte = static_cast(st_byte | status);
+ }
+ /// To flag a variable
+ inline void setFlagged( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] | 64);
+ }
+ inline void clearFlagged( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] & ~64);
+ }
+ inline bool flagged(int sequence) const {
+ return ((status_[sequence] & 64) != 0);
+ }
+ /// To say key is above ub
+ inline void setAbove( int sequence) {
+ unsigned char iStat = status_[sequence];
+ iStat = static_cast(iStat & ~24);
+ status_[sequence] = static_cast(iStat | 16);
+ }
+ /// To say key is feasible
+ inline void setFeasible( int sequence) {
+ unsigned char iStat = status_[sequence];
+ iStat = static_cast(iStat & ~24);
+ status_[sequence] = static_cast(iStat | 8);
+ }
+ /// To say key is below lb
+ inline void setBelow( int sequence) {
+ unsigned char iStat = status_[sequence];
+ iStat = static_cast(iStat & ~24);
+ status_[sequence] = iStat;
+ }
+ inline double weight( int sequence) const {
+ int iStat = status_[sequence] & 31;
+ iStat = iStat >> 3;
+ return static_cast (iStat - 1);
+ }
+ /// Starts
+ inline int * start() const {
+ return start_;
+ }
+ /// End
+ inline int * end() const {
+ return end_;
+ }
+ /// Lower bounds on sets
+ inline double * lower() const {
+ return lower_;
+ }
+ /// Upper bounds on sets
+ inline double * upper() const {
+ return upper_;
+ }
+ /// Key variable of set
+ inline int * keyVariable() const {
+ return keyVariable_;
+ }
+ /// Backward pointer to set number
+ inline int * backward() const {
+ return backward_;
+ }
+ /// Number of sets (gub rows)
+ inline int numberSets() const {
+ return numberSets_;
+ }
+ /// Switches off dj checking each factorization (for BIG models)
+ void switchOffCheck();
+ //@}
+
+
+protected:
+ /**@name Data members
+ The data members are protected to allow access for derived classes. */
+ //@{
+ /// Sum of dual infeasibilities
+ double sumDualInfeasibilities_;
+ /// Sum of primal infeasibilities
+ double sumPrimalInfeasibilities_;
+ /// Sum of Dual infeasibilities using tolerance based on error in duals
+ double sumOfRelaxedDualInfeasibilities_;
+ /// Sum of Primal infeasibilities using tolerance based on error in primals
+ double sumOfRelaxedPrimalInfeasibilities_;
+ /// Infeasibility weight when last full pass done
+ double infeasibilityWeight_;
+ /// Starts
+ int * start_;
+ /// End
+ int * end_;
+ /// Lower bounds on sets
+ double * lower_;
+ /// Upper bounds on sets
+ double * upper_;
+ /// Status of slacks
+ mutable unsigned char * status_;
+ /// Saved status of slacks
+ unsigned char * saveStatus_;
+ /// Saved key variables
+ int * savedKeyVariable_;
+ /// Backward pointer to set number
+ int * backward_;
+ /// Backward pointer to pivot row !!!
+ int * backToPivotRow_;
+ /// Change in costs for keys
+ double * changeCost_;
+ /// Key variable of set
+ mutable int * keyVariable_;
+ /** Next basic variable in set - starts at key and end with -(set+1).
+ Now changes to -(nonbasic+1).
+ next_ has extra space for 2* longest set */
+ mutable int * next_;
+ /// Backward pointer to index in CoinIndexedVector
+ int * toIndex_;
+ // Reverse pointer from index to set
+ int * fromIndex_;
+ /// Pointer back to model
+ ClpSimplex * model_;
+ /// Number of dual infeasibilities
+ int numberDualInfeasibilities_;
+ /// Number of primal infeasibilities
+ int numberPrimalInfeasibilities_;
+ /** If pricing will declare victory (i.e. no check every factorization).
+ -1 - always check
+ 0 - don't check
+ 1 - in don't check mode but looks optimal
+ */
+ int noCheck_;
+ /// Number of sets (gub rows)
+ int numberSets_;
+ /// Number in vector without gub extension
+ int saveNumber_;
+ /// Pivot row of possible next key
+ int possiblePivotKey_;
+ /// Gub slack in (set number or -1)
+ int gubSlackIn_;
+ /// First gub variables (same as start_[0] at present)
+ int firstGub_;
+ /// last gub variable (same as end_[numberSets_-1] at present)
+ int lastGub_;
+ /** type of gub - 0 not contiguous, 1 contiguous
+ add 8 bit to say no ubs on individual variables */
+ int gubType_;
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpInterior.hpp b/thirdparty/windows/include/coin/ClpInterior.hpp
new file mode 100644
index 0000000..7f87e1e
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpInterior.hpp
@@ -0,0 +1,570 @@
+/* $Id: ClpInterior.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// Copyright (C) 2003, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+/*
+ Authors
+
+ John Tomlin (pdco)
+ John Forrest (standard predictor-corrector)
+
+ Note JJF has added arrays - this takes more memory but makes
+ flow easier to understand and hopefully easier to extend
+
+ */
+#ifndef ClpInterior_H
+#define ClpInterior_H
+
+#include
+#include
+#include "ClpModel.hpp"
+#include "ClpMatrixBase.hpp"
+#include "ClpSolve.hpp"
+#include "CoinDenseVector.hpp"
+class ClpLsqr;
+class ClpPdcoBase;
+/// ******** DATA to be moved into protected section of ClpInterior
+typedef struct {
+ double atolmin;
+ double r3norm;
+ double LSdamp;
+ double* deltay;
+} Info;
+/// ******** DATA to be moved into protected section of ClpInterior
+
+typedef struct {
+ double atolold;
+ double atolnew;
+ double r3ratio;
+ int istop;
+ int itncg;
+} Outfo;
+/// ******** DATA to be moved into protected section of ClpInterior
+
+typedef struct {
+ double gamma;
+ double delta;
+ int MaxIter;
+ double FeaTol;
+ double OptTol;
+ double StepTol;
+ double x0min;
+ double z0min;
+ double mu0;
+ int LSmethod; // 1=Cholesky 2=QR 3=LSQR
+ int LSproblem; // See below
+ int LSQRMaxIter;
+ double LSQRatol1; // Initial atol
+ double LSQRatol2; // Smallest atol (unless atol1 is smaller)
+ double LSQRconlim;
+ int wait;
+} Options;
+class Lsqr;
+class ClpCholeskyBase;
+// ***** END
+/** This solves LPs using interior point methods
+
+ It inherits from ClpModel and all its arrays are created at
+ algorithm time.
+
+*/
+
+class ClpInterior : public ClpModel {
+ friend void ClpInteriorUnitTest(const std::string & mpsDir,
+ const std::string & netlibDir);
+
+public:
+
+ /**@name Constructors and destructor and copy */
+ //@{
+ /// Default constructor
+ ClpInterior ( );
+
+ /// Copy constructor.
+ ClpInterior(const ClpInterior &);
+ /// Copy constructor from model.
+ ClpInterior(const ClpModel &);
+ /** Subproblem constructor. A subset of whole model is created from the
+ row and column lists given. The new order is given by list order and
+ duplicates are allowed. Name and integer information can be dropped
+ */
+ ClpInterior (const ClpModel * wholeModel,
+ int numberRows, const int * whichRows,
+ int numberColumns, const int * whichColumns,
+ bool dropNames = true, bool dropIntegers = true);
+ /// Assignment operator. This copies the data
+ ClpInterior & operator=(const ClpInterior & rhs);
+ /// Destructor
+ ~ClpInterior ( );
+ // Ones below are just ClpModel with some changes
+ /** Loads a problem (the constraints on the
+ rows are given by lower and upper bounds). If a pointer is 0 then the
+ following values are the default:
+
+ -
colub: all columns have upper bound infinity
+ -
collb: all columns have lower bound 0
+ -
rowub: all rows have upper bound infinity
+ -
rowlb: all rows have lower bound -infinity
+ -
obj: all variables have 0 objective coefficient
+
+ */
+ void loadProblem ( const ClpMatrixBase& matrix,
+ const double* collb, const double* colub,
+ const double* obj,
+ const double* rowlb, const double* rowub,
+ const double * rowObjective = NULL);
+ void loadProblem ( const CoinPackedMatrix& matrix,
+ const double* collb, const double* colub,
+ const double* obj,
+ const double* rowlb, const double* rowub,
+ const double * rowObjective = NULL);
+
+ /** Just like the other loadProblem() method except that the matrix is
+ given in a standard column major ordered format (without gaps). */
+ void loadProblem ( const int numcols, const int numrows,
+ const CoinBigIndex* start, const int* index,
+ const double* value,
+ const double* collb, const double* colub,
+ const double* obj,
+ const double* rowlb, const double* rowub,
+ const double * rowObjective = NULL);
+ /// This one is for after presolve to save memory
+ void loadProblem ( const int numcols, const int numrows,
+ const CoinBigIndex* start, const int* index,
+ const double* value, const int * length,
+ const double* collb, const double* colub,
+ const double* obj,
+ const double* rowlb, const double* rowub,
+ const double * rowObjective = NULL);
+ /// Read an mps file from the given filename
+ int readMps(const char *filename,
+ bool keepNames = false,
+ bool ignoreErrors = false);
+ /** Borrow model. This is so we dont have to copy large amounts
+ of data around. It assumes a derived class wants to overwrite
+ an empty model with a real one - while it does an algorithm.
+ This is same as ClpModel one. */
+ void borrowModel(ClpModel & otherModel);
+ /** Return model - updates any scalars */
+ void returnModel(ClpModel & otherModel);
+ //@}
+
+ /**@name Functions most useful to user */
+ //@{
+ /** Pdco algorithm - see ClpPdco.hpp for method */
+ int pdco();
+ // ** Temporary version
+ int pdco( ClpPdcoBase * stuff, Options &options, Info &info, Outfo &outfo);
+ /// Primal-Dual Predictor-Corrector barrier
+ int primalDual();
+ //@}
+
+ /**@name most useful gets and sets */
+ //@{
+ /// If problem is primal feasible
+ inline bool primalFeasible() const {
+ return (sumPrimalInfeasibilities_ <= 1.0e-5);
+ }
+ /// If problem is dual feasible
+ inline bool dualFeasible() const {
+ return (sumDualInfeasibilities_ <= 1.0e-5);
+ }
+ /// Current (or last) algorithm
+ inline int algorithm() const {
+ return algorithm_;
+ }
+ /// Set algorithm
+ inline void setAlgorithm(int value) {
+ algorithm_ = value;
+ }
+ /// Sum of dual infeasibilities
+ inline CoinWorkDouble sumDualInfeasibilities() const {
+ return sumDualInfeasibilities_;
+ }
+ /// Sum of primal infeasibilities
+ inline CoinWorkDouble sumPrimalInfeasibilities() const {
+ return sumPrimalInfeasibilities_;
+ }
+ /// dualObjective.
+ inline CoinWorkDouble dualObjective() const {
+ return dualObjective_;
+ }
+ /// primalObjective.
+ inline CoinWorkDouble primalObjective() const {
+ return primalObjective_;
+ }
+ /// diagonalNorm
+ inline CoinWorkDouble diagonalNorm() const {
+ return diagonalNorm_;
+ }
+ /// linearPerturbation
+ inline CoinWorkDouble linearPerturbation() const {
+ return linearPerturbation_;
+ }
+ inline void setLinearPerturbation(CoinWorkDouble value) {
+ linearPerturbation_ = value;
+ }
+ /// projectionTolerance
+ inline CoinWorkDouble projectionTolerance() const {
+ return projectionTolerance_;
+ }
+ inline void setProjectionTolerance(CoinWorkDouble value) {
+ projectionTolerance_ = value;
+ }
+ /// diagonalPerturbation
+ inline CoinWorkDouble diagonalPerturbation() const {
+ return diagonalPerturbation_;
+ }
+ inline void setDiagonalPerturbation(CoinWorkDouble value) {
+ diagonalPerturbation_ = value;
+ }
+ /// gamma
+ inline CoinWorkDouble gamma() const {
+ return gamma_;
+ }
+ inline void setGamma(CoinWorkDouble value) {
+ gamma_ = value;
+ }
+ /// delta
+ inline CoinWorkDouble delta() const {
+ return delta_;
+ }
+ inline void setDelta(CoinWorkDouble value) {
+ delta_ = value;
+ }
+ /// ComplementarityGap
+ inline CoinWorkDouble complementarityGap() const {
+ return complementarityGap_;
+ }
+ //@}
+
+ /**@name most useful gets and sets */
+ //@{
+ /// Largest error on Ax-b
+ inline CoinWorkDouble largestPrimalError() const {
+ return largestPrimalError_;
+ }
+ /// Largest error on basic duals
+ inline CoinWorkDouble largestDualError() const {
+ return largestDualError_;
+ }
+ /// Maximum iterations
+ inline int maximumBarrierIterations() const {
+ return maximumBarrierIterations_;
+ }
+ inline void setMaximumBarrierIterations(int value) {
+ maximumBarrierIterations_ = value;
+ }
+ /// Set cholesky (and delete present one)
+ void setCholesky(ClpCholeskyBase * cholesky);
+ /// Return number fixed to see if worth presolving
+ int numberFixed() const;
+ /** fix variables interior says should be. If reallyFix false then just
+ set values to exact bounds */
+ void fixFixed(bool reallyFix = true);
+ /// Primal erturbation vector
+ inline CoinWorkDouble * primalR() const {
+ return primalR_;
+ }
+ /// Dual erturbation vector
+ inline CoinWorkDouble * dualR() const {
+ return dualR_;
+ }
+ //@}
+
+protected:
+ /**@name protected methods */
+ //@{
+ /// Does most of deletion
+ void gutsOfDelete();
+ /// Does most of copying
+ void gutsOfCopy(const ClpInterior & rhs);
+ /// Returns true if data looks okay, false if not
+ bool createWorkingData();
+ void deleteWorkingData();
+ /// Sanity check on input rim data
+ bool sanityCheck();
+ /// This does housekeeping
+ int housekeeping();
+ //@}
+public:
+ /**@name public methods */
+ //@{
+ /// Raw objective value (so always minimize)
+ inline CoinWorkDouble rawObjectiveValue() const {
+ return objectiveValue_;
+ }
+ /// Returns 1 if sequence indicates column
+ inline int isColumn(int sequence) const {
+ return sequence < numberColumns_ ? 1 : 0;
+ }
+ /// Returns sequence number within section
+ inline int sequenceWithin(int sequence) const {
+ return sequence < numberColumns_ ? sequence : sequence - numberColumns_;
+ }
+ /// Checks solution
+ void checkSolution();
+ /** Modifies djs to allow for quadratic.
+ returns quadratic offset */
+ CoinWorkDouble quadraticDjs(CoinWorkDouble * djRegion, const CoinWorkDouble * solution,
+ CoinWorkDouble scaleFactor);
+
+ /// To say a variable is fixed
+ inline void setFixed( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] | 1) ;
+ }
+ inline void clearFixed( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] & ~1) ;
+ }
+ inline bool fixed(int sequence) const {
+ return ((status_[sequence] & 1) != 0);
+ }
+
+ /// To flag a variable
+ inline void setFlagged( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] | 2) ;
+ }
+ inline void clearFlagged( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] & ~2) ;
+ }
+ inline bool flagged(int sequence) const {
+ return ((status_[sequence] & 2) != 0);
+ }
+
+ /// To say a variable is fixed OR free
+ inline void setFixedOrFree( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] | 4) ;
+ }
+ inline void clearFixedOrFree( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] & ~4) ;
+ }
+ inline bool fixedOrFree(int sequence) const {
+ return ((status_[sequence] & 4) != 0);
+ }
+
+ /// To say a variable has lower bound
+ inline void setLowerBound( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] | 8) ;
+ }
+ inline void clearLowerBound( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] & ~8) ;
+ }
+ inline bool lowerBound(int sequence) const {
+ return ((status_[sequence] & 8) != 0);
+ }
+
+ /// To say a variable has upper bound
+ inline void setUpperBound( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] | 16) ;
+ }
+ inline void clearUpperBound( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] & ~16) ;
+ }
+ inline bool upperBound(int sequence) const {
+ return ((status_[sequence] & 16) != 0);
+ }
+
+ /// To say a variable has fake lower bound
+ inline void setFakeLower( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] | 32) ;
+ }
+ inline void clearFakeLower( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] & ~32) ;
+ }
+ inline bool fakeLower(int sequence) const {
+ return ((status_[sequence] & 32) != 0);
+ }
+
+ /// To say a variable has fake upper bound
+ inline void setFakeUpper( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] | 64) ;
+ }
+ inline void clearFakeUpper( int sequence) {
+ status_[sequence] = static_cast(status_[sequence] & ~64) ;
+ }
+ inline bool fakeUpper(int sequence) const {
+ return ((status_[sequence] & 64) != 0);
+ }
+ //@}
+
+////////////////// data //////////////////
+protected:
+
+ /**@name data. Many arrays have a row part and a column part.
+ There is a single array with both - columns then rows and
+ then normally two arrays pointing to rows and columns. The
+ single array is the owner of memory
+ */
+ //@{
+ /// Largest error on Ax-b
+ CoinWorkDouble largestPrimalError_;
+ /// Largest error on basic duals
+ CoinWorkDouble largestDualError_;
+ /// Sum of dual infeasibilities
+ CoinWorkDouble sumDualInfeasibilities_;
+ /// Sum of primal infeasibilities
+ CoinWorkDouble sumPrimalInfeasibilities_;
+ /// Worst complementarity
+ CoinWorkDouble worstComplementarity_;
+ ///
+public:
+ CoinWorkDouble xsize_;
+ CoinWorkDouble zsize_;
+protected:
+ /// Working copy of lower bounds (Owner of arrays below)
+ CoinWorkDouble * lower_;
+ /// Row lower bounds - working copy
+ CoinWorkDouble * rowLowerWork_;
+ /// Column lower bounds - working copy
+ CoinWorkDouble * columnLowerWork_;
+ /// Working copy of upper bounds (Owner of arrays below)
+ CoinWorkDouble * upper_;
+ /// Row upper bounds - working copy
+ CoinWorkDouble * rowUpperWork_;
+ /// Column upper bounds - working copy
+ CoinWorkDouble * columnUpperWork_;
+ /// Working copy of objective
+ CoinWorkDouble * cost_;
+public:
+ /// Rhs
+ CoinWorkDouble * rhs_;
+ CoinWorkDouble * x_;
+ CoinWorkDouble * y_;
+ CoinWorkDouble * dj_;
+protected:
+ /// Pointer to Lsqr object
+ ClpLsqr * lsqrObject_;
+ /// Pointer to stuff
+ ClpPdcoBase * pdcoStuff_;
+ /// Below here is standard barrier stuff
+ /// mu.
+ CoinWorkDouble mu_;
+ /// objectiveNorm.
+ CoinWorkDouble objectiveNorm_;
+ /// rhsNorm.
+ CoinWorkDouble rhsNorm_;
+ /// solutionNorm.
+ CoinWorkDouble solutionNorm_;
+ /// dualObjective.
+ CoinWorkDouble dualObjective_;
+ /// primalObjective.
+ CoinWorkDouble primalObjective_;
+ /// diagonalNorm.
+ CoinWorkDouble diagonalNorm_;
+ /// stepLength
+ CoinWorkDouble stepLength_;
+ /// linearPerturbation
+ CoinWorkDouble linearPerturbation_;
+ /// diagonalPerturbation
+ CoinWorkDouble diagonalPerturbation_;
+ // gamma from Saunders and Tomlin regularized
+ CoinWorkDouble gamma_;
+ // delta from Saunders and Tomlin regularized
+ CoinWorkDouble delta_;
+ /// targetGap
+ CoinWorkDouble targetGap_;
+ /// projectionTolerance
+ CoinWorkDouble projectionTolerance_;
+ /// maximumRHSError. maximum Ax
+ CoinWorkDouble maximumRHSError_;
+ /// maximumBoundInfeasibility.
+ CoinWorkDouble maximumBoundInfeasibility_;
+ /// maximumDualError.
+ CoinWorkDouble maximumDualError_;
+ /// diagonalScaleFactor.
+ CoinWorkDouble diagonalScaleFactor_;
+ /// scaleFactor. For scaling objective
+ CoinWorkDouble scaleFactor_;
+ /// actualPrimalStep
+ CoinWorkDouble actualPrimalStep_;
+ /// actualDualStep
+ CoinWorkDouble actualDualStep_;
+ /// smallestInfeasibility
+ CoinWorkDouble smallestInfeasibility_;
+ /// historyInfeasibility.
+#define LENGTH_HISTORY 5
+ CoinWorkDouble historyInfeasibility_[LENGTH_HISTORY];
+ /// complementarityGap.
+ CoinWorkDouble complementarityGap_;
+ /// baseObjectiveNorm
+ CoinWorkDouble baseObjectiveNorm_;
+ /// worstDirectionAccuracy
+ CoinWorkDouble worstDirectionAccuracy_;
+ /// maximumRHSChange
+ CoinWorkDouble maximumRHSChange_;
+ /// errorRegion. i.e. Ax
+ CoinWorkDouble * errorRegion_;
+ /// rhsFixRegion.
+ CoinWorkDouble * rhsFixRegion_;
+ /// upperSlack
+ CoinWorkDouble * upperSlack_;
+ /// lowerSlack
+ CoinWorkDouble * lowerSlack_;
+ /// diagonal
+ CoinWorkDouble * diagonal_;
+ /// solution
+ CoinWorkDouble * solution_;
+ /// work array
+ CoinWorkDouble * workArray_;
+ /// delta X
+ CoinWorkDouble * deltaX_;
+ /// delta Y
+ CoinWorkDouble * deltaY_;
+ /// deltaZ.
+ CoinWorkDouble * deltaZ_;
+ /// deltaW.
+ CoinWorkDouble * deltaW_;
+ /// deltaS.
+ CoinWorkDouble * deltaSU_;
+ CoinWorkDouble * deltaSL_;
+ /// Primal regularization array
+ CoinWorkDouble * primalR_;
+ /// Dual regularization array
+ CoinWorkDouble * dualR_;
+ /// rhs B
+ CoinWorkDouble * rhsB_;
+ /// rhsU.
+ CoinWorkDouble * rhsU_;
+ /// rhsL.
+ CoinWorkDouble * rhsL_;
+ /// rhsZ.
+ CoinWorkDouble * rhsZ_;
+ /// rhsW.
+ CoinWorkDouble * rhsW_;
+ /// rhs C
+ CoinWorkDouble * rhsC_;
+ /// zVec
+ CoinWorkDouble * zVec_;
+ /// wVec
+ CoinWorkDouble * wVec_;
+ /// cholesky.
+ ClpCholeskyBase * cholesky_;
+ /// numberComplementarityPairs i.e. ones with lower and/or upper bounds (not fixed)
+ int numberComplementarityPairs_;
+ /// numberComplementarityItems_ i.e. number of active bounds
+ int numberComplementarityItems_;
+ /// Maximum iterations
+ int maximumBarrierIterations_;
+ /// gonePrimalFeasible.
+ bool gonePrimalFeasible_;
+ /// goneDualFeasible.
+ bool goneDualFeasible_;
+ /// Which algorithm being used
+ int algorithm_;
+ //@}
+};
+//#############################################################################
+/** A function that tests the methods in the ClpInterior class. The
+ only reason for it not to be a member method is that this way it doesn't
+ have to be compiled into the library. And that's a gain, because the
+ library should be compiled with optimization on, but this method should be
+ compiled with debugging.
+
+ It also does some testing of ClpFactorization class
+ */
+void
+ClpInteriorUnitTest(const std::string & mpsDir,
+ const std::string & netlibDir);
+
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpLinearObjective.hpp b/thirdparty/windows/include/coin/ClpLinearObjective.hpp
new file mode 100644
index 0000000..ff035d4
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpLinearObjective.hpp
@@ -0,0 +1,103 @@
+/* $Id: ClpLinearObjective.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// Copyright (C) 2003, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpLinearObjective_H
+#define ClpLinearObjective_H
+
+#include "ClpObjective.hpp"
+
+//#############################################################################
+
+/** Linear Objective Class
+
+*/
+
+class ClpLinearObjective : public ClpObjective {
+
+public:
+
+ ///@name Stuff
+ //@{
+
+ /** Returns objective coefficients.
+
+ Offset is always set to 0.0. All other parameters unused.
+ */
+ virtual double * gradient(const ClpSimplex * model,
+ const double * solution, double & offset, bool refresh,
+ int includeLinear = 2);
+ /** Returns reduced gradient.Returns an offset (to be added to current one).
+ */
+ virtual double reducedGradient(ClpSimplex * model, double * region,
+ bool useFeasibleCosts);
+ /** Returns step length which gives minimum of objective for
+ solution + theta * change vector up to maximum theta.
+
+ arrays are numberColumns+numberRows
+ Also sets current objective, predicted and at maximumTheta
+ */
+ virtual double stepLength(ClpSimplex * model,
+ const double * solution,
+ const double * change,
+ double maximumTheta,
+ double & currentObj,
+ double & predictedObj,
+ double & thetaObj);
+ /// Return objective value (without any ClpModel offset) (model may be NULL)
+ virtual double objectiveValue(const ClpSimplex * model, const double * solution) const ;
+ /// Resize objective
+ virtual void resize(int newNumberColumns) ;
+ /// Delete columns in objective
+ virtual void deleteSome(int numberToDelete, const int * which) ;
+ /// Scale objective
+ virtual void reallyScale(const double * columnScale) ;
+
+ //@}
+
+
+ ///@name Constructors and destructors
+ //@{
+ /// Default Constructor
+ ClpLinearObjective();
+
+ /// Constructor from objective
+ ClpLinearObjective(const double * objective, int numberColumns);
+
+ /// Copy constructor
+ ClpLinearObjective(const ClpLinearObjective &);
+ /** Subset constructor. Duplicates are allowed
+ and order is as given.
+ */
+ ClpLinearObjective (const ClpLinearObjective &rhs, int numberColumns,
+ const int * whichColumns) ;
+
+ /// Assignment operator
+ ClpLinearObjective & operator=(const ClpLinearObjective& rhs);
+
+ /// Destructor
+ virtual ~ClpLinearObjective ();
+
+ /// Clone
+ virtual ClpObjective * clone() const;
+ /** Subset clone. Duplicates are allowed
+ and order is as given.
+ */
+ virtual ClpObjective * subsetClone (int numberColumns,
+ const int * whichColumns) const;
+
+ //@}
+
+ //---------------------------------------------------------------------------
+
+private:
+ ///@name Private member data
+ /// Objective
+ double * objective_;
+ /// number of columns
+ int numberColumns_;
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpMatrixBase.hpp b/thirdparty/windows/include/coin/ClpMatrixBase.hpp
new file mode 100644
index 0000000..06dc523
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpMatrixBase.hpp
@@ -0,0 +1,524 @@
+/* $Id: ClpMatrixBase.hpp 2078 2015-01-05 12:39:49Z forrest $ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpMatrixBase_H
+#define ClpMatrixBase_H
+
+#include "CoinPragma.hpp"
+#include "CoinTypes.hpp"
+
+#include "CoinPackedMatrix.hpp"
+class CoinIndexedVector;
+class ClpSimplex;
+class ClpModel;
+// Compilers can produce better code if they know about __restrict
+#ifndef COIN_RESTRICT
+#ifdef COIN_USE_RESTRICT
+#define COIN_RESTRICT __restrict
+#else
+#define COIN_RESTRICT
+#endif
+#endif
+
+/** Abstract base class for Clp Matrices
+
+Since this class is abstract, no object of this type can be created.
+
+If a derived class provides all methods then all Clp algorithms
+should work. Some can be very inefficient e.g. getElements etc is
+only used for tightening bounds for dual and the copies are
+deleted. Many methods can just be dummy i.e. abort(); if not
+all features are being used. So if column generation was being done
+then it makes no sense to do steepest edge so there would be
+no point providing subsetTransposeTimes.
+*/
+
+class ClpMatrixBase {
+
+public:
+ /**@name Virtual methods that the derived classes must provide */
+ //@{
+ /// Return a complete CoinPackedMatrix
+ virtual CoinPackedMatrix * getPackedMatrix() const = 0;
+ /** Whether the packed matrix is column major ordered or not. */
+ virtual bool isColOrdered() const = 0;
+ /** Number of entries in the packed matrix. */
+ virtual CoinBigIndex getNumElements() const = 0;
+ /** Number of columns. */
+ virtual int getNumCols() const = 0;
+ /** Number of rows. */
+ virtual int getNumRows() const = 0;
+
+ /** A vector containing the elements in the packed matrix. Note that there
+ might be gaps in this list, entries that do not belong to any
+ major-dimension vector. To get the actual elements one should look at
+ this vector together with vectorStarts and vectorLengths. */
+ virtual const double * getElements() const = 0;
+ /** A vector containing the minor indices of the elements in the packed
+ matrix. Note that there might be gaps in this list, entries that do not
+ belong to any major-dimension vector. To get the actual elements one
+ should look at this vector together with vectorStarts and
+ vectorLengths. */
+ virtual const int * getIndices() const = 0;
+
+ virtual const CoinBigIndex * getVectorStarts() const = 0;
+ /** The lengths of the major-dimension vectors. */
+ virtual const int * getVectorLengths() const = 0 ;
+ /** The length of a single major-dimension vector. */
+ virtual int getVectorLength(int index) const ;
+ /** Delete the columns whose indices are listed in indDel. */
+ virtual void deleteCols(const int numDel, const int * indDel) = 0;
+ /** Delete the rows whose indices are listed in indDel. */
+ virtual void deleteRows(const int numDel, const int * indDel) = 0;
+#ifndef CLP_NO_VECTOR
+ /// Append Columns
+ virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
+ /// Append Rows
+ virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
+#endif
+ /** Modify one element of packed matrix. An element may be added.
+ This works for either ordering If the new element is zero it will be
+ deleted unless keepZero true */
+ virtual void modifyCoefficient(int row, int column, double newElement,
+ bool keepZero = false);
+ /** Append a set of rows/columns to the end of the matrix. Returns number of errors
+ i.e. if any of the new rows/columns contain an index that's larger than the
+ number of columns-1/rows-1 (if numberOther>0) or duplicates
+ If 0 then rows, 1 if columns */
+ virtual int appendMatrix(int number, int type,
+ const CoinBigIndex * starts, const int * index,
+ const double * element, int numberOther = -1);
+
+ /** Returns a new matrix in reverse order without gaps
+ Is allowed to return NULL if doesn't want to have row copy */
+ virtual ClpMatrixBase * reverseOrderedCopy() const {
+ return NULL;
+ }
+
+ /// Returns number of elements in column part of basis
+ virtual CoinBigIndex countBasis(const int * whichColumn,
+ int & numberColumnBasic) = 0;
+ /// Fills in column part of basis
+ virtual void fillBasis(ClpSimplex * model,
+ const int * whichColumn,
+ int & numberColumnBasic,
+ int * row, int * start,
+ int * rowCount, int * columnCount,
+ CoinFactorizationDouble * element) = 0;
+ /** Creates scales for column copy (rowCopy in model may be modified)
+ default does not allow scaling
+ returns non-zero if no scaling done */
+ virtual int scale(ClpModel * , const ClpSimplex * = NULL) const {
+ return 1;
+ }
+ /** Scales rowCopy if column copy scaled
+ Only called if scales already exist */
+ virtual void scaleRowCopy(ClpModel * ) const { }
+ /// Returns true if can create row copy
+ virtual bool canGetRowCopy() const {
+ return true;
+ }
+ /** Realy really scales column copy
+ Only called if scales already exist.
+ Up to user to delete */
+ inline virtual ClpMatrixBase * scaledColumnCopy(ClpModel * ) const {
+ return this->clone();
+ }
+
+ /** Checks if all elements are in valid range. Can just
+ return true if you are not paranoid. For Clp I will
+ probably expect no zeros. Code can modify matrix to get rid of
+ small elements.
+ check bits (can be turned off to save time) :
+ 1 - check if matrix has gaps
+ 2 - check if zero elements
+ 4 - check and compress duplicates
+ 8 - report on large and small
+ */
+ virtual bool allElementsInRange(ClpModel * ,
+ double , double ,
+ int = 15) {
+ return true;
+ }
+ /** Set the dimensions of the matrix. In effect, append new empty
+ columns/rows to the matrix. A negative number for either dimension
+ means that that dimension doesn't change. Otherwise the new dimensions
+ MUST be at least as large as the current ones otherwise an exception
+ is thrown. */
+ virtual void setDimensions(int numrows, int numcols);
+ /** Returns largest and smallest elements of both signs.
+ Largest refers to largest absolute value.
+ If returns zeros then can't tell anything */
+ virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
+ double & smallestPositive, double & largestPositive);
+
+ /** Unpacks a column into an CoinIndexedvector
+ */
+ virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
+ int column) const = 0;
+ /** Unpacks a column into an CoinIndexedvector
+ ** in packed format
+ Note that model is NOT const. Bounds and objective could
+ be modified if doing column generation (just for this variable) */
+ virtual void unpackPacked(ClpSimplex * model,
+ CoinIndexedVector * rowArray,
+ int column) const = 0;
+ /** Purely for column generation and similar ideas. Allows
+ matrix and any bounds or costs to be updated (sensibly).
+ Returns non-zero if any changes.
+ */
+ virtual int refresh(ClpSimplex * ) {
+ return 0;
+ }
+
+ // Really scale matrix
+ virtual void reallyScale(const double * rowScale, const double * columnScale);
+ /** Given positive integer weights for each row fills in sum of weights
+ for each column (and slack).
+ Returns weights vector
+ Default returns vector of ones
+ */
+ virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model, int * inputWeights) const;
+ /** Adds multiple of a column into an CoinIndexedvector
+ You can use quickAdd to add to vector */
+ virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
+ int column, double multiplier) const = 0;
+ /** Adds multiple of a column into an array */
+ virtual void add(const ClpSimplex * model, double * array,
+ int column, double multiplier) const = 0;
+ /// Allow any parts of a created CoinPackedMatrix to be deleted
+ virtual void releasePackedMatrix() const = 0;
+ /// Says whether it can do partial pricing
+ virtual bool canDoPartialPricing() const;
+ /// Returns number of hidden rows e.g. gub
+ virtual int hiddenRows() const;
+ /// Partial pricing
+ virtual void partialPricing(ClpSimplex * model, double start, double end,
+ int & bestSequence, int & numberWanted);
+ /** expands an updated column to allow for extra rows which the main
+ solver does not know about and returns number added.
+
+ This will normally be a no-op - it is in for GUB but may get extended to
+ general non-overlapping and embedded networks.
+
+ mode 0 - extend
+ mode 1 - delete etc
+ */
+ virtual int extendUpdated(ClpSimplex * model, CoinIndexedVector * update, int mode);
+ /**
+ utility primal function for dealing with dynamic constraints
+ mode=0 - Set up before "update" and "times" for primal solution using extended rows
+ mode=1 - Cleanup primal solution after "times" using extended rows.
+ mode=2 - Check (or report on) primal infeasibilities
+ */
+ virtual void primalExpanded(ClpSimplex * model, int mode);
+ /**
+ utility dual function for dealing with dynamic constraints
+ mode=0 - Set up before "updateTranspose" and "transposeTimes" for duals using extended
+ updates array (and may use other if dual values pass)
+ mode=1 - Update dual solution after "transposeTimes" using extended rows.
+ mode=2 - Compute all djs and compute key dual infeasibilities
+ mode=3 - Report on key dual infeasibilities
+ mode=4 - Modify before updateTranspose in partial pricing
+ */
+ virtual void dualExpanded(ClpSimplex * model, CoinIndexedVector * array,
+ double * other, int mode);
+ /**
+ general utility function for dealing with dynamic constraints
+ mode=0 - Create list of non-key basics in pivotVariable_ using
+ number as numberBasic in and out
+ mode=1 - Set all key variables as basic
+ mode=2 - return number extra rows needed, number gives maximum number basic
+ mode=3 - before replaceColumn
+ mode=4 - return 1 if can do primal, 2 if dual, 3 if both
+ mode=5 - save any status stuff (when in good state)
+ mode=6 - restore status stuff
+ mode=7 - flag given variable (normally sequenceIn)
+ mode=8 - unflag all variables
+ mode=9 - synchronize costs and bounds
+ mode=10 - return 1 if there may be changing bounds on variable (column generation)
+ mode=11 - make sure set is clean (used when a variable rejected - but not flagged)
+ mode=12 - after factorize but before permute stuff
+ mode=13 - at end of simplex to delete stuff
+
+ */
+ virtual int generalExpanded(ClpSimplex * model, int mode, int & number);
+ /**
+ update information for a pivot (and effective rhs)
+ */
+ virtual int updatePivot(ClpSimplex * model, double oldInValue, double oldOutValue);
+ /** Creates a variable. This is called after partial pricing and may modify matrix.
+ May update bestSequence.
+ */
+ virtual void createVariable(ClpSimplex * model, int & bestSequence);
+ /** Just for debug if odd type matrix.
+ Returns number of primal infeasibilities. */
+ virtual int checkFeasible(ClpSimplex * model, double & sum) const ;
+ /// Returns reduced cost of a variable
+ double reducedCost(ClpSimplex * model, int sequence) const;
+ /// Correct sequence in and out to give true value (if both -1 maybe do whole matrix)
+ virtual void correctSequence(const ClpSimplex * model, int & sequenceIn, int & sequenceOut) ;
+ //@}
+
+ //---------------------------------------------------------------------------
+ /**@name Matrix times vector methods
+ They can be faster if scalar is +- 1
+ Also for simplex I am not using basic/non-basic split */
+ //@{
+ /** Return y + A * x * scalar in y.
+ @pre x must be of size numColumns()
+ @pre y must be of size numRows() */
+ virtual void times(double scalar,
+ const double * COIN_RESTRICT x, double * COIN_RESTRICT y) const = 0;
+ /** And for scaling - default aborts for when scaling not supported
+ (unless pointers NULL when as normal)
+ */
+ virtual void times(double scalar,
+ const double * COIN_RESTRICT x, double * COIN_RESTRICT y,
+ const double * COIN_RESTRICT rowScale,
+ const double * COIN_RESTRICT columnScale) const;
+ /** Return y + x * scalar * A in y.
+ @pre x must be of size numRows()
+ @pre y must be of size numColumns() */
+ virtual void transposeTimes(double scalar,
+ const double * COIN_RESTRICT x, double * COIN_RESTRICT y) const = 0;
+ /** And for scaling - default aborts for when scaling not supported
+ (unless pointers NULL when as normal)
+ */
+ virtual void transposeTimes(double scalar,
+ const double * COIN_RESTRICT x, double * COIN_RESTRICT y,
+ const double * COIN_RESTRICT rowScale,
+ const double * COIN_RESTRICT columnScale,
+ double * COIN_RESTRICT spare = NULL) const;
+#if COIN_LONG_WORK
+ // For long double versions (aborts if not supported)
+ virtual void times(CoinWorkDouble scalar,
+ const CoinWorkDouble * COIN_RESTRICT x, CoinWorkDouble * COIN_RESTRICT y) const ;
+ virtual void transposeTimes(CoinWorkDouble scalar,
+ const CoinWorkDouble * COIN_RESTRICT x, CoinWorkDouble * COIN_RESTRICT y) const ;
+#endif
+ /** Return x * scalar *A + y in z.
+ Can use y as temporary array (will be empty at end)
+ Note - If x packed mode - then z packed mode
+ Squashes small elements and knows about ClpSimplex */
+ virtual void transposeTimes(const ClpSimplex * model, double scalar,
+ const CoinIndexedVector * x,
+ CoinIndexedVector * y,
+ CoinIndexedVector * z) const = 0;
+ /** Return x *A in z but
+ just for indices in y.
+ This is only needed for primal steepest edge.
+ Note - z always packed mode */
+ virtual void subsetTransposeTimes(const ClpSimplex * model,
+ const CoinIndexedVector * x,
+ const CoinIndexedVector * y,
+ CoinIndexedVector * z) const = 0;
+ /** Returns true if can combine transposeTimes and subsetTransposeTimes
+ and if it would be faster */
+ virtual bool canCombine(const ClpSimplex * ,
+ const CoinIndexedVector * ) const {
+ return false;
+ }
+ /// Updates two arrays for steepest and does devex weights (need not be coded)
+ virtual void transposeTimes2(const ClpSimplex * model,
+ const CoinIndexedVector * pi1, CoinIndexedVector * dj1,
+ const CoinIndexedVector * pi2,
+ CoinIndexedVector * spare,
+ double referenceIn, double devex,
+ // Array for exact devex to say what is in reference framework
+ unsigned int * reference,
+ double * weights, double scaleFactor);
+ /// Updates second array for steepest and does devex weights (need not be coded)
+ virtual void subsetTimes2(const ClpSimplex * model,
+ CoinIndexedVector * dj1,
+ const CoinIndexedVector * pi2, CoinIndexedVector * dj2,
+ double referenceIn, double devex,
+ // Array for exact devex to say what is in reference framework
+ unsigned int * reference,
+ double * weights, double scaleFactor);
+ /** Return x *A in z but
+ just for number indices in y.
+ Default cheats with fake CoinIndexedVector and
+ then calls subsetTransposeTimes */
+ virtual void listTransposeTimes(const ClpSimplex * model,
+ double * x,
+ int * y,
+ int number,
+ double * z) const;
+ //@}
+ //@{
+ ///@name Other
+ /// Clone
+ virtual ClpMatrixBase * clone() const = 0;
+ /** Subset clone (without gaps). Duplicates are allowed
+ and order is as given.
+ Derived classes need not provide this as it may not always make
+ sense */
+ virtual ClpMatrixBase * subsetClone (
+ int numberRows, const int * whichRows,
+ int numberColumns, const int * whichColumns) const;
+ /// Gets rid of any mutable by products
+ virtual void backToBasics() {}
+ /** Returns type.
+ The types which code may need to know about are:
+ 1 - ClpPackedMatrix
+ 11 - ClpNetworkMatrix
+ 12 - ClpPlusMinusOneMatrix
+ */
+ inline int type() const {
+ return type_;
+ }
+ /// Sets type
+ void setType(int newtype) {
+ type_ = newtype;
+ }
+ /// Sets up an effective RHS
+ void useEffectiveRhs(ClpSimplex * model);
+ /** Returns effective RHS offset if it is being used. This is used for long problems
+ or big gub or anywhere where going through full columns is
+ expensive. This may re-compute */
+ virtual double * rhsOffset(ClpSimplex * model, bool forceRefresh = false,
+ bool check = false);
+ /// If rhsOffset used this is iteration last refreshed
+ inline int lastRefresh() const {
+ return lastRefresh_;
+ }
+ /// If rhsOffset used this is refresh frequency (0==off)
+ inline int refreshFrequency() const {
+ return refreshFrequency_;
+ }
+ inline void setRefreshFrequency(int value) {
+ refreshFrequency_ = value;
+ }
+ /// whether to skip dual checks most of time
+ inline bool skipDualCheck() const {
+ return skipDualCheck_;
+ }
+ inline void setSkipDualCheck(bool yes) {
+ skipDualCheck_ = yes;
+ }
+ /** Partial pricing tuning parameter - minimum number of "objects" to scan.
+ e.g. number of Gub sets but could be number of variables */
+ inline int minimumObjectsScan() const {
+ return minimumObjectsScan_;
+ }
+ inline void setMinimumObjectsScan(int value) {
+ minimumObjectsScan_ = value;
+ }
+ /// Partial pricing tuning parameter - minimum number of negative reduced costs to get
+ inline int minimumGoodReducedCosts() const {
+ return minimumGoodReducedCosts_;
+ }
+ inline void setMinimumGoodReducedCosts(int value) {
+ minimumGoodReducedCosts_ = value;
+ }
+ /// Current start of search space in matrix (as fraction)
+ inline double startFraction() const {
+ return startFraction_;
+ }
+ inline void setStartFraction(double value) {
+ startFraction_ = value;
+ }
+ /// Current end of search space in matrix (as fraction)
+ inline double endFraction() const {
+ return endFraction_;
+ }
+ inline void setEndFraction(double value) {
+ endFraction_ = value;
+ }
+ /// Current best reduced cost
+ inline double savedBestDj() const {
+ return savedBestDj_;
+ }
+ inline void setSavedBestDj(double value) {
+ savedBestDj_ = value;
+ }
+ /// Initial number of negative reduced costs wanted
+ inline int originalWanted() const {
+ return originalWanted_;
+ }
+ inline void setOriginalWanted(int value) {
+ originalWanted_ = value;
+ }
+ /// Current number of negative reduced costs which we still need
+ inline int currentWanted() const {
+ return currentWanted_;
+ }
+ inline void setCurrentWanted(int value) {
+ currentWanted_ = value;
+ }
+ /// Current best sequence
+ inline int savedBestSequence() const {
+ return savedBestSequence_;
+ }
+ inline void setSavedBestSequence(int value) {
+ savedBestSequence_ = value;
+ }
+ //@}
+
+
+protected:
+
+ /**@name Constructors, destructor
+ NOTE: All constructors are protected. There's no need
+ to expose them, after all, this is an abstract class. */
+ //@{
+ /** Default constructor. */
+ ClpMatrixBase();
+ /** Destructor (has to be public) */
+public:
+ virtual ~ClpMatrixBase();
+protected:
+ // Copy
+ ClpMatrixBase(const ClpMatrixBase&);
+ // Assignment
+ ClpMatrixBase& operator=(const ClpMatrixBase&);
+ //@}
+
+
+protected:
+ /**@name Data members
+ The data members are protected to allow access for derived classes. */
+ //@{
+ /** Effective RHS offset if it is being used. This is used for long problems
+ or big gub or anywhere where going through full columns is
+ expensive */
+ double * rhsOffset_;
+ /// Current start of search space in matrix (as fraction)
+ double startFraction_;
+ /// Current end of search space in matrix (as fraction)
+ double endFraction_;
+ /// Best reduced cost so far
+ double savedBestDj_;
+ /// Initial number of negative reduced costs wanted
+ int originalWanted_;
+ /// Current number of negative reduced costs which we still need
+ int currentWanted_;
+ /// Saved best sequence in pricing
+ int savedBestSequence_;
+ /// type (may be useful)
+ int type_;
+ /// If rhsOffset used this is iteration last refreshed
+ int lastRefresh_;
+ /// If rhsOffset used this is refresh frequency (0==off)
+ int refreshFrequency_;
+ /// Partial pricing tuning parameter - minimum number of "objects" to scan
+ int minimumObjectsScan_;
+ /// Partial pricing tuning parameter - minimum number of negative reduced costs to get
+ int minimumGoodReducedCosts_;
+ /// True sequence in (i.e. from larger problem)
+ int trueSequenceIn_;
+ /// True sequence out (i.e. from larger problem)
+ int trueSequenceOut_;
+ /// whether to skip dual checks most of time
+ bool skipDualCheck_;
+ //@}
+};
+// bias for free variables
+#define FREE_BIAS 1.0e1
+// Acceptance criteria for free variables
+#define FREE_ACCEPT 1.0e2
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpMessage.hpp b/thirdparty/windows/include/coin/ClpMessage.hpp
new file mode 100644
index 0000000..5eb3653
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpMessage.hpp
@@ -0,0 +1,131 @@
+/* $Id: ClpMessage.hpp 1926 2013-03-26 15:23:38Z forrest $ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpMessage_H
+#define ClpMessage_H
+
+
+#include "CoinPragma.hpp"
+#include
+
+// This deals with Clp messages (as against Osi messages etc)
+
+#include "CoinMessageHandler.hpp"
+enum CLP_Message {
+ CLP_SIMPLEX_FINISHED,
+ CLP_SIMPLEX_INFEASIBLE,
+ CLP_SIMPLEX_UNBOUNDED,
+ CLP_SIMPLEX_STOPPED,
+ CLP_SIMPLEX_ERROR,
+ CLP_SIMPLEX_INTERRUPT,
+ CLP_SIMPLEX_STATUS,
+ CLP_DUAL_BOUNDS,
+ CLP_SIMPLEX_ACCURACY,
+ CLP_SIMPLEX_BADFACTOR,
+ CLP_SIMPLEX_BOUNDTIGHTEN,
+ CLP_SIMPLEX_INFEASIBILITIES,
+ CLP_SIMPLEX_FLAG,
+ CLP_SIMPLEX_GIVINGUP,
+ CLP_DUAL_CHECKB,
+ CLP_DUAL_ORIGINAL,
+ CLP_SIMPLEX_PERTURB,
+ CLP_PRIMAL_ORIGINAL,
+ CLP_PRIMAL_WEIGHT,
+ CLP_PRIMAL_OPTIMAL,
+ CLP_SINGULARITIES,
+ CLP_MODIFIEDBOUNDS,
+ CLP_RIMSTATISTICS1,
+ CLP_RIMSTATISTICS2,
+ CLP_RIMSTATISTICS3,
+ CLP_POSSIBLELOOP,
+ CLP_SMALLELEMENTS,
+ CLP_DUPLICATEELEMENTS,
+ CLP_SIMPLEX_HOUSE1,
+ CLP_SIMPLEX_HOUSE2,
+ CLP_SIMPLEX_NONLINEAR,
+ CLP_SIMPLEX_FREEIN,
+ CLP_SIMPLEX_PIVOTROW,
+ CLP_DUAL_CHECK,
+ CLP_PRIMAL_DJ,
+ CLP_PACKEDSCALE_INITIAL,
+ CLP_PACKEDSCALE_WHILE,
+ CLP_PACKEDSCALE_FINAL,
+ CLP_PACKEDSCALE_FORGET,
+ CLP_INITIALIZE_STEEP,
+ CLP_UNABLE_OPEN,
+ CLP_BAD_BOUNDS,
+ CLP_BAD_MATRIX,
+ CLP_LOOP,
+ CLP_IMPORT_RESULT,
+ CLP_IMPORT_ERRORS,
+ CLP_EMPTY_PROBLEM,
+ CLP_CRASH,
+ CLP_END_VALUES_PASS,
+ CLP_QUADRATIC_BOTH,
+ CLP_QUADRATIC_PRIMAL_DETAILS,
+ CLP_IDIOT_ITERATION,
+ CLP_INFEASIBLE,
+ CLP_MATRIX_CHANGE,
+ CLP_TIMING,
+ CLP_INTERVAL_TIMING,
+ CLP_SPRINT,
+ CLP_BARRIER_ITERATION,
+ CLP_BARRIER_OBJECTIVE_GAP,
+ CLP_BARRIER_GONE_INFEASIBLE,
+ CLP_BARRIER_CLOSE_TO_OPTIMAL,
+ CLP_BARRIER_COMPLEMENTARITY,
+ CLP_BARRIER_EXIT2,
+ CLP_BARRIER_STOPPING,
+ CLP_BARRIER_EXIT,
+ CLP_BARRIER_SCALING,
+ CLP_BARRIER_MU,
+ CLP_BARRIER_INFO,
+ CLP_BARRIER_END,
+ CLP_BARRIER_ACCURACY,
+ CLP_BARRIER_SAFE,
+ CLP_BARRIER_NEGATIVE_GAPS,
+ CLP_BARRIER_REDUCING,
+ CLP_BARRIER_DIAGONAL,
+ CLP_BARRIER_SLACKS,
+ CLP_BARRIER_DUALINF,
+ CLP_BARRIER_KILLED,
+ CLP_BARRIER_ABS_DROPPED,
+ CLP_BARRIER_ABS_ERROR,
+ CLP_BARRIER_FEASIBLE,
+ CLP_BARRIER_STEP,
+ CLP_BARRIER_KKT,
+ CLP_RIM_SCALE,
+ CLP_SLP_ITER,
+ CLP_COMPLICATED_MODEL,
+ CLP_BAD_STRING_VALUES,
+ CLP_CRUNCH_STATS,
+ CLP_PARAMETRICS_STATS,
+ CLP_PARAMETRICS_STATS2,
+#ifndef NO_FATHOM_PRINT
+ CLP_FATHOM_STATUS,
+ CLP_FATHOM_SOLUTION,
+ CLP_FATHOM_FINISH,
+#endif
+ CLP_GENERAL,
+ CLP_GENERAL2,
+ CLP_GENERAL_WARNING,
+ CLP_DUMMY_END
+};
+
+/** This deals with Clp messages (as against Osi messages etc)
+ */
+class ClpMessage : public CoinMessages {
+
+public:
+
+ /**@name Constructors etc */
+ //@{
+ /** Constructor */
+ ClpMessage(Language language = us_en);
+ //@}
+
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpModel.hpp b/thirdparty/windows/include/coin/ClpModel.hpp
new file mode 100644
index 0000000..4a22539
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpModel.hpp
@@ -0,0 +1,1307 @@
+/* $Id: ClpModel.hpp 2074 2014-12-10 09:43:54Z forrest $ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpModel_H
+#define ClpModel_H
+
+#include "ClpConfig.h"
+
+#include
+#include
+#include
+#include
+#include
+//#ifndef COIN_USE_CLP
+//#define COIN_USE_CLP
+//#endif
+#include "ClpPackedMatrix.hpp"
+#include "CoinMessageHandler.hpp"
+#include "CoinHelperFunctions.hpp"
+#include "CoinTypes.hpp"
+#include "CoinFinite.hpp"
+#include "ClpParameters.hpp"
+#include "ClpObjective.hpp"
+class ClpEventHandler;
+/** This is the base class for Linear and quadratic Models
+ This knows nothing about the algorithm, but it seems to
+ have a reasonable amount of information
+
+ I would welcome suggestions for what should be in this and
+ how it relates to OsiSolverInterface. Some methods look
+ very similar.
+
+*/
+class CoinBuild;
+class CoinModel;
+class ClpModel {
+
+public:
+
+ /**@name Constructors and destructor
+ Note - copy methods copy ALL data so can chew up memory
+ until other copy is freed
+ */
+ //@{
+ /// Default constructor
+ ClpModel (bool emptyMessages = false );
+
+ /** Copy constructor. May scale depending on mode
+ -1 leave mode as is
+ 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 auto-but-as-initialSolve-in-bab
+ */
+ ClpModel(const ClpModel & rhs, int scalingMode = -1);
+ /// Assignment operator. This copies the data
+ ClpModel & operator=(const ClpModel & rhs);
+ /** Subproblem constructor. A subset of whole model is created from the
+ row and column lists given. The new order is given by list order and
+ duplicates are allowed. Name and integer information can be dropped
+ */
+ ClpModel (const ClpModel * wholeModel,
+ int numberRows, const int * whichRows,
+ int numberColumns, const int * whichColumns,
+ bool dropNames = true, bool dropIntegers = true);
+ /// Destructor
+ ~ClpModel ( );
+ //@}
+
+ /**@name Load model - loads some stuff and initializes others */
+ //@{
+ /** Loads a problem (the constraints on the
+ rows are given by lower and upper bounds). If a pointer is 0 then the
+ following values are the default:
+
+ -
colub: all columns have upper bound infinity
+ -
collb: all columns have lower bound 0
+ -
rowub: all rows have upper bound infinity
+ -
rowlb: all rows have lower bound -infinity
+ -
obj: all variables have 0 objective coefficient
+
+ */
+ void loadProblem ( const ClpMatrixBase& matrix,
+ const double* collb, const double* colub,
+ const double* obj,
+ const double* rowlb, const double* rowub,
+ const double * rowObjective = NULL);
+ void loadProblem ( const CoinPackedMatrix& matrix,
+ const double* collb, const double* colub,
+ const double* obj,
+ const double* rowlb, const double* rowub,
+ const double * rowObjective = NULL);
+
+ /** Just like the other loadProblem() method except that the matrix is
+ given in a standard column major ordered format (without gaps). */
+ void loadProblem ( const int numcols, const int numrows,
+ const CoinBigIndex* start, const int* index,
+ const double* value,
+ const double* collb, const double* colub,
+ const double* obj,
+ const double* rowlb, const double* rowub,
+ const double * rowObjective = NULL);
+ /** This loads a model from a coinModel object - returns number of errors.
+
+ modelObject not const as may be changed as part of process
+ If tryPlusMinusOne then will try adding as +-1 matrix
+ */
+ int loadProblem ( CoinModel & modelObject, bool tryPlusMinusOne = false);
+ /// This one is for after presolve to save memory
+ void loadProblem ( const int numcols, const int numrows,
+ const CoinBigIndex* start, const int* index,
+ const double* value, const int * length,
+ const double* collb, const double* colub,
+ const double* obj,
+ const double* rowlb, const double* rowub,
+ const double * rowObjective = NULL);
+ /** Load up quadratic objective. This is stored as a CoinPackedMatrix */
+ void loadQuadraticObjective(const int numberColumns,
+ const CoinBigIndex * start,
+ const int * column, const double * element);
+ void loadQuadraticObjective ( const CoinPackedMatrix& matrix);
+ /// Get rid of quadratic objective
+ void deleteQuadraticObjective();
+ /// This just loads up a row objective
+ void setRowObjective(const double * rowObjective);
+ /// Read an mps file from the given filename
+ int readMps(const char *filename,
+ bool keepNames = false,
+ bool ignoreErrors = false);
+ /// Read GMPL files from the given filenames
+ int readGMPL(const char *filename, const char * dataName,
+ bool keepNames = false);
+ /// Copy in integer informations
+ void copyInIntegerInformation(const char * information);
+ /// Drop integer informations
+ void deleteIntegerInformation();
+ /** Set the index-th variable to be a continuous variable */
+ void setContinuous(int index);
+ /** Set the index-th variable to be an integer variable */
+ void setInteger(int index);
+ /** Return true if the index-th variable is an integer variable */
+ bool isInteger(int index) const;
+ /// Resizes rim part of model
+ void resize (int newNumberRows, int newNumberColumns);
+ /// Deletes rows
+ void deleteRows(int number, const int * which);
+ /// Add one row
+ void addRow(int numberInRow, const int * columns,
+ const double * elements, double rowLower = -COIN_DBL_MAX,
+ double rowUpper = COIN_DBL_MAX);
+ /// Add rows
+ void addRows(int number, const double * rowLower,
+ const double * rowUpper,
+ const CoinBigIndex * rowStarts, const int * columns,
+ const double * elements);
+ /// Add rows
+ void addRows(int number, const double * rowLower,
+ const double * rowUpper,
+ const CoinBigIndex * rowStarts, const int * rowLengths,
+ const int * columns,
+ const double * elements);
+#ifndef CLP_NO_VECTOR
+ void addRows(int number, const double * rowLower,
+ const double * rowUpper,
+ const CoinPackedVectorBase * const * rows);
+#endif
+ /** Add rows from a build object.
+ If tryPlusMinusOne then will try adding as +-1 matrix
+ if no matrix exists.
+ Returns number of errors e.g. duplicates
+ */
+ int addRows(const CoinBuild & buildObject, bool tryPlusMinusOne = false,
+ bool checkDuplicates = true);
+ /** Add rows from a model object. returns
+ -1 if object in bad state (i.e. has column information)
+ otherwise number of errors.
+
+ modelObject non const as can be regularized as part of build
+ If tryPlusMinusOne then will try adding as +-1 matrix
+ if no matrix exists.
+ */
+ int addRows(CoinModel & modelObject, bool tryPlusMinusOne = false,
+ bool checkDuplicates = true);
+
+ /// Deletes columns
+ void deleteColumns(int number, const int * which);
+ /// Deletes rows AND columns (keeps old sizes)
+ void deleteRowsAndColumns(int numberRows, const int * whichRows,
+ int numberColumns, const int * whichColumns);
+ /// Add one column
+ void addColumn(int numberInColumn,
+ const int * rows,
+ const double * elements,
+ double columnLower = 0.0,
+ double columnUpper = COIN_DBL_MAX,
+ double objective = 0.0);
+ /// Add columns
+ void addColumns(int number, const double * columnLower,
+ const double * columnUpper,
+ const double * objective,
+ const CoinBigIndex * columnStarts, const int * rows,
+ const double * elements);
+ void addColumns(int number, const double * columnLower,
+ const double * columnUpper,
+ const double * objective,
+ const CoinBigIndex * columnStarts, const int * columnLengths,
+ const int * rows,
+ const double * elements);
+#ifndef CLP_NO_VECTOR
+ void addColumns(int number, const double * columnLower,
+ const double * columnUpper,
+ const double * objective,
+ const CoinPackedVectorBase * const * columns);
+#endif
+ /** Add columns from a build object
+ If tryPlusMinusOne then will try adding as +-1 matrix
+ if no matrix exists.
+ Returns number of errors e.g. duplicates
+ */
+ int addColumns(const CoinBuild & buildObject, bool tryPlusMinusOne = false,
+ bool checkDuplicates = true);
+ /** Add columns from a model object. returns
+ -1 if object in bad state (i.e. has row information)
+ otherwise number of errors
+ modelObject non const as can be regularized as part of build
+ If tryPlusMinusOne then will try adding as +-1 matrix
+ if no matrix exists.
+ */
+ int addColumns(CoinModel & modelObject, bool tryPlusMinusOne = false,
+ bool checkDuplicates = true);
+ /// Modify one element of a matrix
+ inline void modifyCoefficient(int row, int column, double newElement,
+ bool keepZero = false) {
+ matrix_->modifyCoefficient(row, column, newElement, keepZero);
+ }
+ /** Change row lower bounds */
+ void chgRowLower(const double * rowLower);
+ /** Change row upper bounds */
+ void chgRowUpper(const double * rowUpper);
+ /** Change column lower bounds */
+ void chgColumnLower(const double * columnLower);
+ /** Change column upper bounds */
+ void chgColumnUpper(const double * columnUpper);
+ /** Change objective coefficients */
+ void chgObjCoefficients(const double * objIn);
+ /** Borrow model. This is so we don't have to copy large amounts
+ of data around. It assumes a derived class wants to overwrite
+ an empty model with a real one - while it does an algorithm */
+ void borrowModel(ClpModel & otherModel);
+ /** Return model - nulls all arrays so can be deleted safely
+ also updates any scalars */
+ void returnModel(ClpModel & otherModel);
+
+ /// Create empty ClpPackedMatrix
+ void createEmptyMatrix();
+ /** Really clean up matrix (if ClpPackedMatrix).
+ a) eliminate all duplicate AND small elements in matrix
+ b) remove all gaps and set extraGap_ and extraMajor_ to 0.0
+ c) reallocate arrays and make max lengths equal to lengths
+ d) orders elements
+ returns number of elements eliminated or -1 if not ClpPackedMatrix
+ */
+ int cleanMatrix(double threshold = 1.0e-20);
+ /// Copy contents - resizing if necessary - otherwise re-use memory
+ void copy(const ClpMatrixBase * from, ClpMatrixBase * & to);
+#ifndef CLP_NO_STD
+ /// Drops names - makes lengthnames 0 and names empty
+ void dropNames();
+ /// Copies in names
+ void copyNames(const std::vector & rowNames,
+ const std::vector & columnNames);
+ /// Copies in Row names - modifies names first .. last-1
+ void copyRowNames(const std::vector & rowNames, int first, int last);
+ /// Copies in Column names - modifies names first .. last-1
+ void copyColumnNames(const std::vector & columnNames, int first, int last);
+ /// Copies in Row names - modifies names first .. last-1
+ void copyRowNames(const char * const * rowNames, int first, int last);
+ /// Copies in Column names - modifies names first .. last-1
+ void copyColumnNames(const char * const * columnNames, int first, int last);
+ /// Set name of row
+ void setRowName(int rowIndex, std::string & name) ;
+ /// Set name of col
+ void setColumnName(int colIndex, std::string & name) ;
+#endif
+ /** Find a network subset.
+ rotate array should be numberRows. On output
+ -1 not in network
+ 0 in network as is
+ 1 in network with signs swapped
+ Returns number of network rows
+ */
+ int findNetwork(char * rotate, double fractionNeeded = 0.75);
+ /** This creates a coinModel object
+ */
+ CoinModel * createCoinModel() const;
+
+ /** Write the problem in MPS format to the specified file.
+
+ Row and column names may be null.
+ formatType is
+
+ - 0 - normal
+
- 1 - extra accuracy
+
- 2 - IEEE hex
+
+
+ Returns non-zero on I/O error
+ */
+ int writeMps(const char *filename,
+ int formatType = 0, int numberAcross = 2,
+ double objSense = 0.0) const ;
+ //@}
+ /**@name gets and sets */
+ //@{
+ /// Number of rows
+ inline int numberRows() const {
+ return numberRows_;
+ }
+ inline int getNumRows() const {
+ return numberRows_;
+ }
+ /// Number of columns
+ inline int getNumCols() const {
+ return numberColumns_;
+ }
+ inline int numberColumns() const {
+ return numberColumns_;
+ }
+ /// Primal tolerance to use
+ inline double primalTolerance() const {
+ return dblParam_[ClpPrimalTolerance];
+ }
+ void setPrimalTolerance( double value) ;
+ /// Dual tolerance to use
+ inline double dualTolerance() const {
+ return dblParam_[ClpDualTolerance];
+ }
+ void setDualTolerance( double value) ;
+ /// Primal objective limit
+ inline double primalObjectiveLimit() const {
+ return dblParam_[ClpPrimalObjectiveLimit];
+ }
+ void setPrimalObjectiveLimit(double value);
+ /// Dual objective limit
+ inline double dualObjectiveLimit() const {
+ return dblParam_[ClpDualObjectiveLimit];
+ }
+ void setDualObjectiveLimit(double value);
+ /// Objective offset
+ inline double objectiveOffset() const {
+ return dblParam_[ClpObjOffset];
+ }
+ void setObjectiveOffset(double value);
+ /// Presolve tolerance to use
+ inline double presolveTolerance() const {
+ return dblParam_[ClpPresolveTolerance];
+ }
+#ifndef CLP_NO_STD
+ inline const std::string & problemName() const {
+ return strParam_[ClpProbName];
+ }
+#endif
+ /// Number of iterations
+ inline int numberIterations() const {
+ return numberIterations_;
+ }
+ inline int getIterationCount() const {
+ return numberIterations_;
+ }
+ inline void setNumberIterations(int numberIterationsNew) {
+ numberIterations_ = numberIterationsNew;
+ }
+ /** Solve type - 1 simplex, 2 simplex interface, 3 Interior.*/
+ inline int solveType() const {
+ return solveType_;
+ }
+ inline void setSolveType(int type) {
+ solveType_ = type;
+ }
+ /// Maximum number of iterations
+ inline int maximumIterations() const {
+ return intParam_[ClpMaxNumIteration];
+ }
+ void setMaximumIterations(int value);
+ /// Maximum time in seconds (from when set called)
+ inline double maximumSeconds() const {
+ return dblParam_[ClpMaxSeconds];
+ }
+ void setMaximumSeconds(double value);
+ void setMaximumWallSeconds(double value);
+ /// Returns true if hit maximum iterations (or time)
+ bool hitMaximumIterations() const;
+ /** Status of problem:
+ -1 - unknown e.g. before solve or if postSolve says not optimal
+ 0 - optimal
+ 1 - primal infeasible
+ 2 - dual infeasible
+ 3 - stopped on iterations or time
+ 4 - stopped due to errors
+ 5 - stopped by event handler (virtual int ClpEventHandler::event())
+ */
+ inline int status() const {
+ return problemStatus_;
+ }
+ inline int problemStatus() const {
+ return problemStatus_;
+ }
+ /// Set problem status
+ inline void setProblemStatus(int problemStatusNew) {
+ problemStatus_ = problemStatusNew;
+ }
+ /** Secondary status of problem - may get extended
+ 0 - none
+ 1 - primal infeasible because dual limit reached OR (probably primal
+ infeasible but can't prove it - main status was 4)
+ 2 - scaled problem optimal - unscaled problem has primal infeasibilities
+ 3 - scaled problem optimal - unscaled problem has dual infeasibilities
+ 4 - scaled problem optimal - unscaled problem has primal and dual infeasibilities
+ 5 - giving up in primal with flagged variables
+ 6 - failed due to empty problem check
+ 7 - postSolve says not optimal
+ 8 - failed due to bad element check
+ 9 - status was 3 and stopped on time
+ 10 - status was 3 but stopped as primal feasible
+ 100 up - translation of enum from ClpEventHandler
+ */
+ inline int secondaryStatus() const {
+ return secondaryStatus_;
+ }
+ inline void setSecondaryStatus(int newstatus) {
+ secondaryStatus_ = newstatus;
+ }
+ /// Are there a numerical difficulties?
+ inline bool isAbandoned() const {
+ return problemStatus_ == 4;
+ }
+ /// Is optimality proven?
+ inline bool isProvenOptimal() const {
+ return problemStatus_ == 0;
+ }
+ /// Is primal infeasiblity proven?
+ inline bool isProvenPrimalInfeasible() const {
+ return problemStatus_ == 1;
+ }
+ /// Is dual infeasiblity proven?
+ inline bool isProvenDualInfeasible() const {
+ return problemStatus_ == 2;
+ }
+ /// Is the given primal objective limit reached?
+ bool isPrimalObjectiveLimitReached() const ;
+ /// Is the given dual objective limit reached?
+ bool isDualObjectiveLimitReached() const ;
+ /// Iteration limit reached?
+ inline bool isIterationLimitReached() const {
+ return problemStatus_ == 3;
+ }
+ /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
+ inline double optimizationDirection() const {
+ return optimizationDirection_;
+ }
+ inline double getObjSense() const {
+ return optimizationDirection_;
+ }
+ void setOptimizationDirection(double value);
+ /// Primal row solution
+ inline double * primalRowSolution() const {
+ return rowActivity_;
+ }
+ inline const double * getRowActivity() const {
+ return rowActivity_;
+ }
+ /// Primal column solution
+ inline double * primalColumnSolution() const {
+ return columnActivity_;
+ }
+ inline const double * getColSolution() const {
+ return columnActivity_;
+ }
+ inline void setColSolution(const double * input) {
+ memcpy(columnActivity_, input, numberColumns_ * sizeof(double));
+ }
+ /// Dual row solution
+ inline double * dualRowSolution() const {
+ return dual_;
+ }
+ inline const double * getRowPrice() const {
+ return dual_;
+ }
+ /// Reduced costs
+ inline double * dualColumnSolution() const {
+ return reducedCost_;
+ }
+ inline const double * getReducedCost() const {
+ return reducedCost_;
+ }
+ /// Row lower
+ inline double* rowLower() const {
+ return rowLower_;
+ }
+ inline const double* getRowLower() const {
+ return rowLower_;
+ }
+ /// Row upper
+ inline double* rowUpper() const {
+ return rowUpper_;
+ }
+ inline const double* getRowUpper() const {
+ return rowUpper_;
+ }
+ //-------------------------------------------------------------------------
+ /**@name Changing bounds on variables and constraints */
+ //@{
+ /** Set an objective function coefficient */
+ void setObjectiveCoefficient( int elementIndex, double elementValue );
+ /** Set an objective function coefficient */
+ inline void setObjCoeff( int elementIndex, double elementValue ) {
+ setObjectiveCoefficient( elementIndex, elementValue);
+ }
+
+ /** Set a single column lower bound
+ Use -DBL_MAX for -infinity. */
+ void setColumnLower( int elementIndex, double elementValue );
+
+ /** Set a single column upper bound
+ Use DBL_MAX for infinity. */
+ void setColumnUpper( int elementIndex, double elementValue );
+
+ /** Set a single column lower and upper bound */
+ void setColumnBounds( int elementIndex,
+ double lower, double upper );
+
+ /** Set the bounds on a number of columns simultaneously
+ The default implementation just invokes setColLower() and
+ setColUpper() over and over again.
+ @param indexFirst,indexLast pointers to the beginning and after the
+ end of the array of the indices of the variables whose
+ either bound changes
+ @param boundList the new lower/upper bound pairs for the variables
+ */
+ void setColumnSetBounds(const int* indexFirst,
+ const int* indexLast,
+ const double* boundList);
+
+ /** Set a single column lower bound
+ Use -DBL_MAX for -infinity. */
+ inline void setColLower( int elementIndex, double elementValue ) {
+ setColumnLower(elementIndex, elementValue);
+ }
+ /** Set a single column upper bound
+ Use DBL_MAX for infinity. */
+ inline void setColUpper( int elementIndex, double elementValue ) {
+ setColumnUpper(elementIndex, elementValue);
+ }
+
+ /** Set a single column lower and upper bound */
+ inline void setColBounds( int elementIndex,
+ double lower, double upper ) {
+ setColumnBounds(elementIndex, lower, upper);
+ }
+
+ /** Set the bounds on a number of columns simultaneously
+ @param indexFirst,indexLast pointers to the beginning and after the
+ end of the array of the indices of the variables whose
+ either bound changes
+ @param boundList the new lower/upper bound pairs for the variables
+ */
+ inline void setColSetBounds(const int* indexFirst,
+ const int* indexLast,
+ const double* boundList) {
+ setColumnSetBounds(indexFirst, indexLast, boundList);
+ }
+
+ /** Set a single row lower bound
+ Use -DBL_MAX for -infinity. */
+ void setRowLower( int elementIndex, double elementValue );
+
+ /** Set a single row upper bound
+ Use DBL_MAX for infinity. */
+ void setRowUpper( int elementIndex, double elementValue ) ;
+
+ /** Set a single row lower and upper bound */
+ void setRowBounds( int elementIndex,
+ double lower, double upper ) ;
+
+ /** Set the bounds on a number of rows simultaneously
+ @param indexFirst,indexLast pointers to the beginning and after the
+ end of the array of the indices of the constraints whose
+ either bound changes
+ @param boundList the new lower/upper bound pairs for the constraints
+ */
+ void setRowSetBounds(const int* indexFirst,
+ const int* indexLast,
+ const double* boundList);
+
+ //@}
+ /// Scaling
+ inline const double * rowScale() const {
+ return rowScale_;
+ }
+ inline const double * columnScale() const {
+ return columnScale_;
+ }
+ inline const double * inverseRowScale() const {
+ return inverseRowScale_;
+ }
+ inline const double * inverseColumnScale() const {
+ return inverseColumnScale_;
+ }
+ inline double * mutableRowScale() const {
+ return rowScale_;
+ }
+ inline double * mutableColumnScale() const {
+ return columnScale_;
+ }
+ inline double * mutableInverseRowScale() const {
+ return inverseRowScale_;
+ }
+ inline double * mutableInverseColumnScale() const {
+ return inverseColumnScale_;
+ }
+ inline double * swapRowScale(double * newScale) {
+ double * oldScale = rowScale_;
+ rowScale_ = newScale;
+ return oldScale;
+ }
+ void setRowScale(double * scale) ;
+ void setColumnScale(double * scale);
+ /// Scaling of objective
+ inline double objectiveScale() const {
+ return objectiveScale_;
+ }
+ inline void setObjectiveScale(double value) {
+ objectiveScale_ = value;
+ }
+ /// Scaling of rhs and bounds
+ inline double rhsScale() const {
+ return rhsScale_;
+ }
+ inline void setRhsScale(double value) {
+ rhsScale_ = value;
+ }
+ /// Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3 auto, 4 auto-but-as-initialSolve-in-bab
+ void scaling(int mode = 1);
+ /** If we constructed a "really" scaled model then this reverses the operation.
+ Quantities may not be exactly as they were before due to rounding errors */
+ void unscale();
+ /// Gets scalingFlag
+ inline int scalingFlag() const {
+ return scalingFlag_;
+ }
+ /// Objective
+ inline double * objective() const {
+ if (objective_) {
+ double offset;
+ return objective_->gradient(NULL, NULL, offset, false);
+ } else {
+ return NULL;
+ }
+ }
+ inline double * objective(const double * solution, double & offset, bool refresh = true) const {
+ offset = 0.0;
+ if (objective_) {
+ return objective_->gradient(NULL, solution, offset, refresh);
+ } else {
+ return NULL;
+ }
+ }
+ inline const double * getObjCoefficients() const {
+ if (objective_) {
+ double offset;
+ return objective_->gradient(NULL, NULL, offset, false);
+ } else {
+ return NULL;
+ }
+ }
+ /// Row Objective
+ inline double * rowObjective() const {
+ return rowObjective_;
+ }
+ inline const double * getRowObjCoefficients() const {
+ return rowObjective_;
+ }
+ /// Column Lower
+ inline double * columnLower() const {
+ return columnLower_;
+ }
+ inline const double * getColLower() const {
+ return columnLower_;
+ }
+ /// Column Upper
+ inline double * columnUpper() const {
+ return columnUpper_;
+ }
+ inline const double * getColUpper() const {
+ return columnUpper_;
+ }
+ /// Matrix (if not ClpPackedmatrix be careful about memory leak
+ inline CoinPackedMatrix * matrix() const {
+ if ( matrix_ == NULL ) return NULL;
+ else return matrix_->getPackedMatrix();
+ }
+ /// Number of elements in matrix
+ inline int getNumElements() const {
+ return matrix_->getNumElements();
+ }
+ /** Small element value - elements less than this set to zero,
+ default is 1.0e-20 */
+ inline double getSmallElementValue() const {
+ return smallElement_;
+ }
+ inline void setSmallElementValue(double value) {
+ smallElement_ = value;
+ }
+ /// Row Matrix
+ inline ClpMatrixBase * rowCopy() const {
+ return rowCopy_;
+ }
+ /// Set new row matrix
+ void setNewRowCopy(ClpMatrixBase * newCopy);
+ /// Clp Matrix
+ inline ClpMatrixBase * clpMatrix() const {
+ return matrix_;
+ }
+ /// Scaled ClpPackedMatrix
+ inline ClpPackedMatrix * clpScaledMatrix() const {
+ return scaledMatrix_;
+ }
+ /// Sets pointer to scaled ClpPackedMatrix
+ inline void setClpScaledMatrix(ClpPackedMatrix * scaledMatrix) {
+ delete scaledMatrix_;
+ scaledMatrix_ = scaledMatrix;
+ }
+ /// Swaps pointer to scaled ClpPackedMatrix
+ inline ClpPackedMatrix * swapScaledMatrix(ClpPackedMatrix * scaledMatrix) {
+ ClpPackedMatrix * oldMatrix = scaledMatrix_;
+ scaledMatrix_ = scaledMatrix;
+ return oldMatrix;
+ }
+ /** Replace Clp Matrix (current is not deleted unless told to
+ and new is used)
+ So up to user to delete current. This was used where
+ matrices were being rotated. ClpModel takes ownership.
+ */
+ void replaceMatrix(ClpMatrixBase * matrix, bool deleteCurrent = false);
+ /** Replace Clp Matrix (current is not deleted unless told to
+ and new is used) So up to user to delete current. This was used where
+ matrices were being rotated. This version changes CoinPackedMatrix
+ to ClpPackedMatrix. ClpModel takes ownership.
+ */
+ inline void replaceMatrix(CoinPackedMatrix * newmatrix,
+ bool deleteCurrent = false) {
+ replaceMatrix(new ClpPackedMatrix(newmatrix), deleteCurrent);
+ }
+ /// Objective value
+ inline double objectiveValue() const {
+ return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
+ }
+ inline void setObjectiveValue(double value) {
+ objectiveValue_ = (value + dblParam_[ClpObjOffset]) / optimizationDirection_;
+ }
+ inline double getObjValue() const {
+ return objectiveValue_ * optimizationDirection_ - dblParam_[ClpObjOffset];
+ }
+ /// Integer information
+ inline char * integerInformation() const {
+ return integerType_;
+ }
+ /** Infeasibility/unbounded ray (NULL returned if none/wrong)
+ Up to user to use delete [] on these arrays. */
+ double * infeasibilityRay(bool fullRay=false) const;
+ double * unboundedRay() const;
+ /// For advanced users - no need to delete - sign not changed
+ inline double * ray() const
+ { return ray_;}
+ /// just test if infeasibility or unbounded Ray exists
+ inline bool rayExists() const {
+ return (ray_!=NULL);
+ }
+ /// just delete ray if exists
+ inline void deleteRay() {
+ delete [] ray_;
+ ray_=NULL;
+ }
+ /// Access internal ray storage. Users should call infeasibilityRay() or unboundedRay() instead.
+ inline const double * internalRay() const {
+ return ray_;
+ }
+ /// See if status (i.e. basis) array exists (partly for OsiClp)
+ inline bool statusExists() const {
+ return (status_ != NULL);
+ }
+ /// Return address of status (i.e. basis) array (char[numberRows+numberColumns])
+ inline unsigned char * statusArray() const {
+ return status_;
+ }
+ /** Return copy of status (i.e. basis) array (char[numberRows+numberColumns]),
+ use delete [] */
+ unsigned char * statusCopy() const;
+ /// Copy in status (basis) vector
+ void copyinStatus(const unsigned char * statusArray);
+
+ /// User pointer for whatever reason
+ inline void setUserPointer (void * pointer) {
+ userPointer_ = pointer;
+ }
+ inline void * getUserPointer () const {
+ return userPointer_;
+ }
+ /// Trusted user pointer
+ inline void setTrustedUserPointer (ClpTrustedData * pointer) {
+ trustedUserPointer_ = pointer;
+ }
+ inline ClpTrustedData * getTrustedUserPointer () const {
+ return trustedUserPointer_;
+ }
+ /// What has changed in model (only for masochistic users)
+ inline int whatsChanged() const {
+ return whatsChanged_;
+ }
+ inline void setWhatsChanged(int value) {
+ whatsChanged_ = value;
+ }
+ /// Number of threads (not really being used)
+ inline int numberThreads() const {
+ return numberThreads_;
+ }
+ inline void setNumberThreads(int value) {
+ numberThreads_ = value;
+ }
+ //@}
+ /**@name Message handling */
+ //@{
+ /// Pass in Message handler (not deleted at end)
+ void passInMessageHandler(CoinMessageHandler * handler);
+ /// Pass in Message handler (not deleted at end) and return current
+ CoinMessageHandler * pushMessageHandler(CoinMessageHandler * handler,
+ bool & oldDefault);
+ /// back to previous message handler
+ void popMessageHandler(CoinMessageHandler * oldHandler, bool oldDefault);
+ /// Set language
+ void newLanguage(CoinMessages::Language language);
+ inline void setLanguage(CoinMessages::Language language) {
+ newLanguage(language);
+ }
+ /// Overrides message handler with a default one
+ void setDefaultMessageHandler();
+ /// Return handler
+ inline CoinMessageHandler * messageHandler() const {
+ return handler_;
+ }
+ /// Return messages
+ inline CoinMessages messages() const {
+ return messages_;
+ }
+ /// Return pointer to messages
+ inline CoinMessages * messagesPointer() {
+ return & messages_;
+ }
+ /// Return Coin messages
+ inline CoinMessages coinMessages() const {
+ return coinMessages_;
+ }
+ /// Return pointer to Coin messages
+ inline CoinMessages * coinMessagesPointer() {
+ return & coinMessages_;
+ }
+ /** Amount of print out:
+ 0 - none
+ 1 - just final
+ 2 - just factorizations
+ 3 - as 2 plus a bit more
+ 4 - verbose
+ above that 8,16,32 etc just for selective debug
+ */
+ inline void setLogLevel(int value) {
+ handler_->setLogLevel(value);
+ }
+ inline int logLevel() const {
+ return handler_->logLevel();
+ }
+ /// Return true if default handler
+ inline bool defaultHandler() const {
+ return defaultHandler_;
+ }
+ /// Pass in Event handler (cloned and deleted at end)
+ void passInEventHandler(const ClpEventHandler * eventHandler);
+ /// Event handler
+ inline ClpEventHandler * eventHandler() const {
+ return eventHandler_;
+ }
+ /// Thread specific random number generator
+ inline CoinThreadRandom * randomNumberGenerator() {
+ return &randomNumberGenerator_;
+ }
+ /// Thread specific random number generator
+ inline CoinThreadRandom & mutableRandomNumberGenerator() {
+ return randomNumberGenerator_;
+ }
+ /// Set seed for thread specific random number generator
+ inline void setRandomSeed(int value) {
+ randomNumberGenerator_.setSeed(value);
+ }
+ /// length of names (0 means no names0
+ inline int lengthNames() const {
+ return lengthNames_;
+ }
+#ifndef CLP_NO_STD
+ /// length of names (0 means no names0
+ inline void setLengthNames(int value) {
+ lengthNames_ = value;
+ }
+ /// Row names
+ inline const std::vector * rowNames() const {
+ return &rowNames_;
+ }
+ inline const std::string& rowName(int iRow) const {
+ return rowNames_[iRow];
+ }
+ /// Return name or Rnnnnnnn
+ std::string getRowName(int iRow) const;
+ /// Column names
+ inline const std::vector * columnNames() const {
+ return &columnNames_;
+ }
+ inline const std::string& columnName(int iColumn) const {
+ return columnNames_[iColumn];
+ }
+ /// Return name or Cnnnnnnn
+ std::string getColumnName(int iColumn) const;
+#endif
+ /// Objective methods
+ inline ClpObjective * objectiveAsObject() const {
+ return objective_;
+ }
+ void setObjective(ClpObjective * objective);
+ inline void setObjectivePointer(ClpObjective * newobjective) {
+ objective_ = newobjective;
+ }
+ /** Solve a problem with no elements - return status and
+ dual and primal infeasibilites */
+ int emptyProblem(int * infeasNumber = NULL, double * infeasSum = NULL, bool printMessage = true);
+
+ //@}
+
+ /**@name Matrix times vector methods
+ They can be faster if scalar is +- 1
+ These are covers so user need not worry about scaling
+ Also for simplex I am not using basic/non-basic split */
+ //@{
+ /** Return y + A * x * scalar in y.
+ @pre x must be of size numColumns()
+ @pre y must be of size numRows() */
+ void times(double scalar,
+ const double * x, double * y) const;
+ /** Return y + x * scalar * A in y.
+ @pre x must be of size numRows()
+ @pre y must be of size numColumns() */
+ void transposeTimes(double scalar,
+ const double * x, double * y) const ;
+ //@}
+
+
+ //---------------------------------------------------------------------------
+ /**@name Parameter set/get methods
+
+ The set methods return true if the parameter was set to the given value,
+ false otherwise. There can be various reasons for failure: the given
+ parameter is not applicable for the solver (e.g., refactorization
+ frequency for the volume algorithm), the parameter is not yet implemented
+ for the solver or simply the value of the parameter is out of the range
+ the solver accepts. If a parameter setting call returns false check the
+ details of your solver.
+
+ The get methods return true if the given parameter is applicable for the
+ solver and is implemented. In this case the value of the parameter is
+ returned in the second argument. Otherwise they return false.
+
+ ** once it has been decided where solver sits this may be redone
+ */
+ //@{
+ /// Set an integer parameter
+ bool setIntParam(ClpIntParam key, int value) ;
+ /// Set an double parameter
+ bool setDblParam(ClpDblParam key, double value) ;
+#ifndef CLP_NO_STD
+ /// Set an string parameter
+ bool setStrParam(ClpStrParam key, const std::string & value);
+#endif
+ // Get an integer parameter
+ inline bool getIntParam(ClpIntParam key, int& value) const {
+ if (key < ClpLastIntParam) {
+ value = intParam_[key];
+ return true;
+ } else {
+ return false;
+ }
+ }
+ // Get an double parameter
+ inline bool getDblParam(ClpDblParam key, double& value) const {
+ if (key < ClpLastDblParam) {
+ value = dblParam_[key];
+ return true;
+ } else {
+ return false;
+ }
+ }
+#ifndef CLP_NO_STD
+ // Get a string parameter
+ inline bool getStrParam(ClpStrParam key, std::string& value) const {
+ if (key < ClpLastStrParam) {
+ value = strParam_[key];
+ return true;
+ } else {
+ return false;
+ }
+ }
+#endif
+ /// Create C++ lines to get to current state
+ void generateCpp( FILE * fp);
+ /** For advanced options
+ 1 - Don't keep changing infeasibility weight
+ 2 - Keep nonLinearCost round solves
+ 4 - Force outgoing variables to exact bound (primal)
+ 8 - Safe to use dense initial factorization
+ 16 -Just use basic variables for operation if column generation
+ 32 -Create ray even in BAB
+ 64 -Treat problem as feasible until last minute (i.e. minimize infeasibilities)
+ 128 - Switch off all matrix sanity checks
+ 256 - No row copy
+ 512 - If not in values pass, solution guaranteed, skip as much as possible
+ 1024 - In branch and bound
+ 2048 - Don't bother to re-factorize if < 20 iterations
+ 4096 - Skip some optimality checks
+ 8192 - Do Primal when cleaning up primal
+ 16384 - In fast dual (so we can switch off things)
+ 32768 - called from Osi
+ 65536 - keep arrays around as much as possible (also use maximumR/C)
+ 131072 - transposeTimes is -1.0 and can skip basic and fixed
+ 262144 - extra copy of scaled matrix
+ 524288 - Clp fast dual
+ 1048576 - don't need to finish dual (can return 3)
+ 2097152 - zero costs!
+ 4194304 - don't scale integer variables
+ 8388608 - Idiot when not really sure about it
+ NOTE - many applications can call Clp but there may be some short cuts
+ which are taken which are not guaranteed safe from all applications.
+ Vetted applications will have a bit set and the code may test this
+ At present I expect a few such applications - if too many I will
+ have to re-think. It is up to application owner to change the code
+ if she/he needs these short cuts. I will not debug unless in Coin
+ repository. See COIN_CLP_VETTED comments.
+ 0x01000000 is Cbc (and in branch and bound)
+ 0x02000000 is in a different branch and bound
+ */
+ inline unsigned int specialOptions() const {
+ return specialOptions_;
+ }
+ void setSpecialOptions(unsigned int value);
+#define COIN_CBC_USING_CLP 0x01000000
+ inline bool inCbcBranchAndBound() const {
+ return (specialOptions_ & COIN_CBC_USING_CLP) != 0;
+ }
+ //@}
+
+ /**@name private or protected methods */
+ //@{
+protected:
+ /// Does most of deletion (0 = all, 1 = most)
+ void gutsOfDelete(int type);
+ /** Does most of copying
+ If trueCopy 0 then just points to arrays
+ If -1 leaves as much as possible */
+ void gutsOfCopy(const ClpModel & rhs, int trueCopy = 1);
+ /// gets lower and upper bounds on rows
+ void getRowBound(int iRow, double& lower, double& upper) const;
+ /// puts in format I like - 4 array matrix - may make row copy
+ void gutsOfLoadModel ( int numberRows, int numberColumns,
+ const double* collb, const double* colub,
+ const double* obj,
+ const double* rowlb, const double* rowub,
+ const double * rowObjective = NULL);
+ /// Does much of scaling
+ void gutsOfScaling();
+ /// Objective value - always minimize
+ inline double rawObjectiveValue() const {
+ return objectiveValue_;
+ }
+ /// If we are using maximumRows_ and Columns_
+ inline bool permanentArrays() const {
+ return (specialOptions_ & 65536) != 0;
+ }
+ /// Start using maximumRows_ and Columns_
+ void startPermanentArrays();
+ /// Stop using maximumRows_ and Columns_
+ void stopPermanentArrays();
+ /// Create row names as char **
+ const char * const * rowNamesAsChar() const;
+ /// Create column names as char **
+ const char * const * columnNamesAsChar() const;
+ /// Delete char * version of names
+ void deleteNamesAsChar(const char * const * names, int number) const;
+ /// On stopped - sets secondary status
+ void onStopped();
+ //@}
+
+
+////////////////// data //////////////////
+protected:
+
+ /**@name data */
+ //@{
+ /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore
+ double optimizationDirection_;
+ /// Array of double parameters
+ double dblParam_[ClpLastDblParam];
+ /// Objective value
+ double objectiveValue_;
+ /// Small element value
+ double smallElement_;
+ /// Scaling of objective
+ double objectiveScale_;
+ /// Scaling of rhs and bounds
+ double rhsScale_;
+ /// Number of rows
+ int numberRows_;
+ /// Number of columns
+ int numberColumns_;
+ /// Row activities
+ double * rowActivity_;
+ /// Column activities
+ double * columnActivity_;
+ /// Duals
+ double * dual_;
+ /// Reduced costs
+ double * reducedCost_;
+ /// Row lower
+ double* rowLower_;
+ /// Row upper
+ double* rowUpper_;
+ /// Objective
+ ClpObjective * objective_;
+ /// Row Objective (? sign) - may be NULL
+ double * rowObjective_;
+ /// Column Lower
+ double * columnLower_;
+ /// Column Upper
+ double * columnUpper_;
+ /// Packed matrix
+ ClpMatrixBase * matrix_;
+ /// Row copy if wanted
+ ClpMatrixBase * rowCopy_;
+ /// Scaled packed matrix
+ ClpPackedMatrix * scaledMatrix_;
+ /// Infeasible/unbounded ray
+ double * ray_;
+ /// Row scale factors for matrix
+ double * rowScale_;
+ /// Column scale factors
+ double * columnScale_;
+ /// Inverse row scale factors for matrix (end of rowScale_)
+ double * inverseRowScale_;
+ /// Inverse column scale factors for matrix (end of columnScale_)
+ double * inverseColumnScale_;
+ /** Scale flag, 0 none, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic,
+ 5 geometric on rows */
+ int scalingFlag_;
+ /** Status (i.e. basis) Region. I know that not all algorithms need a status
+ array, but it made sense for things like crossover and put
+ all permanent stuff in one place. No assumption is made
+ about what is in status array (although it might be good to reserve
+ bottom 3 bits (i.e. 0-7 numeric) for classic status). This
+ is number of columns + number of rows long (in that order).
+ */
+ unsigned char * status_;
+ /// Integer information
+ char * integerType_;
+ /// User pointer for whatever reason
+ void * userPointer_;
+ /// Trusted user pointer e.g. for heuristics
+ ClpTrustedData * trustedUserPointer_;
+ /// Array of integer parameters
+ int intParam_[ClpLastIntParam];
+ /// Number of iterations
+ int numberIterations_;
+ /** Solve type - 1 simplex, 2 simplex interface, 3 Interior.*/
+ int solveType_;
+ /** Whats changed since last solve. This is a work in progress
+ It is designed so careful people can make go faster.
+ It is only used when startFinishOptions used in dual or primal.
+ Bit 1 - number of rows/columns has not changed (so work arrays valid)
+ 2 - matrix has not changed
+ 4 - if matrix has changed only by adding rows
+ 8 - if matrix has changed only by adding columns
+ 16 - row lbs not changed
+ 32 - row ubs not changed
+ 64 - column objective not changed
+ 128 - column lbs not changed
+ 256 - column ubs not changed
+ 512 - basis not changed (up to user to set this to 0)
+ top bits may be used internally
+ shift by 65336 is 3 all same, 1 all except col bounds
+ */
+#define ROW_COLUMN_COUNTS_SAME 1
+#define MATRIX_SAME 2
+#define MATRIX_JUST_ROWS_ADDED 4
+#define MATRIX_JUST_COLUMNS_ADDED 8
+#define ROW_LOWER_SAME 16
+#define ROW_UPPER_SAME 32
+#define OBJECTIVE_SAME 64
+#define COLUMN_LOWER_SAME 128
+#define COLUMN_UPPER_SAME 256
+#define BASIS_SAME 512
+#define ALL_SAME 65339
+#define ALL_SAME_EXCEPT_COLUMN_BOUNDS 65337
+ unsigned int whatsChanged_;
+ /// Status of problem
+ int problemStatus_;
+ /// Secondary status of problem
+ int secondaryStatus_;
+ /// length of names (0 means no names)
+ int lengthNames_;
+ /// Number of threads (not very operational)
+ int numberThreads_;
+ /** For advanced options
+ See get and set for meaning
+ */
+ unsigned int specialOptions_;
+ /// Message handler
+ CoinMessageHandler * handler_;
+ /// Flag to say if default handler (so delete)
+ bool defaultHandler_;
+ /// Thread specific random number generator
+ CoinThreadRandom randomNumberGenerator_;
+ /// Event handler
+ ClpEventHandler * eventHandler_;
+#ifndef CLP_NO_STD
+ /// Row names
+ std::vector rowNames_;
+ /// Column names
+ std::vector columnNames_;
+#endif
+ /// Messages
+ CoinMessages messages_;
+ /// Coin messages
+ CoinMessages coinMessages_;
+ /// Maximum number of columns in model
+ int maximumColumns_;
+ /// Maximum number of rows in model
+ int maximumRows_;
+ /// Maximum number of columns (internal arrays) in model
+ int maximumInternalColumns_;
+ /// Maximum number of rows (internal arrays) in model
+ int maximumInternalRows_;
+ /// Base packed matrix
+ CoinPackedMatrix baseMatrix_;
+ /// Base row copy
+ CoinPackedMatrix baseRowCopy_;
+ /// Saved row scale factors for matrix
+ double * savedRowScale_;
+ /// Saved column scale factors
+ double * savedColumnScale_;
+#ifndef CLP_NO_STD
+ /// Array of string parameters
+ std::string strParam_[ClpLastStrParam];
+#endif
+ //@}
+};
+/** This is a tiny class where data can be saved round calls.
+ */
+class ClpDataSave {
+
+public:
+ /**@name Constructors and destructor
+ */
+ //@{
+ /// Default constructor
+ ClpDataSave ( );
+
+ /// Copy constructor.
+ ClpDataSave(const ClpDataSave &);
+ /// Assignment operator. This copies the data
+ ClpDataSave & operator=(const ClpDataSave & rhs);
+ /// Destructor
+ ~ClpDataSave ( );
+
+ //@}
+
+////////////////// data //////////////////
+public:
+
+ /**@name data - with same names as in other classes*/
+ //@{
+ double dualBound_;
+ double infeasibilityCost_;
+ double pivotTolerance_;
+ double zeroFactorizationTolerance_;
+ double zeroSimplexTolerance_;
+ double acceptablePivot_;
+ double objectiveScale_;
+ int sparseThreshold_;
+ int perturbation_;
+ int forceFactorization_;
+ int scalingFlag_;
+ unsigned int specialOptions_;
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpNetworkMatrix.hpp b/thirdparty/windows/include/coin/ClpNetworkMatrix.hpp
new file mode 100644
index 0000000..ec650a4
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpNetworkMatrix.hpp
@@ -0,0 +1,229 @@
+/* $Id: ClpNetworkMatrix.hpp 1665 2011-01-04 17:55:54Z lou $ */
+// Copyright (C) 2003, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpNetworkMatrix_H
+#define ClpNetworkMatrix_H
+
+
+#include "CoinPragma.hpp"
+
+#include "ClpMatrixBase.hpp"
+
+/** This implements a simple network matrix as derived from ClpMatrixBase.
+
+If you want more sophisticated version then you could inherit from this.
+Also you might want to allow networks with gain */
+
+class ClpNetworkMatrix : public ClpMatrixBase {
+
+public:
+ /**@name Useful methods */
+ //@{
+ /// Return a complete CoinPackedMatrix
+ virtual CoinPackedMatrix * getPackedMatrix() const;
+ /** Whether the packed matrix is column major ordered or not. */
+ virtual bool isColOrdered() const {
+ return true;
+ }
+ /** Number of entries in the packed matrix. */
+ virtual CoinBigIndex getNumElements() const {
+ return 2 * numberColumns_;
+ }
+ /** Number of columns. */
+ virtual int getNumCols() const {
+ return numberColumns_;
+ }
+ /** Number of rows. */
+ virtual int getNumRows() const {
+ return numberRows_;
+ }
+
+ /** A vector containing the elements in the packed matrix. Note that there
+ might be gaps in this list, entries that do not belong to any
+ major-dimension vector. To get the actual elements one should look at
+ this vector together with vectorStarts and vectorLengths. */
+ virtual const double * getElements() const;
+ /** A vector containing the minor indices of the elements in the packed
+ matrix. Note that there might be gaps in this list, entries that do not
+ belong to any major-dimension vector. To get the actual elements one
+ should look at this vector together with vectorStarts and
+ vectorLengths. */
+ virtual const int * getIndices() const {
+ return indices_;
+ }
+
+ virtual const CoinBigIndex * getVectorStarts() const;
+ /** The lengths of the major-dimension vectors. */
+ virtual const int * getVectorLengths() const;
+
+ /** Delete the columns whose indices are listed in indDel. */
+ virtual void deleteCols(const int numDel, const int * indDel);
+ /** Delete the rows whose indices are listed in indDel. */
+ virtual void deleteRows(const int numDel, const int * indDel);
+ /// Append Columns
+ virtual void appendCols(int number, const CoinPackedVectorBase * const * columns);
+ /// Append Rows
+ virtual void appendRows(int number, const CoinPackedVectorBase * const * rows);
+#ifndef SLIM_CLP
+ /** Append a set of rows/columns to the end of the matrix. Returns number of errors
+ i.e. if any of the new rows/columns contain an index that's larger than the
+ number of columns-1/rows-1 (if numberOther>0) or duplicates
+ If 0 then rows, 1 if columns */
+ virtual int appendMatrix(int number, int type,
+ const CoinBigIndex * starts, const int * index,
+ const double * element, int numberOther = -1);
+#endif
+ /** Returns a new matrix in reverse order without gaps */
+ virtual ClpMatrixBase * reverseOrderedCopy() const;
+ /// Returns number of elements in column part of basis
+ virtual CoinBigIndex countBasis(
+ const int * whichColumn,
+ int & numberColumnBasic);
+ /// Fills in column part of basis
+ virtual void fillBasis(ClpSimplex * model,
+ const int * whichColumn,
+ int & numberColumnBasic,
+ int * row, int * start,
+ int * rowCount, int * columnCount,
+ CoinFactorizationDouble * element);
+ /** Given positive integer weights for each row fills in sum of weights
+ for each column (and slack).
+ Returns weights vector
+ */
+ virtual CoinBigIndex * dubiousWeights(const ClpSimplex * model, int * inputWeights) const;
+ /** Returns largest and smallest elements of both signs.
+ Largest refers to largest absolute value.
+ */
+ virtual void rangeOfElements(double & smallestNegative, double & largestNegative,
+ double & smallestPositive, double & largestPositive);
+ /** Unpacks a column into an CoinIndexedvector
+ */
+ virtual void unpack(const ClpSimplex * model, CoinIndexedVector * rowArray,
+ int column) const ;
+ /** Unpacks a column into an CoinIndexedvector
+ ** in packed format
+ Note that model is NOT const. Bounds and objective could
+ be modified if doing column generation (just for this variable) */
+ virtual void unpackPacked(ClpSimplex * model,
+ CoinIndexedVector * rowArray,
+ int column) const;
+ /** Adds multiple of a column into an CoinIndexedvector
+ You can use quickAdd to add to vector */
+ virtual void add(const ClpSimplex * model, CoinIndexedVector * rowArray,
+ int column, double multiplier) const ;
+ /** Adds multiple of a column into an array */
+ virtual void add(const ClpSimplex * model, double * array,
+ int column, double multiplier) const;
+ /// Allow any parts of a created CoinMatrix to be deleted
+ virtual void releasePackedMatrix() const ;
+ /// Says whether it can do partial pricing
+ virtual bool canDoPartialPricing() const;
+ /// Partial pricing
+ virtual void partialPricing(ClpSimplex * model, double start, double end,
+ int & bestSequence, int & numberWanted);
+ //@}
+
+ /**@name Matrix times vector methods */
+ //@{
+ /** Return y + A * scalar *x in y.
+ @pre x must be of size numColumns()
+ @pre y must be of size numRows() */
+ virtual void times(double scalar,
+ const double * x, double * y) const;
+ /// And for scaling
+ virtual void times(double scalar,
+ const double * x, double * y,
+ const double * rowScale,
+ const double * columnScale) const;
+ /** Return y + x * scalar * A in y.
+ @pre x must be of size numRows()
+ @pre y must be of size numColumns() */
+ virtual void transposeTimes(double scalar,
+ const double * x, double * y) const;
+ /// And for scaling
+ virtual void transposeTimes(double scalar,
+ const double * x, double * y,
+ const double * rowScale,
+ const double * columnScale, double * spare = NULL) const;
+ /** Return x * scalar * A + y in z.
+ Can use y as temporary array (will be empty at end)
+ Note - If x packed mode - then z packed mode
+ Squashes small elements and knows about ClpSimplex */
+ virtual void transposeTimes(const ClpSimplex * model, double scalar,
+ const CoinIndexedVector * x,
+ CoinIndexedVector * y,
+ CoinIndexedVector * z) const;
+ /** Return x *A in z but
+ just for indices in y.
+ Note - z always packed mode */
+ virtual void subsetTransposeTimes(const ClpSimplex * model,
+ const CoinIndexedVector * x,
+ const CoinIndexedVector * y,
+ CoinIndexedVector * z) const;
+ //@}
+
+ /**@name Other */
+ //@{
+ /// Return true if really network, false if has slacks
+ inline bool trueNetwork() const {
+ return trueNetwork_;
+ }
+ //@}
+
+
+ /**@name Constructors, destructor */
+ //@{
+ /** Default constructor. */
+ ClpNetworkMatrix();
+ /** Constructor from two arrays */
+ ClpNetworkMatrix(int numberColumns, const int * head,
+ const int * tail);
+ /** Destructor */
+ virtual ~ClpNetworkMatrix();
+ //@}
+
+ /**@name Copy method */
+ //@{
+ /** The copy constructor. */
+ ClpNetworkMatrix(const ClpNetworkMatrix&);
+ /** The copy constructor from an CoinNetworkMatrix. */
+ ClpNetworkMatrix(const CoinPackedMatrix&);
+
+ ClpNetworkMatrix& operator=(const ClpNetworkMatrix&);
+ /// Clone
+ virtual ClpMatrixBase * clone() const ;
+ /** Subset constructor (without gaps). Duplicates are allowed
+ and order is as given */
+ ClpNetworkMatrix (const ClpNetworkMatrix & wholeModel,
+ int numberRows, const int * whichRows,
+ int numberColumns, const int * whichColumns);
+ /** Subset clone (without gaps). Duplicates are allowed
+ and order is as given */
+ virtual ClpMatrixBase * subsetClone (
+ int numberRows, const int * whichRows,
+ int numberColumns, const int * whichColumns) const ;
+ //@}
+
+
+protected:
+ /**@name Data members
+ The data members are protected to allow access for derived classes. */
+ //@{
+ /// For fake CoinPackedMatrix
+ mutable CoinPackedMatrix * matrix_;
+ mutable int * lengths_;
+ /// Data -1, then +1 rows in pairs (row==-1 if one entry)
+ int * indices_;
+ /// Number of rows
+ int numberRows_;
+ /// Number of columns
+ int numberColumns_;
+ /// True if all entries have two elements
+ bool trueNetwork_;
+
+ //@}
+};
+
+#endif
diff --git a/thirdparty/windows/include/coin/ClpNode.hpp b/thirdparty/windows/include/coin/ClpNode.hpp
new file mode 100644
index 0000000..671d62f
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpNode.hpp
@@ -0,0 +1,349 @@
+/* $Id: ClpNode.hpp 1910 2013-01-27 02:00:13Z stefan $ */
+// Copyright (C) 2008, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpNode_H
+#define ClpNode_H
+
+#include "CoinPragma.hpp"
+
+// This implements all stuff for Clp fathom
+/** This contains what is in a Clp "node"
+
+ */
+
+class ClpFactorization;
+class ClpDualRowSteepest;
+class ClpNodeStuff;
+class ClpNode {
+
+public:
+ /**@name Useful methods */
+ //@{
+ /** Applies node to model
+ 0 - just tree bounds
+ 1 - tree bounds and basis etc
+ 2 - saved bounds and basis etc
+ */
+ void applyNode(ClpSimplex * model, int doBoundsEtc );
+ /// Choose a new variable
+ void chooseVariable(ClpSimplex * model, ClpNodeStuff * info);
+ /// Fix on reduced costs
+ int fixOnReducedCosts(ClpSimplex * model);
+ /// Create odd arrays
+ void createArrays(ClpSimplex * model);
+ /// Clean up as crunch is different model
+ void cleanUpForCrunch();
+ //@}
+
+ /**@name Gets and sets */
+ //@{
+ /// Objective value
+ inline double objectiveValue() const {
+ return objectiveValue_;
+ }
+ /// Set objective value
+ inline void setObjectiveValue(double value) {
+ objectiveValue_ = value;
+ }
+ /// Primal solution
+ inline const double * primalSolution() const {
+ return primalSolution_;
+ }
+ /// Dual solution
+ inline const double * dualSolution() const {
+ return dualSolution_;
+ }
+ /// Initial value of integer variable
+ inline double branchingValue() const {
+ return branchingValue_;
+ }
+ /// Sum infeasibilities
+ inline double sumInfeasibilities() const {
+ return sumInfeasibilities_;
+ }
+ /// Number infeasibilities
+ inline int numberInfeasibilities() const {
+ return numberInfeasibilities_;
+ }
+ /// Relative depth
+ inline int depth() const {
+ return depth_;
+ }
+ /// Estimated solution value
+ inline double estimatedSolution() const {
+ return estimatedSolution_;
+ }
+ /** Way for integer variable -1 down , +1 up */
+ int way() const;
+ /// Return true if branch exhausted
+ bool fathomed() const;
+ /// Change state of variable i.e. go other way
+ void changeState();
+ /// Sequence number of integer variable (-1 if none)
+ inline int sequence() const {
+ return sequence_;
+ }
+ /// If odd arrays exist
+ inline bool oddArraysExist() const {
+ return lower_ != NULL;
+ }
+ /// Status array
+ inline const unsigned char * statusArray() const {
+ return status_;
+ }
+ //@}
+
+ /**@name Constructors, destructor */
+ //@{
+ /** Default constructor. */
+ ClpNode();
+ /// Constructor from model
+ ClpNode (ClpSimplex * model, const ClpNodeStuff * stuff, int depth);
+ /// Does work of constructor (partly so gdb will work)
+ void gutsOfConstructor(ClpSimplex * model, const ClpNodeStuff * stuff,
+ int arraysExist, int depth);
+ /** Destructor */
+ virtual ~ClpNode();
+ //@}
+
+ /**@name Copy methods (at present illegal - will abort) */
+ //@{
+ /** The copy constructor. */
+ ClpNode(const ClpNode&);
+ /// Operator =
+ ClpNode& operator=(const ClpNode&);
+ //@}
+
+protected:
+// For state of branch
+ typedef struct {
+ unsigned int firstBranch: 1; // nonzero if first branch on variable is up
+ unsigned int branch: 2; // 0 means do first branch next, 1 second, 2 finished
+ unsigned int spare: 29;
+ } branchState;
+ /**@name Data */
+ //@{
+ /// Initial value of integer variable
+ double branchingValue_;
+ /// Value of objective
+ double objectiveValue_;
+ /// Sum of infeasibilities
+ double sumInfeasibilities_;
+ /// Estimated solution value
+ double estimatedSolution_;
+ /// Factorization
+ ClpFactorization * factorization_;
+ /// Steepest edge weights
+ ClpDualRowSteepest * weights_;
+ /// Status vector
+ unsigned char * status_;
+ /// Primal solution
+ double * primalSolution_;
+ /// Dual solution
+ double * dualSolution_;
+ /// Integer lower bounds (only used in fathomMany)
+ int * lower_;
+ /// Integer upper bounds (only used in fathomMany)
+ int * upper_;
+ /// Pivot variables for factorization
+ int * pivotVariables_;
+ /// Variables fixed by reduced costs (at end of branch) 0x10000000 added if fixed to UB
+ int * fixed_;
+ /// State of branch
+ branchState branchState_;
+ /// Sequence number of integer variable (-1 if none)
+ int sequence_;
+ /// Number of infeasibilities
+ int numberInfeasibilities_;
+ /// Relative depth
+ int depth_;
+ /// Number fixed by reduced cost
+ int numberFixed_;
+ /// Flags - 1 duals scaled
+ int flags_;
+ /// Maximum number fixed by reduced cost
+ int maximumFixed_;
+ /// Maximum rows so far
+ int maximumRows_;
+ /// Maximum columns so far
+ int maximumColumns_;
+ /// Maximum Integers so far
+ int maximumIntegers_;
+ //@}
+};
+class ClpNodeStuff {
+
+public:
+ /**@name Constructors, destructor */
+ //@{
+ /** Default constructor. */
+ ClpNodeStuff();
+ /** Destructor */
+ virtual ~ClpNodeStuff();
+ //@}
+
+ /**@name Copy methods (only copies ints etc, nulls arrays) */
+ //@{
+ /** The copy constructor. */
+ ClpNodeStuff(const ClpNodeStuff&);
+ /// Operator =
+ ClpNodeStuff& operator=(const ClpNodeStuff&);
+ /// Zaps stuff 1 - arrays, 2 ints, 3 both
+ void zap(int type);
+ //@}
+
+
+ /**@name Fill methods */
+ //@{
+ /** Fill with pseudocosts */
+ void fillPseudoCosts(const double * down, const double * up,
+ const int * priority,
+ const int * numberDown, const int * numberUp,
+ const int * numberDownInfeasible, const int * numberUpInfeasible,
+ int number);
+ /// Update pseudo costs
+ void update(int way, int sequence, double change, bool feasible);
+ /// Return maximum number of nodes
+ int maximumNodes() const;
+ /// Return maximum space for nodes
+ int maximumSpace() const;
+ //@}
+
+public:
+ /**@name Data */
+ //@{
+ /// Integer tolerance
+ double integerTolerance_;
+ /// Integer increment
+ double integerIncrement_;
+ /// Small change in branch
+ double smallChange_;
+ /// Down pseudo costs
+ double * downPseudo_;
+ /// Up pseudo costs
+ double * upPseudo_;
+ /// Priority
+ int * priority_;
+ /// Number of times down
+ int * numberDown_;
+ /// Number of times up
+ int * numberUp_;
+ /// Number of times down infeasible
+ int * numberDownInfeasible_;
+ /// Number of times up infeasible
+ int * numberUpInfeasible_;
+ /// Copy of costs (local)
+ double * saveCosts_;
+ /// Array of ClpNodes
+ ClpNode ** nodeInfo_;
+ /// Large model if crunched
+ ClpSimplex * large_;
+ /// Which rows in large model
+ int * whichRow_;
+ /// Which columns in large model
+ int * whichColumn_;
+#ifndef NO_FATHOM_PRINT
+ /// Cbc's message handler
+ CoinMessageHandler * handler_;
+#endif
+ /// Number bounds in large model
+ int nBound_;
+ /// Save of specialOptions_ (local)
+ int saveOptions_;
+ /** Options to pass to solver
+ 1 - create external reduced costs for columns
+ 2 - create external reduced costs for rows
+ 4 - create external row activity (columns always done)
+ Above only done if feasible
+ 32 - just create up to nDepth_+1 nodes
+ 65536 - set if activated
+ */
+ int solverOptions_;
+ /// Maximum number of nodes to do
+ int maximumNodes_;
+ /// Number before trust from CbcModel
+ int numberBeforeTrust_;
+ /// State of search from CbcModel
+ int stateOfSearch_;
+ /// Number deep
+ int nDepth_;
+ /// Number nodes returned (-1 if fathom aborted)
+ int nNodes_;
+ /// Number of nodes explored
+ int numberNodesExplored_;
+ /// Number of iterations
+ int numberIterations_;
+ /// Type of presolve - 0 none, 1 crunch
+ int presolveType_;
+#ifndef NO_FATHOM_PRINT
+ /// Depth passed in
+ int startingDepth_;
+ /// Node at which called
+ int nodeCalled_;
+#endif
+ //@}
+};
+class ClpHashValue {
+
+public:
+ /**@name Useful methods */
+ //@{
+ /// Return index or -1 if not found
+ int index(double value) const;
+ /// Add value to list and return index
+ int addValue(double value) ;
+ /// Number of different entries
+ inline int numberEntries() const {
+ return numberHash_;
+ }
+ //@}
+
+ /**@name Constructors, destructor */
+ //@{
+ /** Default constructor. */
+ ClpHashValue();
+ /** Useful constructor. */
+ ClpHashValue(ClpSimplex * model);
+ /** Destructor */
+ virtual ~ClpHashValue();
+ //@}
+
+ /**@name Copy method */
+ //@{
+ /** The copy constructor. */
+ ClpHashValue(const ClpHashValue&);
+ /// =
+ ClpHashValue& operator=(const ClpHashValue&);
+ //@}
+private:
+ /**@name private stuff */
+ //@{
+ /** returns hash */
+ int hash(double value) const;
+ /// Resizes
+ void resize(bool increaseMax);
+ //@}
+
+protected:
+ /**@name Data members
+ The data members are protected to allow access for derived classes. */
+ //@{
+ /// Data
+ // for hashing
+ typedef struct {
+ double value;
+ int index, next;
+ } CoinHashLink;
+ /// Hash table
+ mutable CoinHashLink *hash_;
+ /// Number of entries in hash table
+ int numberHash_;
+ /// Maximum number of entries in hash table i.e. size
+ int maxHash_;
+ /// Last used space
+ int lastUsed_;
+ //@}
+};
+#endif
diff --git a/thirdparty/windows/include/coin/ClpNonLinearCost.hpp b/thirdparty/windows/include/coin/ClpNonLinearCost.hpp
new file mode 100644
index 0000000..1007865
--- /dev/null
+++ b/thirdparty/windows/include/coin/ClpNonLinearCost.hpp
@@ -0,0 +1,401 @@
+/* $Id: ClpNonLinearCost.hpp 1769 2011-07-26 09:31:51Z forrest $ */
+// Copyright (C) 2002, International Business Machines
+// Corporation and others. All Rights Reserved.
+// This code is licensed under the terms of the Eclipse Public License (EPL).
+
+#ifndef ClpNonLinearCost_H
+#define ClpNonLinearCost_H
+
+
+#include "CoinPragma.hpp"
+
+class ClpSimplex;
+class CoinIndexedVector;
+
+/** Trivial class to deal with non linear costs
+
+ I don't make any explicit assumptions about convexity but I am
+ sure I do make implicit ones.
+
+ One interesting idea for normal LP's will be to allow non-basic
+ variables to come into basis as infeasible i.e. if variable at
+ lower bound has very large positive reduced cost (when problem
+ is infeasible) could it reduce overall problem infeasibility more
+ by bringing it into basis below its lower bound.
+
+ Another feature would be to automatically discover when problems
+ are convex piecewise linear and re-formulate to use non-linear.
+ I did some work on this many years ago on "grade" problems, but
+ while it improved primal interior point algorithms were much better
+ for that particular problem.
+*/
+/* status has original status and current status
+ 0 - below lower so stored is upper
+ 1 - in range
+ 2 - above upper so stored is lower
+ 4 - (for current) - same as original
+*/
+#define CLP_BELOW_LOWER 0
+#define CLP_FEASIBLE 1
+#define CLP_ABOVE_UPPER 2
+#define CLP_SAME 4
+inline int originalStatus(unsigned char status)
+{
+ return (status & 15);
+}
+inline int currentStatus(unsigned char status)
+{
+ return (status >> 4);
+}
+inline void setOriginalStatus(unsigned char & status, int value)
+{
+ status = static_cast(status & ~15);
+ status = static_cast(status | value);
+}
+inline void setCurrentStatus(unsigned char &status, int value)
+{
+ status = static_cast(status & ~(15 << 4));
+ status = static_cast