diff options
| author | harpreet | 2016-07-01 00:11:55 +0530 |
|---|---|---|
| committer | harpreet | 2016-07-01 00:11:55 +0530 |
| commit | 89b96cb79cbe75ba8c1afea61b3caca37a083f62 (patch) | |
| tree | 1b879fb0dce2406c1c49bf5bdabcedfb12ff020c | |
| parent | 10e2e4d8b4a7592a8631ddac8e8d1664d6f0b9e3 (diff) | |
| download | FOSSEE-Optimization-toolbox-89b96cb79cbe75ba8c1afea61b3caca37a083f62.tar.gz FOSSEE-Optimization-toolbox-89b96cb79cbe75ba8c1afea61b3caca37a083f62.tar.bz2 FOSSEE-Optimization-toolbox-89b96cb79cbe75ba8c1afea61b3caca37a083f62.zip | |
Windows Included
341 files changed, 67832 insertions, 1915 deletions
diff --git a/builder.sce b/builder.sce index df239c6..e1f4760 100644 --- a/builder.sce +++ b/builder.sce @@ -23,10 +23,6 @@ if ~with_module("development_tools") then error(msprintf(gettext("%s module not installed."),"development_tools")); end // ==================================================================== -if getos()=="Windows" then - error(msprintf(gettext("Module is not availabe on Windows."))); -end -// ==================================================================== TOOLBOX_NAME = "FOSSEE_Optimization_Toolbox"; TOOLBOX_TITLE = "FOSSEE Optimization Toolbox"; // ==================================================================== diff --git a/demos/fmincon.dem.sce b/demos/fmincon.dem.sce index dc6aa39..d379a50 100644 --- a/demos/fmincon.dem.sce +++ b/demos/fmincon.dem.sce @@ -155,4 +155,5 @@ endfunction options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", fGrad, "Hessian", lHess,"GradCon", cGrad); //Calling Ipopt [x,fval,exitflag,output,lambda,grad,hessian] =fmincon(f, x0,A,b,Aeq,beq,lb,ub,nlc,options) +// Press ENTER to continue //========= E N D === O F === D E M O =========// diff --git a/demos/fminunc.dem.sce b/demos/fminunc.dem.sce index a43603e..c68aaeb 100644 --- a/demos/fminunc.dem.sce +++ b/demos/fminunc.dem.sce @@ -20,7 +20,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) // Press ENTER to continue @@ -57,7 +57,7 @@ function y= fHess(x) y= [-2,0;0,-2]; 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) //========= E N D === O F === D E M O =========// diff --git a/demos/linprog.dem.sce b/demos/linprog.dem.sce index 074cf61..074cf61 100755..100644 --- a/demos/linprog.dem.sce +++ b/demos/linprog.dem.sce diff --git a/demos/symphony.dem.sce b/demos/symphony.dem.sce index a0b629e..dbb755b 100644 --- a/demos/symphony.dem.sce +++ b/demos/symphony.dem.sce @@ -106,7 +106,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); //========= E N D === O F === D E M O =========// diff --git a/demos/symphonymat.dem.sce b/demos/symphonymat.dem.sce index 7bc751e..9b15b66 100644 --- a/demos/symphonymat.dem.sce +++ b/demos/symphonymat.dem.sce @@ -98,7 +98,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); //========= E N D === O F === D E M O =========// diff --git a/etc/FOSSEE_Optimization_Toolbox.quit b/etc/FOSSEE_Optimization_Toolbox.quit index 8e6aa18..5bc3b4c 100644 --- a/etc/FOSSEE_Optimization_Toolbox.quit +++ b/etc/FOSSEE_Optimization_Toolbox.quit @@ -27,10 +27,8 @@ function quitModule() if getscilabmode() == "STD" then removeModulePreferences(root_tlbx); end - + ulink(); endfunction - -quitModule(); clear quitModule; diff --git a/etc/FOSSEE_Optimization_Toolbox.start b/etc/FOSSEE_Optimization_Toolbox.start index d6dcfb1..5ab588a 100644 --- a/etc/FOSSEE_Optimization_Toolbox.start +++ b/etc/FOSSEE_Optimization_Toolbox.start @@ -11,11 +11,6 @@ mprintf("Start FOSSEE Optimization Toolbox\n"); -if ( isdef("sym_open") ) then - warning("Library is already loaded"); - return; -end - etc_tlbx = get_absolute_file_path("FOSSEE_Optimization_Toolbox.start"); etc_tlbx = getshortpathname(etc_tlbx); root_tlbx = strncpy( etc_tlbx, length(etc_tlbx)-length("\etc\") ); @@ -35,7 +30,9 @@ mprintf("\tLoad gateways\n"); Version = opt(2); ilib_verbose(0); if getos()=="Windows" then - error(msprintf(gettext("Module is not for Windows."))); + lib_path = root_tlbx + "/thirdparty/windows/lib/" + Version; + link(lib_path+filesep()+"IpOptFSS.dll"); + link(lib_path+filesep()+"IpOpt-vc10.dll"); else lib_path = root_tlbx + "/thirdparty/linux/lib/" + Version; link(lib_path + "/libCoinUtils.so"); @@ -47,15 +44,6 @@ else link(lib_path + "/libCgl.so"); link(lib_path + "/libSym.so"); link(lib_path + "/libOsiSym.so"); - try - link(lib_path + "/libcoinblas.so"); - catch - if(~isfile('/usr/lib/x86_64-linux-gnu/libstdc++.so.6') | ~isfile('/usr/lib/x86_64-linux-gnu/libgfortran.so.3')) then - errmsg = msprintf(gettext("%s: Please install gfortran"), "FOSSEE_Optimization_Toolbox"); - error(errmsg); - end - unix_s('export LD_PRELOAD=/usr/lib/x86_64-linux-gnu/libstdc++.so.6:/usr/lib/x86_64-linux-gnu/libgfortran.so.3') - end link(lib_path + "/libcoinblas.so"); link(lib_path + "/libcoinlapack.so"); link(lib_path + "/libcoinmumps.so"); @@ -91,6 +79,4 @@ end // ============================================================================= -clear root_tlbx; -clear etc_tlbx; - +clear etc_tlbx root_tlbx Version a opt lib_path; diff --git a/help/en_US/Symphony Native Function/CHAPTER~ b/help/en_US/Symphony Native Function/CHAPTER~ deleted file mode 100644 index a0a7f5d..0000000 --- a/help/en_US/Symphony Native Function/CHAPTER~ +++ /dev/null @@ -1 +0,0 @@ -title = API Functions
diff --git a/help/en_US/fminbnd.xml b/help/en_US/fminbnd.xml index 54f5abb..99d21ea 100644 --- a/help/en_US/fminbnd.xml +++ b/help/en_US/fminbnd.xml @@ -109,6 +109,7 @@ It has type "struct" and contains the following fields. <listitem>output.Cpu_Time: The total cpu-time spend during the search</listitem> <listitem>output.Objective_Evaluation: The number of Objective Evaluations performed during the search</listitem> <listitem>output.Dual_Infeasibility: The Dual Infeasiblity of the final soution</listitem> +<listitem>output.Message: The output message for the problem</listitem> </itemizedlist> </para> <para> diff --git a/help/en_US/fmincon.xml b/help/en_US/fmincon.xml index c4a70a7..a6bef9f 100644 --- a/help/en_US/fmincon.xml +++ b/help/en_US/fmincon.xml @@ -136,6 +136,7 @@ It has type "struct" and contains the following fields. <listitem>output.Cpu_Time: The total cpu-time spend during the search</listitem> <listitem>output.Objective_Evaluation: The number of Objective Evaluations performed during the search</listitem> <listitem>output.Dual_Infeasibility: The Dual Infeasiblity of the final soution</listitem> +<listitem>output.Message: The output message for the problem</listitem> </itemizedlist> </para> <para> @@ -325,6 +326,7 @@ endfunction options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", fGrad, "Hessian", lHess,"GradCon", cGrad); //Calling Ipopt [x,fval,exitflag,output,lambda,grad,hessian] =fmincon(f, x0,A,b,Aeq,beq,lb,ub,nlc,options) +// Press ENTER to continue ]]></programlisting> </refsection> diff --git a/help/en_US/fminimax.xml b/help/en_US/fminimax.xml index e733a3d..efe4812 100644 --- a/help/en_US/fminimax.xml +++ b/help/en_US/fminimax.xml @@ -30,11 +30,11 @@ 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(.....) </synopsis> </refsynopsisdiv> diff --git a/help/en_US/fminunc.xml b/help/en_US/fminunc.xml index fe12831..e5a46c3 100644 --- a/help/en_US/fminunc.xml +++ b/help/en_US/fminunc.xml @@ -110,6 +110,7 @@ It has type "struct" and contains the following fields. <listitem>output.Cpu_Time: The total cpu-time spend during the search</listitem> <listitem>output.Objective_Evaluation: The number of Objective Evaluations performed during the search</listitem> <listitem>output.Dual_Infeasibility: The Dual Infeasiblity of the final soution</listitem> +<listitem>output.Message: The output message for the problem</listitem> </itemizedlist> </para> <para> diff --git a/help/en_US/linprog.xml b/help/en_US/linprog.xml index c293b7e..c293b7e 100755..100644 --- a/help/en_US/linprog.xml +++ b/help/en_US/linprog.xml diff --git a/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS b/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS Binary files differindex e29698f..236a815 100644 --- a/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS +++ b/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS diff --git a/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS.TAB b/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS.TAB Binary files differindex 0d7319d..2133bb0 100644 --- a/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS.TAB +++ b/help/en_US/scilab_en_US_help/JavaHelpSearch/DOCS.TAB diff --git a/help/en_US/scilab_en_US_help/JavaHelpSearch/OFFSETS b/help/en_US/scilab_en_US_help/JavaHelpSearch/OFFSETS Binary files differindex 3bc2a52..8728452 100644 --- a/help/en_US/scilab_en_US_help/JavaHelpSearch/OFFSETS +++ b/help/en_US/scilab_en_US_help/JavaHelpSearch/OFFSETS diff --git a/help/en_US/scilab_en_US_help/JavaHelpSearch/POSITIONS b/help/en_US/scilab_en_US_help/JavaHelpSearch/POSITIONS Binary files differindex 5b008c5..bfc07ce 100644 --- a/help/en_US/scilab_en_US_help/JavaHelpSearch/POSITIONS +++ b/help/en_US/scilab_en_US_help/JavaHelpSearch/POSITIONS 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 Binary files differindex 6b36ea7..882bad7 100644 --- a/help/en_US/scilab_en_US_help/JavaHelpSearch/TMAP +++ b/help/en_US/scilab_en_US_help/JavaHelpSearch/TMAP 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. <ul class="itemizedlist"><li>output.Iterations: The number of iterations performed during the search</li> <li>output.Cpu_Time: The total cpu-time spend during the search</li> <li>output.Objective_Evaluation: The number of Objective Evaluations performed during the search</li> -<li>output.Dual_Infeasibility: The Dual Infeasiblity of the final soution</li></ul></p> +<li>output.Dual_Infeasibility: The Dual Infeasiblity of the final soution</li> +<li>output.Message: The output message for the problem</li></ul></p> <p class="para">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. <ul class="itemizedlist"><li>output.Iterations: The number of iterations performed during the search</li> <li>output.Cpu_Time: The total cpu-time spend during the search</li> <li>output.Objective_Evaluation: The number of Objective Evaluations performed during the search</li> -<li>output.Dual_Infeasibility: The Dual Infeasiblity of the final soution</li></ul></p> +<li>output.Dual_Infeasibility: The Dual Infeasiblity of the final soution</li> +<li>output.Message: The output message for the problem</li></ul></p> <p class="para">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. <span class="scilabcomment">//Options</span> <span class="scilabid">options</span><span class="scilaboperator">=</span><a class="scilabcommand" href="scilab://list">list</a><span class="scilabopenclose">(</span><span class="scilabstring">"</span><span class="scilabstring">MaxIter</span><span class="scilabstring">"</span><span class="scilabdefault">,</span> <span class="scilabopenclose">[</span><span class="scilabnumber">1500</span><span class="scilabopenclose">]</span><span class="scilabdefault">,</span> <span class="scilabstring">"</span><span class="scilabstring">CpuTime</span><span class="scilabstring">"</span><span class="scilabdefault">,</span> <span class="scilabopenclose">[</span><span class="scilabnumber">500</span><span class="scilabopenclose">]</span><span class="scilabdefault">,</span> <span class="scilabstring">"</span><span class="scilabstring">GradObj</span><span class="scilabstring">"</span><span class="scilabdefault">,</span> <span class="scilabfunctionid">fGrad</span><span class="scilabdefault">,</span> <span class="scilabstring">"</span><span class="scilabstring">Hessian</span><span class="scilabstring">"</span><span class="scilabdefault">,</span> <span class="scilabfunctionid">lHess</span><span class="scilabdefault">,</span><span class="scilabstring">"</span><span class="scilabstring">GradCon</span><span class="scilabstring">"</span><span class="scilabdefault">,</span> <span class="scilabfunctionid">cGrad</span><span class="scilabopenclose">)</span><span class="scilabdefault">;</span> <span class="scilabcomment">//Calling Ipopt</span> -<span class="scilabopenclose">[</span><span class="scilabid">x</span><span class="scilabdefault">,</span><span class="scilabid">fval</span><span class="scilabdefault">,</span><span class="scilabid">exitflag</span><span class="scilabdefault">,</span><span class="scilabid">output</span><span class="scilabdefault">,</span><span class="scilabid">lambda</span><span class="scilabdefault">,</span><span class="scilabid">grad</span><span class="scilabdefault">,</span><span class="scilabid">hessian</span><span class="scilabopenclose">]</span> <span class="scilaboperator">=</span><span class="scilabid">fmincon</span><span class="scilabopenclose">(</span><span class="scilabfunctionid">f</span><span class="scilabdefault">,</span> <span class="scilabid">x0</span><span class="scilabdefault">,</span><span class="scilabid">A</span><span class="scilabdefault">,</span><span class="scilabid">b</span><span class="scilabdefault">,</span><span class="scilabid">Aeq</span><span class="scilabdefault">,</span><span class="scilabid">beq</span><span class="scilabdefault">,</span><span class="scilabid">lb</span><span class="scilabdefault">,</span><span class="scilabid">ub</span><span class="scilabdefault">,</span><span class="scilabfunctionid">nlc</span><span class="scilabdefault">,</span><span class="scilabid">options</span><span class="scilabopenclose">)</span></pre></td><td valign="top"><a href="scilab://scilab.execexample/"><img src="ScilabExecute.png" border="0"/></a></td><td valign="top"><a href="scilab://scilab.editexample/"><img src="ScilabEdit.png" border="0"/></a></td><td></td></tr></table></div></div> +<span class="scilabopenclose">[</span><span class="scilabid">x</span><span class="scilabdefault">,</span><span class="scilabid">fval</span><span class="scilabdefault">,</span><span class="scilabid">exitflag</span><span class="scilabdefault">,</span><span class="scilabid">output</span><span class="scilabdefault">,</span><span class="scilabid">lambda</span><span class="scilabdefault">,</span><span class="scilabid">grad</span><span class="scilabdefault">,</span><span class="scilabid">hessian</span><span class="scilabopenclose">]</span> <span class="scilaboperator">=</span><span class="scilabid">fmincon</span><span class="scilabopenclose">(</span><span class="scilabfunctionid">f</span><span class="scilabdefault">,</span> <span class="scilabid">x0</span><span class="scilabdefault">,</span><span class="scilabid">A</span><span class="scilabdefault">,</span><span class="scilabid">b</span><span class="scilabdefault">,</span><span class="scilabid">Aeq</span><span class="scilabdefault">,</span><span class="scilabid">beq</span><span class="scilabdefault">,</span><span class="scilabid">lb</span><span class="scilabdefault">,</span><span class="scilabid">ub</span><span class="scilabdefault">,</span><span class="scilabfunctionid">nlc</span><span class="scilabdefault">,</span><span class="scilabid">options</span><span class="scilabopenclose">)</span> +<span class="scilabcomment">// Press ENTER to continue</span></pre></td><td valign="top"><a href="scilab://scilab.execexample/"><img src="ScilabExecute.png" border="0"/></a></td><td valign="top"><a href="scilab://scilab.editexample/"><img src="ScilabEdit.png" border="0"/></a></td><td></td></tr></table></div></div> <div class="refsection"><h3 class="title">Authors</h3> <ul class="itemizedlist"><li class="member">R.Vidyadhar , Vignesh Kannan</li></ul></div> diff --git a/help/en_US/scilab_en_US_help/fminimax.html b/help/en_US/scilab_en_US_help/fminimax.html index 4143821..a701aa7 100644 --- a/help/en_US/scilab_en_US_help/fminimax.html +++ b/help/en_US/scilab_en_US_help/fminimax.html @@ -43,11 +43,11 @@ <span class="default">xopt</span><span class="default"> = </span><span class="functionid">fminimax</span><span class="default">(</span><span class="default">fun</span><span class="default">,</span><span class="default">x0</span><span class="default">,</span><span class="default">A</span><span class="default">,</span><span class="default">b</span><span class="default">,</span><span class="default">Aeq</span><span class="default">,</span><span class="default">beq</span><span class="default">,</span><span class="default">lb</span><span class="default">,</span><span class="default">ub</span><span class="default">)</span> <span class="default">xopt</span><span class="default"> = </span><span class="functionid">fminimax</span><span class="default">(</span><span class="default">fun</span><span class="default">,</span><span class="default">x0</span><span class="default">,</span><span class="default">A</span><span class="default">,</span><span class="default">b</span><span class="default">,</span><span class="default">Aeq</span><span class="default">,</span><span class="default">beq</span><span class="default">,</span><span class="default">lb</span><span class="default">,</span><span class="default">ub</span><span class="default">,</span><span class="default">nonlinfun</span><span class="default">)</span> <span class="default">xopt</span><span class="default"> = </span><span class="functionid">fminimax</span><span class="default">(</span><span class="default">fun</span><span class="default">,</span><span class="default">x0</span><span class="default">,</span><span class="default">A</span><span class="default">,</span><span class="default">b</span><span class="default">,</span><span class="default">Aeq</span><span class="default">,</span><span class="default">beq</span><span class="default">,</span><span class="default">lb</span><span class="default">,</span><span class="default">ub</span><span class="default">,</span><span class="default">nonlinfun</span><span class="default">,</span><span class="default">options</span><span class="default">)</span> -<span class="default">[</span><span class="default">xopt</span><span class="default">, </span><span class="default">fval</span><span class="default">] = </span><span class="functionid">fminimax</span><span class="default">(.....)</span> -<span class="default">[</span><span class="default">xopt</span><span class="default">, </span><span class="default">fval</span><span class="default">, </span><span class="default">maxfval</span><span class="default">]= </span><span class="functionid">fminimax</span><span class="default">(.....)</span> -<span class="default">[</span><span class="default">xopt</span><span class="default">, </span><span class="default">fval</span><span class="default">, </span><span class="default">maxfval</span><span class="default">, </span><span class="default">exitflag</span><span class="default">]= </span><span class="functionid">fminimax</span><span class="default">(.....)</span> -<span class="default">[</span><span class="default">xopt</span><span class="default">, </span><span class="default">fval</span><span class="default">, </span><span class="default">maxfval</span><span class="default">, </span><span class="default">exitflag</span><span class="default">, </span><span class="default">output</span><span class="default">]= </span><span class="functionid">fminimax</span><span class="default">(.....)</span> -<span class="default">[</span><span class="default">xopt</span><span class="default">, </span><span class="default">fval</span><span class="default">, </span><span class="default">maxfval</span><span class="default">, </span><span class="default">exitflag</span><span class="default">, </span><span class="default">output</span><span class="default">, </span><span class="default">lambda</span><span class="default">]= </span><span class="functionid">fminimax</span><span class="default">(.....)</span></pre></div></div> +<span class="default">[</span><span class="default">xopt</span><span class="default">, </span><span class="default">fval</span><span class="default">] = </span><span class="default">fmincon</span><span class="default">(.....)</span> +<span class="default">[</span><span class="default">xopt</span><span class="default">, </span><span class="default">fval</span><span class="default">, </span><span class="default">maxfval</span><span class="default">]= </span><span class="default">fmincon</span><span class="default">(.....)</span> +<span class="default">[</span><span class="default">xopt</span><span class="default">, </span><span class="default">fval</span><span class="default">, </span><span class="default">maxfval</span><span class="default">, </span><span class="default">exitflag</span><span class="default">]= </span><span class="default">fmincon</span><span class="default">(.....)</span> +<span class="default">[</span><span class="default">xopt</span><span class="default">, </span><span class="default">fval</span><span class="default">, </span><span class="default">maxfval</span><span class="default">, </span><span class="default">exitflag</span><span class="default">, </span><span class="default">output</span><span class="default">]= </span><span class="default">fmincon</span><span class="default">(.....)</span> +<span class="default">[</span><span class="default">xopt</span><span class="default">, </span><span class="default">fval</span><span class="default">, </span><span class="default">maxfval</span><span class="default">, </span><span class="default">exitflag</span><span class="default">, </span><span class="default">output</span><span class="default">, </span><span class="default">lambda</span><span class="default">]= </span><span class="default">fmincon</span><span class="default">(.....)</span></pre></div></div> <div class="refsection"><h3 class="title">Parameters</h3> <dl><dt><span class="term">fun:</span> 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. <ul class="itemizedlist"><li>output.Iterations: The number of iterations performed during the search</li> <li>output.Cpu_Time: The total cpu-time spend during the search</li> <li>output.Objective_Evaluation: The number of Objective Evaluations performed during the search</li> -<li>output.Dual_Infeasibility: The Dual Infeasiblity of the final soution</li></ul></p> +<li>output.Dual_Infeasibility: The Dual Infeasiblity of the final soution</li> +<li>output.Message: The output message for the problem</li></ul></p> <p class="para"></p></div> <div class="refsection"><h3 class="title">Examples</h3> 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 @@ +<html><head> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + <title></title> + <style type="text/css" media="all"> + @import url("scilab_code.css"); + @import url("xml_code.css"); + @import url("c_code.css"); + @import url("style.css"); + </style> + </head> + <body> + <div class="manualnavbar"> + <table width="100%"><tr> + <td width="30%"> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="index.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + + + + <span class="path"><a href="index.html">FOSSEE Optimization Toolbox</a> >> FOSSEE Optimization Toolbox</span> + + <br /><br /> + <h3 class="title-part">FOSSEE Optimization Toolbox</h3> +<ul class="list-chapter"><li><a href="fgoalattain.html" class="refentry">fgoalattain</a> — <span class="refentry-description">Solves a multiobjective goal attainment problem</span></li> + + + + + +<li><a href="fminbnd.html" class="refentry">fminbnd</a> — <span class="refentry-description">Solves a multi-variable optimization problem on a bounded interval</span></li> + + + + + +<li><a href="fmincon.html" class="refentry">fmincon</a> — <span class="refentry-description">Solves a multi-variable constrainted optimization problem</span></li> + + + + + +<li><a href="fminimax.html" class="refentry">fminimax</a> — <span class="refentry-description">Solves minimax constraint problem</span></li> + + + + + +<li><a href="fminunc.html" class="refentry">fminunc</a> — <span class="refentry-description">Solves a multi-variable unconstrainted optimization problem</span></li> + + + + + +<li><a href="linprog.html" class="refentry">linprog</a> — <span class="refentry-description">Solves a linear programming problem.</span></li> + + + + + +<li><a href="lsqlin.html" class="refentry">lsqlin</a> — <span class="refentry-description">Solves a linear quadratic problem.</span></li> + + + + + +<li><a href="lsqnonlin.html" class="refentry">lsqnonlin</a> — <span class="refentry-description">Solves a non linear data fitting problems.</span></li> + + + + + +<li><a href="lsqnonneg.html" class="refentry">lsqnonneg</a> — <span class="refentry-description">Solves nonnegative least-squares curve fitting problems.</span></li> + + + + + +<li><a href="qpipopt.html" class="refentry">qpipopt</a> — <span class="refentry-description">Solves a linear quadratic problem.</span></li> + + + + + +<li><a href="qpipoptmat.html" class="refentry">qpipoptmat</a> — <span class="refentry-description">Solves a linear quadratic problem.</span></li> + + + + + +<li><a href="symphony.html" class="refentry">symphony</a> — <span class="refentry-description">Solves a mixed integer linear programming constrained optimization problem.</span></li> + + + + + +<li><a href="symphonymat.html" class="refentry">symphonymat</a> — <span class="refentry-description">Solves a mixed integer linear programming constrained optimization problem in intlinprog format.</span></li> + +<li><a href="section_acc9053f8b9eb28fc8444868aeb726ed.html" class="chapter">Symphony Native Functions</a> +<ul class="list-refentry"><li><a href="sym_addConstr.html" class="refentry">sym_addConstr</a> — <span class="refentry-description">Add a new constraint</span></li> + + + +<li><a href="sym_addVar.html" class="refentry">sym_addVar</a> — <span class="refentry-description">Add a new variable</span></li> + + + +<li><a href="sym_close.html" class="refentry">sym_close</a> — <span class="refentry-description">Close the Symphony environment</span></li> + + + +<li><a href="sym_deleteConstrs.html" class="refentry">sym_deleteConstrs</a> — <span class="refentry-description">This routine is used to delete rows from the original constraint matrix.</span></li> + + + +<li><a href="sym_deleteVars.html" class="refentry">sym_deleteVars</a> — <span class="refentry-description">This routine is used to delete columns from the original problem description.</span></li> + + + +<li><a href="sym_getConstrActivity.html" class="refentry">sym_getConstrActivity</a> — <span class="refentry-description">Get the activity of the constraints in the solution</span></li> + + + +<li><a href="sym_getConstrLower.html" class="refentry">sym_getConstrLower</a> — <span class="refentry-description">To get the lower bounds of the constraints.</span></li> + + + +<li><a href="sym_getConstrRange.html" class="refentry">sym_getConstrRange</a> — <span class="refentry-description">To to get the constraint ranges.</span></li> + + + +<li><a href="sym_getConstrSense.html" class="refentry">sym_getConstrSense</a> — <span class="refentry-description">To get the row senses.</span></li> + + + +<li><a href="sym_getConstrUpper.html" class="refentry">sym_getConstrUpper</a> — <span class="refentry-description">To get the upper bounds of the constraints.</span></li> + + + +<li><a href="sym_getDblParam.html" class="refentry">sym_getDblParam</a> — <span class="refentry-description">This routine is used to get the value of a double type parameter.</span></li> + + + +<li><a href="sym_getInfinity.html" class="refentry">sym_getInfinity</a> — <span class="refentry-description">Get Symphony's infinity value</span></li> + + + +<li><a href="sym_getIntParam.html" class="refentry">sym_getIntParam</a> — <span class="refentry-description">This routine is used to get the value of an integer type parameter.</span></li> + + + +<li><a href="sym_getIterCount.html" class="refentry">sym_getIterCount</a> — <span class="refentry-description">To get the number of the analyzed nodes of the branching tree after solving the problem.</span></li> + + + +<li><a href="sym_getMatrix.html" class="refentry">sym_getMatrix</a> — <span class="refentry-description">To get the constraint matrix.</span></li> + + + +<li><a href="sym_getNumConstr.html" class="refentry">sym_getNumConstr</a> — <span class="refentry-description">To get the number of the constraints of the current problem.</span></li> + + + +<li><a href="sym_getNumElements.html" class="refentry">sym_getNumElements</a> — <span class="refentry-description">To get the number of non-zero entries of the constraint matrix of the current problem.</span></li> + + + +<li><a href="sym_getNumVar.html" class="refentry">sym_getNumVar</a> — <span class="refentry-description">To get the number of the variables of the current problem.</span></li> + + + +<li><a href="sym_getObjCoeff.html" class="refentry">sym_getObjCoeff</a> — <span class="refentry-description">To get the objective vector.</span></li> + + + +<li><a href="sym_getObjSense.html" class="refentry">sym_getObjSense</a> — <span class="refentry-description">Get the objective sense</span></li> + + + +<li><a href="sym_getObjVal.html" class="refentry">sym_getObjVal</a> — <span class="refentry-description">Get the optimized objective value</span></li> + + + +<li><a href="sym_getPrimalBound.html" class="refentry">sym_getPrimalBound</a> — <span class="refentry-description">Get the primal bound of the problem</span></li> + + + +<li><a href="sym_getRhs.html" class="refentry">sym_getRhs</a> — <span class="refentry-description">To to get the right hand side vector(column vector).</span></li> + + + +<li><a href="sym_getStatus.html" class="refentry">sym_getStatus</a> — <span class="refentry-description">To get status of the problem solver.</span></li> + + + +<li><a href="sym_getStrParam.html" class="refentry">sym_getStrParam</a> — <span class="refentry-description">This routine is used to get the value of a string type parameter.</span></li> + + + +<li><a href="sym_getVarLower.html" class="refentry">sym_getVarLower</a> — <span class="refentry-description">To get the lower bounds of the variables.</span></li> + + + +<li><a href="sym_getVarSoln.html" class="refentry">sym_getVarSoln</a> — <span class="refentry-description">Get the solution for the problem</span></li> + + + +<li><a href="sym_getVarUpper.html" class="refentry">sym_getVarUpper</a> — <span class="refentry-description">To get the upper bounds of the variables.</span></li> + + + +<li><a href="sym_isAbandoned.html" class="refentry">sym_isAbandoned</a> — <span class="refentry-description">To check whether the problem was abandoned for some reason.</span></li> + + + +<li><a href="sym_isBinary.html" class="refentry">sym_isBinary</a> — <span class="refentry-description">Check if a variable is constrained to be binary</span></li> + + + +<li><a href="sym_isContinuous.html" class="refentry">sym_isContinuous</a> — <span class="refentry-description">Check if a variable is continuous</span></li> + + + +<li><a href="sym_isEnvActive.html" class="refentry">sym_isEnvActive</a> — <span class="refentry-description">Check if Symphony environment is active</span></li> + + + +<li><a href="sym_isInfeasible.html" class="refentry">sym_isInfeasible</a> — <span class="refentry-description">To check whether the problem was proven to be infeasible.</span></li> + + + +<li><a href="sym_isInteger.html" class="refentry">sym_isInteger</a> — <span class="refentry-description">Check if a variable is constrained to be an integer</span></li> + + + +<li><a href="sym_isIterLimitReached.html" class="refentry">sym_isIterLimitReached</a> — <span class="refentry-description">To know whether the iteration limit (node limit) was reached.</span></li> + + + +<li><a href="sym_isOptimal.html" class="refentry">sym_isOptimal</a> — <span class="refentry-description">To check whether the problem was solved to optimality.</span></li> + + + +<li><a href="sym_isTargetGapAchieved.html" class="refentry">sym_isTargetGapAchieved</a> — <span class="refentry-description">To know whether the target gap was reached.</span></li> + + + +<li><a href="sym_isTimeLimitReached.html" class="refentry">sym_isTimeLimitReached</a> — <span class="refentry-description">To know whether the time limit was reached.</span></li> + + + +<li><a href="sym_loadMPS.html" class="refentry">sym_loadMPS</a> — <span class="refentry-description">This routine is used to load an instance from an MPS file.</span></li> + + + +<li><a href="sym_loadProblem.html" class="refentry">sym_loadProblem</a> — <span class="refentry-description">Load a problem into Symphony</span></li> + + + +<li><a href="sym_loadProblemBasic.html" class="refentry">sym_loadProblemBasic</a> — <span class="refentry-description">Load a problem into Symphony (basic version)</span></li> + + + +<li><a href="sym_open.html" class="refentry">sym_open</a> — <span class="refentry-description">Open the Symphony environment</span></li> + + + +<li><a href="sym_resetParams.html" class="refentry">sym_resetParams</a> — <span class="refentry-description">This routine sets all the environment variables and parameters to their default values.</span></li> + + + +<li><a href="sym_setConstrLower.html" class="refentry">sym_setConstrLower</a> — <span class="refentry-description">Set the lower bound of a constraint</span></li> + + + +<li><a href="sym_setConstrType.html" class="refentry">sym_setConstrType</a> — <span class="refentry-description">Set the type of a constraint</span></li> + + + +<li><a href="sym_setConstrUpper.html" class="refentry">sym_setConstrUpper</a> — <span class="refentry-description">Set the upper bound of a constraint</span></li> + + + +<li><a href="sym_setContinuous.html" class="refentry">sym_setContinuous</a> — <span class="refentry-description">This routine is used to set the type of a variable to be continuous.</span></li> + + + +<li><a href="sym_setDblParam.html" class="refentry">sym_setDblParam</a> — <span class="refentry-description">This routine is used to set a double type parameter.</span></li> + + + +<li><a href="sym_setIntParam.html" class="refentry">sym_setIntParam</a> — <span class="refentry-description">This routine is used to set an integer type parameter.</span></li> + + + +<li><a href="sym_setInteger.html" class="refentry">sym_setInteger</a> — <span class="refentry-description">This routine is used to set the type of a variable to be integer.</span></li> + + + +<li><a href="sym_setObjCoeff.html" class="refentry">sym_setObjCoeff</a> — <span class="refentry-description">Set coefficient of a variable in the objective</span></li> + + + +<li><a href="sym_setObjSense.html" class="refentry">sym_setObjSense</a> — <span class="refentry-description">Set the objective sense</span></li> + + + +<li><a href="sym_setPrimalBound.html" class="refentry">sym_setPrimalBound</a> — <span class="refentry-description">Set the primal bound of the problem</span></li> + + + +<li><a href="sym_setStrParam.html" class="refentry">sym_setStrParam</a> — <span class="refentry-description">This routine is used to set a string type parameter.</span></li> + + + +<li><a href="sym_setVarLower.html" class="refentry">sym_setVarLower</a> — <span class="refentry-description">Set lower bound of a variable</span></li> + + + +<li><a href="sym_setVarSoln.html" class="refentry">sym_setVarSoln</a> — <span class="refentry-description">Set a solution for the problem</span></li> + + + +<li><a href="sym_setVarUpper.html" class="refentry">sym_setVarUpper</a> — <span class="refentry-description">Set upper bound of a variable</span></li> + + + +<li><a href="sym_solve.html" class="refentry">sym_solve</a> — <span class="refentry-description">To solve the currently loaded MILP problem from scratch.</span></li></ul></li></ul> + <br /> + + <div class="manualnavbar"> + <table width="100%"> + <tr><td colspan="3" class="next"><a href="http://bugzilla.scilab.org/enter_bug.cgi?product=Scilab%20software&component=Documentation%20pages" class="ulink">Report an issue</a></td></tr> +<tr> + <td width="30%"> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="index.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + </body> +</html> 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 @@ +<html><head> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + <title></title> + <style type="text/css" media="all"> + @import url("scilab_code.css"); + @import url("xml_code.css"); + @import url("c_code.css"); + @import url("style.css"); + </style> + </head> + <body> + <div class="manualnavbar"> + <table width="100%"><tr> + <td width="30%"> + <span class="previous"><a href="symphonymat.html"><< symphonymat</a></span> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="section_f892b70a029847ba39043aa5f758cc43.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + + + + <span class="path"><a href="index.html">FOSSEE Optimization Toolbox</a> >> <a href="section_f892b70a029847ba39043aa5f758cc43.html">FOSSEE Optimization Toolbox</a> > Symphony Native Functions</span> + + <br /><br /> + <h3 class="title-chapter">Symphony Native Functions</h3> +<ul class="list-refentry"><li><a href="sym_addConstr.html" class="refentry">sym_addConstr</a> — <span class="refentry-description">Add a new constraint</span></li> + + + +<li><a href="sym_addVar.html" class="refentry">sym_addVar</a> — <span class="refentry-description">Add a new variable</span></li> + + + +<li><a href="sym_close.html" class="refentry">sym_close</a> — <span class="refentry-description">Close the Symphony environment</span></li> + + + +<li><a href="sym_deleteConstrs.html" class="refentry">sym_deleteConstrs</a> — <span class="refentry-description">This routine is used to delete rows from the original constraint matrix.</span></li> + + + +<li><a href="sym_deleteVars.html" class="refentry">sym_deleteVars</a> — <span class="refentry-description">This routine is used to delete columns from the original problem description.</span></li> + + + +<li><a href="sym_getConstrActivity.html" class="refentry">sym_getConstrActivity</a> — <span class="refentry-description">Get the activity of the constraints in the solution</span></li> + + + +<li><a href="sym_getConstrLower.html" class="refentry">sym_getConstrLower</a> — <span class="refentry-description">To get the lower bounds of the constraints.</span></li> + + + +<li><a href="sym_getConstrRange.html" class="refentry">sym_getConstrRange</a> — <span class="refentry-description">To to get the constraint ranges.</span></li> + + + +<li><a href="sym_getConstrSense.html" class="refentry">sym_getConstrSense</a> — <span class="refentry-description">To get the row senses.</span></li> + + + +<li><a href="sym_getConstrUpper.html" class="refentry">sym_getConstrUpper</a> — <span class="refentry-description">To get the upper bounds of the constraints.</span></li> + + + +<li><a href="sym_getDblParam.html" class="refentry">sym_getDblParam</a> — <span class="refentry-description">This routine is used to get the value of a double type parameter.</span></li> + + + +<li><a href="sym_getInfinity.html" class="refentry">sym_getInfinity</a> — <span class="refentry-description">Get Symphony's infinity value</span></li> + + + +<li><a href="sym_getIntParam.html" class="refentry">sym_getIntParam</a> — <span class="refentry-description">This routine is used to get the value of an integer type parameter.</span></li> + + + +<li><a href="sym_getIterCount.html" class="refentry">sym_getIterCount</a> — <span class="refentry-description">To get the number of the analyzed nodes of the branching tree after solving the problem.</span></li> + + + +<li><a href="sym_getMatrix.html" class="refentry">sym_getMatrix</a> — <span class="refentry-description">To get the constraint matrix.</span></li> + + + +<li><a href="sym_getNumConstr.html" class="refentry">sym_getNumConstr</a> — <span class="refentry-description">To get the number of the constraints of the current problem.</span></li> + + + +<li><a href="sym_getNumElements.html" class="refentry">sym_getNumElements</a> — <span class="refentry-description">To get the number of non-zero entries of the constraint matrix of the current problem.</span></li> + + + +<li><a href="sym_getNumVar.html" class="refentry">sym_getNumVar</a> — <span class="refentry-description">To get the number of the variables of the current problem.</span></li> + + + +<li><a href="sym_getObjCoeff.html" class="refentry">sym_getObjCoeff</a> — <span class="refentry-description">To get the objective vector.</span></li> + + + +<li><a href="sym_getObjSense.html" class="refentry">sym_getObjSense</a> — <span class="refentry-description">Get the objective sense</span></li> + + + +<li><a href="sym_getObjVal.html" class="refentry">sym_getObjVal</a> — <span class="refentry-description">Get the optimized objective value</span></li> + + + +<li><a href="sym_getPrimalBound.html" class="refentry">sym_getPrimalBound</a> — <span class="refentry-description">Get the primal bound of the problem</span></li> + + + +<li><a href="sym_getRhs.html" class="refentry">sym_getRhs</a> — <span class="refentry-description">To to get the right hand side vector(column vector).</span></li> + + + +<li><a href="sym_getStatus.html" class="refentry">sym_getStatus</a> — <span class="refentry-description">To get status of the problem solver.</span></li> + + + +<li><a href="sym_getStrParam.html" class="refentry">sym_getStrParam</a> — <span class="refentry-description">This routine is used to get the value of a string type parameter.</span></li> + + + +<li><a href="sym_getVarLower.html" class="refentry">sym_getVarLower</a> — <span class="refentry-description">To get the lower bounds of the variables.</span></li> + + + +<li><a href="sym_getVarSoln.html" class="refentry">sym_getVarSoln</a> — <span class="refentry-description">Get the solution for the problem</span></li> + + + +<li><a href="sym_getVarUpper.html" class="refentry">sym_getVarUpper</a> — <span class="refentry-description">To get the upper bounds of the variables.</span></li> + + + +<li><a href="sym_isAbandoned.html" class="refentry">sym_isAbandoned</a> — <span class="refentry-description">To check whether the problem was abandoned for some reason.</span></li> + + + +<li><a href="sym_isBinary.html" class="refentry">sym_isBinary</a> — <span class="refentry-description">Check if a variable is constrained to be binary</span></li> + + + +<li><a href="sym_isContinuous.html" class="refentry">sym_isContinuous</a> — <span class="refentry-description">Check if a variable is continuous</span></li> + + + +<li><a href="sym_isEnvActive.html" class="refentry">sym_isEnvActive</a> — <span class="refentry-description">Check if Symphony environment is active</span></li> + + + +<li><a href="sym_isInfeasible.html" class="refentry">sym_isInfeasible</a> — <span class="refentry-description">To check whether the problem was proven to be infeasible.</span></li> + + + +<li><a href="sym_isInteger.html" class="refentry">sym_isInteger</a> — <span class="refentry-description">Check if a variable is constrained to be an integer</span></li> + + + +<li><a href="sym_isIterLimitReached.html" class="refentry">sym_isIterLimitReached</a> — <span class="refentry-description">To know whether the iteration limit (node limit) was reached.</span></li> + + + +<li><a href="sym_isOptimal.html" class="refentry">sym_isOptimal</a> — <span class="refentry-description">To check whether the problem was solved to optimality.</span></li> + + + +<li><a href="sym_isTargetGapAchieved.html" class="refentry">sym_isTargetGapAchieved</a> — <span class="refentry-description">To know whether the target gap was reached.</span></li> + + + +<li><a href="sym_isTimeLimitReached.html" class="refentry">sym_isTimeLimitReached</a> — <span class="refentry-description">To know whether the time limit was reached.</span></li> + + + +<li><a href="sym_loadMPS.html" class="refentry">sym_loadMPS</a> — <span class="refentry-description">This routine is used to load an instance from an MPS file.</span></li> + + + +<li><a href="sym_loadProblem.html" class="refentry">sym_loadProblem</a> — <span class="refentry-description">Load a problem into Symphony</span></li> + + + +<li><a href="sym_loadProblemBasic.html" class="refentry">sym_loadProblemBasic</a> — <span class="refentry-description">Load a problem into Symphony (basic version)</span></li> + + + +<li><a href="sym_open.html" class="refentry">sym_open</a> — <span class="refentry-description">Open the Symphony environment</span></li> + + + +<li><a href="sym_resetParams.html" class="refentry">sym_resetParams</a> — <span class="refentry-description">This routine sets all the environment variables and parameters to their default values.</span></li> + + + +<li><a href="sym_setConstrLower.html" class="refentry">sym_setConstrLower</a> — <span class="refentry-description">Set the lower bound of a constraint</span></li> + + + +<li><a href="sym_setConstrType.html" class="refentry">sym_setConstrType</a> — <span class="refentry-description">Set the type of a constraint</span></li> + + + +<li><a href="sym_setConstrUpper.html" class="refentry">sym_setConstrUpper</a> — <span class="refentry-description">Set the upper bound of a constraint</span></li> + + + +<li><a href="sym_setContinuous.html" class="refentry">sym_setContinuous</a> — <span class="refentry-description">This routine is used to set the type of a variable to be continuous.</span></li> + + + +<li><a href="sym_setDblParam.html" class="refentry">sym_setDblParam</a> — <span class="refentry-description">This routine is used to set a double type parameter.</span></li> + + + +<li><a href="sym_setIntParam.html" class="refentry">sym_setIntParam</a> — <span class="refentry-description">This routine is used to set an integer type parameter.</span></li> + + + +<li><a href="sym_setInteger.html" class="refentry">sym_setInteger</a> — <span class="refentry-description">This routine is used to set the type of a variable to be integer.</span></li> + + + +<li><a href="sym_setObjCoeff.html" class="refentry">sym_setObjCoeff</a> — <span class="refentry-description">Set coefficient of a variable in the objective</span></li> + + + +<li><a href="sym_setObjSense.html" class="refentry">sym_setObjSense</a> — <span class="refentry-description">Set the objective sense</span></li> + + + +<li><a href="sym_setPrimalBound.html" class="refentry">sym_setPrimalBound</a> — <span class="refentry-description">Set the primal bound of the problem</span></li> + + + +<li><a href="sym_setStrParam.html" class="refentry">sym_setStrParam</a> — <span class="refentry-description">This routine is used to set a string type parameter.</span></li> + + + +<li><a href="sym_setVarLower.html" class="refentry">sym_setVarLower</a> — <span class="refentry-description">Set lower bound of a variable</span></li> + + + +<li><a href="sym_setVarSoln.html" class="refentry">sym_setVarSoln</a> — <span class="refentry-description">Set a solution for the problem</span></li> + + + +<li><a href="sym_setVarUpper.html" class="refentry">sym_setVarUpper</a> — <span class="refentry-description">Set upper bound of a variable</span></li> + + + +<li><a href="sym_solve.html" class="refentry">sym_solve</a> — <span class="refentry-description">To solve the currently loaded MILP problem from scratch.</span></li></ul> + <br /> + + <div class="manualnavbar"> + <table width="100%"> + <tr><td colspan="3" class="next"><a href="http://bugzilla.scilab.org/enter_bug.cgi?product=Scilab%20software&component=Documentation%20pages" class="ulink">Report an issue</a></td></tr> +<tr> + <td width="30%"> + <span class="previous"><a href="symphonymat.html"><< symphonymat</a></span> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="section_f892b70a029847ba39043aa5f758cc43.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + </body> +</html> 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 @@ +<html><head> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + <title></title> + <style type="text/css" media="all"> + @import url("scilab_code.css"); + @import url("xml_code.css"); + @import url("c_code.css"); + @import url("style.css"); + </style> + </head> + <body> + <div class="manualnavbar"> + <table width="100%"><tr> + <td width="30%"> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="index.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + + + + <span class="path"><a href="index.html">FOSSEE Optimization Toolbox</a> >> FOSSEE Optimization Toolbox</span> + + <br /><br /> + <h3 class="title-part">FOSSEE Optimization Toolbox</h3> +<ul class="list-chapter"><li><a href="fgoalattain.html" class="refentry">fgoalattain</a> — <span class="refentry-description">Solves a multiobjective goal attainment problem</span></li> + + + + + +<li><a href="fminbnd.html" class="refentry">fminbnd</a> — <span class="refentry-description">Solves a multi-variable optimization problem on a bounded interval</span></li> + + + + + +<li><a href="fmincon.html" class="refentry">fmincon</a> — <span class="refentry-description">Solves a multi-variable constrainted optimization problem</span></li> + + + + + +<li><a href="fminimax.html" class="refentry">fminimax</a> — <span class="refentry-description">Solves minimax constraint problem</span></li> + + + + + +<li><a href="fminunc.html" class="refentry">fminunc</a> — <span class="refentry-description">Solves a multi-variable unconstrainted optimization problem</span></li> + + + + + +<li><a href="linprog.html" class="refentry">linprog</a> — <span class="refentry-description">Solves a linear programming problem.</span></li> + + + + + +<li><a href="lsqlin.html" class="refentry">lsqlin</a> — <span class="refentry-description">Solves a linear quadratic problem.</span></li> + + + + + +<li><a href="lsqnonlin.html" class="refentry">lsqnonlin</a> — <span class="refentry-description">Solves a non linear data fitting problems.</span></li> + + + + + +<li><a href="lsqnonneg.html" class="refentry">lsqnonneg</a> — <span class="refentry-description">Solves nonnegative least-squares curve fitting problems.</span></li> + + + + + +<li><a href="qpipopt.html" class="refentry">qpipopt</a> — <span class="refentry-description">Solves a linear quadratic problem.</span></li> + + + + + +<li><a href="qpipoptmat.html" class="refentry">qpipoptmat</a> — <span class="refentry-description">Solves a linear quadratic problem.</span></li> + + + + + +<li><a href="symphony.html" class="refentry">symphony</a> — <span class="refentry-description">Solves a mixed integer linear programming constrained optimization problem.</span></li> + + + + + +<li><a href="symphonymat.html" class="refentry">symphonymat</a> — <span class="refentry-description">Solves a mixed integer linear programming constrained optimization problem in intlinprog format.</span></li> + +<li><a href="section_5e696f2d03a3604c545d1892ce44a062.html" class="chapter">Symphony Native Functions</a> +<ul class="list-refentry"><li><a href="sym_addConstr.html" class="refentry">sym_addConstr</a> — <span class="refentry-description">Add a new constraint</span></li> + + + +<li><a href="sym_addVar.html" class="refentry">sym_addVar</a> — <span class="refentry-description">Add a new variable</span></li> + + + +<li><a href="sym_close.html" class="refentry">sym_close</a> — <span class="refentry-description">Close the Symphony environment</span></li> + + + +<li><a href="sym_deleteConstrs.html" class="refentry">sym_deleteConstrs</a> — <span class="refentry-description">This routine is used to delete rows from the original constraint matrix.</span></li> + + + +<li><a href="sym_deleteVars.html" class="refentry">sym_deleteVars</a> — <span class="refentry-description">This routine is used to delete columns from the original problem description.</span></li> + + + +<li><a href="sym_getConstrActivity.html" class="refentry">sym_getConstrActivity</a> — <span class="refentry-description">Get the activity of the constraints in the solution</span></li> + + + +<li><a href="sym_getConstrLower.html" class="refentry">sym_getConstrLower</a> — <span class="refentry-description">To get the lower bounds of the constraints.</span></li> + + + +<li><a href="sym_getConstrRange.html" class="refentry">sym_getConstrRange</a> — <span class="refentry-description">To to get the constraint ranges.</span></li> + + + +<li><a href="sym_getConstrSense.html" class="refentry">sym_getConstrSense</a> — <span class="refentry-description">To get the row senses.</span></li> + + + +<li><a href="sym_getConstrUpper.html" class="refentry">sym_getConstrUpper</a> — <span class="refentry-description">To get the upper bounds of the constraints.</span></li> + + + +<li><a href="sym_getDblParam.html" class="refentry">sym_getDblParam</a> — <span class="refentry-description">This routine is used to get the value of a double type parameter.</span></li> + + + +<li><a href="sym_getInfinity.html" class="refentry">sym_getInfinity</a> — <span class="refentry-description">Get Symphony's infinity value</span></li> + + + +<li><a href="sym_getIntParam.html" class="refentry">sym_getIntParam</a> — <span class="refentry-description">This routine is used to get the value of an integer type parameter.</span></li> + + + +<li><a href="sym_getIterCount.html" class="refentry">sym_getIterCount</a> — <span class="refentry-description">To get the number of the analyzed nodes of the branching tree after solving the problem.</span></li> + + + +<li><a href="sym_getMatrix.html" class="refentry">sym_getMatrix</a> — <span class="refentry-description">To get the constraint matrix.</span></li> + + + +<li><a href="sym_getNumConstr.html" class="refentry">sym_getNumConstr</a> — <span class="refentry-description">To get the number of the constraints of the current problem.</span></li> + + + +<li><a href="sym_getNumElements.html" class="refentry">sym_getNumElements</a> — <span class="refentry-description">To get the number of non-zero entries of the constraint matrix of the current problem.</span></li> + + + +<li><a href="sym_getNumVar.html" class="refentry">sym_getNumVar</a> — <span class="refentry-description">To get the number of the variables of the current problem.</span></li> + + + +<li><a href="sym_getObjCoeff.html" class="refentry">sym_getObjCoeff</a> — <span class="refentry-description">To get the objective vector.</span></li> + + + +<li><a href="sym_getObjSense.html" class="refentry">sym_getObjSense</a> — <span class="refentry-description">Get the objective sense</span></li> + + + +<li><a href="sym_getObjVal.html" class="refentry">sym_getObjVal</a> — <span class="refentry-description">Get the optimized objective value</span></li> + + + +<li><a href="sym_getPrimalBound.html" class="refentry">sym_getPrimalBound</a> — <span class="refentry-description">Get the primal bound of the problem</span></li> + + + +<li><a href="sym_getRhs.html" class="refentry">sym_getRhs</a> — <span class="refentry-description">To to get the right hand side vector(column vector).</span></li> + + + +<li><a href="sym_getStatus.html" class="refentry">sym_getStatus</a> — <span class="refentry-description">To get status of the problem solver.</span></li> + + + +<li><a href="sym_getStrParam.html" class="refentry">sym_getStrParam</a> — <span class="refentry-description">This routine is used to get the value of a string type parameter.</span></li> + + + +<li><a href="sym_getVarLower.html" class="refentry">sym_getVarLower</a> — <span class="refentry-description">To get the lower bounds of the variables.</span></li> + + + +<li><a href="sym_getVarSoln.html" class="refentry">sym_getVarSoln</a> — <span class="refentry-description">Get the solution for the problem</span></li> + + + +<li><a href="sym_getVarUpper.html" class="refentry">sym_getVarUpper</a> — <span class="refentry-description">To get the upper bounds of the variables.</span></li> + + + +<li><a href="sym_isAbandoned.html" class="refentry">sym_isAbandoned</a> — <span class="refentry-description">To check whether the problem was abandoned for some reason.</span></li> + + + +<li><a href="sym_isBinary.html" class="refentry">sym_isBinary</a> — <span class="refentry-description">Check if a variable is constrained to be binary</span></li> + + + +<li><a href="sym_isContinuous.html" class="refentry">sym_isContinuous</a> — <span class="refentry-description">Check if a variable is continuous</span></li> + + + +<li><a href="sym_isEnvActive.html" class="refentry">sym_isEnvActive</a> — <span class="refentry-description">Check if Symphony environment is active</span></li> + + + +<li><a href="sym_isInfeasible.html" class="refentry">sym_isInfeasible</a> — <span class="refentry-description">To check whether the problem was proven to be infeasible.</span></li> + + + +<li><a href="sym_isInteger.html" class="refentry">sym_isInteger</a> — <span class="refentry-description">Check if a variable is constrained to be an integer</span></li> + + + +<li><a href="sym_isIterLimitReached.html" class="refentry">sym_isIterLimitReached</a> — <span class="refentry-description">To know whether the iteration limit (node limit) was reached.</span></li> + + + +<li><a href="sym_isOptimal.html" class="refentry">sym_isOptimal</a> — <span class="refentry-description">To check whether the problem was solved to optimality.</span></li> + + + +<li><a href="sym_isTargetGapAchieved.html" class="refentry">sym_isTargetGapAchieved</a> — <span class="refentry-description">To know whether the target gap was reached.</span></li> + + + +<li><a href="sym_isTimeLimitReached.html" class="refentry">sym_isTimeLimitReached</a> — <span class="refentry-description">To know whether the time limit was reached.</span></li> + + + +<li><a href="sym_loadMPS.html" class="refentry">sym_loadMPS</a> — <span class="refentry-description">This routine is used to load an instance from an MPS file.</span></li> + + + +<li><a href="sym_loadProblem.html" class="refentry">sym_loadProblem</a> — <span class="refentry-description">Load a problem into Symphony</span></li> + + + +<li><a href="sym_loadProblemBasic.html" class="refentry">sym_loadProblemBasic</a> — <span class="refentry-description">Load a problem into Symphony (basic version)</span></li> + + + +<li><a href="sym_open.html" class="refentry">sym_open</a> — <span class="refentry-description">Open the Symphony environment</span></li> + + + +<li><a href="sym_resetParams.html" class="refentry">sym_resetParams</a> — <span class="refentry-description">This routine sets all the environment variables and parameters to their default values.</span></li> + + + +<li><a href="sym_setConstrLower.html" class="refentry">sym_setConstrLower</a> — <span class="refentry-description">Set the lower bound of a constraint</span></li> + + + +<li><a href="sym_setConstrType.html" class="refentry">sym_setConstrType</a> — <span class="refentry-description">Set the type of a constraint</span></li> + + + +<li><a href="sym_setConstrUpper.html" class="refentry">sym_setConstrUpper</a> — <span class="refentry-description">Set the upper bound of a constraint</span></li> + + + +<li><a href="sym_setContinuous.html" class="refentry">sym_setContinuous</a> — <span class="refentry-description">This routine is used to set the type of a variable to be continuous.</span></li> + + + +<li><a href="sym_setDblParam.html" class="refentry">sym_setDblParam</a> — <span class="refentry-description">This routine is used to set a double type parameter.</span></li> + + + +<li><a href="sym_setIntParam.html" class="refentry">sym_setIntParam</a> — <span class="refentry-description">This routine is used to set an integer type parameter.</span></li> + + + +<li><a href="sym_setInteger.html" class="refentry">sym_setInteger</a> — <span class="refentry-description">This routine is used to set the type of a variable to be integer.</span></li> + + + +<li><a href="sym_setObjCoeff.html" class="refentry">sym_setObjCoeff</a> — <span class="refentry-description">Set coefficient of a variable in the objective</span></li> + + + +<li><a href="sym_setObjSense.html" class="refentry">sym_setObjSense</a> — <span class="refentry-description">Set the objective sense</span></li> + + + +<li><a href="sym_setPrimalBound.html" class="refentry">sym_setPrimalBound</a> — <span class="refentry-description">Set the primal bound of the problem</span></li> + + + +<li><a href="sym_setStrParam.html" class="refentry">sym_setStrParam</a> — <span class="refentry-description">This routine is used to set a string type parameter.</span></li> + + + +<li><a href="sym_setVarLower.html" class="refentry">sym_setVarLower</a> — <span class="refentry-description">Set lower bound of a variable</span></li> + + + +<li><a href="sym_setVarSoln.html" class="refentry">sym_setVarSoln</a> — <span class="refentry-description">Set a solution for the problem</span></li> + + + +<li><a href="sym_setVarUpper.html" class="refentry">sym_setVarUpper</a> — <span class="refentry-description">Set upper bound of a variable</span></li> + + + +<li><a href="sym_solve.html" class="refentry">sym_solve</a> — <span class="refentry-description">To solve the currently loaded MILP problem from scratch.</span></li></ul></li></ul> + <br /> + + <div class="manualnavbar"> + <table width="100%"> + <tr><td colspan="3" class="next"><a href="http://bugzilla.scilab.org/enter_bug.cgi?product=Scilab%20software&component=Documentation%20pages" class="ulink">Report an issue</a></td></tr> +<tr> + <td width="30%"> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="index.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + </body> +</html> 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 @@ +<html><head> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + <title></title> + <style type="text/css" media="all"> + @import url("scilab_code.css"); + @import url("xml_code.css"); + @import url("c_code.css"); + @import url("style.css"); + </style> + </head> + <body> + <div class="manualnavbar"> + <table width="100%"><tr> + <td width="30%"> + <span class="previous"><a href="symphonymat.html"><< symphonymat</a></span> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="section_4fff750f952bf1f67f4b2a1869ada898.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + + + + <span class="path"><a href="index.html">FOSSEE Optimization Toolbox</a> >> <a href="section_4fff750f952bf1f67f4b2a1869ada898.html">FOSSEE Optimization Toolbox</a> > Symphony Native Functions</span> + + <br /><br /> + <h3 class="title-chapter">Symphony Native Functions</h3> +<ul class="list-refentry"><li><a href="sym_addConstr.html" class="refentry">sym_addConstr</a> — <span class="refentry-description">Add a new constraint</span></li> + + + +<li><a href="sym_addVar.html" class="refentry">sym_addVar</a> — <span class="refentry-description">Add a new variable</span></li> + + + +<li><a href="sym_close.html" class="refentry">sym_close</a> — <span class="refentry-description">Close the Symphony environment</span></li> + + + +<li><a href="sym_deleteConstrs.html" class="refentry">sym_deleteConstrs</a> — <span class="refentry-description">This routine is used to delete rows from the original constraint matrix.</span></li> + + + +<li><a href="sym_deleteVars.html" class="refentry">sym_deleteVars</a> — <span class="refentry-description">This routine is used to delete columns from the original problem description.</span></li> + + + +<li><a href="sym_getConstrActivity.html" class="refentry">sym_getConstrActivity</a> — <span class="refentry-description">Get the activity of the constraints in the solution</span></li> + + + +<li><a href="sym_getConstrLower.html" class="refentry">sym_getConstrLower</a> — <span class="refentry-description">To get the lower bounds of the constraints.</span></li> + + + +<li><a href="sym_getConstrRange.html" class="refentry">sym_getConstrRange</a> — <span class="refentry-description">To to get the constraint ranges.</span></li> + + + +<li><a href="sym_getConstrSense.html" class="refentry">sym_getConstrSense</a> — <span class="refentry-description">To get the row senses.</span></li> + + + +<li><a href="sym_getConstrUpper.html" class="refentry">sym_getConstrUpper</a> — <span class="refentry-description">To get the upper bounds of the constraints.</span></li> + + + +<li><a href="sym_getDblParam.html" class="refentry">sym_getDblParam</a> — <span class="refentry-description">This routine is used to get the value of a double type parameter.</span></li> + + + +<li><a href="sym_getInfinity.html" class="refentry">sym_getInfinity</a> — <span class="refentry-description">Get Symphony's infinity value</span></li> + + + +<li><a href="sym_getIntParam.html" class="refentry">sym_getIntParam</a> — <span class="refentry-description">This routine is used to get the value of an integer type parameter.</span></li> + + + +<li><a href="sym_getIterCount.html" class="refentry">sym_getIterCount</a> — <span class="refentry-description">To get the number of the analyzed nodes of the branching tree after solving the problem.</span></li> + + + +<li><a href="sym_getMatrix.html" class="refentry">sym_getMatrix</a> — <span class="refentry-description">To get the constraint matrix.</span></li> + + + +<li><a href="sym_getNumConstr.html" class="refentry">sym_getNumConstr</a> — <span class="refentry-description">To get the number of the constraints of the current problem.</span></li> + + + +<li><a href="sym_getNumElements.html" class="refentry">sym_getNumElements</a> — <span class="refentry-description">To get the number of non-zero entries of the constraint matrix of the current problem.</span></li> + + + +<li><a href="sym_getNumVar.html" class="refentry">sym_getNumVar</a> — <span class="refentry-description">To get the number of the variables of the current problem.</span></li> + + + +<li><a href="sym_getObjCoeff.html" class="refentry">sym_getObjCoeff</a> — <span class="refentry-description">To get the objective vector.</span></li> + + + +<li><a href="sym_getObjSense.html" class="refentry">sym_getObjSense</a> — <span class="refentry-description">Get the objective sense</span></li> + + + +<li><a href="sym_getObjVal.html" class="refentry">sym_getObjVal</a> — <span class="refentry-description">Get the optimized objective value</span></li> + + + +<li><a href="sym_getPrimalBound.html" class="refentry">sym_getPrimalBound</a> — <span class="refentry-description">Get the primal bound of the problem</span></li> + + + +<li><a href="sym_getRhs.html" class="refentry">sym_getRhs</a> — <span class="refentry-description">To to get the right hand side vector(column vector).</span></li> + + + +<li><a href="sym_getStatus.html" class="refentry">sym_getStatus</a> — <span class="refentry-description">To get status of the problem solver.</span></li> + + + +<li><a href="sym_getStrParam.html" class="refentry">sym_getStrParam</a> — <span class="refentry-description">This routine is used to get the value of a string type parameter.</span></li> + + + +<li><a href="sym_getVarLower.html" class="refentry">sym_getVarLower</a> — <span class="refentry-description">To get the lower bounds of the variables.</span></li> + + + +<li><a href="sym_getVarSoln.html" class="refentry">sym_getVarSoln</a> — <span class="refentry-description">Get the solution for the problem</span></li> + + + +<li><a href="sym_getVarUpper.html" class="refentry">sym_getVarUpper</a> — <span class="refentry-description">To get the upper bounds of the variables.</span></li> + + + +<li><a href="sym_isAbandoned.html" class="refentry">sym_isAbandoned</a> — <span class="refentry-description">To check whether the problem was abandoned for some reason.</span></li> + + + +<li><a href="sym_isBinary.html" class="refentry">sym_isBinary</a> — <span class="refentry-description">Check if a variable is constrained to be binary</span></li> + + + +<li><a href="sym_isContinuous.html" class="refentry">sym_isContinuous</a> — <span class="refentry-description">Check if a variable is continuous</span></li> + + + +<li><a href="sym_isEnvActive.html" class="refentry">sym_isEnvActive</a> — <span class="refentry-description">Check if Symphony environment is active</span></li> + + + +<li><a href="sym_isInfeasible.html" class="refentry">sym_isInfeasible</a> — <span class="refentry-description">To check whether the problem was proven to be infeasible.</span></li> + + + +<li><a href="sym_isInteger.html" class="refentry">sym_isInteger</a> — <span class="refentry-description">Check if a variable is constrained to be an integer</span></li> + + + +<li><a href="sym_isIterLimitReached.html" class="refentry">sym_isIterLimitReached</a> — <span class="refentry-description">To know whether the iteration limit (node limit) was reached.</span></li> + + + +<li><a href="sym_isOptimal.html" class="refentry">sym_isOptimal</a> — <span class="refentry-description">To check whether the problem was solved to optimality.</span></li> + + + +<li><a href="sym_isTargetGapAchieved.html" class="refentry">sym_isTargetGapAchieved</a> — <span class="refentry-description">To know whether the target gap was reached.</span></li> + + + +<li><a href="sym_isTimeLimitReached.html" class="refentry">sym_isTimeLimitReached</a> — <span class="refentry-description">To know whether the time limit was reached.</span></li> + + + +<li><a href="sym_loadMPS.html" class="refentry">sym_loadMPS</a> — <span class="refentry-description">This routine is used to load an instance from an MPS file.</span></li> + + + +<li><a href="sym_loadProblem.html" class="refentry">sym_loadProblem</a> — <span class="refentry-description">Load a problem into Symphony</span></li> + + + +<li><a href="sym_loadProblemBasic.html" class="refentry">sym_loadProblemBasic</a> — <span class="refentry-description">Load a problem into Symphony (basic version)</span></li> + + + +<li><a href="sym_open.html" class="refentry">sym_open</a> — <span class="refentry-description">Open the Symphony environment</span></li> + + + +<li><a href="sym_resetParams.html" class="refentry">sym_resetParams</a> — <span class="refentry-description">This routine sets all the environment variables and parameters to their default values.</span></li> + + + +<li><a href="sym_setConstrLower.html" class="refentry">sym_setConstrLower</a> — <span class="refentry-description">Set the lower bound of a constraint</span></li> + + + +<li><a href="sym_setConstrType.html" class="refentry">sym_setConstrType</a> — <span class="refentry-description">Set the type of a constraint</span></li> + + + +<li><a href="sym_setConstrUpper.html" class="refentry">sym_setConstrUpper</a> — <span class="refentry-description">Set the upper bound of a constraint</span></li> + + + +<li><a href="sym_setContinuous.html" class="refentry">sym_setContinuous</a> — <span class="refentry-description">This routine is used to set the type of a variable to be continuous.</span></li> + + + +<li><a href="sym_setDblParam.html" class="refentry">sym_setDblParam</a> — <span class="refentry-description">This routine is used to set a double type parameter.</span></li> + + + +<li><a href="sym_setIntParam.html" class="refentry">sym_setIntParam</a> — <span class="refentry-description">This routine is used to set an integer type parameter.</span></li> + + + +<li><a href="sym_setInteger.html" class="refentry">sym_setInteger</a> — <span class="refentry-description">This routine is used to set the type of a variable to be integer.</span></li> + + + +<li><a href="sym_setObjCoeff.html" class="refentry">sym_setObjCoeff</a> — <span class="refentry-description">Set coefficient of a variable in the objective</span></li> + + + +<li><a href="sym_setObjSense.html" class="refentry">sym_setObjSense</a> — <span class="refentry-description">Set the objective sense</span></li> + + + +<li><a href="sym_setPrimalBound.html" class="refentry">sym_setPrimalBound</a> — <span class="refentry-description">Set the primal bound of the problem</span></li> + + + +<li><a href="sym_setStrParam.html" class="refentry">sym_setStrParam</a> — <span class="refentry-description">This routine is used to set a string type parameter.</span></li> + + + +<li><a href="sym_setVarLower.html" class="refentry">sym_setVarLower</a> — <span class="refentry-description">Set lower bound of a variable</span></li> + + + +<li><a href="sym_setVarSoln.html" class="refentry">sym_setVarSoln</a> — <span class="refentry-description">Set a solution for the problem</span></li> + + + +<li><a href="sym_setVarUpper.html" class="refentry">sym_setVarUpper</a> — <span class="refentry-description">Set upper bound of a variable</span></li> + + + +<li><a href="sym_solve.html" class="refentry">sym_solve</a> — <span class="refentry-description">To solve the currently loaded MILP problem from scratch.</span></li></ul> + <br /> + + <div class="manualnavbar"> + <table width="100%"> + <tr><td colspan="3" class="next"><a href="http://bugzilla.scilab.org/enter_bug.cgi?product=Scilab%20software&component=Documentation%20pages" class="ulink">Report an issue</a></td></tr> +<tr> + <td width="30%"> + <span class="previous"><a href="symphonymat.html"><< symphonymat</a></span> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="section_4fff750f952bf1f67f4b2a1869ada898.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + </body> +</html> 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 @@ +<html><head> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + <title></title> + <style type="text/css" media="all"> + @import url("scilab_code.css"); + @import url("xml_code.css"); + @import url("c_code.css"); + @import url("style.css"); + </style> + </head> + <body> + <div class="manualnavbar"> + <table width="100%"><tr> + <td width="30%"> + <span class="previous"><a href="symphonymat.html"><< symphonymat</a></span> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="section_24af5d179784a48827745fa0aa9df4dd.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + + + + <span class="path"><a href="index.html">FOSSEE Optimization Toolbox</a> >> <a href="section_24af5d179784a48827745fa0aa9df4dd.html">FOSSEE Optimization Toolbox</a> > Symphony Native Functions</span> + + <br /><br /> + <h3 class="title-chapter">Symphony Native Functions</h3> +<ul class="list-refentry"><li><a href="sym_addConstr.html" class="refentry">sym_addConstr</a> — <span class="refentry-description">Add a new constraint</span></li> + + + +<li><a href="sym_addVar.html" class="refentry">sym_addVar</a> — <span class="refentry-description">Add a new variable</span></li> + + + +<li><a href="sym_close.html" class="refentry">sym_close</a> — <span class="refentry-description">Close the Symphony environment</span></li> + + + +<li><a href="sym_deleteConstrs.html" class="refentry">sym_deleteConstrs</a> — <span class="refentry-description">This routine is used to delete rows from the original constraint matrix.</span></li> + + + +<li><a href="sym_deleteVars.html" class="refentry">sym_deleteVars</a> — <span class="refentry-description">This routine is used to delete columns from the original problem description.</span></li> + + + +<li><a href="sym_getConstrActivity.html" class="refentry">sym_getConstrActivity</a> — <span class="refentry-description">Get the activity of the constraints in the solution</span></li> + + + +<li><a href="sym_getConstrLower.html" class="refentry">sym_getConstrLower</a> — <span class="refentry-description">To get the lower bounds of the constraints.</span></li> + + + +<li><a href="sym_getConstrRange.html" class="refentry">sym_getConstrRange</a> — <span class="refentry-description">To to get the constraint ranges.</span></li> + + + +<li><a href="sym_getConstrSense.html" class="refentry">sym_getConstrSense</a> — <span class="refentry-description">To get the row senses.</span></li> + + + +<li><a href="sym_getConstrUpper.html" class="refentry">sym_getConstrUpper</a> — <span class="refentry-description">To get the upper bounds of the constraints.</span></li> + + + +<li><a href="sym_getDblParam.html" class="refentry">sym_getDblParam</a> — <span class="refentry-description">This routine is used to get the value of a double type parameter.</span></li> + + + +<li><a href="sym_getInfinity.html" class="refentry">sym_getInfinity</a> — <span class="refentry-description">Get Symphony's infinity value</span></li> + + + +<li><a href="sym_getIntParam.html" class="refentry">sym_getIntParam</a> — <span class="refentry-description">This routine is used to get the value of an integer type parameter.</span></li> + + + +<li><a href="sym_getIterCount.html" class="refentry">sym_getIterCount</a> — <span class="refentry-description">To get the number of the analyzed nodes of the branching tree after solving the problem.</span></li> + + + +<li><a href="sym_getMatrix.html" class="refentry">sym_getMatrix</a> — <span class="refentry-description">To get the constraint matrix.</span></li> + + + +<li><a href="sym_getNumConstr.html" class="refentry">sym_getNumConstr</a> — <span class="refentry-description">To get the number of the constraints of the current problem.</span></li> + + + +<li><a href="sym_getNumElements.html" class="refentry">sym_getNumElements</a> — <span class="refentry-description">To get the number of non-zero entries of the constraint matrix of the current problem.</span></li> + + + +<li><a href="sym_getNumVar.html" class="refentry">sym_getNumVar</a> — <span class="refentry-description">To get the number of the variables of the current problem.</span></li> + + + +<li><a href="sym_getObjCoeff.html" class="refentry">sym_getObjCoeff</a> — <span class="refentry-description">To get the objective vector.</span></li> + + + +<li><a href="sym_getObjSense.html" class="refentry">sym_getObjSense</a> — <span class="refentry-description">Get the objective sense</span></li> + + + +<li><a href="sym_getObjVal.html" class="refentry">sym_getObjVal</a> — <span class="refentry-description">Get the optimized objective value</span></li> + + + +<li><a href="sym_getPrimalBound.html" class="refentry">sym_getPrimalBound</a> — <span class="refentry-description">Get the primal bound of the problem</span></li> + + + +<li><a href="sym_getRhs.html" class="refentry">sym_getRhs</a> — <span class="refentry-description">To to get the right hand side vector(column vector).</span></li> + + + +<li><a href="sym_getStatus.html" class="refentry">sym_getStatus</a> — <span class="refentry-description">To get status of the problem solver.</span></li> + + + +<li><a href="sym_getStrParam.html" class="refentry">sym_getStrParam</a> — <span class="refentry-description">This routine is used to get the value of a string type parameter.</span></li> + + + +<li><a href="sym_getVarLower.html" class="refentry">sym_getVarLower</a> — <span class="refentry-description">To get the lower bounds of the variables.</span></li> + + + +<li><a href="sym_getVarSoln.html" class="refentry">sym_getVarSoln</a> — <span class="refentry-description">Get the solution for the problem</span></li> + + + +<li><a href="sym_getVarUpper.html" class="refentry">sym_getVarUpper</a> — <span class="refentry-description">To get the upper bounds of the variables.</span></li> + + + +<li><a href="sym_isAbandoned.html" class="refentry">sym_isAbandoned</a> — <span class="refentry-description">To check whether the problem was abandoned for some reason.</span></li> + + + +<li><a href="sym_isBinary.html" class="refentry">sym_isBinary</a> — <span class="refentry-description">Check if a variable is constrained to be binary</span></li> + + + +<li><a href="sym_isContinuous.html" class="refentry">sym_isContinuous</a> — <span class="refentry-description">Check if a variable is continuous</span></li> + + + +<li><a href="sym_isEnvActive.html" class="refentry">sym_isEnvActive</a> — <span class="refentry-description">Check if Symphony environment is active</span></li> + + + +<li><a href="sym_isInfeasible.html" class="refentry">sym_isInfeasible</a> — <span class="refentry-description">To check whether the problem was proven to be infeasible.</span></li> + + + +<li><a href="sym_isInteger.html" class="refentry">sym_isInteger</a> — <span class="refentry-description">Check if a variable is constrained to be an integer</span></li> + + + +<li><a href="sym_isIterLimitReached.html" class="refentry">sym_isIterLimitReached</a> — <span class="refentry-description">To know whether the iteration limit (node limit) was reached.</span></li> + + + +<li><a href="sym_isOptimal.html" class="refentry">sym_isOptimal</a> — <span class="refentry-description">To check whether the problem was solved to optimality.</span></li> + + + +<li><a href="sym_isTargetGapAchieved.html" class="refentry">sym_isTargetGapAchieved</a> — <span class="refentry-description">To know whether the target gap was reached.</span></li> + + + +<li><a href="sym_isTimeLimitReached.html" class="refentry">sym_isTimeLimitReached</a> — <span class="refentry-description">To know whether the time limit was reached.</span></li> + + + +<li><a href="sym_loadMPS.html" class="refentry">sym_loadMPS</a> — <span class="refentry-description">This routine is used to load an instance from an MPS file.</span></li> + + + +<li><a href="sym_loadProblem.html" class="refentry">sym_loadProblem</a> — <span class="refentry-description">Load a problem into Symphony</span></li> + + + +<li><a href="sym_loadProblemBasic.html" class="refentry">sym_loadProblemBasic</a> — <span class="refentry-description">Load a problem into Symphony (basic version)</span></li> + + + +<li><a href="sym_open.html" class="refentry">sym_open</a> — <span class="refentry-description">Open the Symphony environment</span></li> + + + +<li><a href="sym_resetParams.html" class="refentry">sym_resetParams</a> — <span class="refentry-description">This routine sets all the environment variables and parameters to their default values.</span></li> + + + +<li><a href="sym_setConstrLower.html" class="refentry">sym_setConstrLower</a> — <span class="refentry-description">Set the lower bound of a constraint</span></li> + + + +<li><a href="sym_setConstrType.html" class="refentry">sym_setConstrType</a> — <span class="refentry-description">Set the type of a constraint</span></li> + + + +<li><a href="sym_setConstrUpper.html" class="refentry">sym_setConstrUpper</a> — <span class="refentry-description">Set the upper bound of a constraint</span></li> + + + +<li><a href="sym_setContinuous.html" class="refentry">sym_setContinuous</a> — <span class="refentry-description">This routine is used to set the type of a variable to be continuous.</span></li> + + + +<li><a href="sym_setDblParam.html" class="refentry">sym_setDblParam</a> — <span class="refentry-description">This routine is used to set a double type parameter.</span></li> + + + +<li><a href="sym_setIntParam.html" class="refentry">sym_setIntParam</a> — <span class="refentry-description">This routine is used to set an integer type parameter.</span></li> + + + +<li><a href="sym_setInteger.html" class="refentry">sym_setInteger</a> — <span class="refentry-description">This routine is used to set the type of a variable to be integer.</span></li> + + + +<li><a href="sym_setObjCoeff.html" class="refentry">sym_setObjCoeff</a> — <span class="refentry-description">Set coefficient of a variable in the objective</span></li> + + + +<li><a href="sym_setObjSense.html" class="refentry">sym_setObjSense</a> — <span class="refentry-description">Set the objective sense</span></li> + + + +<li><a href="sym_setPrimalBound.html" class="refentry">sym_setPrimalBound</a> — <span class="refentry-description">Set the primal bound of the problem</span></li> + + + +<li><a href="sym_setStrParam.html" class="refentry">sym_setStrParam</a> — <span class="refentry-description">This routine is used to set a string type parameter.</span></li> + + + +<li><a href="sym_setVarLower.html" class="refentry">sym_setVarLower</a> — <span class="refentry-description">Set lower bound of a variable</span></li> + + + +<li><a href="sym_setVarSoln.html" class="refentry">sym_setVarSoln</a> — <span class="refentry-description">Set a solution for the problem</span></li> + + + +<li><a href="sym_setVarUpper.html" class="refentry">sym_setVarUpper</a> — <span class="refentry-description">Set upper bound of a variable</span></li> + + + +<li><a href="sym_solve.html" class="refentry">sym_solve</a> — <span class="refentry-description">To solve the currently loaded MILP problem from scratch.</span></li></ul> + <br /> + + <div class="manualnavbar"> + <table width="100%"> + <tr><td colspan="3" class="next"><a href="http://bugzilla.scilab.org/enter_bug.cgi?product=Scilab%20software&component=Documentation%20pages" class="ulink">Report an issue</a></td></tr> +<tr> + <td width="30%"> + <span class="previous"><a href="symphonymat.html"><< symphonymat</a></span> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="section_24af5d179784a48827745fa0aa9df4dd.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + </body> +</html> 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 @@ +<html><head> + <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> + <title></title> + <style type="text/css" media="all"> + @import url("scilab_code.css"); + @import url("xml_code.css"); + @import url("c_code.css"); + @import url("style.css"); + </style> + </head> + <body> + <div class="manualnavbar"> + <table width="100%"><tr> + <td width="30%"> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="index.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + + + + <span class="path"><a href="index.html">FOSSEE Optimization Toolbox</a> >> FOSSEE Optimization Toolbox</span> + + <br /><br /> + <h3 class="title-part">FOSSEE Optimization Toolbox</h3> +<ul class="list-chapter"><li><a href="fgoalattain.html" class="refentry">fgoalattain</a> — <span class="refentry-description">Solves a multiobjective goal attainment problem</span></li> + + + + + +<li><a href="fminbnd.html" class="refentry">fminbnd</a> — <span class="refentry-description">Solves a multi-variable optimization problem on a bounded interval</span></li> + + + + + +<li><a href="fmincon.html" class="refentry">fmincon</a> — <span class="refentry-description">Solves a multi-variable constrainted optimization problem</span></li> + + + + + +<li><a href="fminimax.html" class="refentry">fminimax</a> — <span class="refentry-description">Solves minimax constraint problem</span></li> + + + + + +<li><a href="fminunc.html" class="refentry">fminunc</a> — <span class="refentry-description">Solves a multi-variable unconstrainted optimization problem</span></li> + + + + + +<li><a href="linprog.html" class="refentry">linprog</a> — <span class="refentry-description">Solves a linear programming problem.</span></li> + + + + + +<li><a href="lsqlin.html" class="refentry">lsqlin</a> — <span class="refentry-description">Solves a linear quadratic problem.</span></li> + + + + + +<li><a href="lsqnonlin.html" class="refentry">lsqnonlin</a> — <span class="refentry-description">Solves a non linear data fitting problems.</span></li> + + + + + +<li><a href="lsqnonneg.html" class="refentry">lsqnonneg</a> — <span class="refentry-description">Solves nonnegative least-squares curve fitting problems.</span></li> + + + + + +<li><a href="qpipopt.html" class="refentry">qpipopt</a> — <span class="refentry-description">Solves a linear quadratic problem.</span></li> + + + + + +<li><a href="qpipoptmat.html" class="refentry">qpipoptmat</a> — <span class="refentry-description">Solves a linear quadratic problem.</span></li> + + + + + +<li><a href="symphony.html" class="refentry">symphony</a> — <span class="refentry-description">Solves a mixed integer linear programming constrained optimization problem.</span></li> + + + + + +<li><a href="symphonymat.html" class="refentry">symphonymat</a> — <span class="refentry-description">Solves a mixed integer linear programming constrained optimization problem in intlinprog format.</span></li> + +<li><a href="section_43d915e486cd1a7dde8c0c09d6ab177e.html" class="chapter">Symphony Native Functions</a> +<ul class="list-refentry"><li><a href="sym_addConstr.html" class="refentry">sym_addConstr</a> — <span class="refentry-description">Add a new constraint</span></li> + + + +<li><a href="sym_addVar.html" class="refentry">sym_addVar</a> — <span class="refentry-description">Add a new variable</span></li> + + + +<li><a href="sym_close.html" class="refentry">sym_close</a> — <span class="refentry-description">Close the Symphony environment</span></li> + + + +<li><a href="sym_deleteConstrs.html" class="refentry">sym_deleteConstrs</a> — <span class="refentry-description">This routine is used to delete rows from the original constraint matrix.</span></li> + + + +<li><a href="sym_deleteVars.html" class="refentry">sym_deleteVars</a> — <span class="refentry-description">This routine is used to delete columns from the original problem description.</span></li> + + + +<li><a href="sym_getConstrActivity.html" class="refentry">sym_getConstrActivity</a> — <span class="refentry-description">Get the activity of the constraints in the solution</span></li> + + + +<li><a href="sym_getConstrLower.html" class="refentry">sym_getConstrLower</a> — <span class="refentry-description">To get the lower bounds of the constraints.</span></li> + + + +<li><a href="sym_getConstrRange.html" class="refentry">sym_getConstrRange</a> — <span class="refentry-description">To to get the constraint ranges.</span></li> + + + +<li><a href="sym_getConstrSense.html" class="refentry">sym_getConstrSense</a> — <span class="refentry-description">To get the row senses.</span></li> + + + +<li><a href="sym_getConstrUpper.html" class="refentry">sym_getConstrUpper</a> — <span class="refentry-description">To get the upper bounds of the constraints.</span></li> + + + +<li><a href="sym_getDblParam.html" class="refentry">sym_getDblParam</a> — <span class="refentry-description">This routine is used to get the value of a double type parameter.</span></li> + + + +<li><a href="sym_getInfinity.html" class="refentry">sym_getInfinity</a> — <span class="refentry-description">Get Symphony's infinity value</span></li> + + + +<li><a href="sym_getIntParam.html" class="refentry">sym_getIntParam</a> — <span class="refentry-description">This routine is used to get the value of an integer type parameter.</span></li> + + + +<li><a href="sym_getIterCount.html" class="refentry">sym_getIterCount</a> — <span class="refentry-description">To get the number of the analyzed nodes of the branching tree after solving the problem.</span></li> + + + +<li><a href="sym_getMatrix.html" class="refentry">sym_getMatrix</a> — <span class="refentry-description">To get the constraint matrix.</span></li> + + + +<li><a href="sym_getNumConstr.html" class="refentry">sym_getNumConstr</a> — <span class="refentry-description">To get the number of the constraints of the current problem.</span></li> + + + +<li><a href="sym_getNumElements.html" class="refentry">sym_getNumElements</a> — <span class="refentry-description">To get the number of non-zero entries of the constraint matrix of the current problem.</span></li> + + + +<li><a href="sym_getNumVar.html" class="refentry">sym_getNumVar</a> — <span class="refentry-description">To get the number of the variables of the current problem.</span></li> + + + +<li><a href="sym_getObjCoeff.html" class="refentry">sym_getObjCoeff</a> — <span class="refentry-description">To get the objective vector.</span></li> + + + +<li><a href="sym_getObjSense.html" class="refentry">sym_getObjSense</a> — <span class="refentry-description">Get the objective sense</span></li> + + + +<li><a href="sym_getObjVal.html" class="refentry">sym_getObjVal</a> — <span class="refentry-description">Get the optimized objective value</span></li> + + + +<li><a href="sym_getPrimalBound.html" class="refentry">sym_getPrimalBound</a> — <span class="refentry-description">Get the primal bound of the problem</span></li> + + + +<li><a href="sym_getRhs.html" class="refentry">sym_getRhs</a> — <span class="refentry-description">To to get the right hand side vector(column vector).</span></li> + + + +<li><a href="sym_getStatus.html" class="refentry">sym_getStatus</a> — <span class="refentry-description">To get status of the problem solver.</span></li> + + + +<li><a href="sym_getStrParam.html" class="refentry">sym_getStrParam</a> — <span class="refentry-description">This routine is used to get the value of a string type parameter.</span></li> + + + +<li><a href="sym_getVarLower.html" class="refentry">sym_getVarLower</a> — <span class="refentry-description">To get the lower bounds of the variables.</span></li> + + + +<li><a href="sym_getVarSoln.html" class="refentry">sym_getVarSoln</a> — <span class="refentry-description">Get the solution for the problem</span></li> + + + +<li><a href="sym_getVarUpper.html" class="refentry">sym_getVarUpper</a> — <span class="refentry-description">To get the upper bounds of the variables.</span></li> + + + +<li><a href="sym_isAbandoned.html" class="refentry">sym_isAbandoned</a> — <span class="refentry-description">To check whether the problem was abandoned for some reason.</span></li> + + + +<li><a href="sym_isBinary.html" class="refentry">sym_isBinary</a> — <span class="refentry-description">Check if a variable is constrained to be binary</span></li> + + + +<li><a href="sym_isContinuous.html" class="refentry">sym_isContinuous</a> — <span class="refentry-description">Check if a variable is continuous</span></li> + + + +<li><a href="sym_isEnvActive.html" class="refentry">sym_isEnvActive</a> — <span class="refentry-description">Check if Symphony environment is active</span></li> + + + +<li><a href="sym_isInfeasible.html" class="refentry">sym_isInfeasible</a> — <span class="refentry-description">To check whether the problem was proven to be infeasible.</span></li> + + + +<li><a href="sym_isInteger.html" class="refentry">sym_isInteger</a> — <span class="refentry-description">Check if a variable is constrained to be an integer</span></li> + + + +<li><a href="sym_isIterLimitReached.html" class="refentry">sym_isIterLimitReached</a> — <span class="refentry-description">To know whether the iteration limit (node limit) was reached.</span></li> + + + +<li><a href="sym_isOptimal.html" class="refentry">sym_isOptimal</a> — <span class="refentry-description">To check whether the problem was solved to optimality.</span></li> + + + +<li><a href="sym_isTargetGapAchieved.html" class="refentry">sym_isTargetGapAchieved</a> — <span class="refentry-description">To know whether the target gap was reached.</span></li> + + + +<li><a href="sym_isTimeLimitReached.html" class="refentry">sym_isTimeLimitReached</a> — <span class="refentry-description">To know whether the time limit was reached.</span></li> + + + +<li><a href="sym_loadMPS.html" class="refentry">sym_loadMPS</a> — <span class="refentry-description">This routine is used to load an instance from an MPS file.</span></li> + + + +<li><a href="sym_loadProblem.html" class="refentry">sym_loadProblem</a> — <span class="refentry-description">Load a problem into Symphony</span></li> + + + +<li><a href="sym_loadProblemBasic.html" class="refentry">sym_loadProblemBasic</a> — <span class="refentry-description">Load a problem into Symphony (basic version)</span></li> + + + +<li><a href="sym_open.html" class="refentry">sym_open</a> — <span class="refentry-description">Open the Symphony environment</span></li> + + + +<li><a href="sym_resetParams.html" class="refentry">sym_resetParams</a> — <span class="refentry-description">This routine sets all the environment variables and parameters to their default values.</span></li> + + + +<li><a href="sym_setConstrLower.html" class="refentry">sym_setConstrLower</a> — <span class="refentry-description">Set the lower bound of a constraint</span></li> + + + +<li><a href="sym_setConstrType.html" class="refentry">sym_setConstrType</a> — <span class="refentry-description">Set the type of a constraint</span></li> + + + +<li><a href="sym_setConstrUpper.html" class="refentry">sym_setConstrUpper</a> — <span class="refentry-description">Set the upper bound of a constraint</span></li> + + + +<li><a href="sym_setContinuous.html" class="refentry">sym_setContinuous</a> — <span class="refentry-description">This routine is used to set the type of a variable to be continuous.</span></li> + + + +<li><a href="sym_setDblParam.html" class="refentry">sym_setDblParam</a> — <span class="refentry-description">This routine is used to set a double type parameter.</span></li> + + + +<li><a href="sym_setIntParam.html" class="refentry">sym_setIntParam</a> — <span class="refentry-description">This routine is used to set an integer type parameter.</span></li> + + + +<li><a href="sym_setInteger.html" class="refentry">sym_setInteger</a> — <span class="refentry-description">This routine is used to set the type of a variable to be integer.</span></li> + + + +<li><a href="sym_setObjCoeff.html" class="refentry">sym_setObjCoeff</a> — <span class="refentry-description">Set coefficient of a variable in the objective</span></li> + + + +<li><a href="sym_setObjSense.html" class="refentry">sym_setObjSense</a> — <span class="refentry-description">Set the objective sense</span></li> + + + +<li><a href="sym_setPrimalBound.html" class="refentry">sym_setPrimalBound</a> — <span class="refentry-description">Set the primal bound of the problem</span></li> + + + +<li><a href="sym_setStrParam.html" class="refentry">sym_setStrParam</a> — <span class="refentry-description">This routine is used to set a string type parameter.</span></li> + + + +<li><a href="sym_setVarLower.html" class="refentry">sym_setVarLower</a> — <span class="refentry-description">Set lower bound of a variable</span></li> + + + +<li><a href="sym_setVarSoln.html" class="refentry">sym_setVarSoln</a> — <span class="refentry-description">Set a solution for the problem</span></li> + + + +<li><a href="sym_setVarUpper.html" class="refentry">sym_setVarUpper</a> — <span class="refentry-description">Set upper bound of a variable</span></li> + + + +<li><a href="sym_solve.html" class="refentry">sym_solve</a> — <span class="refentry-description">To solve the currently loaded MILP problem from scratch.</span></li></ul></li></ul> + <br /> + + <div class="manualnavbar"> + <table width="100%"> + <tr><td colspan="3" class="next"><a href="http://bugzilla.scilab.org/enter_bug.cgi?product=Scilab%20software&component=Documentation%20pages" class="ulink">Report an issue</a></td></tr> +<tr> + <td width="30%"> + + </td> + <td width="40%" class="center"> + <span class="top"><a href="index.html">FOSSEE Optimization Toolbox</a></span> + + </td> + <td width="30%" class="next"> + + </td> + </tr></table> + <hr /> + </div> + </body> +</html> 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. <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabspecial">..</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span><span class="scilabopenclose">]</span> <span class="scilabcomment">// Optimal value</span> -<span class="scilabid">fopt</span> <span class="scilaboperator">=</span> <span class="scilabopenclose">[</span> <span class="scilabnumber">24381</span> <span class="scilabopenclose">]</span> +<span class="scilabid">fopt</span> <span class="scilaboperator">=</span> <span class="scilabopenclose">[</span> <span class="scilaboperator">-</span><span class="scilabnumber">24381</span> <span class="scilabopenclose">]</span> <span class="scilabcomment">// Calling Symphony</span> <span class="scilabopenclose">[</span><span class="scilabid">x</span><span class="scilabdefault">,</span><span class="scilabid">f</span><span class="scilabdefault">,</span><span class="scilabid">status</span><span class="scilabdefault">,</span><span class="scilabid">output</span><span class="scilabopenclose">]</span> <span class="scilaboperator">=</span> <span class="scilabid">symphony</span><span class="scilabopenclose">(</span><span class="scilabid">nbVar</span><span class="scilabdefault">,</span><span class="scilabid">nbCon</span><span class="scilabdefault">,</span><span class="scilabid">c</span><span class="scilabdefault">,</span><span class="scilabid">isInt</span><span class="scilabdefault">,</span><span class="scilabid">lb</span><span class="scilabdefault">,</span><span class="scilabid">ub</span><span class="scilabdefault">,</span><span class="scilabid">A</span><span class="scilabdefault">,</span><span class="scilabid">conLB</span><span class="scilabdefault">,</span><span class="scilabid">conUB</span><span class="scilabdefault">,</span><span class="scilaboperator">-</span><span class="scilabnumber">1</span><span class="scilabdefault">,</span><span class="scilabid">options</span><span class="scilabopenclose">)</span><span class="scilabdefault">;</span></pre></td><td valign="top"><a href="scilab://scilab.execexample/"><img src="ScilabExecute.png" border="0"/></a></td><td valign="top"><a href="scilab://scilab.editexample/"><img src="ScilabEdit.png" border="0"/></a></td><td></td></tr></table></div></div> diff --git a/help/en_US/scilab_en_US_help/symphonymat.html b/help/en_US/scilab_en_US_help/symphonymat.html index 75edb56..b11afc6 100644 --- a/help/en_US/scilab_en_US_help/symphonymat.html +++ b/help/en_US/scilab_en_US_help/symphonymat.html @@ -182,7 +182,7 @@ It has type "struct" and contains the following fields. <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">1</span> <span class="scilabspecial">..</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span> <span class="scilabnumber">0</span> <span class="scilabnumber">1</span> <span class="scilabnumber">0</span><span class="scilabopenclose">]</span> <span class="scilabcomment">// Optimal value</span> -<span class="scilabid">fopt</span> <span class="scilaboperator">=</span> <span class="scilabopenclose">[</span> <span class="scilabnumber">24381</span> <span class="scilabopenclose">]</span> +<span class="scilabid">fopt</span> <span class="scilaboperator">=</span> <span class="scilabopenclose">[</span> <span class="scilaboperator">-</span><span class="scilabnumber">24381</span> <span class="scilabopenclose">]</span> <span class="scilabcomment">// Calling Symphony</span> <span class="scilabopenclose">[</span><span class="scilabid">x</span><span class="scilabdefault">,</span><span class="scilabid">f</span><span class="scilabdefault">,</span><span class="scilabid">status</span><span class="scilabdefault">,</span><span class="scilabid">output</span><span class="scilabopenclose">]</span> <span class="scilaboperator">=</span> <span class="scilabid">symphonymat</span><span class="scilabopenclose">(</span><span class="scilabid">c</span><span class="scilabdefault">,</span><span class="scilabid">intcon</span><span class="scilabdefault">,</span><span class="scilabid">A</span><span class="scilabdefault">,</span><span class="scilabid">b</span><span class="scilabdefault">,</span><span class="scilabopenclose">[</span><span class="scilabopenclose">]</span><span class="scilabdefault">,</span><span class="scilabopenclose">[</span><span class="scilabopenclose">]</span><span class="scilabdefault">,</span><span class="scilabid">lb</span><span class="scilabdefault">,</span><span class="scilabid">ub</span><span class="scilabdefault">,</span><span class="scilabid">options</span><span class="scilabopenclose">)</span><span class="scilabdefault">;</span></pre></td><td valign="top"><a href="scilab://scilab.execexample/"><img src="ScilabExecute.png" border="0"/></a></td><td valign="top"><a href="scilab://scilab.editexample/"><img src="ScilabEdit.png" border="0"/></a></td><td></td></tr></table></div></div> 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); ]]></programlisting> 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); ]]></programlisting> 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: <offset 0x621020> in /usr/lib/scilab/libscilab-cli.so.0 at 0x00007efbf4901000 -RCX=0x000000000000a04d is an unknown value -RDX=0x00007efbf6ece008: <offset 0x4008> 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: <offset 0x621020> 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: <unknown> -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 Binary files differindex f06df33..01dc38a 100644 --- a/jar/scilab_en_US_help.jar +++ b/jar/scilab_en_US_help.jar diff --git a/macros/Checkdims.bin b/macros/Checkdims.bin Binary files differindex 40e385a..8df0367 100644 --- a/macros/Checkdims.bin +++ b/macros/Checkdims.bin diff --git a/macros/Checklhs.bin b/macros/Checklhs.bin Binary files differindex 7156107..34561dc 100644 --- a/macros/Checklhs.bin +++ b/macros/Checklhs.bin diff --git a/macros/Checkrhs.bin b/macros/Checkrhs.bin Binary files differindex 2c45876..2ec00b7 100644 --- a/macros/Checkrhs.bin +++ b/macros/Checkrhs.bin diff --git a/macros/Checktype.bin b/macros/Checktype.bin Binary files differindex bbe1585..a43e55c 100644 --- a/macros/Checktype.bin +++ b/macros/Checktype.bin diff --git a/macros/Checkvector.bin b/macros/Checkvector.bin Binary files differindex 710f1ff..9a6bfdc 100644 --- a/macros/Checkvector.bin +++ b/macros/Checkvector.bin 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 Binary files differindex faa0821..c329f4a 100644 --- a/macros/fgoalattain.bin +++ b/macros/fgoalattain.bin diff --git a/macros/fminbnd.bin b/macros/fminbnd.bin Binary files differindex 24cd387..c9ddb2e 100644 --- a/macros/fminbnd.bin +++ b/macros/fminbnd.bin diff --git a/macros/fmincon.bin b/macros/fmincon.bin Binary files differindex ef503f1..dacdfd9 100644 --- a/macros/fmincon.bin +++ b/macros/fmincon.bin diff --git a/macros/fminimax.bin b/macros/fminimax.bin Binary files differindex c023720..9704302 100644 --- a/macros/fminimax.bin +++ b/macros/fminimax.bin 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 Binary files differindex 0160e5f..ab53755 100644 --- a/macros/fminunc.bin +++ b/macros/fminunc.bin 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; Binary files differdiff --git a/macros/linprog.bin b/macros/linprog.bin Binary files differindex 1d3a5aa..7ba3ab3 100644 --- a/macros/linprog.bin +++ b/macros/linprog.bin diff --git a/macros/lsqlin.bin b/macros/lsqlin.bin Binary files differindex 4e07959..56c1e69 100644 --- a/macros/lsqlin.bin +++ b/macros/lsqlin.bin 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 Binary files differindex 01a1a7d..17b5808 100644 --- a/macros/lsqnonneg.bin +++ b/macros/lsqnonneg.bin 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 Binary files differindex a490aaf..2b4af21 100644 --- a/macros/matrix_linprog.bin +++ b/macros/matrix_linprog.bin diff --git a/macros/matrix_linprog.sci b/macros/matrix_linprog.sci index 667fd3d..469066c 100755..100644 --- 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 Binary files differindex 2bc6eca..f45ed06 100644 --- a/macros/mps_linprog.bin +++ b/macros/mps_linprog.bin 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 Binary files differindex f6de035..d33679e 100644 --- a/macros/qpipopt.bin +++ b/macros/qpipopt.bin 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 Binary files differindex 3e9d8f6..0bd1c14 100644 --- a/macros/qpipoptmat.bin +++ b/macros/qpipoptmat.bin 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 Binary files differindex 8d23e73..8953829 100644 --- a/macros/setOptions.bin +++ b/macros/setOptions.bin diff --git a/macros/symphony.bin b/macros/symphony.bin Binary files differindex 2c3a43a..3dacf06 100644 --- a/macros/symphony.bin +++ b/macros/symphony.bin 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 Binary files differindex 5e0d5e1..57ce782 100644 --- a/macros/symphony_call.bin +++ b/macros/symphony_call.bin 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 Binary files differindex 7dffa2f..9d7271a 100644 --- a/macros/symphonymat.bin +++ b/macros/symphonymat.bin 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 index bd08505..bd08505 100755..100644 --- a/sci_gateway/cpp/LinCLP.hpp +++ b/sci_gateway/cpp/LinCLP.hpp 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 Binary files differindex 28c2d3b..78cf4da 100755 --- a/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so +++ b/sci_gateway/cpp/libFOSSEE_Optimization_Toolbox.so 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 <api_scilab.h> @@ -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 ; i<nCons ; i++) + { + CoinPackedVector row; + for(int j=0 ; j<nVars; j++) + { + row.insert(j, conMatrix[i+j*nCons]); + } + matrix->appendRow(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;i<nVars;i++) + { + sciprint("%lf",xValue[i]); + } //get objective value - double objValue = Prob->getObjVal(); - - //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 <IpIpoptApplication.hpp> +#include <IpSolveStatistics.hpp> +#include <IpTNLP.hpp> +#include <IpIpoptCalculatedQuantities.hpp> +#include <IpSmartPtr.hpp> extern "C"{ #include <api_scilab.h> @@ -18,7 +22,11 @@ extern "C"{ #include <BOOL.h> #include <localization.h> #include <sciprint.h> - +#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<IpoptApplication> 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<TNLP>&)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<minbndNLP> Prob = new minbndNLP(nVars,nCons,varLB,varUB); SmartPtr<IpoptApplication> 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<TNLP>&)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<minconNLP> 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<IpoptApplication> 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<TNLP>&)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<minuncNLP> Prob = new minuncNLP(nVars, nCons, x0ptr, flag1, flag2); SmartPtr<IpoptApplication> 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<TNLP>&)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 <sciprint.h> #include <string.h> #include <assert.h> -#include <iostream> 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 <sciprint.h> #include <string.h> #include <assert.h> -#include <iostream> 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 <sciprint.h> #include <string.h> #include <assert.h> -#include <iostream> 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 <symphony.h> +#include <sci_iofunc.hpp> +extern sym_environment* global_sym_env;//defined in globals.cpp + +extern "C" { +#include <api_scilab.h> +#include <Scierror.h> +#include <BOOL.h> +#include <stdlib.h> +#include <malloc.h> +#include <localization.h> +#include <sciprint.h> + +#include <string.h> + +/* 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 <symphony.h> +#include <sci_iofunc.hpp> +extern sym_environment* global_sym_env;//defined in globals.cpp + +extern "C" { +#include <api_scilab.h> +#include <Scierror.h> +#include <BOOL.h> +#include <stdlib.h> +#include <malloc.h> +#include <localization.h> +#include <sciprint.h> + +#include <string.h> + +/* + * 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 <symphony.h> +#include <sci_iofunc.hpp> +extern sym_environment* global_sym_env;//defined in globals.cpp + +extern "C" { +#include <api_scilab.h> +#include <Scierror.h> +#include <BOOL.h> +#include <stdlib.h> +#include <malloc.h> +#include <localization.h> +#include <sciprint.h> + +#include <string.h> + +/* + * 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 <symphony.h> +#include <sci_iofunc.hpp> +extern sym_environment* global_sym_env;//defined in globals.cpp + +extern "C" { +#include <api_scilab.h> +#include <Scierror.h> +#include <BOOL.h> +#include <stdlib.h> +#include <malloc.h> +#include <localization.h> +#include <sciprint.h> + +#include <string.h> + +/* + * 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 <api_scilab.h> #include <Scierror.h> #include <BOOL.h> +#include <stdlib.h> +#include <malloc.h> #include <localization.h> #include <sciprint.h> //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(count<columns) { - value[count]=(unsigned int)array_ptr[count]; + value[count]=(int)array_ptr[count]; count++; } sciprint("\n"); @@ -103,7 +105,7 @@ int sci_sym_delete_cols(char *fname, unsigned long fname_len){ } //only when the number of columns to be deleted is lesser than the actual number of columns ,execution is proceeded with if(columns<=num_cols){ - output=sym_delete_cols(global_sym_env,(unsigned int)columns,value);//symphony function to delete the columns specified + output=sym_delete_cols(global_sym_env,(int)columns,value);//symphony function to delete the columns specified if(output==FUNCTION_TERMINATED_NORMALLY) { sciprint("Execution is successfull\n"); @@ -147,7 +149,7 @@ int sci_sym_delete_rows(char *fname, unsigned long fname_len){ int num_rows;//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 row 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 rows numbers to be deleted int *piAddressVarTwo = NULL;//pointer used to access first and second arguments of the function int output=0;//output parameter for the symphony sym_delete_rows function @@ -179,11 +181,11 @@ int sci_sym_delete_rows(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(count<columns) { - value[count]=(unsigned int)array_ptr[count]; + value[count]=(int)array_ptr[count]; count++; } sciprint("\n"); @@ -219,7 +221,7 @@ int sci_sym_delete_rows(char *fname, unsigned long fname_len){ } //only when the number of rows to be deleted is lesser than the actual number of rows ,execution is proceeded with if(columns<=num_rows){ - output=sym_delete_rows(global_sym_env,(unsigned int)columns,value);//symphony function to delete the rows specified + output=sym_delete_rows(global_sym_env,(int)columns,value);//symphony function to delete the rows specified if(output==FUNCTION_TERMINATED_NORMALLY) { sciprint("Execution is successfull\n"); @@ -252,8 +254,4 @@ int sci_sym_delete_rows(char *fname, unsigned long fname_len){ return 0; } - - - - } diff --git a/tests/general_tests/fminunc/fminunc_f.sce b/tests/general_tests/fminunc/fminunc_f.sce index 7fd0e2c..416f5cf 100644 --- a/tests/general_tests/fminunc/fminunc_f.sce +++ b/tests/general_tests/fminunc/fminunc_f.sce @@ -3,7 +3,7 @@ fun = []; x0 = [1,2,3,4,5,6]; -options=list("MaxIter", [1500], "CpuTime", [500], "Gradient", "OFF", "Hessian", "OFF"); +options=list("MaxIter", [1500], "CpuTime", [500], "GradObj", "OFF", "Hessian", "OFF"); //Error //fminbnd: Expected function for Objective (1st Parameter) diff --git a/tests/general_tests/fminunc/fminunc_gradient1.sce b/tests/general_tests/fminunc/fminunc_gradient1.sce index 214ff89..0da9b1c 100644 --- a/tests/general_tests/fminunc/fminunc_gradient1.sce +++ b/tests/general_tests/fminunc/fminunc_gradient1.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", [100], "Gradient", "OFn", "Hessian", "OFF"); +options=list("MaxIter", [1000], "CpuTime", [100], "GradObj", "OFn", "Hessian", "OFF"); //Error //fminunc: Unrecognized String [OFn] entered for the option- Gradient. diff --git a/tests/general_tests/fminunc/fminunc_gradient2.sce b/tests/general_tests/fminunc/fminunc_gradient2.sce index 5c1c3d3..921e6ef 100644 --- a/tests/general_tests/fminunc/fminunc_gradient2.sce +++ b/tests/general_tests/fminunc/fminunc_gradient2.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", [100], "Gradient", "", "Hessian", "OFF"); +options=list("MaxIter", [1000], "CpuTime", [100], "GradObj", "", "Hessian", "OFF"); //Error //fminunc: Unrecognized String [] entered for the option- Gradient. diff --git a/tests/general_tests/fminunc/fminunc_gradient3.sce b/tests/general_tests/fminunc/fminunc_gradient3.sce index f35f7f1..0cb85d7 100644 --- a/tests/general_tests/fminunc/fminunc_gradient3.sce +++ b/tests/general_tests/fminunc/fminunc_gradient3.sce @@ -6,7 +6,7 @@ function y = fun(x) endfunction x0 = [1,2]; grad = []; -options=list("MaxIter", [1000], "CpuTime", [100], "Gradient", grad, "Hessian", "OFF"); +options=list("MaxIter", [1000], "CpuTime", [100], "GradObj", grad, "Hessian", "OFF"); //Error //fminunc: Expected function for Gradient of Objective diff --git a/tests/general_tests/fminunc/fminunc_gradient4.sce b/tests/general_tests/fminunc/fminunc_gradient4.sce index 3a6a716..b4ddc39 100644 --- a/tests/general_tests/fminunc/fminunc_gradient4.sce +++ b/tests/general_tests/fminunc/fminunc_gradient4.sce @@ -8,7 +8,7 @@ x0 = [1,2]; function y = grad(x) y=[2*x(1)]; endfunction -options=list("MaxIter", [1000], "CpuTime", [100], "Gradient", grad, "Hessian", "OFF"); +options=list("MaxIter", [1000], "CpuTime", [100], "GradObj", grad, "Hessian", "OFF"); //Error //fminunc: Expected function for Hessian of Objective diff --git a/tests/general_tests/fminunc/fminunc_hessian1.sce b/tests/general_tests/fminunc/fminunc_hessian1.sce index a8ba79b..f4be9d4 100644 --- a/tests/general_tests/fminunc/fminunc_hessian1.sce +++ b/tests/general_tests/fminunc/fminunc_hessian1.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", [100], "Gradient", "OFF", "Hessian", "OFn"); +options=list("MaxIter", [1000], "CpuTime", [100], "GradObj", "OFF", "Hessian", "OFn"); //Error //fminunc: Unrecognized String [OFn] entered for the option- Hessian. diff --git a/tests/general_tests/fminunc/fminunc_hessian2.sce b/tests/general_tests/fminunc/fminunc_hessian2.sce index 99fd6c1..f2c9335 100644 --- a/tests/general_tests/fminunc/fminunc_hessian2.sce +++ b/tests/general_tests/fminunc/fminunc_hessian2.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", [100], "Gradient", "OFf", "Hessian", ""); +options=list("MaxIter", [1000], "CpuTime", [100], "GradObj", "OFf", "Hessian", ""); //Error //fminunc: Unrecognized String [] entered for the option- Hessian. diff --git a/tests/general_tests/fminunc/fminunc_hessian4.sce b/tests/general_tests/fminunc/fminunc_hessian4.sce index 47ce1c4..60c3177 100644 --- a/tests/general_tests/fminunc/fminunc_hessian4.sce +++ b/tests/general_tests/fminunc/fminunc_hessian4.sce @@ -8,7 +8,7 @@ x0 = [1,2]; function y = hess(x) y=[2,0]; endfunction -options=list("MaxIter", [1000], "CpuTime", [100], "Gradient", "OFF", "Hessian", hess); +options=list("MaxIter", [1000], "CpuTime", [100], "GradObj", "OFF", "Hessian", hess); //Error //fminunc: Wrong Input for Objective Hessian function(3rd Parameter)---->Symmetric 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 Binary files differindex 93ce388..ea97588 100755 --- a/thirdparty/linux/lib/x64/libcoinblas.so.1.4.4 +++ b/thirdparty/linux/lib/x64/libcoinblas.so.1.4.4 diff --git a/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4 b/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4 Binary files differindex 038c68d..73eac4c 100755 --- a/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4 +++ b/thirdparty/linux/lib/x64/libcoinlapack.so.1.5.4 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 Binary files differnew file mode 100755 index 0000000..48b6591 --- /dev/null +++ b/thirdparty/linux/lib/x64/libcoinmetis.so.1.3.4 diff --git a/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4 b/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4 Binary files differindex 6f582d8..6a33b7c 100755 --- a/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4 +++ b/thirdparty/linux/lib/x64/libcoinmumps.so.1.5.4 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 <string> +#include <iostream> +#include <cassert> + +#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 <readline/readline.h> +#include <readline/history.h> +#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<unsigned int>(name_.length()); + if ( shriekPos == std::string::npos ) { + //does not contain '!' + lengthMatch_ = lengthName_; + } else { + lengthMatch_ = static_cast<unsigned int>(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<int>(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_<fakeKeyWord_){ + return currentKeyWord_; + } else { + // fake + if (currentKeyWord_<0) + fakeInteger = currentKeyWord_ + 1000; + else + fakeInteger = currentKeyWord_ - 1000; + return fakeValue_; + } +} +// Returns length of name for printing +int +CbcOrClpParam::lengthMatchName ( ) const +{ + if (lengthName_ == lengthMatch_) + return lengthName_; + else + return lengthName_ + 2; +} +// Insert string (only valid for keywords) +void +CbcOrClpParam::append(std::string keyWord) +{ + definedKeyWords_.push_back(keyWord); +} + +int +CbcOrClpParam::matches (std::string input) const +{ + // look up strings to do more elegantly + if (input.length() > 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<int>(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<int>(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 << "<Possible options for " << name_ << " are:"; + unsigned int it; + for (it = 0; it < definedKeyWords_.size(); it++) { + std::string thisOne = definedKeyWords_[it]; + std::string::size_type shriekPos = thisOne.find('!'); + if ( shriekPos != std::string::npos ) { + //contains '!' + thisOne = thisOne.substr(0, shriekPos) + + "(" + thisOne.substr(shriekPos + 1) + ")"; + } + std::cout << " " << thisOne; + } + assert (currentKeyWord_ >= 0 && currentKeyWord_ < static_cast<int>(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<int>(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("<Range of values is %g to %g;\n\tcurrent %g>\n", lowerDoubleValue_, upperDoubleValue_, doubleValue_); + assert (upperDoubleValue_ > lowerDoubleValue_); + } else if (type_ < CLP_PARAM_STR_DIRECTION) { + printf("<Range of values is %d to %d;\n\tcurrent %d>\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<int>(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_<fakeKeyWord_)) + strcpy(current,definedKeyWords_[currentKeyWord_].c_str()); + else if (currentKeyWord_<0) + sprintf(current,"minus%d",-currentKeyWord_-1000); + else + sprintf(current,"plus%d",currentKeyWord_-1000); + if (value>=0&&(fakeKeyWord_<=0||value<fakeKeyWord_) ) + strcpy(newString,definedKeyWords_[value].c_str()); + else if (value<0) + sprintf(newString,"minus%d",-value-1000); + else + sprintf(newString,"plus%d",value-1000); + sprintf(printArray, "Option for %s changed from %s to %s", + name_.c_str(), current, newString); +#if FLUSH_PRINT_BUFFER > 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_<fakeKeyWord_)) + strcpy(current,definedKeyWords_[currentKeyWord_].c_str()); + else if (currentKeyWord_<0) + sprintf(current,"minus%d",-currentKeyWord_-1000); + else + sprintf(current,"plus%d",currentKeyWord_-1000); + sprintf(printArray, "Option for %s changed from %s to %s", + name_.c_str(), current, value.c_str()); + currentKeyWord_ = action; + } else { + sprintf(printArray, "Option for %s given illegal value %s", + name_.c_str(), value.c_str()); + } + return printArray; +} +void +CbcOrClpParam::setIntValue ( int value ) +{ + if (value < lowerIntValue_ || value > 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<int>(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<int>(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 "<<field<<std::endl; + // field="EOL"; // skip + } else if (CbcOrClpEnvironmentIndex < 0) { + // special dispensation - taken as -import name + CbcOrClpRead_mode--; + field = "import"; + } + } else { + if (field != "--") { + // take off - + field = field.substr(1); + } else { + // special dispensation - taken as -import -- + CbcOrClpRead_mode--; + field = "import"; + } + } + } else { + field = ""; + } + } else { + field = CoinReadNextField(); + } + } + // if = then modify and save + std::string::size_type found = field.find('='); + if (found != std::string::npos) { + afterEquals = field.substr(found + 1); + field = field.substr(0, found); + } + //std::cout<<field<<std::endl; + return field; +} +std::string +CoinReadGetString(int argc, const char *argv[]) +{ + std::string field = "EOL"; + if (afterEquals == "") { + if (CbcOrClpRead_mode > 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<<field<<std::endl; + return field; +} +// valid 0 - okay, 1 bad, 2 not there +int +CoinReadGetIntField(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 = ""; + } + long int value = 0; + //std::cout<<field<<std::endl; + if (field != "EOL") { + const char * start = field.c_str(); + char * endPointer = NULL; + // check valid + value = strtol(start, &endPointer, 10); + if (*endPointer == '\0') { + *valid = 0; + } else { + *valid = 1; + std::cout << "String of " << field; + } + } else { + *valid = 2; + } + return static_cast<int>(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<<field<<std::endl; + if (field != "EOL") { + const char * start = field.c_str(); + char * endPointer = NULL; + // check valid + value = strtod(start, &endPointer); + if (*endPointer == '\0') { + *valid = 0; + } else { + *valid = 1; + std::cout << "String of " << field; + } + } else { + *valid = 2; + } + return value; +} +/* + 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) +{ + numberParameters = 0; + parameters[numberParameters++] = + CbcOrClpParam("?", "For help", CBC_PARAM_GENERALQUERY, 7, 0); + parameters[numberParameters++] = + CbcOrClpParam("???", "For help", CBC_PARAM_FULLGENERALQUERY, 7, 0); + parameters[numberParameters++] = + CbcOrClpParam("-", "From stdin", + CLP_PARAM_ACTION_STDIN, 3, 0); +#ifdef ABC_INHERIT + parameters[numberParameters++] = + CbcOrClpParam("abc", "Whether to visit Aboca", + "off", CLP_PARAM_STR_ABCWANTED, 7, 0); + parameters[numberParameters-1].append("one"); + parameters[numberParameters-1].append("two"); + parameters[numberParameters-1].append("three"); + parameters[numberParameters-1].append("four"); + parameters[numberParameters-1].append("five"); + parameters[numberParameters-1].append("six"); + parameters[numberParameters-1].append("seven"); + parameters[numberParameters-1].append("eight"); + parameters[numberParameters-1].append("on"); + parameters[numberParameters-1].append("decide"); + parameters[numberParameters-1].setFakeKeyWord(10); + parameters[numberParameters-1].setLonghelp + ( + "Decide whether to use A Basic Optimization Code (Accelerated?) \ +and whether to try going parallel!" + ); +#endif + parameters[numberParameters++] = + CbcOrClpParam("allC!ommands", "Whether to print less used commands", + "no", CLP_PARAM_STR_ALLCOMMANDS); + parameters[numberParameters-1].append("more"); + parameters[numberParameters-1].append("all"); + parameters[numberParameters-1].setLonghelp + ( + "For the sake of your sanity, only the more useful and simple commands \ +are printed out on ?." + ); +#ifdef COIN_HAS_CBC + parameters[numberParameters++] = + CbcOrClpParam("allow!ableGap", "Stop when gap between best possible and \ +best less than this", + 0.0, 1.0e20, CBC_PARAM_DBL_ALLOWABLEGAP); + parameters[numberParameters-1].setDoubleValue(0.0); + parameters[numberParameters-1].setLonghelp + ( + "If the gap between best solution and best possible solution is less than this \ +then the search will be terminated. Also see ratioGap." + ); +#endif +#ifdef COIN_HAS_CLP + parameters[numberParameters++] = + CbcOrClpParam("allS!lack", "Set basis back to all slack and reset solution", + CLP_PARAM_ACTION_ALLSLACK, 3); + parameters[numberParameters-1].setLonghelp + ( + "Mainly useful for tuning purposes. Normally the first dual or primal will be using an all slack \ +basis anyway." + ); +#endif +#ifdef COIN_HAS_CBC + parameters[numberParameters++] = + CbcOrClpParam("artif!icialCost", "Costs >= 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<size_t>(numberRows)) + throw("Error in fread"); + nRead = fread(dualRowSolution, sizeof(double), numberRows, fp); + if (nRead != static_cast<size_t>(numberRows)) + throw("Error in fread"); + nRead = fread(primalColumnSolution, sizeof(double), numberColumns, fp); + if (nRead != static_cast<size_t>(numberColumns)) + throw("Error in fread"); + nRead = fread(dualColumnSolution, sizeof(double), numberColumns, fp); + if (nRead != static_cast<size_t>(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<size_t>(numberRowsFile)) + throw("Error in fread"); + CoinMemcpyN(temp, numberRows, primalRowSolution); + nRead = fread(temp, sizeof(double), numberRowsFile, fp); + if (nRead != static_cast<size_t>(numberRowsFile)) + throw("Error in fread"); + CoinMemcpyN(temp, numberRows, dualRowSolution); + nRead = fread(temp, sizeof(double), numberColumnsFile, fp); + if (nRead != static_cast<size_t>(numberColumnsFile)) + throw("Error in fread"); + CoinMemcpyN(temp, numberColumns, primalColumnSolution); + nRead = fread(temp, sizeof(double), numberColumnsFile, fp); + if (nRead != static_cast<size_t>(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<ClpSimplex *>(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<size_t>(numberRows)) + throw("Error in fwrite"); + nWrite = fwrite(dualRowSolution, sizeof(double), numberRows, fp); + if (nWrite != static_cast<size_t>(numberRows)) + throw("Error in fwrite"); + double * dualColumnSolution = lpSolver->dualColumnSolution(); + double * primalColumnSolution = lpSolver->primalColumnSolution(); + nWrite = fwrite(primalColumnSolution, sizeof(double), numberColumns, fp); + if (nWrite != static_cast<size_t>(numberColumns)) + throw("Error in fwrite"); + nWrite = fwrite(dualColumnSolution, sizeof(double), numberColumns, fp); + if (nWrite != static_cast<size_t>(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 + <ul> + <li> 1 -- 100 double parameters + <li> 101 -- 200 integer parameters + <li> 201 -- 250 string parameters + <li> 251 -- 300 cuts etc(string but broken out for clarity) + <li> 301 -- 400 `actions' + </ul> + + `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 <vector> +#include <string> + +/// 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<std::string> 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 <cstdio> +#include <cstdlib> +#include <cmath> + +#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 <string> + +#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:<BR> + 0: must be kept (for #includes etc)<BR> + 3: Set to changed (not default) values<BR> + 4: Set to default values (redundant)<BR> + + 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 <string> + +#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 <iostream> + +#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: + * <ul> + * <li> classify row types + * <li> indentify vubs and vlbs + * </ul> + * This function is called by + * <CODE>generateCuts(const OsiSolverInterface & si, OsiCuts & cs)</CODE>. + */ + 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 <string> + +#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 <normal then use normal) + void setLimitAtRoot(int limit); + /// Get at root + int getLimitAtRoot() const; + /// Return maximum length of cut in tree + virtual int maximumLengthOfCutInTree() const; + //@} + + /**@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; + //@} + + /**@name Change criterion on which the cut id relaxed if the code + thinks the factorization has inaccuracies. The relaxation to + RHS is smallest of - + 1) 1.0e-4 + 2) conditionNumberMultiplier * condition number of factorization + 3) largestFactorMultiplier * largest (dual*element) forming tableau + row + */ + //@{ + /// Set ConditionNumberMultiplier + void setConditionNumberMultiplier(double value); + /// Get ConditionNumberMultiplier + double getConditionNumberMultiplier() const; + /// Set LargestFactorMultiplier + void setLargestFactorMultiplier(double value); + /// Get LargestFactorMultiplier + double getLargestFactorMultiplier() const; + //@} + + /**@name change factorization */ + //@{ + /// Set/unset alternative factorization + inline void useAlternativeFactorization(bool yes=true) + { alternateFactorization_= (yes) ? 1 : 0;} + /// Get whether alternative factorization being used + inline bool alternativeFactorization() const + { return (alternateFactorization_!=0);} + //@} + + /**@name Constructors and destructors */ + //@{ + /// Default constructor + CglGomory (); + + /// Copy constructor + CglGomory ( + const CglGomory &); + + /// Clone + virtual CglCutGenerator * clone() const; + + /// Assignment operator + CglGomory & + operator=( + const CglGomory& rhs); + + /// Destructor + virtual + ~CglGomory (); + /// 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 methods + + // Private member data + + /**@name Private member data */ + //@{ + /// Only investigate if more than this away from integrality + double away_; + /// Only investigate if more than this away from integrality (at root) + double awayAtRoot_; + /// Multiplier for conditionNumber cut relaxation + double conditionNumberMultiplier_; + /// Multiplier for largest factor cut relaxation + double largestFactorMultiplier_; + /// Original solver + OsiSolverInterface * originalSolver_; + /// Limit - only generate if fewer than this in cut + int limit_; + /// Limit - only generate if fewer than this in cut (at root) + int limitAtRoot_; + /// Dynamic limit in tree + int dynamicLimitInTree_; + /// Number of times stalled + int numberTimesStalled_; + /// nonzero to use alternative factorization + int alternateFactorization_; + /// Type - 0 normal, 1 add original matrix one, 2 replace + int gomoryType_; + //@} +}; + +//############################################################################# +/** A function that tests the methods in the CglGomory 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 CglGomoryUnitTest(const OsiSolverInterface * siP, + const std::string mpdDir ); + +#endif diff --git a/thirdparty/windows/include/coin/CglKnapsackCover.hpp b/thirdparty/windows/include/coin/CglKnapsackCover.hpp new file mode 100644 index 0000000..b0e81d6 --- /dev/null +++ b/thirdparty/windows/include/coin/CglKnapsackCover.hpp @@ -0,0 +1,310 @@ +// $Id: CglKnapsackCover.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 CglKnapsackCover_H +#define CglKnapsackCover_H + +#include <string> + +#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 <iostream> +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 : + <ol start=0 > + <li> for none </li> + <li> for log at begin and end of procedure + at some time interval </li> + <li> for log at every cut generated </li> + </ol> + */ + 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<int>& 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 <vector> + +/** 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<int> (code)]; + } + const char* failureString(int code) const + { + return rejections_[ code]; + } + int numRejected(RejectionsReasons code)const + { + return numRejected_[static_cast<int> (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<int> 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 <string> + +#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<double>(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 <iostream> +#include <fstream> +//#include <vector> + +#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<int>& 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<int>& 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<int>& 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.<UL> + <LI> -1: preprocess according to solver settings; + <LI> 0: Do preprocessing only if it has not yet been done; + <LI> 1: Do preprocessing. + </UL> + 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 <iostream> +#include <fstream> +//#include <vector> + +#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.<UL> + <LI> -1: preprocess according to solver settings; + <LI> 0: Do preprocessing only if it has not yet been done; + <LI> 1: Do preprocessing. + </UL> + 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 <string> + +#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 <string> +#include <vector> + +#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<numberSolvers_) return model_[iPass]; else return NULL;} + /// Copies of solver at various stages after presolve after modifications + inline OsiSolverInterface * modifiedModel(int iPass) const + { if (iPass>=0&&iPass<numberSolvers_) return modifiedModel_[iPass]; else return NULL;} + /// Matching presolve information + inline OsiPresolve * presolve(int iPass) const + { if (iPass>=0&&iPass<numberSolvers_) return presolve_[iPass]; else return NULL;} + /** Return a pointer to the original columns (with possible clique slacks) + MUST be called before postProcess otherwise you just get 0,1,2.. */ + const int * originalColumns(); + /** Return a pointer to the original rows + MUST be called before postProcess otherwise you just get 0,1,2.. */ + const int * originalRows(); + /// Number of SOS if found + inline int numberSOS() const + { return numberSOS_;} + /// Type of each SOS + inline const int * typeSOS() const + { return typeSOS_;} + /// Start of each SOS + inline const int * startSOS() const + { return startSOS_;} + /// Columns in SOS + inline const int * whichSOS() const + { return whichSOS_;} + /// Weights for each SOS column + inline const double * weightSOS() const + { return weightSOS_;} + /// Pass in prohibited columns + void passInProhibited(const char * prohibited,int numberColumns); + /// Updated prohibited columns + inline const char * prohibited() + { return prohibited_;} + /// Number of iterations PreProcessing + inline int numberIterationsPre() const + { return numberIterationsPre_;} + /// Number of iterations PostProcessing + inline int numberIterationsPost() const + { return numberIterationsPost_;} + /** Pass in row types + 0 normal + 1 cut rows - will be dropped if remain in + At end of preprocess cut rows will be dropped + and put into cuts + */ + void passInRowTypes(const char * rowTypes,int numberRows); + /** Updated row types - may be NULL + Carried around and corresponds to existing rows + -1 added by preprocess e.g. x+y=1 + 0 normal + 1 cut rows - can be dropped if wanted + */ + inline const char * rowTypes() + { return rowType_;} + /// Return cuts from dropped rows + inline const CglStored & cuts() const + { return cuts_;} + /// Return pointer to cuts from dropped rows + inline const CglStored * cutsPointer() const + { return &cuts_;} + /// Update prohibited and rowType + void update(const OsiPresolve * pinfo,const OsiSolverInterface * solver); + /// Set options + inline void setOptions(int value) + { options_=value;} + //@} + + ///@name Cut generator methods + //@{ + /// Get the number of cut generators + inline int numberCutGenerators() const + { return numberCutGenerators_;} + /// Get the list of cut generators + inline CglCutGenerator ** cutGenerators() const + { return generator_;} + ///Get the specified cut generator + inline CglCutGenerator * cutGenerator(int i) const + { return generator_[i];} + /** Add one generator - up to user to delete generators. + */ + void addCutGenerator(CglCutGenerator * generator); +//@} + + /**@name Setting/Accessing application data */ + //@{ + /** Set application data. + + This is a pointer that the application can store into and + retrieve. + This field is available for the application to optionally + define and use. + */ + void setApplicationData (void * appData); + + /// Get application data + void * getApplicationData() const; + //@} + + //--------------------------------------------------------------------------- + + /**@name Message handling */ + //@{ + /// Pass in Message handler (not deleted at end) + void passInMessageHandler(CoinMessageHandler * handler); + /// Set language + void newLanguage(CoinMessages::Language language); + inline void setLanguage(CoinMessages::Language language) + {newLanguage(language);} + /// Return handler + inline CoinMessageHandler * messageHandler() const + {return handler_;} + /// Return messages + inline CoinMessages messages() + {return messages_;} + /// Return pointer to messages + inline CoinMessages * messagesPointer() + {return &messages_;} + //@} + //--------------------------------------------------------------------------- + + + ///@name Constructors and destructors etc + //@{ + /// Constructor + CglPreProcess(); + + /// Copy constructor . + CglPreProcess(const CglPreProcess & rhs); + + /// Assignment operator + CglPreProcess & operator=(const CglPreProcess& rhs); + + /// Destructor + ~CglPreProcess (); + + /// Clears out as much as possible + void gutsOfDestructor(); + //@} +private: + + ///@name private methods + //@{ + /** Return model with useful modifications. + If constraints true then adds any x+y=1 or x-y=0 constraints + If NULL infeasible + */ + OsiSolverInterface * modified(OsiSolverInterface * model, + bool constraints, + int & numberChanges, + int iBigPass, + int numberPasses); + /// create original columns and rows + void createOriginalIndices(); + /// Make continuous variables integer + void makeInteger(); + //@} + +//--------------------------------------------------------------------------- + +private: + ///@name Private member data + //@{ + + /// The original solver associated with this model. + OsiSolverInterface * originalModel_; + /// Solver after making clique equalities (may == original) + OsiSolverInterface * startModel_; + /// Number of solvers at various stages + int numberSolvers_; + /// Copies of solver at various stages after presolve + OsiSolverInterface ** model_; + /// Copies of solver at various stages after presolve after modifications + OsiSolverInterface ** modifiedModel_; + /// Matching presolve information + OsiPresolve ** presolve_; + + /// Message handler + CoinMessageHandler * handler_; + + /** Flag to say if handler_ is the default handler. + + The default handler is deleted when the model is deleted. Other + handlers (supplied by the client) will not be deleted. + */ + bool defaultHandler_; + + /// Cgl messages + CoinMessages messages_; + + /// Pointer to user-defined data structure + void * appData_; + /// Original column numbers + int * originalColumn_; + /// Original row numbers + int * originalRow_; + /// Number of cut generators + int numberCutGenerators_; + /// Cut generators + CglCutGenerator ** generator_; + /// Number of SOS if found + int numberSOS_; + /// Type of each SOS + int * typeSOS_; + /// Start of each SOS + int * startSOS_; + /// Columns in SOS + int * whichSOS_; + /// Weights for each SOS column + double * weightSOS_; + /// Number of columns in original prohibition set + int numberProhibited_; + /// Number of iterations done in PreProcessing + int numberIterationsPre_; + /// Number of iterations done in PostProcessing + int numberIterationsPost_; + /// Columns which should not be presolved e.g. SOS + char * prohibited_; + /// Number of rows in original row types + int numberRowType_; + /** Options + 1 - original model had integer bounds before tightening + 2 - don't do probing + 4 - don't do duplicate rows + 8 - don't do cliques + 16 - some heavy probing options + 64 - very heavy probing + */ + int options_; + /** Row types (may be NULL) + Carried around and corresponds to existing rows + -1 added by preprocess e.g. x+y=1 + 0 normal + 1 cut rows - can be dropped if wanted + */ + char * rowType_; + /// Cuts from dropped rows + CglStored cuts_; + //@} +}; +/// For Bron-Kerbosch +class CglBK { + +public: + + ///@name Main methods + //@{ + /// For recursive Bron-Kerbosch + void bronKerbosch(); + /// Creates strengthened smaller model + OsiSolverInterface * newSolver(const 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. + + */ + //@{ + //@} + + //--------------------------------------------------------------------------- + + + ///@name Constructors and destructors etc + //@{ + /// Default constructor + CglBK(); + + /// Useful constructor + CglBK(const OsiSolverInterface & model, const char * rowType, + int numberElements); + + /// Copy constructor . + CglBK(const CglBK & rhs); + + /// Assignment operator + CglBK & operator=(const CglBK& rhs); + + /// Destructor + ~CglBK (); + + //@} + +//--------------------------------------------------------------------------- + +private: + ///@name Private member data + //@{ + /// Current candidates (created at each level) + int * candidates_; + /// Array to mark stuff + char * mark_; + /// Starts for graph (numberPossible+1) + int * start_; + /// Other column/node + int * otherColumn_; + /// Original row (in parallel with otherColumn_) + int * originalRow_; + /// How many times each original row dominated + int * dominated_; + /// Clique entries + CoinPackedMatrix * cliqueMatrix_; + /// points to row types + const char * rowType_; + /// Number of original columns + int numberColumns_; + /// Number of original rows + int numberRows_; + /// Number possible + int numberPossible_; + /// Current number of candidates + int numberCandidates_; + /// First not (stored backwards from numberPossible_) + int firstNot_; + /// Current number in clique + int numberIn_; + /// For acceleration + int left_; + int lastColumn_; + //@} +}; +/** + Only store unique row cuts +*/ +// for hashing +typedef struct { + int index, next; +} CglHashLink; +class OsiRowCut; +class CglUniqueRowCuts { +public: + + CglUniqueRowCuts(int initialMaxSize=0, int hashMultiplier=4 ); + ~CglUniqueRowCuts(); + CglUniqueRowCuts(const CglUniqueRowCuts& rhs); + CglUniqueRowCuts& operator=(const CglUniqueRowCuts& rhs); + inline OsiRowCut * cut(int sequence) const + { return rowCut_[sequence];} + inline int numberCuts() const + { return numberCuts_;} + inline int sizeRowCuts() const + { return numberCuts_;} + inline OsiRowCut * rowCutPtr(int sequence) + { return rowCut_[sequence];} + void eraseRowCut(int sequence); + // insert cut + inline void insert(const OsiRowCut & cut) + { insertIfNotDuplicate(cut);} + // Return 0 if added, 1 if not + int insertIfNotDuplicate(const OsiRowCut & cut); + // Add in cuts as normal cuts (and delete) + void addCuts(OsiCuts & cs); +private: + OsiRowCut ** rowCut_; + /// Hash table + CglHashLink *hash_; + int size_; + int hashMultiplier_; + int numberCuts_; + int lastHash_; +}; +#endif diff --git a/thirdparty/windows/include/coin/CglProbing.hpp b/thirdparty/windows/include/coin/CglProbing.hpp new file mode 100644 index 0000000..5ca8996 --- /dev/null +++ b/thirdparty/windows/include/coin/CglProbing.hpp @@ -0,0 +1,543 @@ +// $Id: CglProbing.hpp 1201 2014-03-07 17:24:04Z 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 CglProbing_H +#define CglProbing_H + +#include <string> + +#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 <vector> + + /**@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<int> 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<ColumnSelectionStrategy> 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<RowSelectionStrategy> 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<int> 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<ColumnSelectionStrategy> 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<RowSelectionStrategy> 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<int> numRowsReduction_; + + /// Column selection method + std::vector<ColumnSelectionStrategy> columnSelectionStrategy_; + + /// Row selection method + std::vector<RowSelectionStrategy> rowSelectionStrategy_; + + /// Maximum number of rows to use for the reduction during Lift & Project + std::vector<int> numRowsReductionLAP_; + + /// Column selection method for Lift & Project + std::vector<ColumnSelectionStrategy> columnSelectionStrategyLAP_; + + /// Row selection method for Lift & Project + std::vector<RowSelectionStrategy> 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 <iostream> +#include <fstream> +//#include <vector> + +#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.<UL> + <LI> -1: preprocess according to solver settings; + <LI> 0: Do preprocessing only if it has not yet been done; + <LI> 1: Do preprocessing. + </UL> + 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 <string> + +#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<n; i++){ + retval=gcd(retval,vi[i]); + } + return retval; +} + +//############################################################################# +/** A function that tests the methods in the CglSimpleRounding 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 CglSimpleRoundingUnitTest(const OsiSolverInterface * siP, + const std::string mpdDir ); + +#endif diff --git a/thirdparty/windows/include/coin/CglStored.hpp b/thirdparty/windows/include/coin/CglStored.hpp new file mode 100644 index 0000000..07039d9 --- /dev/null +++ b/thirdparty/windows/include/coin/CglStored.hpp @@ -0,0 +1,125 @@ +// $Id: CglStored.hpp 1119 2013-04-06 20:24:18Z stefan $ +// 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 CglStored_H +#define CglStored_H + +#include <string> + +#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 <string> + +#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 <stdlib.h> +#include <stdio.h> +#include <stdarg.h> +#include <math.h> +#include <float.h> +#include <cassert> +#include <iostream.h> +*/ + +/******************** 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) ( (a<b)?a:b ) +#define DGG_MAX(a,b) ( (a>b)?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 <string> + +#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 <code>indDel</code>. */ + virtual void deleteCols(const int numDel, const int * indDel); + /** Delete the rows whose indices are listed in <code>indDel</code>. */ + 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 <code>y + A * scalar *x</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numColumns()</code> + @pre <code>y</code> must be of size <code>numRows()</code> */ + 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 <code>y + x * scalar * A</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numRows()</code> + @pre <code>y</code> must be of size <code>numColumns()</code> */ + 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 <code>x * scalar * A + y</code> in <code>z</code>. + 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 <code>x *A</code> in <code>z</code> 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<unsigned char>(st_byte & ~7); + st_byte = static_cast<unsigned char>(st_byte | status); + } + inline DynamicStatus getDynamicStatusGen(int sequence) const { + return static_cast<DynamicStatus> (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<unsigned char>(dynamicStatusGen_[i] | 8); + } + inline void unsetFlagged(int i) { + dynamicStatusGen_[i] = static_cast<unsigned char>(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 <code>y + A * scalar *x</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numColumns()</code> + @pre <code>y</code> must be of size <code>numRows()</code> */ + 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<ClpSimplex::Status> (status_[sequence] & 7); + } + inline void setStatus(int sequence, ClpSimplex::Status status) { + unsigned char & st_byte = status_[sequence]; + st_byte = static_cast<unsigned char>(st_byte & ~7); + st_byte = static_cast<unsigned char>(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<unsigned char>(status_[i] | 8); + } + inline void unsetFlaggedSlack(int i) { + status_[i] = static_cast<unsigned char>(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<unsigned char>(dynamicStatus_[i] | 8); + } + inline void unsetFlagged(int i) { + dynamicStatus_[i] = static_cast<unsigned char>(dynamicStatus_[i] & ~8); + } + inline void setDynamicStatus(int sequence, DynamicStatus status) { + unsigned char & st_byte = dynamicStatus_[sequence]; + st_byte = static_cast<unsigned char>(st_byte & ~7); + st_byte = static_cast<unsigned char>(st_byte | status); + } + inline DynamicStatus getDynamicStatus(int sequence) const { + return static_cast<DynamicStatus> (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 <code>y + A * scalar *x</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numColumns()</code> + @pre <code>y</code> must be of size <code>numRows()</code> */ + 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<unsigned char>(dynamicStatus_[i] | 8); + } + inline void unsetFlagged(int i) { + dynamicStatus_[i] = static_cast<unsigned char>(dynamicStatus_[i] & ~8); + } + inline void setDynamicStatus(int sequence, DynamicStatus status) { + unsigned char & st_byte = dynamicStatus_[sequence]; + st_byte = static_cast<unsigned char>(st_byte & ~7); + st_byte = static_cast<unsigned char>(st_byte | status); + } + inline DynamicStatus getDynamicStatus(int sequence) const { + return static_cast<DynamicStatus> (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 <code>x * scalar * A + y</code> in <code>z</code>. + 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 <code>x * scalar * A + y</code> in <code>z</code>. + 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 <code>x *A</code> in <code>z</code> 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<ClpSimplex::Status> (status_[sequence] & 7); + } + inline void setStatus(int sequence, ClpSimplex::Status status) { + unsigned char & st_byte = status_[sequence]; + st_byte = static_cast<unsigned char>(st_byte & ~7); + st_byte = static_cast<unsigned char>(st_byte | status); + } + /// To flag a variable + inline void setFlagged( int sequence) { + status_[sequence] = static_cast<unsigned char>(status_[sequence] | 64); + } + inline void clearFlagged( int sequence) { + status_[sequence] = static_cast<unsigned char>(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<unsigned char>(iStat & ~24); + status_[sequence] = static_cast<unsigned char>(iStat | 16); + } + /// To say key is feasible + inline void setFeasible( int sequence) { + unsigned char iStat = status_[sequence]; + iStat = static_cast<unsigned char>(iStat & ~24); + status_[sequence] = static_cast<unsigned char>(iStat | 8); + } + /// To say key is below lb + inline void setBelow( int sequence) { + unsigned char iStat = status_[sequence]; + iStat = static_cast<unsigned char>(iStat & ~24); + status_[sequence] = iStat; + } + inline double weight( int sequence) const { + int iStat = status_[sequence] & 31; + iStat = iStat >> 3; + return static_cast<double> (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 <iostream> +#include <cfloat> +#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: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>rowub</code>: all rows have upper bound infinity + <li> <code>rowlb</code>: all rows have lower bound -infinity + <li> <code>obj</code>: all variables have 0 objective coefficient + </ul> + */ + 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<unsigned char>(status_[sequence] | 1) ; + } + inline void clearFixed( int sequence) { + status_[sequence] = static_cast<unsigned char>(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<unsigned char>(status_[sequence] | 2) ; + } + inline void clearFlagged( int sequence) { + status_[sequence] = static_cast<unsigned char>(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<unsigned char>(status_[sequence] | 4) ; + } + inline void clearFixedOrFree( int sequence) { + status_[sequence] = static_cast<unsigned char>(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<unsigned char>(status_[sequence] | 8) ; + } + inline void clearLowerBound( int sequence) { + status_[sequence] = static_cast<unsigned char>(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<unsigned char>(status_[sequence] | 16) ; + } + inline void clearUpperBound( int sequence) { + status_[sequence] = static_cast<unsigned char>(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<unsigned char>(status_[sequence] | 32) ; + } + inline void clearFakeLower( int sequence) { + status_[sequence] = static_cast<unsigned char>(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<unsigned char>(status_[sequence] | 64) ; + } + inline void clearFakeUpper( int sequence) { + status_[sequence] = static_cast<unsigned char>(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 <code>indDel</code>. */ + virtual void deleteCols(const int numDel, const int * indDel) = 0; + /** Delete the rows whose indices are listed in <code>indDel</code>. */ + 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 <code>y + A * x * scalar</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numColumns()</code> + @pre <code>y</code> must be of size <code>numRows()</code> */ + 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 <code>y + x * scalar * A</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numRows()</code> + @pre <code>y</code> must be of size <code>numColumns()</code> */ + 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 <code>x * scalar *A + y</code> in <code>z</code>. + 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 <code>x *A</code> in <code>z</code> 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 <code>x *A</code> in <code>z</code> 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<br> + <strong>NOTE</strong>: 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 <cstring> + +// 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 <iostream> +#include <cassert> +#include <cmath> +#include <vector> +#include <string> +//#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: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>rowub</code>: all rows have upper bound infinity + <li> <code>rowlb</code>: all rows have lower bound -infinity + <li> <code>obj</code>: all variables have 0 objective coefficient + </ul> + */ + 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<std::string> & rowNames, + const std::vector<std::string> & columnNames); + /// Copies in Row names - modifies names first .. last-1 + void copyRowNames(const std::vector<std::string> & rowNames, int first, int last); + /// Copies in Column names - modifies names first .. last-1 + void copyColumnNames(const std::vector<std::string> & 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 + <ul> + <li> 0 - normal + <li> 1 - extra accuracy + <li> 2 - IEEE hex + </ul> + + 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<br> + Use -DBL_MAX for -infinity. */ + void setColumnLower( int elementIndex, double elementValue ); + + /** Set a single column upper bound<br> + 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<br> + 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 + <em>either</em> 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<br> + Use -DBL_MAX for -infinity. */ + inline void setColLower( int elementIndex, double elementValue ) { + setColumnLower(elementIndex, elementValue); + } + /** Set a single column upper bound<br> + 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<br> + @param indexFirst,indexLast pointers to the beginning and after the + end of the array of the indices of the variables whose + <em>either</em> 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<br> + Use -DBL_MAX for -infinity. */ + void setRowLower( int elementIndex, double elementValue ); + + /** Set a single row upper bound<br> + 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<br> + @param indexFirst,indexLast pointers to the beginning and after the + end of the array of the indices of the constraints whose + <em>either</em> 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<std::string> * 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<std::string> * 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 <code>y + A * x * scalar</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numColumns()</code> + @pre <code>y</code> must be of size <code>numRows()</code> */ + void times(double scalar, + const double * x, double * y) const; + /** Return <code>y + x * scalar * A</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numRows()</code> + @pre <code>y</code> must be of size <code>numColumns()</code> */ + 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<std::string> rowNames_; + /// Column names + std::vector<std::string> 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 <code>indDel</code>. */ + virtual void deleteCols(const int numDel, const int * indDel); + /** Delete the rows whose indices are listed in <code>indDel</code>. */ + 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 <code>y + A * scalar *x</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numColumns()</code> + @pre <code>y</code> must be of size <code>numRows()</code> */ + 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 <code>y + x * scalar * A</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numRows()</code> + @pre <code>y</code> must be of size <code>numColumns()</code> */ + 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 <code>x * scalar * A + y</code> in <code>z</code>. + 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 <code>x *A</code> in <code>z</code> 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<unsigned char>(status & ~15); + status = static_cast<unsigned char>(status | value); +} +inline void setCurrentStatus(unsigned char &status, int value) +{ + status = static_cast<unsigned char>(status & ~(15 << 4)); + status = static_cast<unsigned char>(status | (value << 4)); +} +inline void setInitialStatus(unsigned char &status) +{ + status = static_cast<unsigned char>(CLP_FEASIBLE | (CLP_SAME << 4)); +} +inline void setSameStatus(unsigned char &status) +{ + status = static_cast<unsigned char>(status & ~(15 << 4)); + status = static_cast<unsigned char>(status | (CLP_SAME << 4)); +} +// Use second version to get more speed +//#define FAST_CLPNON +#ifndef FAST_CLPNON +#define CLP_METHOD1 ((method_&1)!=0) +#define CLP_METHOD2 ((method_&2)!=0) +#else +#define CLP_METHOD1 (false) +#define CLP_METHOD2 (true) +#endif +class ClpNonLinearCost { + +public: + +public: + + /**@name Constructors, destructor */ + //@{ + /// Default constructor. + ClpNonLinearCost(); + /** Constructor from simplex. + This will just set up wasteful arrays for linear, but + later may do dual analysis and even finding duplicate columns . + */ + ClpNonLinearCost(ClpSimplex * model, int method = 1); + /** Constructor from simplex and list of non-linearities (columns only) + First lower of each column has to match real lower + Last lower has to be <= upper (if == then cost ignored) + This could obviously be changed to make more user friendly + */ + ClpNonLinearCost(ClpSimplex * model, const int * starts, + const double * lower, const double * cost); + /// Destructor + ~ClpNonLinearCost(); + // Copy + ClpNonLinearCost(const ClpNonLinearCost&); + // Assignment + ClpNonLinearCost& operator=(const ClpNonLinearCost&); + //@} + + + /**@name Actual work in primal */ + //@{ + /** Changes infeasible costs and computes number and cost of infeas + Puts all non-basic (non free) variables to bounds + and all free variables to zero if oldTolerance is non-zero + - but does not move those <= oldTolerance away*/ + void checkInfeasibilities(double oldTolerance = 0.0); + /** Changes infeasible costs for each variable + The indices are row indices and need converting to sequences + */ + void checkInfeasibilities(int numberInArray, const int * index); + /** Puts back correct infeasible costs for each variable + The input indices are row indices and need converting to sequences + for costs. + On input array is empty (but indices exist). On exit just + changed costs will be stored as normal CoinIndexedVector + */ + void checkChanged(int numberInArray, CoinIndexedVector * update); + /** Goes through one bound for each variable. + If multiplier*work[iRow]>0 goes down, otherwise up. + The indices are row indices and need converting to sequences + Temporary offsets may be set + Rhs entries are increased + */ + void goThru(int numberInArray, double multiplier, + const int * index, const double * work, + double * rhs); + /** Takes off last iteration (i.e. offsets closer to 0) + */ + void goBack(int numberInArray, const int * index, + double * rhs); + /** Puts back correct infeasible costs for each variable + The input indices are row indices and need converting to sequences + for costs. + At the end of this all temporary offsets are zero + */ + void goBackAll(const CoinIndexedVector * update); + /// Temporary zeroing of feasible costs + void zapCosts(); + /// Refreshes costs always makes row costs zero + void refreshCosts(const double * columnCosts); + /// Puts feasible bounds into lower and upper + void feasibleBounds(); + /// Refresh - assuming regions OK + void refresh(); + /** Sets bounds and cost for one variable + Returns change in cost + May need to be inline for speed */ + double setOne(int sequence, double solutionValue); + /** Sets bounds and infeasible cost and true cost for one variable + This is for gub and column generation etc */ + void setOne(int sequence, double solutionValue, double lowerValue, double upperValue, + double costValue = 0.0); + /** Sets bounds and cost for outgoing variable + may change value + Returns direction */ + int setOneOutgoing(int sequence, double &solutionValue); + /// Returns nearest bound + double nearest(int sequence, double solutionValue); + /** Returns change in cost - one down if alpha >0.0, up if <0.0 + Value is current - new + */ + inline double changeInCost(int sequence, double alpha) const { + double returnValue = 0.0; + if (CLP_METHOD1) { + int iRange = whichRange_[sequence] + offset_[sequence]; + if (alpha > 0.0) + returnValue = cost_[iRange] - cost_[iRange-1]; + else + returnValue = cost_[iRange] - cost_[iRange+1]; + } + if (CLP_METHOD2) { + returnValue = (alpha > 0.0) ? infeasibilityWeight_ : -infeasibilityWeight_; + } + return returnValue; + } + inline double changeUpInCost(int sequence) const { + double returnValue = 0.0; + if (CLP_METHOD1) { + int iRange = whichRange_[sequence] + offset_[sequence]; + if (iRange + 1 != start_[sequence+1] && !infeasible(iRange + 1)) + returnValue = cost_[iRange] - cost_[iRange+1]; + else + returnValue = -1.0e100; + } + if (CLP_METHOD2) { + returnValue = -infeasibilityWeight_; + } + return returnValue; + } + inline double changeDownInCost(int sequence) const { + double returnValue = 0.0; + if (CLP_METHOD1) { + int iRange = whichRange_[sequence] + offset_[sequence]; + if (iRange != start_[sequence] && !infeasible(iRange - 1)) + returnValue = cost_[iRange] - cost_[iRange-1]; + else + returnValue = 1.0e100; + } + if (CLP_METHOD2) { + returnValue = infeasibilityWeight_; + } + return returnValue; + } + /// This also updates next bound + inline double changeInCost(int sequence, double alpha, double &rhs) { + double returnValue = 0.0; +#ifdef NONLIN_DEBUG + double saveRhs = rhs; +#endif + if (CLP_METHOD1) { + int iRange = whichRange_[sequence] + offset_[sequence]; + if (alpha > 0.0) { + assert(iRange - 1 >= start_[sequence]); + offset_[sequence]--; + rhs += lower_[iRange] - lower_[iRange-1]; + returnValue = alpha * (cost_[iRange] - cost_[iRange-1]); + } else { + assert(iRange + 1 < start_[sequence+1] - 1); + offset_[sequence]++; + rhs += lower_[iRange+2] - lower_[iRange+1]; + returnValue = alpha * (cost_[iRange] - cost_[iRange+1]); + } + } + if (CLP_METHOD2) { +#ifdef NONLIN_DEBUG + double saveRhs1 = rhs; + rhs = saveRhs; +#endif + unsigned char iStatus = status_[sequence]; + int iWhere = currentStatus(iStatus); + if (iWhere == CLP_SAME) + iWhere = originalStatus(iStatus); + // rhs always increases + if (iWhere == CLP_FEASIBLE) { + if (alpha > 0.0) { + // going below + iWhere = CLP_BELOW_LOWER; + rhs = COIN_DBL_MAX; + } else { + // going above + iWhere = CLP_ABOVE_UPPER; + rhs = COIN_DBL_MAX; + } + } else if (iWhere == CLP_BELOW_LOWER) { + assert (alpha < 0); + // going feasible + iWhere = CLP_FEASIBLE; + rhs += bound_[sequence] - model_->upperRegion()[sequence]; + } else { + assert (iWhere == CLP_ABOVE_UPPER); + // going feasible + iWhere = CLP_FEASIBLE; + rhs += model_->lowerRegion()[sequence] - bound_[sequence]; + } + setCurrentStatus(status_[sequence], iWhere); +#ifdef NONLIN_DEBUG + assert(saveRhs1 == rhs); +#endif + returnValue = fabs(alpha) * infeasibilityWeight_; + } + return returnValue; + } + /// Returns current lower bound + inline double lower(int sequence) const { + return lower_[whichRange_[sequence] + offset_[sequence]]; + } + /// Returns current upper bound + inline double upper(int sequence) const { + return lower_[whichRange_[sequence] + offset_[sequence] + 1]; + } + /// Returns current cost + inline double cost(int sequence) const { + return cost_[whichRange_[sequence] + offset_[sequence]]; + } + //@} + + + /**@name Gets and sets */ + //@{ + /// Number of infeasibilities + inline int numberInfeasibilities() const { + return numberInfeasibilities_; + } + /// Change in cost + inline double changeInCost() const { + return changeCost_; + } + /// Feasible cost + inline double feasibleCost() const { + return feasibleCost_; + } + /// Feasible cost with offset and direction (i.e. for reporting) + double feasibleReportCost() const; + /// Sum of infeasibilities + inline double sumInfeasibilities() const { + return sumInfeasibilities_; + } + /// Largest infeasibility + inline double largestInfeasibility() const { + return largestInfeasibility_; + } + /// Average theta + inline double averageTheta() const { + return averageTheta_; + } + inline void setAverageTheta(double value) { + averageTheta_ = value; + } + inline void setChangeInCost(double value) { + changeCost_ = value; + } + inline void setMethod(int value) { + method_ = value; + } + /// See if may want to look both ways + inline bool lookBothWays() const { + return bothWays_; + } + //@} + ///@name Private functions to deal with infeasible regions + inline bool infeasible(int i) const { + return ((infeasible_[i>>5] >> (i & 31)) & 1) != 0; + } + inline void setInfeasible(int i, bool trueFalse) { + unsigned int & value = infeasible_[i>>5]; + int bit = i & 31; + if (trueFalse) + value |= (1 << bit); + else + value &= ~(1 << bit); + } + inline unsigned char * statusArray() const { + return status_; + } + /// For debug + void validate(); + //@} + +private: + /**@name Data members */ + //@{ + /// Change in cost because of infeasibilities + double changeCost_; + /// Feasible cost + double feasibleCost_; + /// Current infeasibility weight + double infeasibilityWeight_; + /// Largest infeasibility + double largestInfeasibility_; + /// Sum of infeasibilities + double sumInfeasibilities_; + /// Average theta - kept here as only for primal + double averageTheta_; + /// Number of rows (mainly for checking and copy) + int numberRows_; + /// Number of columns (mainly for checking and copy) + int numberColumns_; + /// Starts for each entry (columns then rows) + int * start_; + /// Range for each entry (columns then rows) + int * whichRange_; + /// Temporary range offset for each entry (columns then rows) + int * offset_; + /** Lower bound for each range (upper bound is next lower). + For various reasons there is always an infeasible range + at bottom - even if lower bound is - infinity */ + double * lower_; + /// Cost for each range + double * cost_; + /// Model + ClpSimplex * model_; + // Array to say which regions are infeasible + unsigned int * infeasible_; + /// Number of infeasibilities found + int numberInfeasibilities_; + // new stuff + /// Contains status at beginning and current + unsigned char * status_; + /// Bound which has been replaced in lower_ or upper_ + double * bound_; + /// Feasible cost array + double * cost2_; + /// Method 1 old, 2 new, 3 both! + int method_; + /// If all non-linear costs convex + bool convex_; + /// If we should look both ways for djs + bool bothWays_; + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/ClpObjective.hpp b/thirdparty/windows/include/coin/ClpObjective.hpp new file mode 100644 index 0000000..f98903a --- /dev/null +++ b/thirdparty/windows/include/coin/ClpObjective.hpp @@ -0,0 +1,134 @@ +/* $Id: ClpObjective.hpp 1825 2011-11-20 16:02:57Z 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 ClpObjective_H +#define ClpObjective_H + + +//############################################################################# +class ClpSimplex; +class ClpModel; + +/** Objective Abstract Base Class + +Abstract Base Class for describing an objective function + +*/ +class ClpObjective { + +public: + + ///@name Stuff + //@{ + + /** Returns gradient. If Linear then solution may be NULL, + also returns an offset (to be added to current one) + If refresh is false then uses last solution + Uses model for scaling + includeLinear 0 - no, 1 as is, 2 as feasible + */ + virtual double * gradient(const ClpSimplex * model, + const double * solution, + double & offset, bool refresh, + int includeLinear = 2) = 0; + /** Returns reduced gradient.Returns an offset (to be added to current one). + */ + virtual double reducedGradient(ClpSimplex * model, double * region, + bool useFeasibleCosts) = 0; + /** 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) = 0; + /// Return objective value (without any ClpModel offset) (model may be NULL) + virtual double objectiveValue(const ClpSimplex * model, const double * solution) const = 0; + /// Resize objective + virtual void resize(int newNumberColumns) = 0; + /// Delete columns in objective + virtual void deleteSome(int numberToDelete, const int * which) = 0; + /// Scale objective + 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); + /// Say we have new primal solution - so may need to recompute + virtual void newXValues() {} + //@} + + + ///@name Constructors and destructors + //@{ + /// Default Constructor + ClpObjective(); + + /// Copy constructor + ClpObjective(const ClpObjective &); + + /// Assignment operator + ClpObjective & operator=(const ClpObjective& rhs); + + /// Destructor + virtual ~ClpObjective (); + + /// Clone + virtual ClpObjective * clone() const = 0; + /** Subset clone. Duplicates are allowed + and order is as given. + Derived classes need not provide this as it may not always make + sense */ + virtual ClpObjective * subsetClone (int numberColumns, + const int * whichColumns) const; + + //@} + + ///@name Other + //@{ + /// Returns type (above 63 is extra information) + inline int type() const { + return type_; + } + /// Sets type (above 63 is extra information) + inline void setType(int value) { + type_ = value; + } + /// Whether activated + inline int activated() const { + return activated_; + } + /// Set whether activated + inline void setActivated(int value) { + activated_ = value; + } + + /// Objective offset + inline double nonlinearOffset () const { + return offset_; + } + //@} + + //--------------------------------------------------------------------------- + +protected: + ///@name Protected member data + //@{ + /// Value of non-linear part of objective + double offset_; + /// Type of objective - linear is 1 + int type_; + /// Whether activated + int activated_; + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/ClpPackedMatrix.hpp b/thirdparty/windows/include/coin/ClpPackedMatrix.hpp new file mode 100644 index 0000000..ec0c0b9 --- /dev/null +++ b/thirdparty/windows/include/coin/ClpPackedMatrix.hpp @@ -0,0 +1,638 @@ +/* $Id: ClpPackedMatrix.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 ClpPackedMatrix_H +#define ClpPackedMatrix_H + +#include "CoinPragma.hpp" + +#include "ClpMatrixBase.hpp" + +/** This implements CoinPackedMatrix as derived from ClpMatrixBase. + + It adds a few methods that know about model as well as matrix + + For details see CoinPackedMatrix */ + +class ClpPackedMatrix2; +class ClpPackedMatrix3; +class ClpPackedMatrix : public ClpMatrixBase { + +public: + /**@name Useful methods */ + //@{ + /// Return a complete CoinPackedMatrix + virtual CoinPackedMatrix * getPackedMatrix() const { + return matrix_; + } + /** Whether the packed matrix is column major ordered or not. */ + virtual bool isColOrdered() const { + return matrix_->isColOrdered(); + } + /** Number of entries in the packed matrix. */ + virtual CoinBigIndex getNumElements() const { + return matrix_->getNumElements(); + } + /** Number of columns. */ + virtual int getNumCols() const { + return matrix_->getNumCols(); + } + /** Number of rows. */ + virtual int getNumRows() const { + return matrix_->getNumRows(); + } + + /** 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 { + return matrix_->getElements(); + } + /// Mutable elements + inline double * getMutableElements() const { + return matrix_->getMutableElements(); + } + /** 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 matrix_->getIndices(); + } + + virtual const CoinBigIndex * getVectorStarts() const { + return matrix_->getVectorStarts(); + } + /** The lengths of the major-dimension vectors. */ + virtual const int * getVectorLengths() const { + return matrix_->getVectorLengths(); + } + /** The length of a single major-dimension vector. */ + virtual int getVectorLength(int index) const { + return matrix_->getVectorSize(index); + } + + /** Delete the columns whose indices are listed in <code>indDel</code>. */ + virtual void deleteCols(const int numDel, const int * indDel); + /** Delete the rows whose indices are listed in <code>indDel</code>. */ + virtual void deleteRows(const int numDel, const int * indDel); +#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 + /** 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); + /** Replace the elements of a vector. The indices remain the same. + This is only needed if scaling and a row copy is used. + At most the number specified will be replaced. + The index is between 0 and major dimension of matrix */ + virtual void replaceVector(const int index, + const int numReplace, const double * newElements) { + matrix_->replaceVector(index, numReplace, newElements); + } + /** 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) { + matrix_->modifyCoefficient(row, column, newElement, keepZero); + } + /** 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); + /** Creates scales for column copy (rowCopy in model may be modified) + returns non-zero if no scaling done */ + virtual int scale(ClpModel * model, const ClpSimplex * baseModel = NULL) const ; + /** Scales rowCopy if column copy scaled + Only called if scales already exist */ + virtual void scaleRowCopy(ClpModel * model) const ; + /// Creates scaled column copy if scales exist + void createScaledMatrix(ClpSimplex * model) const; + /** Realy really scales column copy + Only called if scales already exist. + Up to user ro delete */ + virtual ClpMatrixBase * scaledColumnCopy(ClpModel * model) const ; + /** 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 * model, + double smallest, double largest, + int check = 15); + /** 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 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 CoinPackedMatrix to be deleted + virtual void releasePackedMatrix() const { } + /** 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; + /// 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); + /// makes sure active columns correct + virtual int refresh(ClpSimplex * model); + // Really scale matrix + virtual void reallyScale(const double * rowScale, const double * columnScale); + /** 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); + //@} + + /**@name Matrix times vector methods */ + //@{ + /** Return <code>y + A * scalar *x</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numColumns()</code> + @pre <code>y</code> must be of size <code>numRows()</code> */ + 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 <code>y + x * scalar * A</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numRows()</code> + @pre <code>y</code> must be of size <code>numColumns()</code> */ + 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 <code>y - pi * A</code> in <code>y</code>. + @pre <code>pi</code> must be of size <code>numRows()</code> + @pre <code>y</code> must be of size <code>numColumns()</code> + This just does subset (but puts in correct place in y) */ + void transposeTimesSubset( int number, + const int * which, + const double * pi, double * y, + const double * rowScale, + const double * columnScale, + double * spare = NULL) const; + /** Return <code>x * scalar * A + y</code> in <code>z</code>. + 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 <code>x * scalar * A + y</code> in <code>z</code>. + Note - If x packed mode - then z packed mode + This does by column and knows no gaps + Squashes small elements and knows about ClpSimplex */ + void transposeTimesByColumn(const ClpSimplex * model, double scalar, + const CoinIndexedVector * x, + CoinIndexedVector * y, + CoinIndexedVector * z) const; + /** Return <code>x * scalar * A + y</code> in <code>z</code>. + 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 <code>x *A</code> in <code>z</code> 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; + /** Returns true if can combine transposeTimes and subsetTransposeTimes + and if it would be faster */ + virtual bool canCombine(const ClpSimplex * model, + const CoinIndexedVector * pi) const; + /// Updates two arrays for steepest + 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 + 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); + /// Sets up an effective RHS + void useEffectiveRhs(ClpSimplex * model); +#if COIN_LONG_WORK + // For long double versions + virtual void times(CoinWorkDouble scalar, + const CoinWorkDouble * x, CoinWorkDouble * y) const ; + virtual void transposeTimes(CoinWorkDouble scalar, + const CoinWorkDouble * x, CoinWorkDouble * y) const ; +#endif +//@} + + /**@name Other */ + //@{ + /// Returns CoinPackedMatrix (non const) + inline CoinPackedMatrix * matrix() const { + return matrix_; + } + /** Just sets matrix_ to NULL so it can be used elsewhere. + used in GUB + */ + inline void setMatrixNull() { + matrix_ = NULL; + } + /// Say we want special column copy + inline void makeSpecialColumnCopy() { + flags_ |= 16; + } + /// Say we don't want special column copy + void releaseSpecialColumnCopy(); + /// Are there zeros? + inline bool zeros() const { + return ((flags_ & 1) != 0); + } + /// Do we want special column copy + inline bool wantsSpecialColumnCopy() const { + return ((flags_ & 16) != 0); + } + /// Flags + inline int flags() const { + return flags_; + } + /// Sets flags_ correctly + inline void checkGaps() { + flags_ = (matrix_->hasGaps()) ? (flags_ | 2) : (flags_ & (~2)); + } + /// number of active columns (normally same as number of columns) + inline int numberActiveColumns() const + { return numberActiveColumns_;} + /// Set number of active columns (normally same as number of columns) + inline void setNumberActiveColumns(int value) + { numberActiveColumns_ = value;} + //@} + + + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + ClpPackedMatrix(); + /** Destructor */ + virtual ~ClpPackedMatrix(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + ClpPackedMatrix(const ClpPackedMatrix&); + /** The copy constructor from an CoinPackedMatrix. */ + ClpPackedMatrix(const CoinPackedMatrix&); + /** Subset constructor (without gaps). Duplicates are allowed + and order is as given */ + ClpPackedMatrix (const ClpPackedMatrix & wholeModel, + int numberRows, const int * whichRows, + int numberColumns, const int * whichColumns); + ClpPackedMatrix (const CoinPackedMatrix & wholeModel, + int numberRows, const int * whichRows, + int numberColumns, const int * whichColumns); + + /** This takes over ownership (for space reasons) */ + ClpPackedMatrix(CoinPackedMatrix * matrix); + + ClpPackedMatrix& operator=(const ClpPackedMatrix&); + /// Clone + virtual ClpMatrixBase * clone() const ; + /// Copy contents - resizing if necessary - otherwise re-use memory + virtual void copy(const ClpPackedMatrix * from); + /** 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 ; + /// make special row copy + void specialRowCopy(ClpSimplex * model, const ClpMatrixBase * rowCopy); + /// make special column copy + void specialColumnCopy(ClpSimplex * model); + /// Correct sequence in and out to give true value + virtual void correctSequence(const ClpSimplex * model, int & sequenceIn, int & sequenceOut) ; + //@} +private: + /// Meat of transposeTimes by column when not scaled + int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi, + int * COIN_RESTRICT index, + double * COIN_RESTRICT array, + const double tolerance) const; + /// Meat of transposeTimes by column when scaled + int gutsOfTransposeTimesScaled(const double * COIN_RESTRICT pi, + const double * COIN_RESTRICT columnScale, + int * COIN_RESTRICT index, + double * COIN_RESTRICT array, + const double tolerance) const; + /// Meat of transposeTimes by column when not scaled and skipping + int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi, + int * COIN_RESTRICT index, + double * COIN_RESTRICT array, + const unsigned char * status, + const double tolerance) const; + /** Meat of transposeTimes by column when not scaled and skipping + and doing part of dualColumn */ + int gutsOfTransposeTimesUnscaled(const double * COIN_RESTRICT pi, + int * COIN_RESTRICT index, + double * COIN_RESTRICT array, + const unsigned char * status, + int * COIN_RESTRICT spareIndex, + double * COIN_RESTRICT spareArray, + const double * COIN_RESTRICT reducedCost, + double & upperTheta, + double & bestPossible, + double acceptablePivot, + double dualTolerance, + int & numberRemaining, + const double zeroTolerance) const; + /// Meat of transposeTimes by column when scaled and skipping + int gutsOfTransposeTimesScaled(const double * COIN_RESTRICT pi, + const double * COIN_RESTRICT columnScale, + int * COIN_RESTRICT index, + double * COIN_RESTRICT array, + const unsigned char * status, + const double tolerance) const; + /// Meat of transposeTimes by row n > K if packed - returns number nonzero + int gutsOfTransposeTimesByRowGEK(const CoinIndexedVector * COIN_RESTRICT piVector, + int * COIN_RESTRICT index, + double * COIN_RESTRICT output, + int numberColumns, + const double tolerance, + const double scalar) const; + /// Meat of transposeTimes by row n > 2 if packed - returns number nonzero + int gutsOfTransposeTimesByRowGE3(const CoinIndexedVector * COIN_RESTRICT piVector, + int * COIN_RESTRICT index, + double * COIN_RESTRICT output, + double * COIN_RESTRICT array2, + const double tolerance, + const double scalar) const; + /// Meat of transposeTimes by row n > 2 if packed - returns number nonzero + int gutsOfTransposeTimesByRowGE3a(const CoinIndexedVector * COIN_RESTRICT piVector, + int * COIN_RESTRICT index, + double * COIN_RESTRICT output, + int * COIN_RESTRICT lookup, + char * COIN_RESTRICT marked, + const double tolerance, + const double scalar) const; + /// Meat of transposeTimes by row n == 2 if packed + void gutsOfTransposeTimesByRowEQ2(const CoinIndexedVector * piVector, CoinIndexedVector * output, + CoinIndexedVector * spareVector, const double tolerance, const double scalar) const; + /// Meat of transposeTimes by row n == 1 if packed + void gutsOfTransposeTimesByRowEQ1(const CoinIndexedVector * piVector, CoinIndexedVector * output, + const double tolerance, const double scalar) const; + /// Gets rid of special copies + void clearCopies(); + + +protected: + /// Check validity + void checkFlags(int type) const; + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Data + CoinPackedMatrix * matrix_; + /// number of active columns (normally same as number of columns) + int numberActiveColumns_; + /** Flags - + 1 - has zero elements + 2 - has gaps + 4 - has special row copy + 8 - has special column copy + 16 - wants special column copy + */ + mutable int flags_; + /// Special row copy + ClpPackedMatrix2 * rowCopy_; + /// Special column copy + ClpPackedMatrix3 * columnCopy_; + //@} +}; +#ifdef THREAD +#include <pthread.h> +typedef struct { + double acceptablePivot; + const ClpSimplex * model; + double * spare; + int * spareIndex; + double * arrayTemp; + int * indexTemp; + int * numberInPtr; + double * bestPossiblePtr; + double * upperThetaPtr; + int * posFreePtr; + double * freePivotPtr; + int * numberOutPtr; + const unsigned short * count; + const double * pi; + const CoinBigIndex * rowStart; + const double * element; + const unsigned short * column; + int offset; + int numberInRowArray; + int numberLook; +} dualColumn0Struct; +#endif +class ClpPackedMatrix2 { + +public: + /**@name Useful methods */ + //@{ + /** Return <code>x * -1 * A in <code>z</code>. + Note - x packed and z will be packed mode + Squashes small elements and knows about ClpSimplex */ + void transposeTimes(const ClpSimplex * model, + const CoinPackedMatrix * rowCopy, + const CoinIndexedVector * x, + CoinIndexedVector * spareArray, + CoinIndexedVector * z) const; + /// Returns true if copy has useful information + inline bool usefulInfo() const { + return rowStart_ != NULL; + } + //@} + + + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + ClpPackedMatrix2(); + /** Constructor from copy. */ + ClpPackedMatrix2(ClpSimplex * model, const CoinPackedMatrix * rowCopy); + /** Destructor */ + virtual ~ClpPackedMatrix2(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + ClpPackedMatrix2(const ClpPackedMatrix2&); + ClpPackedMatrix2& operator=(const ClpPackedMatrix2&); + //@} + + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Number of blocks + int numberBlocks_; + /// Number of rows + int numberRows_; + /// Column offset for each block (plus one at end) + int * offset_; + /// Counts of elements in each part of row + mutable unsigned short * count_; + /// Row starts + mutable CoinBigIndex * rowStart_; + /// columns within block + unsigned short * column_; + /// work arrays + double * work_; +#ifdef THREAD + pthread_t * threadId_; + dualColumn0Struct * info_; +#endif + //@} +}; +typedef struct { + CoinBigIndex startElements_; // point to data + int startIndices_; // point to column_ + int numberInBlock_; + int numberPrice_; // at beginning + int numberElements_; // number elements per column +} blockStruct; +class ClpPackedMatrix3 { + +public: + /**@name Useful methods */ + //@{ + /** Return <code>x * -1 * A in <code>z</code>. + Note - x packed and z will be packed mode + Squashes small elements and knows about ClpSimplex */ + void transposeTimes(const ClpSimplex * model, + const double * pi, + CoinIndexedVector * output) const; + /// Updates two arrays for steepest + void transposeTimes2(const ClpSimplex * model, + const double * pi, CoinIndexedVector * dj1, + const double * piWeight, + double referenceIn, double devex, + // Array for exact devex to say what is in reference framework + unsigned int * reference, + double * weights, double scaleFactor); + //@} + + + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + ClpPackedMatrix3(); + /** Constructor from copy. */ + ClpPackedMatrix3(ClpSimplex * model, const CoinPackedMatrix * columnCopy); + /** Destructor */ + virtual ~ClpPackedMatrix3(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + ClpPackedMatrix3(const ClpPackedMatrix3&); + ClpPackedMatrix3& operator=(const ClpPackedMatrix3&); + //@} + /**@name Sort methods */ + //@{ + /** Sort blocks */ + void sortBlocks(const ClpSimplex * model); + /// Swap one variable + void swapOne(const ClpSimplex * model, const ClpPackedMatrix * matrix, + int iColumn); + //@} + + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Number of blocks + int numberBlocks_; + /// Number of columns + int numberColumns_; + /// Column indices and reverse lookup (within block) + int * column_; + /// Starts for odd/long vectors + CoinBigIndex * start_; + /// Rows + int * row_; + /// Elements + double * element_; + /// Blocks (ordinary start at 0 and go to first block) + blockStruct * block_; + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/ClpParameters.hpp b/thirdparty/windows/include/coin/ClpParameters.hpp new file mode 100644 index 0000000..7252d2b --- /dev/null +++ b/thirdparty/windows/include/coin/ClpParameters.hpp @@ -0,0 +1,126 @@ +/* $Id: ClpParameters.hpp 2046 2014-08-14 04:13:10Z tkr $ */ +// Copyright (C) 2000, 2002, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef _ClpParameters_H +#define _ClpParameters_H + +/** This is where to put any useful stuff. + +*/ +enum ClpIntParam { + /** The maximum number of iterations Clp can execute in the simplex methods + */ + ClpMaxNumIteration = 0, + /** The maximum number of iterations Clp can execute in hotstart before + terminating */ + ClpMaxNumIterationHotStart, + /** The name discipline; specifies how the solver will handle row and + column names. + - 0: Auto names: Names cannot be set by the client. Names of the form + Rnnnnnnn or Cnnnnnnn are generated on demand when a name for a + specific row or column is requested; nnnnnnn is derived from the row + or column index. Requests for a vector of names return a vector with + zero entries. + - 1: Lazy names: Names supplied by the client are retained. Names of the + form Rnnnnnnn or Cnnnnnnn are generated on demand if no name has been + supplied by the client. Requests for a vector of names return a + vector sized to the largest index of a name supplied by the client; + some entries in the vector may be null strings. + - 2: Full names: Names supplied by the client are retained. Names of the + form Rnnnnnnn or Cnnnnnnn are generated on demand if no name has been + supplied by the client. Requests for a vector of names return a + vector sized to match the constraint system, and all entries will + contain either the name specified by the client or a generated name. + */ + ClpNameDiscipline, + /** Just a marker, so that we can allocate a static sized array to store + parameters. */ + ClpLastIntParam +}; + +enum ClpDblParam { + /** Set Dual objective limit. This is to be used as a termination criteria + in methods where the dual objective monotonically changes (dual + simplex). */ + ClpDualObjectiveLimit, + /** Primal objective limit. This is to be used as a termination + criteria in methods where the primal objective monotonically changes + (e.g., primal simplex) */ + ClpPrimalObjectiveLimit, + /** The maximum amount the dual constraints can be violated and still be + considered feasible. */ + ClpDualTolerance, + /** The maximum amount the primal constraints can be violated and still be + considered feasible. */ + ClpPrimalTolerance, + /** Objective function constant. This the value of the constant term in + the objective function. */ + ClpObjOffset, + /// Maximum time in seconds - after, this action is as max iterations + ClpMaxSeconds, + /// Maximum wallclock running time in seconds - after, this action is as max iterations + ClpMaxWallSeconds, + /// Tolerance to use in presolve + ClpPresolveTolerance, + /** Just a marker, so that we can allocate a static sized array to store + parameters. */ + ClpLastDblParam +}; + + +enum ClpStrParam { + /** Name of the problem. This is the found on the Name card of + an mps file. */ + ClpProbName = 0, + /** Just a marker, so that we can allocate a static sized array to store + parameters. */ + ClpLastStrParam +}; + +/// Copy (I don't like complexity of Coin version) +template <class T> inline void +ClpDisjointCopyN( const T * array, const int size, T * newArray) +{ + memcpy(reinterpret_cast<void *> (newArray), array, size * sizeof(T)); +} +/// And set +template <class T> inline void +ClpFillN( T * array, const int size, T value) +{ + int i; + for (i = 0; i < size; i++) + array[i] = value; +} +/// This returns a non const array filled with input from scalar or actual array +template <class T> inline T* +ClpCopyOfArray( const T * array, const int size, T value) +{ + T * arrayNew = new T[size]; + if (array) + ClpDisjointCopyN(array, size, arrayNew); + else + ClpFillN ( arrayNew, size, value); + return arrayNew; +} + +/// This returns a non const array filled with actual array (or NULL) +template <class T> inline T* +ClpCopyOfArray( const T * array, const int size) +{ + if (array) { + T * arrayNew = new T[size]; + ClpDisjointCopyN(array, size, arrayNew); + return arrayNew; + } else { + return NULL; + } +} +/// For a structure to be used by trusted code +typedef struct { + int typeStruct; // allocated as 1,2 etc + int typeCall; + void * data; +} ClpTrustedData; +#endif diff --git a/thirdparty/windows/include/coin/ClpPdcoBase.hpp b/thirdparty/windows/include/coin/ClpPdcoBase.hpp new file mode 100644 index 0000000..cb8fd8f --- /dev/null +++ b/thirdparty/windows/include/coin/ClpPdcoBase.hpp @@ -0,0 +1,103 @@ +/* $Id: ClpPdcoBase.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 ClpPdcoBase_H +#define ClpPdcoBase_H + +#include "CoinPragma.hpp" + +#include "CoinPackedMatrix.hpp" +#include "CoinDenseVector.hpp" +class ClpInterior; + +/** Abstract base class for tailoring everything for Pcdo + + Since this class is abstract, no object of this type can be created. + + If a derived class provides all methods then all ClpPcdo algorithms + should work. + + Eventually we should be able to use ClpObjective and ClpMatrixBase. +*/ + +class ClpPdcoBase { + +public: + /**@name Virtual methods that the derived classes must provide */ + //@{ + virtual void matVecMult(ClpInterior * model, int mode, double * x, double * y) const = 0; + + virtual void getGrad(ClpInterior * model, CoinDenseVector<double> &x, CoinDenseVector<double> &grad) const = 0; + + virtual void getHessian(ClpInterior * model, CoinDenseVector<double> &x, CoinDenseVector<double> &H) const = 0; + + virtual double getObj(ClpInterior * model, CoinDenseVector<double> &x) const = 0; + + virtual void matPrecon(ClpInterior * model, double delta, double * x, double * y) const = 0; + + //@} + //@{ + ///@name Other + /// Clone + virtual ClpPdcoBase * clone() const = 0; + /// Returns type + inline int type() const { + return type_; + }; + /// Sets type + inline void setType(int type) { + type_ = type; + }; + /// Returns size of d1 + inline int sizeD1() const { + return 1; + }; + /// Returns d1 as scalar + inline double getD1() const { + return d1_; + }; + /// Returns size of d2 + inline int sizeD2() const { + return 1; + }; + /// Returns d2 as scalar + inline double getD2() const { + return d2_; + }; + //@} + + +protected: + + /**@name Constructors, destructor<br> + <strong>NOTE</strong>: All constructors are protected. There's no need + to expose them, after all, this is an abstract class. */ + //@{ + /** Default constructor. */ + ClpPdcoBase(); + /** Destructor (has to be public) */ +public: + virtual ~ClpPdcoBase(); +protected: + // Copy + ClpPdcoBase(const ClpPdcoBase&); + // Assignment + ClpPdcoBase& operator=(const ClpPdcoBase&); + //@} + + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Should be dense vectors + double d1_; + double d2_; + /// type (may be useful) + int type_; + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/ClpPlusMinusOneMatrix.hpp b/thirdparty/windows/include/coin/ClpPlusMinusOneMatrix.hpp new file mode 100644 index 0000000..0cf27a4 --- /dev/null +++ b/thirdparty/windows/include/coin/ClpPlusMinusOneMatrix.hpp @@ -0,0 +1,290 @@ +/* $Id: ClpPlusMinusOneMatrix.hpp 2078 2015-01-05 12:39:49Z forrest $ */ +// 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 ClpPlusMinusOneMatrix_H +#define ClpPlusMinusOneMatrix_H + + +#include "CoinPragma.hpp" + +#include "ClpMatrixBase.hpp" + +/** This implements a simple +- one matrix as derived from ClpMatrixBase. + +*/ + +class ClpPlusMinusOneMatrix : 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 ; + /** Number of entries in the packed matrix. */ + virtual CoinBigIndex getNumElements() const; + /** 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_; + } + // and for advanced use + int * getMutableIndices() 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 <code>indDel</code>. */ + virtual void deleteCols(const int numDel, const int * indDel); + /** Delete the rows whose indices are listed in <code>indDel</code>. */ + 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 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 + virtual void releasePackedMatrix() const; + /** 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); + /// Just checks matrix valid - will say if dimensions not quite right if detail + void checkValid(bool detail) const; + //@} + + /**@name Matrix times vector methods */ + //@{ + /** Return <code>y + A * scalar *x</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numColumns()</code> + @pre <code>y</code> must be of size <code>numRows()</code> */ + 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 <code>y + x * scalar * A</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numRows()</code> + @pre <code>y</code> must be of size <code>numColumns()</code> */ + 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 <code>x * scalar * A + y</code> in <code>z</code>. + 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 <code>x * scalar * A + y</code> in <code>z</code>. + 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 <code>x *A</code> in <code>z</code> 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; + /** Returns true if can combine transposeTimes and subsetTransposeTimes + and if it would be faster */ + virtual bool canCombine(const ClpSimplex * model, + const CoinIndexedVector * pi) const; + /// Updates two arrays for steepest + 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 + 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); + //@} + + /**@name Other */ + //@{ + /// Return starts of +1s + inline CoinBigIndex * startPositive() const { + return startPositive_; + } + /// Return starts of -1s + inline CoinBigIndex * startNegative() const { + return startNegative_; + } + //@} + + + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + ClpPlusMinusOneMatrix(); + /** Destructor */ + virtual ~ClpPlusMinusOneMatrix(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + ClpPlusMinusOneMatrix(const ClpPlusMinusOneMatrix&); + /** The copy constructor from an CoinPlusMinusOneMatrix. + If not a valid matrix then getIndices will be NULL and + startPositive[0] will have number of +1, + startPositive[1] will have number of -1, + startPositive[2] will have number of others, + */ + ClpPlusMinusOneMatrix(const CoinPackedMatrix&); + /// Constructor from arrays + ClpPlusMinusOneMatrix(int numberRows, int numberColumns, + bool columnOrdered, const int * indices, + const CoinBigIndex * startPositive, const CoinBigIndex * startNegative); + /** Subset constructor (without gaps). Duplicates are allowed + and order is as given */ + ClpPlusMinusOneMatrix (const ClpPlusMinusOneMatrix & wholeModel, + int numberRows, const int * whichRows, + int numberColumns, const int * whichColumns); + + ClpPlusMinusOneMatrix& operator=(const ClpPlusMinusOneMatrix&); + /// 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 ; + /// pass in copy (object takes ownership) + void passInCopy(int numberRows, int numberColumns, + bool columnOrdered, int * indices, + CoinBigIndex * startPositive, CoinBigIndex * startNegative); + /// 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); + //@} + + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// For fake CoinPackedMatrix + mutable CoinPackedMatrix * matrix_; + mutable int * lengths_; + /// Start of +1's for each + CoinBigIndex * COIN_RESTRICT startPositive_; + /// Start of -1's for each + CoinBigIndex * COIN_RESTRICT startNegative_; + /// Data -1, then +1 rows in pairs (row==-1 if one entry) + int * COIN_RESTRICT indices_; + /// Number of rows + int numberRows_; + /// Number of columns + int numberColumns_; +#ifdef CLP_PLUS_ONE_MATRIX + /** Other flags (could have columnOrdered_?) + 1 bit - says just +1 + */ + mutable int otherFlags_; +#endif + /// True if column ordered + bool columnOrdered_; + + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/ClpPresolve.hpp b/thirdparty/windows/include/coin/ClpPresolve.hpp new file mode 100644 index 0000000..5e28289 --- /dev/null +++ b/thirdparty/windows/include/coin/ClpPresolve.hpp @@ -0,0 +1,299 @@ +/* $Id: ClpPresolve.hpp 2134 2015-03-22 16:40: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). + +#ifndef ClpPresolve_H +#define ClpPresolve_H +#include "ClpSimplex.hpp" + +class CoinPresolveAction; +#include "CoinPresolveMatrix.hpp" +/** This is the Clp interface to CoinPresolve + +*/ +class ClpPresolve { +public: + /**@name Main Constructor, destructor */ + //@{ + /// Default constructor + ClpPresolve(); + + /// Virtual destructor + virtual ~ClpPresolve(); + //@} + /**@name presolve - presolves a model, transforming the model + * and saving information in the ClpPresolve object needed for postsolving. + * This underlying (protected) method is virtual; the idea is that in the future, + * one could override this method to customize how the various + * presolve techniques are applied. + + This version of presolve returns a pointer to a new presolved + model. NULL if infeasible or unbounded. + This should be paired with postsolve + below. The advantage of going back to original model is that it + will be exactly as it was i.e. 0.0 will not become 1.0e-19. + If keepIntegers is true then bounds may be tightened in + original. Bounds will be moved by up to feasibilityTolerance + to try and stay feasible. + Names will be dropped in presolved model if asked + */ + ClpSimplex * presolvedModel(ClpSimplex & si, + double feasibilityTolerance = 0.0, + bool keepIntegers = true, + int numberPasses = 5, + bool dropNames = false, + bool doRowObjective = false, + const char * prohibitedRows=NULL, + const char * prohibitedColumns=NULL); +#ifndef CLP_NO_STD + /** This version saves data in a file. The passed in model + is updated to be presolved model. + Returns non-zero if infeasible*/ + int presolvedModelToFile(ClpSimplex &si, std::string fileName, + double feasibilityTolerance = 0.0, + bool keepIntegers = true, + int numberPasses = 5, + bool dropNames = false, + bool doRowObjective = false); +#endif + /** Return pointer to presolved model, + Up to user to destroy */ + ClpSimplex * model() const; + /// Return pointer to original model + ClpSimplex * originalModel() const; + /// Set pointer to original model + void setOriginalModel(ClpSimplex * model); + + /// return pointer to original columns + const int * originalColumns() const; + /// return pointer to original rows + const int * originalRows() const; + /** "Magic" number. If this is non-zero then any elements with this value + may change and so presolve is very limited in what can be done + to the row and column. This is for non-linear problems. + */ + inline void setNonLinearValue(double value) { + nonLinearValue_ = value; + } + inline double nonLinearValue() const { + return nonLinearValue_; + } + /// Whether we want to do dual part of presolve + inline bool doDual() const { + return (presolveActions_ & 1) == 0; + } + inline void setDoDual(bool doDual) { + if (doDual) presolveActions_ &= ~1; + else presolveActions_ |= 1; + } + /// Whether we want to do singleton part of presolve + inline bool doSingleton() const { + return (presolveActions_ & 2) == 0; + } + inline void setDoSingleton(bool doSingleton) { + if (doSingleton) presolveActions_ &= ~2; + else presolveActions_ |= 2; + } + /// Whether we want to do doubleton part of presolve + inline bool doDoubleton() const { + return (presolveActions_ & 4) == 0; + } + inline void setDoDoubleton(bool doDoubleton) { + if (doDoubleton) presolveActions_ &= ~4; + else presolveActions_ |= 4; + } + /// Whether we want to do tripleton part of presolve + inline bool doTripleton() const { + return (presolveActions_ & 8) == 0; + } + inline void setDoTripleton(bool doTripleton) { + if (doTripleton) presolveActions_ &= ~8; + else presolveActions_ |= 8; + } + /// Whether we want to do tighten part of presolve + inline bool doTighten() const { + return (presolveActions_ & 16) == 0; + } + inline void setDoTighten(bool doTighten) { + if (doTighten) presolveActions_ &= ~16; + else presolveActions_ |= 16; + } + /// Whether we want to do forcing part of presolve + inline bool doForcing() const { + return (presolveActions_ & 32) == 0; + } + inline void setDoForcing(bool doForcing) { + if (doForcing) presolveActions_ &= ~32; + else presolveActions_ |= 32; + } + /// Whether we want to do impliedfree part of presolve + inline bool doImpliedFree() const { + return (presolveActions_ & 64) == 0; + } + inline void setDoImpliedFree(bool doImpliedfree) { + if (doImpliedfree) presolveActions_ &= ~64; + else presolveActions_ |= 64; + } + /// Whether we want to do dupcol part of presolve + inline bool doDupcol() const { + return (presolveActions_ & 128) == 0; + } + inline void setDoDupcol(bool doDupcol) { + if (doDupcol) presolveActions_ &= ~128; + else presolveActions_ |= 128; + } + /// Whether we want to do duprow part of presolve + inline bool doDuprow() const { + return (presolveActions_ & 256) == 0; + } + inline void setDoDuprow(bool doDuprow) { + if (doDuprow) presolveActions_ &= ~256; + else presolveActions_ |= 256; + } + /// Whether we want to do dependency part of presolve + inline bool doDependency() const { + return (presolveActions_ & 32768) != 0; + } + inline void setDoDependency(bool doDependency) { + if (doDependency) presolveActions_ |= 32768; + else presolveActions_ &= ~32768; + } + /// Whether we want to do singleton column part of presolve + inline bool doSingletonColumn() const { + return (presolveActions_ & 512) == 0; + } + inline void setDoSingletonColumn(bool doSingleton) { + if (doSingleton) presolveActions_ &= ~512; + else presolveActions_ |= 512; + } + /// Whether we want to do gubrow part of presolve + inline bool doGubrow() const { + return (presolveActions_ & 1024) == 0; + } + inline void setDoGubrow(bool doGubrow) { + if (doGubrow) presolveActions_ &= ~1024; + else presolveActions_ |= 1024; + } + /// Whether we want to do twoxtwo part of presolve + inline bool doTwoxTwo() const { + return (presolveActions_ & 2048) != 0; + } + inline void setDoTwoxtwo(bool doTwoxTwo) { + if (!doTwoxTwo) presolveActions_ &= ~2048; + else presolveActions_ |= 2048; + } + /// Whether we want to allow duplicate intersections + inline bool doIntersection() const { + return (presolveActions_ & 4096) != 0; + } + inline void setDoIntersection(bool doIntersection) { + if (doIntersection) presolveActions_ &= ~4096; + else presolveActions_ |= 4096; + } + /** How much we want to zero small values from aggregation - ratio + 0 - 1.0e-12, 1 1.0e-11, 2 1.0e-10, 3 1.0e-9 */ + inline int zeroSmall() const { + return (presolveActions_&(8192|16384))>>13; + } + inline void setZeroSmall(int value) { + presolveActions_ &= ~(8192|16384); + presolveActions_ |= value<<13; + } + /// Set whole group + inline int presolveActions() const { + return presolveActions_ & 0xffff; + } + inline void setPresolveActions(int action) { + presolveActions_ = (presolveActions_ & 0xffff0000) | (action & 0xffff); + } + /// Substitution level + inline void setSubstitution(int value) { + substitution_ = value; + } + /// Asks for statistics + inline void statistics() { + presolveActions_ |= 0x80000000; + } + /// Return presolve status (0,1,2) + int presolveStatus() const; + + /**@name postsolve - postsolve the problem. If the problem + has not been solved to optimality, there are no guarantees. + If you are using an algorithm like simplex that has a concept + of "basic" rows/cols, then set updateStatus + + Note that if you modified the original problem after presolving, + then you must ``undo'' these modifications before calling postsolve. + This version updates original*/ + virtual void postsolve(bool updateStatus = true); + + /// Gets rid of presolve actions (e.g.when infeasible) + void destroyPresolve(); + + /**@name private or protected data */ +private: + /// Original model - must not be destroyed before postsolve + ClpSimplex * originalModel_; + + /// ClpPresolved model - up to user to destroy by deleteClpPresolvedModel + ClpSimplex * presolvedModel_; + /** "Magic" number. If this is non-zero then any elements with this value + may change and so presolve is very limited in what can be done + to the row and column. This is for non-linear problems. + One could also allow for cases where sign of coefficient is known. + */ + double nonLinearValue_; + /// Original column numbers + int * originalColumn_; + /// Original row numbers + int * originalRow_; + /// Row objective + double * rowObjective_; + /// The list of transformations applied. + const CoinPresolveAction *paction_; + + /// The postsolved problem will expand back to its former size + /// as postsolve transformations are applied. + /// It is efficient to allocate data structures for the final size + /// of the problem rather than expand them as needed. + /// These fields give the size of the original problem. + int ncols_; + int nrows_; + CoinBigIndex nelems_; + /// Number of major passes + int numberPasses_; + /// Substitution level + int substitution_; +#ifndef CLP_NO_STD + /// Name of saved model file + std::string saveFile_; +#endif + /** Whether we want to skip dual part of presolve etc. + 512 bit allows duplicate column processing on integer columns + and dual stuff on integers + */ + int presolveActions_; +protected: + /// If you want to apply the individual presolve routines differently, + /// or perhaps add your own to the mix, + /// define a derived class and override this method + virtual const CoinPresolveAction *presolve(CoinPresolveMatrix *prob); + + /// Postsolving is pretty generic; just apply the transformations + /// in reverse order. + /// You will probably only be interested in overriding this method + /// if you want to add code to test for consistency + /// while debugging new presolve techniques. + virtual void postsolve(CoinPostsolveMatrix &prob); + /** This is main part of Presolve */ + virtual ClpSimplex * gutsOfPresolvedModel(ClpSimplex * originalModel, + double feasibilityTolerance, + bool keepIntegers, + int numberPasses, + bool dropNames, + bool doRowObjective, + const char * prohibitedRows=NULL, + const char * prohibitedColumns=NULL); +}; +#endif diff --git a/thirdparty/windows/include/coin/ClpPrimalColumnDantzig.hpp b/thirdparty/windows/include/coin/ClpPrimalColumnDantzig.hpp new file mode 100644 index 0000000..7289ead --- /dev/null +++ b/thirdparty/windows/include/coin/ClpPrimalColumnDantzig.hpp @@ -0,0 +1,72 @@ +/* $Id: ClpPrimalColumnDantzig.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 ClpPrimalColumnDantzig_H +#define ClpPrimalColumnDantzig_H + +#include "ClpPrimalColumnPivot.hpp" + +//############################################################################# + +/** Primal Column Pivot Dantzig Algorithm Class + +This is simplest choice - choose largest infeasibility + +*/ + +class ClpPrimalColumnDantzig : public ClpPrimalColumnPivot { + +public: + + ///@name Algorithmic methods + //@{ + + /** Returns pivot column, -1 if none. + Lumbers over all columns - slow + The Packed CoinIndexedVector updates has cost updates - for normal LP + that is just +-weight where a feasibility changed. It also has + reduced cost from last iteration in pivot row + Can just do full price if you really want to be slow + */ + virtual int pivotColumn(CoinIndexedVector * updates, + CoinIndexedVector * spareRow1, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2); + + /// Just sets model + virtual void saveWeights(ClpSimplex * model, int) { + model_ = model; + } + //@} + + + ///@name Constructors and destructors + //@{ + /// Default Constructor + ClpPrimalColumnDantzig(); + + /// Copy constructor + ClpPrimalColumnDantzig(const ClpPrimalColumnDantzig &); + + /// Assignment operator + ClpPrimalColumnDantzig & operator=(const ClpPrimalColumnDantzig& rhs); + + /// Destructor + virtual ~ClpPrimalColumnDantzig (); + + /// Clone + virtual ClpPrimalColumnPivot * clone(bool copyData = true) const; + + //@} + + //--------------------------------------------------------------------------- + +private: + ///@name Private member data + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/ClpPrimalColumnPivot.hpp b/thirdparty/windows/include/coin/ClpPrimalColumnPivot.hpp new file mode 100644 index 0000000..678da30 --- /dev/null +++ b/thirdparty/windows/include/coin/ClpPrimalColumnPivot.hpp @@ -0,0 +1,155 @@ +/* $Id: ClpPrimalColumnPivot.hpp 1732 2011-05-31 08:09:41Z 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 ClpPrimalcolumnPivot_H +#define ClpPrimalcolumnPivot_H + +class ClpSimplex; +class CoinIndexedVector; + +//############################################################################# + +/** Primal Column Pivot Abstract Base Class + +Abstract Base Class for describing an interface to an algorithm +to choose column pivot in primal simplex algorithm. For some algorithms +e.g. Dantzig choice then some functions may be null. For Dantzig +the only one of any importance is pivotColumn. + +If you wish to inherit from this look at ClpPrimalColumnDantzig.cpp +as that is simplest version. +*/ + +class ClpPrimalColumnPivot { + +public: + + ///@name Algorithmic methods + //@{ + + /** Returns pivot column, -1 if none + + Normally updates reduced costs using result of last iteration + before selecting incoming column. + + The Packed CoinIndexedVector updates has cost updates - for normal LP + that is just +-weight where a feasibility changed. It also has + reduced cost from last iteration in pivot row + + Inside pivotColumn the pivotRow_ and reduced cost from last iteration + are also used. + + So in the simplest case i.e. feasible we compute the row of the + tableau corresponding to last pivot and add a multiple of this + to current reduced costs. + + We can use other arrays to help updates + */ + virtual int pivotColumn(CoinIndexedVector * updates, + CoinIndexedVector * spareRow1, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2) = 0; + + /// Updates weights - part 1 (may be empty) + virtual void updateWeights(CoinIndexedVector * input); + + /** 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) forces some initialization e.g. weights + Also sets model + */ + virtual void saveWeights(ClpSimplex * model, int mode) = 0; + /** Signals pivot row choice: + -2 (default) - use normal pivot row choice + -1 to numberRows-1 - use this (will be checked) + way should be -1 to go to lower bound, +1 to upper bound + */ + virtual int pivotRow(double & way) { + way = 0; + return -2; + } + /// Gets rid of all arrays (may be empty) + virtual void clearArrays(); + /// Returns true if would not find any column + virtual bool looksOptimal() const { + return looksOptimal_; + } + /// Sets optimality flag (for advanced use) + virtual void setLooksOptimal(bool flag) { + looksOptimal_ = flag; + } + //@} + + + ///@name Constructors and destructors + //@{ + /// Default Constructor + ClpPrimalColumnPivot(); + + /// Copy constructor + ClpPrimalColumnPivot(const ClpPrimalColumnPivot &); + + /// Assignment operator + ClpPrimalColumnPivot & operator=(const ClpPrimalColumnPivot& rhs); + + /// Destructor + virtual ~ClpPrimalColumnPivot (); + + /// Clone + virtual ClpPrimalColumnPivot * clone(bool copyData = true) const = 0; + + //@} + + ///@name Other + //@{ + /// Returns model + inline ClpSimplex * model() { + return model_; + } + /// Sets model + inline void setModel(ClpSimplex * newmodel) { + model_ = newmodel; + } + + /// Returns type (above 63 is extra information) + inline int type() { + return type_; + } + + /** Returns number of extra columns for sprint algorithm - 0 means off. + Also number of iterations before recompute + */ + virtual int numberSprintColumns(int & numberIterations) const; + /// Switch off sprint idea + virtual void switchOffSprint(); + /// Called when maximum pivots changes + virtual void maximumPivotsChanged() {} + + //@} + + //--------------------------------------------------------------------------- + +protected: + ///@name Protected member data + //@{ + /// Pointer to model + ClpSimplex * model_; + /// Type of column pivot algorithm + int type_; + /// Says if looks optimal (normally computed) + bool looksOptimal_; + //@} +}; +#ifndef CLP_PRIMAL_SLACK_MULTIPLIER +#define CLP_PRIMAL_SLACK_MULTIPLIER 1.01 +#endif +#endif diff --git a/thirdparty/windows/include/coin/ClpPrimalColumnSteepest.hpp b/thirdparty/windows/include/coin/ClpPrimalColumnSteepest.hpp new file mode 100644 index 0000000..2da7542 --- /dev/null +++ b/thirdparty/windows/include/coin/ClpPrimalColumnSteepest.hpp @@ -0,0 +1,247 @@ +/* $Id: ClpPrimalColumnSteepest.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 ClpPrimalColumnSteepest_H +#define ClpPrimalColumnSteepest_H + +#include "ClpPrimalColumnPivot.hpp" +#include <bitset> + +//############################################################################# +class CoinIndexedVector; + + +/** Primal Column Pivot Steepest Edge Algorithm Class + +See Forrest-Goldfarb paper for algorithm + +*/ + + +class ClpPrimalColumnSteepest : public ClpPrimalColumnPivot { + +public: + + ///@name Algorithmic methods + //@{ + + /** Returns pivot column, -1 if none. + The Packed CoinIndexedVector updates has cost updates - for normal LP + that is just +-weight where a feasibility changed. It also has + reduced cost from last iteration in pivot row + Parts of operation split out into separate functions for + profiling and speed + */ + virtual int pivotColumn(CoinIndexedVector * updates, + CoinIndexedVector * spareRow1, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2); + /// For quadratic or funny nonlinearities + int pivotColumnOldMethod(CoinIndexedVector * updates, + CoinIndexedVector * spareRow1, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2); + /// Just update djs + void justDjs(CoinIndexedVector * updates, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2); + /// Update djs doing partial pricing (dantzig) + int partialPricing(CoinIndexedVector * updates, + CoinIndexedVector * spareRow2, + int numberWanted, + int numberLook); + /// Update djs, weights for Devex using djs + void djsAndDevex(CoinIndexedVector * updates, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2); + /// Update djs, weights for Steepest using djs + void djsAndSteepest(CoinIndexedVector * updates, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2); + /// Update djs, weights for Devex using pivot row + void djsAndDevex2(CoinIndexedVector * updates, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2); + /// Update djs, weights for Steepest using pivot row + void djsAndSteepest2(CoinIndexedVector * updates, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2); + /// Update weights for Devex + void justDevex(CoinIndexedVector * updates, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2); + /// Update weights for Steepest + void justSteepest(CoinIndexedVector * updates, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2); + /// Updates two arrays for steepest + void transposeTimes2(const CoinIndexedVector * pi1, CoinIndexedVector * dj1, + const CoinIndexedVector * pi2, CoinIndexedVector * dj2, + CoinIndexedVector * spare, double scaleFactor); + + /// Updates weights - part 1 - also checks accuracy + virtual void updateWeights(CoinIndexedVector * input); + + /// Checks accuracy - just for debug + void checkAccuracy(int sequence, double relativeTolerance, + CoinIndexedVector * rowArray1, + CoinIndexedVector * rowArray2); + + /// Initialize weights + void initializeWeights(); + + /** Save weights - this may initialize weights as well + mode is - + 1) before factorization + 2) after factorization + 3) just redo infeasibilities + 4) restore weights + 5) at end of values pass (so need initialization) + */ + virtual void saveWeights(ClpSimplex * model, int mode); + /// Gets rid of last update + virtual void unrollWeights(); + /// Gets rid of all arrays + virtual void clearArrays(); + /// Returns true if would not find any column + virtual bool looksOptimal() const; + /// Called when maximum pivots changes + virtual void maximumPivotsChanged(); + //@} + + /**@name gets and sets */ + //@{ + /// Mode + inline int mode() const { + return mode_; + } + /** Returns number of extra columns for sprint algorithm - 0 means off. + Also number of iterations before recompute + */ + virtual int numberSprintColumns(int & numberIterations) const; + /// Switch off sprint idea + virtual void switchOffSprint(); + +//@} + + /** 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 exact devex, 1 full steepest, 2 is partial exact devex + 3 switches between 0 and 2 depending on factorization + 4 starts as partial dantzig/devex but then may switch between 0 and 2. + By partial exact devex is meant that the weights are updated as normal + but only part of the nonbasic variables are scanned. + This can be faster on very easy problems. + */ + ClpPrimalColumnSteepest(int mode = 3); + + /// Copy constructor + ClpPrimalColumnSteepest(const ClpPrimalColumnSteepest & rhs); + + /// Assignment operator + ClpPrimalColumnSteepest & operator=(const ClpPrimalColumnSteepest& rhs); + + /// Destructor + virtual ~ClpPrimalColumnSteepest (); + + /// Clone + virtual ClpPrimalColumnPivot * clone(bool copyData = true) const; + + //@} + + ///@name Private functions to deal with devex + /** reference would be faster using ClpSimplex's status_, + but I prefer to keep modularity. + */ + inline bool reference(int i) const { + return ((reference_[i>>5] >> (i & 31)) & 1) != 0; + } + inline void setReference(int i, bool trueFalse) { + unsigned int & value = reference_[i>>5]; + int bit = i & 31; + if (trueFalse) + value |= (1 << bit); + else + value &= ~(1 << bit); + } + /// Set/ get persistence + inline void setPersistence(Persistence life) { + persistence_ = life; + } + inline Persistence persistence() const { + return persistence_ ; + } + + //@} + //--------------------------------------------------------------------------- + +private: + ///@name Private member data + // Update weight + double devex_; + /// weight array + double * weights_; + /// square of infeasibility array (just for infeasible columns) + CoinIndexedVector * infeasible_; + /// alternate weight array (so we can unroll) + CoinIndexedVector * alternateWeights_; + /// save weight array (so we can use checkpoint) + double * savedWeights_; + // Array for exact devex to say what is in reference framework + unsigned int * reference_; + /** Status + 0) Normal + -1) Needs initialization + 1) Weights are stored by sequence number + */ + int state_; + /** + 0 is exact devex, 1 full steepest, 2 is partial exact devex + 3 switches between 0 and 2 depending on factorization + 4 starts as partial dantzig/devex but then may switch between 0 and 2. + 5 is always partial dantzig + By partial exact devex is meant that the weights are updated as normal + but only part of the nonbasic variables are scanned. + This can be faster on very easy problems. + + New dubious option is >=10 which does mini-sprint + + */ + int mode_; + /// Life of weights + Persistence persistence_; + /// Number of times switched from partial dantzig to 0/2 + int numberSwitched_; + // This is pivot row (or pivot sequence round re-factorization) + int pivotSequence_; + // This is saved pivot sequence + int savedPivotSequence_; + // This is saved outgoing variable + int savedSequenceOut_; + // Iteration when last rectified + int lastRectified_; + // Size of factorization at invert (used to decide algorithm) + int sizeFactorization_; + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/ClpQuadraticObjective.hpp b/thirdparty/windows/include/coin/ClpQuadraticObjective.hpp new file mode 100644 index 0000000..a52b097 --- /dev/null +++ b/thirdparty/windows/include/coin/ClpQuadraticObjective.hpp @@ -0,0 +1,155 @@ +/* $Id: ClpQuadraticObjective.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 ClpQuadraticObjective_H +#define ClpQuadraticObjective_H + +#include "ClpObjective.hpp" +#include "CoinPackedMatrix.hpp" + +//############################################################################# + +/** Quadratic Objective Class + +*/ + +class ClpQuadraticObjective : public ClpObjective { + +public: + + ///@name Stuff + //@{ + + /** Returns gradient. If Quadratic then solution may be NULL, + also returns an offset (to be added to current one) + If refresh is false then uses last solution + Uses model for scaling + includeLinear 0 - no, 1 as is, 2 as feasible + */ + virtual double * gradient(const ClpSimplex * model, + const double * solution, double & offset, bool refresh, + int includeLinear = 2); + /// Resize objective + /** 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 ; + 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) ; + /** Given a zeroed array sets nonlinear columns to 1. + Returns number of nonlinear columns + */ + virtual int markNonlinear(char * which); + + //@} + + + ///@name Constructors and destructors + //@{ + /// Default Constructor + ClpQuadraticObjective(); + + /// Constructor from objective + ClpQuadraticObjective(const double * linearObjective, int numberColumns, + const CoinBigIndex * start, + const int * column, const double * element, + int numberExtendedColumns_ = -1); + + /** Copy constructor . + If type is -1 then make sure half symmetric, + if +1 then make sure full + */ + ClpQuadraticObjective(const ClpQuadraticObjective & rhs, int type = 0); + /** Subset constructor. Duplicates are allowed + and order is as given. + */ + ClpQuadraticObjective (const ClpQuadraticObjective &rhs, int numberColumns, + const int * whichColumns) ; + + /// Assignment operator + ClpQuadraticObjective & operator=(const ClpQuadraticObjective& rhs); + + /// Destructor + virtual ~ClpQuadraticObjective (); + + /// Clone + virtual ClpObjective * clone() const; + /** Subset clone. Duplicates are allowed + and order is as given. + */ + virtual ClpObjective * subsetClone (int numberColumns, + const int * whichColumns) const; + + /** Load up quadratic objective. This is stored as a CoinPackedMatrix */ + void loadQuadraticObjective(const int numberColumns, + const CoinBigIndex * start, + const int * column, const double * element, + int numberExtendedColumns = -1); + void loadQuadraticObjective ( const CoinPackedMatrix& matrix); + /// Get rid of quadratic objective + void deleteQuadraticObjective(); + //@} + ///@name Gets and sets + //@{ + /// Quadratic objective + inline CoinPackedMatrix * quadraticObjective() const { + return quadraticObjective_; + } + /// Linear objective + inline double * linearObjective() const { + return objective_; + } + /// Length of linear objective which could be bigger + inline int numberExtendedColumns() const { + return numberExtendedColumns_; + } + /// Number of columns in quadratic objective + inline int numberColumns() const { + return numberColumns_; + } + /// If a full or half matrix + inline bool fullMatrix() const { + return fullMatrix_; + } + //@} + + //--------------------------------------------------------------------------- + +private: + ///@name Private member data + /// Quadratic objective + CoinPackedMatrix * quadraticObjective_; + /// Objective + double * objective_; + /// Gradient + double * gradient_; + /// Useful to have number of columns about + int numberColumns_; + /// Also length of linear objective which could be bigger + int numberExtendedColumns_; + /// True if full symmetric matrix, false if half + bool fullMatrix_; + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/ClpSimplex.hpp b/thirdparty/windows/include/coin/ClpSimplex.hpp new file mode 100644 index 0000000..bab4506 --- /dev/null +++ b/thirdparty/windows/include/coin/ClpSimplex.hpp @@ -0,0 +1,1797 @@ +/* $Id: ClpSimplex.hpp 2114 2015-02-10 12:12:46Z 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). +/* + Authors + + John Forrest + + */ +#ifndef ClpSimplex_H +#define ClpSimplex_H + +#include <iostream> +#include <cfloat> +#include "ClpModel.hpp" +#include "ClpMatrixBase.hpp" +#include "ClpSolve.hpp" +#include "ClpConfig.h" +class ClpDualRowPivot; +class ClpPrimalColumnPivot; +class ClpFactorization; +class CoinIndexedVector; +class ClpNonLinearCost; +class ClpNodeStuff; +class CoinStructuredModel; +class OsiClpSolverInterface; +class CoinWarmStartBasis; +class ClpDisasterHandler; +class ClpConstraint; +/* + May want to use Clp defaults so that with ABC defined but not used + it behaves as Clp (and ABC used will be different than if not defined) + */ +#ifdef ABC_INHERIT +#ifndef CLP_INHERIT_MODE +#define CLP_INHERIT_MODE 1 +#endif +#ifndef ABC_CLP_DEFAULTS +#define ABC_CLP_DEFAULTS 0 +#endif +#else +#undef ABC_CLP_DEFAULTS +#define ABC_CLP_DEFAULTS 1 +#endif +#ifdef CLP_HAS_ABC +#include "AbcCommon.hpp" +class AbcTolerancesEtc; +class AbcSimplex; +#include "CoinAbcCommon.hpp" +#endif +/** This solves LPs using the simplex method + + It inherits from ClpModel and all its arrays are created at + algorithm time. Originally I tried to work with model arrays + but for simplicity of coding I changed to single arrays with + structural variables then row variables. Some coding is still + based on old style and needs cleaning up. + + For a description of algorithms: + + for dual see ClpSimplexDual.hpp and at top of ClpSimplexDual.cpp + for primal see ClpSimplexPrimal.hpp and at top of ClpSimplexPrimal.cpp + + There is an algorithm data member. + for primal variations + and - for dual variations + +*/ + +class ClpSimplex : public ClpModel { + friend void ClpSimplexUnitTest(const std::string & mpsDir); + +public: + /** enums for status of various sorts. + First 4 match CoinWarmStartBasis, + isFixed means fixed at lower bound and out of basis + */ + enum Status { + isFree = 0x00, + basic = 0x01, + atUpperBound = 0x02, + atLowerBound = 0x03, + superBasic = 0x04, + isFixed = 0x05 + }; + // For Dual + enum FakeBound { + noFake = 0x00, + lowerFake = 0x01, + upperFake = 0x02, + bothFake = 0x03 + }; + + /**@name Constructors and destructor and copy */ + //@{ + /// Default constructor + ClpSimplex (bool emptyMessages = false ); + + /** Copy constructor. May scale depending on mode + -1 leave mode as is + 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) + */ + ClpSimplex(const ClpSimplex & rhs, int scalingMode = -1); + /** Copy constructor from model. May scale depending on mode + -1 leave mode as is + 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) + */ + ClpSimplex(const ClpModel & rhs, int scalingMode = -1); + /** 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 + Can optionally modify rhs to take into account variables NOT in list + in this case duplicates are not allowed (also see getbackSolution) + */ + ClpSimplex (const ClpModel * wholeModel, + int numberRows, const int * whichRows, + int numberColumns, const int * whichColumns, + bool dropNames = true, bool dropIntegers = true, + bool fixOthers = false); + /** 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 + Can optionally modify rhs to take into account variables NOT in list + in this case duplicates are not allowed (also see getbackSolution) + */ + ClpSimplex (const ClpSimplex * wholeModel, + int numberRows, const int * whichRows, + int numberColumns, const int * whichColumns, + bool dropNames = true, bool dropIntegers = true, + bool fixOthers = false); + /** This constructor modifies original ClpSimplex and stores + original stuff in created ClpSimplex. It is only to be used in + conjunction with originalModel */ + ClpSimplex (ClpSimplex * wholeModel, + int numberColumns, const int * whichColumns); + /** This copies back stuff from miniModel and then deletes miniModel. + Only to be used with mini constructor */ + void originalModel(ClpSimplex * miniModel); + inline int abcState() const + { return abcState_;} + inline void setAbcState(int state) + { abcState_=state;} +#ifdef ABC_INHERIT + inline AbcSimplex * abcSimplex() const + { return abcSimplex_;} + inline void setAbcSimplex(AbcSimplex * simplex) + { abcSimplex_=simplex;} + /// Returns 0 if dual can be skipped + int doAbcDual(); + /// Returns 0 if primal can be skipped + int doAbcPrimal(int ifValuesPass); +#endif + /** 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 + */ + void setPersistenceFlag(int value); + /// Save a copy of model with certain state - normally without cuts + void makeBaseModel(); + /// Switch off base model + void deleteBaseModel(); + /// See if we have base model + inline ClpSimplex * baseModel() const { + return baseModel_; + } + /** Reset to base model (just size and arrays needed) + If model NULL use internal copy + */ + void setToBaseModel(ClpSimplex * model = NULL); + /// Assignment operator. This copies the data + ClpSimplex & operator=(const ClpSimplex & rhs); + /// Destructor + ~ClpSimplex ( ); + // 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: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>rowub</code>: all rows have upper bound infinity + <li> <code>rowlb</code>: all rows have lower bound -infinity + <li> <code>obj</code>: all variables have 0 objective coefficient + </ul> + */ + 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); + /** This loads a model from a coinModel object - returns number of errors. + If keepSolution true and size is same as current then + keeps current status and solution + */ + int loadProblem ( CoinModel & modelObject, bool keepSolution = false); + /// 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); + /// Read file in LP format from file with name filename. + /// See class CoinLpIO for description of this format. + int readLp(const char *filename, const double epsilon = 1e-5); + /** 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, but sets scaling on etc. */ + void borrowModel(ClpModel & otherModel); + void borrowModel(ClpSimplex & otherModel); + /// Pass in Event handler (cloned and deleted at end) + void passInEventHandler(const ClpEventHandler * eventHandler); + /// Puts solution back into small model + void getbackSolution(const ClpSimplex & smallModel, const int * whichRow, const int * whichColumn); + /** Load nonlinear part of problem from AMPL info + Returns 0 if linear + 1 if quadratic objective + 2 if quadratic constraints + 3 if nonlinear objective + 4 if nonlinear constraints + -1 on failure + */ + int loadNonLinear(void * info, int & numberConstraints, + ClpConstraint ** & constraints); +#ifdef ABC_INHERIT + /// Loads tolerances etc + void loadTolerancesEtc(const AbcTolerancesEtc & data); + /// Unloads tolerances etc + void unloadTolerancesEtc(AbcTolerancesEtc & data); +#endif + //@} + + /**@name Functions most useful to user */ + //@{ + /** General solve algorithm which can do presolve. + See ClpSolve.hpp for options + */ + int initialSolve(ClpSolve & options); + /// Default initial solve + int initialSolve(); + /// Dual initial solve + int initialDualSolve(); + /// Primal initial solve + int initialPrimalSolve(); + /// Barrier initial solve + int initialBarrierSolve(); + /// Barrier initial solve, not to be followed by crossover + int initialBarrierNoCrossSolve(); + /** Dual algorithm - see ClpSimplexDual.hpp for method. + ifValuesPass==2 just does values pass and then stops. + + startFinishOptions - bits + 1 - do not delete work areas and factorization at end + 2 - use old factorization if same number of rows + 4 - skip as much initialization of work areas as possible + (based on whatsChanged in clpmodel.hpp) ** work in progress + maybe other bits later + */ + int dual(int ifValuesPass = 0, int startFinishOptions = 0); + // If using Debug + int dualDebug(int ifValuesPass = 0, int startFinishOptions = 0); + /** Primal algorithm - see ClpSimplexPrimal.hpp for method. + ifValuesPass==2 just does values pass and then stops. + + startFinishOptions - bits + 1 - do not delete work areas and factorization at end + 2 - use old factorization if same number of rows + 4 - skip as much initialization of work areas as possible + (based on whatsChanged in clpmodel.hpp) ** work in progress + maybe other bits later + */ + int primal(int ifValuesPass = 0, int startFinishOptions = 0); + /** Solves nonlinear problem using SLP - may be used as crash + for other algorithms when number of iterations small. + Also exits if all problematical variables are changing + less than deltaTolerance + */ + int nonlinearSLP(int numberPasses, double deltaTolerance); + /** Solves problem with nonlinear constraints using SLP - may be used as crash + for other algorithms when number of iterations small. + Also exits if all problematical variables are changing + less than deltaTolerance + */ + int nonlinearSLP(int numberConstraints, ClpConstraint ** constraints, + int numberPasses, double deltaTolerance); + /** Solves using barrier (assumes you have good cholesky factor code). + Does crossover to simplex if asked*/ + int barrier(bool crossover = true); + /** Solves non-linear using reduced gradient. Phase = 0 get feasible, + =1 use solution */ + int reducedGradient(int phase = 0); + /// Solve using structure of model and maybe in parallel + int solve(CoinStructuredModel * model); +#ifdef ABC_INHERIT + /** solvetype 0 for dual, 1 for primal + startup 1 for values pass + interrupt whether to pass across interrupt handler + add 10 to return AbcSimplex + */ + AbcSimplex * dealWithAbc(int solveType,int startUp,bool interrupt=false); + //void dealWithAbc(int solveType,int startUp,bool interrupt=false); +#endif + /** This loads a model from a CoinStructuredModel object - returns number of errors. + If originalOrder then keep to order stored in blocks, + otherwise first column/rows correspond to first block - etc. + If keepSolution true and size is same as current then + keeps current status and solution + */ + int loadProblem ( CoinStructuredModel & modelObject, + bool originalOrder = true, bool keepSolution = false); + /** + When scaling is on it is possible that the scaled problem + is feasible but the unscaled is not. Clp returns a secondary + status code to that effect. This option allows for a cleanup. + If you use it I would suggest 1. + This only affects actions when scaled optimal + 0 - no action + 1 - clean up using dual if primal infeasibility + 2 - clean up using dual if dual infeasibility + 3 - clean up using dual if primal or dual infeasibility + 11,12,13 - as 1,2,3 but use primal + + return code as dual/primal + */ + int cleanup(int cleanupScaling); + /** Dual ranging. + This computes increase/decrease in cost for each given variable and corresponding + sequence numbers which would change basis. Sequence numbers are 0..numberColumns + and numberColumns.. for artificials/slacks. + For non-basic variables the information is trivial to compute and the change in cost is just minus the + reduced cost and the sequence number will be that of the non-basic variables. + For basic variables a ratio test is between the reduced costs for non-basic variables + and the row of the tableau corresponding to the basic variable. + The increase/decrease value is always >= 0.0 + + Up to user to provide correct length arrays where each array is of length numberCheck. + which contains list of variables for which information is desired. All other + arrays will be filled in by function. If fifth entry in which is variable 7 then fifth entry in output arrays + will be information for variable 7. + + If valueIncrease/Decrease not NULL (both must be NULL or both non NULL) then these are filled with + the value of variable if such a change in cost were made (the existing bounds are ignored) + + Returns non-zero if infeasible unbounded etc + */ + int dualRanging(int numberCheck, const int * which, + double * costIncrease, int * sequenceIncrease, + double * costDecrease, int * sequenceDecrease, + double * valueIncrease = NULL, double * valueDecrease = NULL); + /** Primal ranging. + This computes increase/decrease in value for each given variable and corresponding + sequence numbers which would change basis. Sequence numbers are 0..numberColumns + and numberColumns.. for artificials/slacks. + This should only be used for non-basic variabls as otherwise information is pretty useless + For basic variables the sequence number will be that of the basic variables. + + Up to user to provide correct length arrays where each array is of length numberCheck. + which contains list of variables for which information is desired. All other + arrays will be filled in by function. If fifth entry in which is variable 7 then fifth entry in output arrays + will be information for variable 7. + + Returns non-zero if infeasible unbounded etc + */ + int primalRanging(int numberCheck, const int * which, + double * valueIncrease, int * sequenceIncrease, + double * valueDecrease, int * sequenceDecrease); + /** + Modifies coefficients etc and if necessary pivots in and out. + All at same status will be done (basis may go singular). + User can tell which others have been done (i.e. if status matches). + If called from outside will change status and return 0. + If called from event handler returns non-zero if user has to take action. + indices>=numberColumns are slacks (obviously no coefficients) + status array is (char) Status enum + */ + int modifyCoefficientsAndPivot(int number, + const int * which, + const CoinBigIndex * start, + const int * row, + const double * newCoefficient, + const unsigned char * newStatus=NULL, + const double * newLower=NULL, + const double * newUpper=NULL, + const double * newObjective=NULL); + /** Take out duplicate rows (includes scaled rows and intersections). + On exit whichRows has rows to delete - return code is number can be deleted + or -1 if would be infeasible. + If tolerance is -1.0 use primalTolerance for equality rows and infeasibility + If cleanUp not zero then spend more time trying to leave more stable row + and make row bounds exact multiple of cleanUp if close enough + */ + int outDuplicateRows(int numberLook,int * whichRows, bool noOverlaps=false, double tolerance=-1.0, + double cleanUp=0.0); + /** Try simple crash like techniques to get closer to primal feasibility + returns final sum of infeasibilities */ + double moveTowardsPrimalFeasible(); + /** Try simple crash like techniques to remove super basic slacks + but only if > threshold */ + void removeSuperBasicSlacks(int threshold=0); + /** Mini presolve (faster) + Char arrays must be numberRows and numberColumns long + on entry second part must be filled in as follows - + 0 - possible + >0 - take out and do something (depending on value - TBD) + -1 row/column can't vanish but can have entries removed/changed + -2 don't touch at all + on exit <=0 ones will be in presolved problem + struct will be created and will be long enough + (information on length etc in first entry) + user must delete struct + */ + ClpSimplex * miniPresolve(char * rowType, char * columnType,void ** info); + /// After mini presolve + void miniPostsolve(const ClpSimplex * presolvedModel,void * info); + /// mini presolve and solve + void miniSolve(char * rowType, char *columnType,int algorithm, int startUp); + /** Write the basis in MPS format to the specified file. + If writeValues true writes values of structurals + (and adds VALUES to end of NAME card) + + Row and column names may be null. + formatType is + <ul> + <li> 0 - normal + <li> 1 - extra accuracy + <li> 2 - IEEE hex (later) + </ul> + + Returns non-zero on I/O error + */ + int writeBasis(const char *filename, + bool writeValues = false, + int formatType = 0) const; + /** Read a basis from the given filename, + returns -1 on file error, 0 if no values, 1 if values */ + int readBasis(const char *filename); + /// Returns a basis (to be deleted by user) + CoinWarmStartBasis * getBasis() const; + /// Passes in factorization + void setFactorization( ClpFactorization & factorization); + // Swaps factorization + ClpFactorization * swapFactorization( ClpFactorization * factorization); + /// Copies in factorization to existing one + void copyFactorization( ClpFactorization & factorization); + /** Tightens primal bounds to make dual faster. Unless + fixed or doTight>10, bounds are slightly looser than they could be. + This is to make dual go faster and is probably not needed + with a presolve. 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(double factor = 0.0, int doTight = 0, bool tightIntegers = false); + /** Crash - at present just aimed at dual, returns + -2 if dual preferred and crash basis created + -1 if dual preferred and all slack basis preferred + 0 if basis going in was not all slack + 1 if primal preferred and all slack basis preferred + 2 if primal preferred and crash basis created. + + if gap between bounds <="gap" variables can be flipped + ( If pivot -1 then can be made super basic!) + + If "pivot" is + -1 No pivoting - always primal + 0 No pivoting (so will just be choice of algorithm) + 1 Simple pivoting e.g. gub + 2 Mini iterations + */ + int crash(double gap, int pivot); + /// Sets row pivot choice algorithm in dual + void setDualRowPivotAlgorithm(ClpDualRowPivot & choice); + /// Sets column pivot choice algorithm in primal + void setPrimalColumnPivotAlgorithm(ClpPrimalColumnPivot & choice); + /// Create a hotstart point of the optimization process + void markHotStart(void * & saveStuff); + /// Optimize starting from the hotstart + void solveFromHotStart(void * saveStuff); + /// Delete the snapshot + void unmarkHotStart(void * saveStuff); + /** For strong branching. On input lower and upper are new bounds + while on output they are change in objective function values + (>1.0e50 infeasible). + Return code is 0 if nothing interesting, -1 if infeasible both + ways and +1 if infeasible one way (check values to see which one(s)) + Solutions are filled in as well - even down, odd up - also + status and number of iterations + */ + int strongBranching(int numberVariables, const int * variables, + double * newLower, double * newUpper, + double ** outputSolution, + int * outputStatus, int * outputIterations, + bool stopOnFirstInfeasible = true, + bool alwaysFinish = false, + int startFinishOptions = 0); + /// Fathom - 1 if solution + int fathom(void * stuff); + /** Do up to N deep - returns + -1 - no solution nNodes_ valid nodes + >= if solution and that node gives solution + ClpNode array is 2**N long. Values for N and + array are in stuff (nNodes_ also in stuff) */ + int fathomMany(void * stuff); + /// Double checks OK + double doubleCheck(); + /// Starts Fast dual2 + int startFastDual2(ClpNodeStuff * stuff); + /// Like Fast dual + int fastDual2(ClpNodeStuff * stuff); + /// Stops Fast dual2 + void stopFastDual2(ClpNodeStuff * stuff); + /** Deals with crunch aspects + mode 0 - in + 1 - out with solution + 2 - out without solution + returns small model or NULL + */ + ClpSimplex * fastCrunch(ClpNodeStuff * stuff, int mode); + //@} + + /**@name Needed for functionality of OsiSimplexInterface */ + //@{ + /** Pivot in a variable and out a variable. Returns 0 if okay, + 1 if inaccuracy forced re-factorization, -1 if would be singular. + Also updates primal/dual infeasibilities. + Assumes sequenceIn_ and pivotRow_ set and also directionIn and Out. + */ + int pivot(); + + /** Pivot in a variable and choose an outgoing one. Assumes primal + feasible - will not go through a bound. Returns step length in theta + Returns ray in ray_ (or NULL if no pivot) + Return codes as before but -1 means no acceptable pivot + */ + int primalPivotResult(); + + /** Pivot out a variable and choose an incoing one. Assumes dual + feasible - will not go through a reduced cost. + Returns step length in theta + Return codes as before but -1 means no acceptable pivot + */ + int dualPivotResultPart1(); + /** Do actual pivot + state is 0 if need tableau column, 1 if in rowArray_[1] + */ + int pivotResultPart2(int algorithm,int state); + + /** Common bits of coding for dual and primal. Return 0 if okay, + 1 if bad matrix, 2 if very bad factorization + + startFinishOptions - bits + 1 - do not delete work areas and factorization at end + 2 - use old factorization if same number of rows + 4 - skip as much initialization of work areas as possible + (based on whatsChanged in clpmodel.hpp) ** work in progress + maybe other bits later + + */ + int startup(int ifValuesPass, int startFinishOptions = 0); + void finish(int startFinishOptions = 0); + + /** Factorizes and returns true if optimal. Used by user */ + bool statusOfProblem(bool initial = false); + /// If user left factorization frequency then compute + void defaultFactorizationFrequency(); + /// Copy across enabled stuff from one solver to another + void copyEnabledStuff(const ClpSimplex * rhs); + //@} + + /**@name most useful gets and sets */ + //@{ + /// If problem is primal feasible + inline bool primalFeasible() const { + return (numberPrimalInfeasibilities_ == 0); + } + /// If problem is dual feasible + inline bool dualFeasible() const { + return (numberDualInfeasibilities_ == 0); + } + /// factorization + inline ClpFactorization * factorization() const { + return factorization_; + } + /// Sparsity on or off + bool sparseFactorization() const; + void setSparseFactorization(bool value); + /// Factorization frequency + int factorizationFrequency() const; + void setFactorizationFrequency(int value); + /// Dual bound + inline double dualBound() const { + return dualBound_; + } + void setDualBound(double value); + /// Infeasibility cost + inline double infeasibilityCost() const { + return infeasibilityCost_; + } + void setInfeasibilityCost(double value); + /** 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 + */ + /** Perturbation: + 50 - switch on perturbation + 100 - auto perturb if takes too long (1.0e-6 largest nonzero) + 101 - we are perturbed + 102 - don't try perturbing again + default is 100 + others are for playing + */ + inline int perturbation() const { + return perturbation_; + } + void setPerturbation(int value); + /// Current (or last) algorithm + inline int algorithm() const { + return algorithm_; + } + /// Set algorithm + inline void setAlgorithm(int value) { + algorithm_ = value; + } + /// Return true if the objective limit test can be relied upon + bool isObjectiveLimitTestValid() const ; + /// Sum of dual infeasibilities + inline double sumDualInfeasibilities() const { + return sumDualInfeasibilities_; + } + inline void setSumDualInfeasibilities(double value) { + sumDualInfeasibilities_ = value; + } + /// Sum of relaxed dual infeasibilities + inline double sumOfRelaxedDualInfeasibilities() const { + return sumOfRelaxedDualInfeasibilities_; + } + inline void setSumOfRelaxedDualInfeasibilities(double value) { + sumOfRelaxedDualInfeasibilities_ = value; + } + /// Number of dual infeasibilities + inline int numberDualInfeasibilities() const { + return numberDualInfeasibilities_; + } + inline void setNumberDualInfeasibilities(int value) { + numberDualInfeasibilities_ = value; + } + /// Number of dual infeasibilities (without free) + inline int numberDualInfeasibilitiesWithoutFree() const { + return numberDualInfeasibilitiesWithoutFree_; + } + /// Sum of primal infeasibilities + inline double sumPrimalInfeasibilities() const { + return sumPrimalInfeasibilities_; + } + inline void setSumPrimalInfeasibilities(double value) { + sumPrimalInfeasibilities_ = value; + } + /// Sum of relaxed primal infeasibilities + inline double sumOfRelaxedPrimalInfeasibilities() const { + return sumOfRelaxedPrimalInfeasibilities_; + } + inline void setSumOfRelaxedPrimalInfeasibilities(double value) { + sumOfRelaxedPrimalInfeasibilities_ = value; + } + /// Number of primal infeasibilities + inline int numberPrimalInfeasibilities() const { + return numberPrimalInfeasibilities_; + } + inline void setNumberPrimalInfeasibilities(int value) { + numberPrimalInfeasibilities_ = value; + } + /** Save model to file, returns 0 if success. This is designed for + use outside algorithms so does not save iterating arrays etc. + It does not save any messaging information. + Does not save scaling values. + It does not know about all types of virtual functions. + */ + int saveModel(const char * fileName); + /** Restore model from file, returns 0 if success, + deletes current model */ + int restoreModel(const char * fileName); + + /** Just check solution (for external use) - sets sum of + infeasibilities etc. + If setToBounds 0 then primal column values not changed + and used to compute primal row activity values. If 1 or 2 + then status used - so all nonbasic variables set to + indicated bound and if any values changed (or ==2) basic values re-computed. + */ + void checkSolution(int setToBounds = 0); + /** Just check solution (for internal use) - sets sum of + infeasibilities etc. */ + void checkSolutionInternal(); + /// Check unscaled primal solution but allow for rounding error + void checkUnscaledSolution(); + /// Useful row length arrays (0,1,2,3,4,5) + inline CoinIndexedVector * rowArray(int index) const { + return rowArray_[index]; + } + /// Useful column length arrays (0,1,2,3,4,5) + inline CoinIndexedVector * columnArray(int index) const { + return columnArray_[index]; + } + //@} + + /******************** End of most useful part **************/ + /**@name Functions less likely to be useful to casual user */ + //@{ + /** Given an existing factorization computes and checks + primal and dual solutions. Uses input arrays for variables at + bounds. Returns feasibility states */ + int getSolution ( const double * rowActivities, + const double * columnActivities); + /** Given an existing factorization computes and checks + primal and dual solutions. Uses current problem arrays for + bounds. Returns feasibility states */ + int getSolution (); + /** Constructs a non linear cost from list of non-linearities (columns only) + First lower of each column is taken as real lower + Last lower is taken as real upper and cost ignored + + Returns nonzero if bad data e.g. lowers not monotonic + */ + int createPiecewiseLinearCosts(const int * starts, + const double * lower, const double * gradient); + /// dual row pivot choice + inline ClpDualRowPivot * dualRowPivot() const { + return dualRowPivot_; + } + /// primal column pivot choice + inline ClpPrimalColumnPivot * primalColumnPivot() const { + return primalColumnPivot_; + } + /// Returns true if model looks OK + inline bool goodAccuracy() const { + return (largestPrimalError_ < 1.0e-7 && largestDualError_ < 1.0e-7); + } + /** Return model - updates any scalars */ + void returnModel(ClpSimplex & otherModel); + /** Factorizes using current basis. + solveType - 1 iterating, 0 initial, -1 external + If 10 added then in primal values pass + Return codes are as from ClpFactorization unless initial factorization + when total number of singularities is returned. + Special case is numberRows_+1 -> all slack basis. + */ + int internalFactorize(int solveType); + /// Save data + ClpDataSave saveData() ; + /// Restore data + void restoreData(ClpDataSave saved); + /// Clean up status + void cleanStatus(); + /// Factorizes using current basis. For external use + int factorize(); + /** Computes duals from scratch. If givenDjs then + allows for nonzero basic djs */ + void computeDuals(double * givenDjs); + /// Computes primals from scratch + void computePrimals ( const double * rowActivities, + const double * columnActivities); + /** Adds multiple of a column into an array */ + void add(double * array, + int column, double multiplier) const; + /** + Unpacks one column of the matrix into indexed array + Uses sequenceIn_ + Also applies scaling if needed + */ + void unpack(CoinIndexedVector * rowArray) const ; + /** + Unpacks one column of the matrix into indexed array + Slack if sequence>= numberColumns + Also applies scaling if needed + */ + void unpack(CoinIndexedVector * rowArray, int sequence) const; + /** + Unpacks one column of the matrix into indexed array + ** as packed vector + Uses sequenceIn_ + Also applies scaling if needed + */ + void unpackPacked(CoinIndexedVector * rowArray) ; + /** + Unpacks one column of the matrix into indexed array + ** as packed vector + Slack if sequence>= numberColumns + Also applies scaling if needed + */ + void unpackPacked(CoinIndexedVector * rowArray, int sequence); +#ifndef CLP_USER_DRIVEN +protected: +#endif + /** + This does basis housekeeping and does values for in/out variables. + Can also decide to re-factorize + */ + int housekeeping(double objectiveChange); + /** This sets largest infeasibility and most infeasible and sum + and number of infeasibilities (Primal) */ + void checkPrimalSolution(const double * rowActivities = NULL, + const double * columnActivies = NULL); + /** This sets largest infeasibility and most infeasible and sum + and number of infeasibilities (Dual) */ + void checkDualSolution(); + /** This sets sum and number of infeasibilities (Dual and Primal) */ + void checkBothSolutions(); + /** If input negative scales objective so maximum <= -value + and returns scale factor used. If positive unscales and also + redoes dual stuff + */ + double scaleObjective(double value); + /// Solve using Dantzig-Wolfe decomposition and maybe in parallel + int solveDW(CoinStructuredModel * model, ClpSolve & options); + /// Solve using Benders decomposition and maybe in parallel + int solveBenders(CoinStructuredModel * model, ClpSolve & options); +public: + /** For advanced use. When doing iterative solves things can get + nasty so on values pass if incoming solution has largest + infeasibility < incomingInfeasibility throw out variables + from basis until largest infeasibility < allowedInfeasibility + or incoming largest infeasibility. + If allowedInfeasibility>= incomingInfeasibility this is + always possible altough you may end up with an all slack basis. + + Defaults are 1.0,10.0 + */ + void setValuesPassAction(double incomingInfeasibility, + double allowedInfeasibility); + /** Get a clean factorization - i.e. throw out singularities + may do more later */ + int cleanFactorization(int ifValuesPass); + //@} + /**@name most useful gets and sets */ + //@{ +public: + /// Initial value for alpha accuracy calculation (-1.0 off) + inline double alphaAccuracy() const { + return alphaAccuracy_; + } + inline void setAlphaAccuracy(double value) { + alphaAccuracy_ = value; + } +public: + /// Objective value + //inline double objectiveValue() const { + //return (objectiveValue_-bestPossibleImprovement_)*optimizationDirection_ - dblParam_[ClpObjOffset]; + //} + /// Set disaster handler + inline void setDisasterHandler(ClpDisasterHandler * handler) { + disasterArea_ = handler; + } + /// Get disaster handler + inline ClpDisasterHandler * disasterHandler() const { + return disasterArea_; + } + /// Large bound value (for complementarity etc) + inline double largeValue() const { + return largeValue_; + } + void setLargeValue( double value) ; + /// Largest error on Ax-b + inline double largestPrimalError() const { + return largestPrimalError_; + } + /// Largest error on basic duals + inline double largestDualError() const { + return largestDualError_; + } + /// Largest error on Ax-b + inline void setLargestPrimalError(double value) { + largestPrimalError_ = value; + } + /// Largest error on basic duals + inline void setLargestDualError(double value) { + largestDualError_ = value; + } + /// Get zero tolerance + inline double zeroTolerance() const { + return zeroTolerance_;/*factorization_->zeroTolerance();*/ + } + /// Set zero tolerance + inline void setZeroTolerance( double value) { + zeroTolerance_ = value; + } + /// Basic variables pivoting on which rows + inline int * pivotVariable() const { + return pivotVariable_; + } + /// If automatic scaling on + inline bool automaticScaling() const { + return automaticScale_ != 0; + } + inline void setAutomaticScaling(bool onOff) { + automaticScale_ = onOff ? 1 : 0; + } + /// Current dual tolerance + inline double currentDualTolerance() const { + return dualTolerance_; + } + inline void setCurrentDualTolerance(double value) { + dualTolerance_ = value; + } + /// Current primal tolerance + inline double currentPrimalTolerance() const { + return primalTolerance_; + } + inline void setCurrentPrimalTolerance(double value) { + primalTolerance_ = value; + } + /// How many iterative refinements to do + inline int numberRefinements() const { + return numberRefinements_; + } + void setNumberRefinements( int value) ; + /// Alpha (pivot element) for use by classes e.g. steepestedge + inline double alpha() const { + return alpha_; + } + inline void setAlpha(double value) { + alpha_ = value; + } + /// Reduced cost of last incoming for use by classes e.g. steepestedge + inline double dualIn() const { + return dualIn_; + } + /// Set reduced cost of last incoming to force error + inline void setDualIn(double value) { + dualIn_ = value; + } + /// Pivot Row for use by classes e.g. steepestedge + inline int pivotRow() const { + return pivotRow_; + } + inline void setPivotRow(int value) { + pivotRow_ = value; + } + /// value of incoming variable (in Dual) + double valueIncomingDual() const; + //@} + +#ifndef CLP_USER_DRIVEN +protected: +#endif + /**@name protected methods */ + //@{ + /** May change basis and then returns number changed. + Computation of solutions may be overriden by given pi and solution + */ + int gutsOfSolution ( double * givenDuals, + const double * givenPrimals, + bool valuesPass = false); + /// Does most of deletion (0 = all, 1 = most, 2 most + factorization) + void gutsOfDelete(int type); + /// Does most of copying + void gutsOfCopy(const ClpSimplex & rhs); + /** puts in format I like (rowLower,rowUpper) also see StandardMatrix + 1 bit does rows (now and columns), (2 bit does column bounds), 4 bit does objective(s). + 8 bit does solution scaling in + 16 bit does rowArray and columnArray indexed vectors + and makes row copy if wanted, also sets columnStart_ etc + Also creates scaling arrays if needed. It does scaling if needed. + 16 also moves solutions etc in to work arrays + On 16 returns false if problem "bad" i.e. matrix or bounds bad + If startFinishOptions is -1 then called by user in getSolution + so do arrays but keep pivotVariable_ + */ + bool createRim(int what, bool makeRowCopy = false, int startFinishOptions = 0); + /// Does rows and columns + void createRim1(bool initial); + /// Does objective + void createRim4(bool initial); + /// Does rows and columns and objective + void createRim5(bool initial); + /** releases above arrays and does solution scaling out. May also + get rid of factorization data - + 0 get rid of nothing, 1 get rid of arrays, 2 also factorization + */ + void deleteRim(int getRidOfFactorizationData = 2); + /// Sanity check on input rim data (after scaling) - returns true if okay + bool sanityCheck(); + //@} +public: + /**@name public methods */ + //@{ + /** Return row or column sections - not as much needed as it + once was. These just map into single arrays */ + inline double * solutionRegion(int section) const { + if (!section) return rowActivityWork_; + else return columnActivityWork_; + } + inline double * djRegion(int section) const { + if (!section) return rowReducedCost_; + else return reducedCostWork_; + } + inline double * lowerRegion(int section) const { + if (!section) return rowLowerWork_; + else return columnLowerWork_; + } + inline double * upperRegion(int section) const { + if (!section) return rowUpperWork_; + else return columnUpperWork_; + } + inline double * costRegion(int section) const { + if (!section) return rowObjectiveWork_; + else return objectiveWork_; + } + /// Return region as single array + inline double * solutionRegion() const { + return solution_; + } + inline double * djRegion() const { + return dj_; + } + inline double * lowerRegion() const { + return lower_; + } + inline double * upperRegion() const { + return upper_; + } + inline double * costRegion() const { + return cost_; + } + inline Status getStatus(int sequence) const { + return static_cast<Status> (status_[sequence] & 7); + } + inline void setStatus(int sequence, Status newstatus) { + unsigned char & st_byte = status_[sequence]; + st_byte = static_cast<unsigned char>(st_byte & ~7); + st_byte = static_cast<unsigned char>(st_byte | newstatus); + } + /// Start or reset using maximumRows_ and Columns_ - true if change + bool startPermanentArrays(); + /** Normally the first factorization does sparse coding because + the factorization could be singular. This allows initial dense + factorization when it is known to be safe + */ + void setInitialDenseFactorization(bool onOff); + bool initialDenseFactorization() const; + /** Return sequence In or Out */ + inline int sequenceIn() const { + return sequenceIn_; + } + inline int sequenceOut() const { + return sequenceOut_; + } + /** Set sequenceIn or Out */ + inline void setSequenceIn(int sequence) { + sequenceIn_ = sequence; + } + inline void setSequenceOut(int sequence) { + sequenceOut_ = sequence; + } + /** Return direction In or Out */ + inline int directionIn() const { + return directionIn_; + } + inline int directionOut() const { + return directionOut_; + } + /** Set directionIn or Out */ + inline void setDirectionIn(int direction) { + directionIn_ = direction; + } + inline void setDirectionOut(int direction) { + directionOut_ = direction; + } + /// Value of Out variable + inline double valueOut() const { + return valueOut_; + } + /// Set value of out variable + inline void setValueOut(double value) { + valueOut_ = value; + } + /// Dual value of Out variable + inline double dualOut() const { + return dualOut_; + } + /// Set dual value of out variable + inline void setDualOut(double value) { + dualOut_ = value; + } + /// Set lower of out variable + inline void setLowerOut(double value) { + lowerOut_ = value; + } + /// Set upper of out variable + inline void setUpperOut(double value) { + upperOut_ = value; + } + /// Set theta of out variable + inline void setTheta(double value) { + theta_ = value; + } + /// 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_; + } + /// Return row or column values + inline double solution(int sequence) { + return solution_[sequence]; + } + /// Return address of row or column values + inline double & solutionAddress(int sequence) { + return solution_[sequence]; + } + inline double reducedCost(int sequence) { + return dj_[sequence]; + } + inline double & reducedCostAddress(int sequence) { + return dj_[sequence]; + } + inline double lower(int sequence) { + return lower_[sequence]; + } + /// Return address of row or column lower bound + inline double & lowerAddress(int sequence) { + return lower_[sequence]; + } + inline double upper(int sequence) { + return upper_[sequence]; + } + /// Return address of row or column upper bound + inline double & upperAddress(int sequence) { + return upper_[sequence]; + } + inline double cost(int sequence) { + return cost_[sequence]; + } + /// Return address of row or column cost + inline double & costAddress(int sequence) { + return cost_[sequence]; + } + /// Return original lower bound + inline double originalLower(int iSequence) const { + if (iSequence < numberColumns_) return columnLower_[iSequence]; + else + return rowLower_[iSequence-numberColumns_]; + } + /// Return original lower bound + inline double originalUpper(int iSequence) const { + if (iSequence < numberColumns_) return columnUpper_[iSequence]; + else + return rowUpper_[iSequence-numberColumns_]; + } + /// Theta (pivot change) + inline double theta() const { + return theta_; + } + /** Best possible improvement using djs (primal) or + obj change by flipping bounds to make dual feasible (dual) */ + inline double bestPossibleImprovement() const { + return bestPossibleImprovement_; + } + /// Return pointer to details of costs + inline ClpNonLinearCost * nonLinearCost() const { + return nonLinearCost_; + } + /** Return more special options + 1 bit - if presolve says infeasible in ClpSolve return + 2 bit - if presolved problem infeasible return + 4 bit - keep arrays like upper_ around + 8 bit - if factorization kept can still declare optimal at once + 16 bit - if checking replaceColumn accuracy before updating + 32 bit - say optimal if primal feasible! + 64 bit - give up easily in dual (and say infeasible) + 128 bit - no objective, 0-1 and in B&B + 256 bit - in primal from dual or vice versa + 512 bit - alternative use of solveType_ + 1024 bit - don't do row copy of factorization + 2048 bit - perturb in complete fathoming + 4096 bit - try more for complete fathoming + 8192 bit - don't even think of using primal if user asks for dual (and vv) + 16384 bit - in initialSolve so be more flexible + 32768 bit - don't swap algorithms from dual if small infeasibility + 65536 bit - perturb in postsolve cleanup (even if < 10000 rows) + 131072 bit (*3) initial stateDualColumn + 524288 bit - stop when primal feasible + */ + inline int moreSpecialOptions() const { + return moreSpecialOptions_; + } + /** Set more special options + 1 bit - if presolve says infeasible in ClpSolve return + 2 bit - if presolved problem infeasible return + 4 bit - keep arrays like upper_ around + 8 bit - no free or superBasic variables + 16 bit - if checking replaceColumn accuracy before updating + 32 bit - say optimal if primal feasible! + 64 bit - give up easily in dual (and say infeasible) + 128 bit - no objective, 0-1 and in B&B + 256 bit - in primal from dual or vice versa + 512 bit - alternative use of solveType_ + 1024 bit - don't do row copy of factorization + 2048 bit - perturb in complete fathoming + 4096 bit - try more for complete fathoming + 8192 bit - don't even think of using primal if user asks for dual (and vv) + 16384 bit - in initialSolve so be more flexible + 32768 bit - don't swap algorithms from dual if small infeasibility + 65536 bit - perturb in postsolve cleanup (even if < 10000 rows) + 131072 bit (*3) initial stateDualColumn + 524288 bit - stop when primal feasible + 1048576 bit - don't perturb even if long time + 2097152 bit - no primal in fastDual2 if feasible + 4194304 bit - tolerances have been changed by code + 8388608 bit - tolerances are dynamic (at first) + */ + inline void setMoreSpecialOptions(int value) { + moreSpecialOptions_ = value; + } + //@} + /**@name status methods */ + //@{ + inline void setFakeBound(int sequence, FakeBound fakeBound) { + unsigned char & st_byte = status_[sequence]; + st_byte = static_cast<unsigned char>(st_byte & ~24); + st_byte = static_cast<unsigned char>(st_byte | (fakeBound << 3)); + } + inline FakeBound getFakeBound(int sequence) const { + return static_cast<FakeBound> ((status_[sequence] >> 3) & 3); + } + inline void setRowStatus(int sequence, Status newstatus) { + unsigned char & st_byte = status_[sequence+numberColumns_]; + st_byte = static_cast<unsigned char>(st_byte & ~7); + st_byte = static_cast<unsigned char>(st_byte | newstatus); + } + inline Status getRowStatus(int sequence) const { + return static_cast<Status> (status_[sequence+numberColumns_] & 7); + } + inline void setColumnStatus(int sequence, Status newstatus) { + unsigned char & st_byte = status_[sequence]; + st_byte = static_cast<unsigned char>(st_byte & ~7); + st_byte = static_cast<unsigned char>(st_byte | newstatus); + } + inline Status getColumnStatus(int sequence) const { + return static_cast<Status> (status_[sequence] & 7); + } + inline void setPivoted( int sequence) { + status_[sequence] = static_cast<unsigned char>(status_[sequence] | 32); + } + inline void clearPivoted( int sequence) { + status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~32); + } + inline bool pivoted(int sequence) const { + return (((status_[sequence] >> 5) & 1) != 0); + } + /// To flag a variable (not inline to allow for column generation) + void setFlagged( int sequence); + inline void clearFlagged( int sequence) { + status_[sequence] = static_cast<unsigned char>(status_[sequence] & ~64); + } + inline bool flagged(int sequence) const { + return ((status_[sequence] & 64) != 0); + } + /// To say row active in primal pivot row choice + inline void setActive( int iRow) { + status_[iRow] = static_cast<unsigned char>(status_[iRow] | 128); + } + inline void clearActive( int iRow) { + status_[iRow] = static_cast<unsigned char>(status_[iRow] & ~128); + } + inline bool active(int iRow) const { + return ((status_[iRow] & 128) != 0); + } + /// To say perturbed + inline void setPerturbed( int iSequence) { + status_[iSequence] = static_cast<unsigned char>(status_[iSequence] | 128); + } + inline void clearPerturbed( int iSequence) { + status_[iSequence] = static_cast<unsigned char>(status_[iSequence] & ~128); + } + inline bool perturbed(int iSequence) const { + return ((status_[iSequence] & 128) != 0); + } + /** Set up status array (can be used by OsiClp). + Also can be used to set up all slack basis */ + void createStatus() ; + /** Sets up all slack basis and resets solution to + as it was after initial load or readMps */ + void allSlackBasis(bool resetSolution = false); + + /// So we know when to be cautious + inline int lastBadIteration() const { + return lastBadIteration_; + } + /// Set so we know when to be cautious + inline void setLastBadIteration(int value) { + lastBadIteration_=value; + } + /// Progress flag - at present 0 bit says artificials out + inline int progressFlag() const { + return (progressFlag_ & 3); + } + /// For dealing with all issues of cycling etc + inline ClpSimplexProgress * progress() + { return &progress_;} + /// Force re-factorization early value + inline int forceFactorization() const { + return forceFactorization_ ; + } + /// Force re-factorization early + inline void forceFactorization(int value) { + forceFactorization_ = value; + } + /// Raw objective value (so always minimize in primal) + inline double rawObjectiveValue() const { + return objectiveValue_; + } + /// Compute objective value from solution and put in objectiveValue_ + void computeObjectiveValue(bool useWorkingSolution = false); + /// Compute minimization objective value from internal solution without perturbation + double computeInternalObjectiveValue(); + /** Infeasibility/unbounded ray (NULL returned if none/wrong) + Up to user to use delete [] on these arrays. */ + double * infeasibilityRay(bool fullRay=false) const; + /** Number of extra rows. These are ones which will be dynamically created + each iteration. This is for GUB but may have other uses. + */ + inline int numberExtraRows() const { + return numberExtraRows_; + } + /** Maximum number of basic variables - can be more than number of rows if GUB + */ + inline int maximumBasic() const { + return maximumBasic_; + } + /// Iteration when we entered dual or primal + inline int baseIteration() const { + return baseIteration_; + } + /// Create C++ lines to get to current state + void generateCpp( FILE * fp, bool defaultFactor = false); + /// Gets clean and emptyish factorization + ClpFactorization * getEmptyFactorization(); + /// May delete or may make clean and emptyish factorization + void setEmptyFactorization(); + /// Move status and solution across + void moveInfo(const ClpSimplex & rhs, bool justStatus = false); + //@} + + ///@name Basis handling + // These are only to be used using startFinishOptions (ClpSimplexDual, ClpSimplexPrimal) + // *** At present only without scaling + // *** Slacks havve -1.0 element (so == row activity) - take care + ///Get a row of the tableau (slack part in slack if not NULL) + void getBInvARow(int row, double* z, double * slack = NULL); + + ///Get a row of the basis inverse + void getBInvRow(int row, double* z); + + ///Get a column of the tableau + void getBInvACol(int col, double* vec); + + ///Get a column of the basis inverse + void getBInvCol(int col, double* vec); + + /** Get basic indices (order of indices corresponds to the + order of elements in a vector retured by getBInvACol() and + getBInvCol()). + */ + void getBasics(int* index); + + //@} + //------------------------------------------------------------------------- + /**@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<br> + Use -DBL_MAX for -infinity. */ + void setColumnLower( int elementIndex, double elementValue ); + + /** Set a single column upper bound<br> + 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<br> + 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 + <em>either</em> 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<br> + Use -DBL_MAX for -infinity. */ + inline void setColLower( int elementIndex, double elementValue ) { + setColumnLower(elementIndex, elementValue); + } + /** Set a single column upper bound<br> + 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 newlower, double newupper ) { + setColumnBounds(elementIndex, newlower, newupper); + } + + /** Set the bounds on a number of columns simultaneously<br> + @param indexFirst,indexLast pointers to the beginning and after the + end of the array of the indices of the variables whose + <em>either</em> 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<br> + Use -DBL_MAX for -infinity. */ + void setRowLower( int elementIndex, double elementValue ); + + /** Set a single row upper bound<br> + 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<br> + @param indexFirst,indexLast pointers to the beginning and after the + end of the array of the indices of the constraints whose + <em>either</em> bound changes + @param boundList the new lower/upper bound pairs for the constraints + */ + void setRowSetBounds(const int* indexFirst, + const int* indexLast, + const double* boundList); + /// Resizes rim part of model + void resize (int newNumberRows, int newNumberColumns); + + //@} + +////////////////// 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 + */ + //@{ + /** Best possible improvement using djs (primal) or + obj change by flipping bounds to make dual feasible (dual) */ + double bestPossibleImprovement_; + /// Zero tolerance + double zeroTolerance_; + /// Sequence of worst (-1 if feasible) + int columnPrimalSequence_; + /// Sequence of worst (-1 if feasible) + int rowPrimalSequence_; + /// "Best" objective value + double bestObjectiveValue_; + /// More special options - see set for details + int moreSpecialOptions_; + /// Iteration when we entered dual or primal + int baseIteration_; + /// Primal tolerance needed to make dual feasible (<largeTolerance) + double primalToleranceToGetOptimal_; + /// Large bound value (for complementarity etc) + double largeValue_; + /// Largest error on Ax-b + double largestPrimalError_; + /// Largest error on basic duals + double largestDualError_; + /// For computing whether to re-factorize + double alphaAccuracy_; + /// Dual bound + double dualBound_; + /// Alpha (pivot element) + double alpha_; + /// Theta (pivot change) + double theta_; + /// Lower Bound on In variable + double lowerIn_; + /// Value of In variable + double valueIn_; + /// Upper Bound on In variable + double upperIn_; + /// Reduced cost of In variable + double dualIn_; + /// Lower Bound on Out variable + double lowerOut_; + /// Value of Out variable + double valueOut_; + /// Upper Bound on Out variable + double upperOut_; + /// Infeasibility (dual) or ? (primal) of Out variable + double dualOut_; + /// Current dual tolerance for algorithm + double dualTolerance_; + /// Current primal tolerance for algorithm + double primalTolerance_; + /// Sum of dual infeasibilities + double sumDualInfeasibilities_; + /// Sum of primal infeasibilities + double sumPrimalInfeasibilities_; + /// Weight assigned to being infeasible in primal + double infeasibilityCost_; + /// 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_; + /// Acceptable pivot value just after factorization + double acceptablePivot_; + /// Minimum primal tolerance + double minimumPrimalTolerance_; + /// Last few infeasibilities +#define CLP_INFEAS_SAVE 5 + double averageInfeasibility_[CLP_INFEAS_SAVE]; + /// Working copy of lower bounds (Owner of arrays below) + double * lower_; + /// Row lower bounds - working copy + double * rowLowerWork_; + /// Column lower bounds - working copy + double * columnLowerWork_; + /// Working copy of upper bounds (Owner of arrays below) + double * upper_; + /// Row upper bounds - working copy + double * rowUpperWork_; + /// Column upper bounds - working copy + double * columnUpperWork_; + /// Working copy of objective (Owner of arrays below) + double * cost_; + /// Row objective - working copy + double * rowObjectiveWork_; + /// Column objective - working copy + double * objectiveWork_; + /// Useful row length arrays + CoinIndexedVector * rowArray_[6]; + /// Useful column length arrays + CoinIndexedVector * columnArray_[6]; + /// Sequence of In variable + int sequenceIn_; + /// Direction of In, 1 going up, -1 going down, 0 not a clude + int directionIn_; + /// Sequence of Out variable + int sequenceOut_; + /// Direction of Out, 1 to upper bound, -1 to lower bound, 0 - superbasic + int directionOut_; + /// Pivot Row + int pivotRow_; + /// Last good iteration (immediately after a re-factorization) + int lastGoodIteration_; + /// Working copy of reduced costs (Owner of arrays below) + double * dj_; + /// Reduced costs of slacks not same as duals (or - duals) + double * rowReducedCost_; + /// Possible scaled reduced costs + double * reducedCostWork_; + /// Working copy of primal solution (Owner of arrays below) + double * solution_; + /// Row activities - working copy + double * rowActivityWork_; + /// Column activities - working copy + double * columnActivityWork_; + /// Number of dual infeasibilities + int numberDualInfeasibilities_; + /// Number of dual infeasibilities (without free) + int numberDualInfeasibilitiesWithoutFree_; + /// Number of primal infeasibilities + int numberPrimalInfeasibilities_; + /// How many iterative refinements to do + int numberRefinements_; + /// dual row pivot choice + ClpDualRowPivot * dualRowPivot_; + /// primal column pivot choice + ClpPrimalColumnPivot * primalColumnPivot_; + /// Basic variables pivoting on which rows + int * pivotVariable_; + /// factorization + ClpFactorization * factorization_; + /// Saved version of solution + double * savedSolution_; + /// Number of times code has tentatively thought optimal + int numberTimesOptimal_; + /// Disaster handler + ClpDisasterHandler * disasterArea_; + /// If change has been made (first attempt at stopping looping) + int changeMade_; + /// Algorithm >0 == Primal, <0 == Dual + int algorithm_; + /** Now for some reliability aids + This forces re-factorization early */ + int forceFactorization_; + /** Perturbation: + -50 to +50 - perturb by this power of ten (-6 sounds good) + 100 - auto perturb if takes too long (1.0e-6 largest nonzero) + 101 - we are perturbed + 102 - don't try perturbing again + default is 100 + */ + int perturbation_; + /// Saved status regions + unsigned char * saveStatus_; + /** Very wasteful way of dealing with infeasibilities in primal. + However it will allow non-linearities and use of dual + analysis. If it doesn't work it can easily be replaced. + */ + ClpNonLinearCost * nonLinearCost_; + /// So we know when to be cautious + int lastBadIteration_; + /// So we know when to open up again + int lastFlaggedIteration_; + /// Can be used for count of fake bounds (dual) or fake costs (primal) + int numberFake_; + /// Can be used for count of changed costs (dual) or changed bounds (primal) + int numberChanged_; + /// Progress flag - at present 0 bit says artificials out, 1 free in + int progressFlag_; + /// First free/super-basic variable (-1 if none) + int firstFree_; + /** Number of extra rows. These are ones which will be dynamically created + each iteration. This is for GUB but may have other uses. + */ + int numberExtraRows_; + /** Maximum number of basic variables - can be more than number of rows if GUB + */ + int maximumBasic_; + /// If may skip final factorize then allow up to this pivots (default 20) + int dontFactorizePivots_; + /** For advanced use. When doing iterative solves things can get + nasty so on values pass if incoming solution has largest + infeasibility < incomingInfeasibility throw out variables + from basis until largest infeasibility < allowedInfeasibility. + if allowedInfeasibility>= incomingInfeasibility this is + always possible altough you may end up with an all slack basis. + + Defaults are 1.0,10.0 + */ + double incomingInfeasibility_; + double allowedInfeasibility_; + /// Automatic scaling of objective and rhs and bounds + int automaticScale_; + /// Maximum perturbation array size (take out when code rewritten) + int maximumPerturbationSize_; + /// Perturbation array (maximumPerturbationSize_) + double * perturbationArray_; + /// A copy of model with certain state - normally without cuts + ClpSimplex * baseModel_; + /// For dealing with all issues of cycling etc + ClpSimplexProgress progress_; +#ifdef ABC_INHERIT + AbcSimplex * abcSimplex_; +#define CLP_ABC_WANTED 1 +#define CLP_ABC_WANTED_PARALLEL 2 +#define CLP_ABC_FULL_DONE 8 + // bits 256,512,1024 for crash +#endif +#define CLP_ABC_BEEN_FEASIBLE 65536 + int abcState_; + /// Number of degenerate pivots since last perturbed + int numberDegeneratePivots_; +public: + /// Spare int array for passing information [0]!=0 switches on + mutable int spareIntArray_[4]; + /// Spare double array for passing information [0]!=0 switches on + mutable double spareDoubleArray_[4]; +protected: + /// Allow OsiClp certain perks + friend class OsiClpSolverInterface; + /// And OsiCLP + friend class OsiCLPSolverInterface; + //@} +}; +//############################################################################# +/** A function that tests the methods in the ClpSimplex 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 +ClpSimplexUnitTest(const std::string & mpsDir); + +// For Devex stuff +#define DEVEX_TRY_NORM 1.0e-4 +#define DEVEX_ADD_ONE 1.0 +#if defined(ABC_INHERIT) || defined(CBC_THREAD) || defined(THREADS_IN_ANALYZE) +// Use pthreads +#include <pthread.h> +typedef struct { + double result; + //const CoinIndexedVector * constVector; // can get rid of + //CoinIndexedVector * vectors[2]; // can get rid of + void * extraInfo; + void * extraInfo2; + int status; + int stuff[4]; +} CoinThreadInfo; +class CoinPthreadStuff { +public: + /**@name Constructors and destructor and copy */ + //@{ + /** Main constructor + */ + CoinPthreadStuff (int numberThreads=0, + void * parallelManager(void * stuff)=NULL); + /// Assignment operator. This copies the data + CoinPthreadStuff & operator=(const CoinPthreadStuff & rhs); + /// Destructor + ~CoinPthreadStuff ( ); + /// set stop start + inline void setStopStart(int value) + { stopStart_=value;} +#ifndef NUMBER_THREADS +#define NUMBER_THREADS 8 +#endif + // For waking up thread + inline pthread_mutex_t * mutexPointer(int which,int thread=0) + { return mutex_+which+3*thread;} +#ifdef PTHREAD_BARRIER_SERIAL_THREAD + inline pthread_barrier_t * barrierPointer() + { return &barrier_;} +#endif + inline int whichLocked(int thread=0) const + { return locked_[thread];} + inline CoinThreadInfo * threadInfoPointer(int thread=0) + { return threadInfo_+thread;} + void startParallelTask(int type,int iThread,void * info=NULL); + int waitParallelTask(int type, int & iThread,bool allowIdle); + void waitAllTasks(); + /// so thread can find out which one it is + int whichThread() const; + void sayIdle(int iThread); + //void startThreads(int numberThreads); + //void stopThreads(); + // For waking up thread + pthread_mutex_t mutex_[3*(NUMBER_THREADS+1)]; +#ifdef PTHREAD_BARRIER_SERIAL_THREAD + pthread_barrier_t barrier_; +#endif + CoinThreadInfo threadInfo_[NUMBER_THREADS+1]; + pthread_t abcThread_[NUMBER_THREADS+1]; + int locked_[NUMBER_THREADS+1]; + int stopStart_; + int numberThreads_; +}; +void * clp_parallelManager(void * stuff); +#endif +#endif diff --git a/thirdparty/windows/include/coin/ClpSimplexDual.hpp b/thirdparty/windows/include/coin/ClpSimplexDual.hpp new file mode 100644 index 0000000..77cc577 --- /dev/null +++ b/thirdparty/windows/include/coin/ClpSimplexDual.hpp @@ -0,0 +1,300 @@ +/* $Id: ClpSimplexDual.hpp 1761 2011-07-06 16:06:24Z 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). +/* + Authors + + John Forrest + + */ +#ifndef ClpSimplexDual_H +#define ClpSimplexDual_H + +#include "ClpSimplex.hpp" + +/** This solves LPs using the dual simplex method + + It inherits from ClpSimplex. It has no data of its own and + is never created - only cast from a ClpSimplex object at algorithm time. + +*/ + +class ClpSimplexDual : public ClpSimplex { + +public: + + /**@name Description of algorithm */ + //@{ + /** Dual algorithm + + Method + + It tries to be a single phase approach with a weight of 1.0 being + given to getting optimal and a weight of updatedDualBound_ being + given to getting dual feasible. In this version I have used the + idea that this weight can be thought of as a fake bound. If the + distance between the lower and upper bounds on a variable is less + than the feasibility weight then we are always better off flipping + to other bound to make dual feasible. If the distance is greater + then we make up a fake bound updatedDualBound_ away from one bound. + If we end up optimal or primal infeasible, we check to see if + bounds okay. If so we have finished, if not we increase updatedDualBound_ + and continue (after checking if unbounded). I am undecided about + free variables - there is coding but I am not sure about it. At + present I put them in basis anyway. + + The code is designed to take advantage of sparsity so arrays are + seldom zeroed out from scratch or gone over in their entirety. + The only exception is a full scan to find outgoing variable for + Dantzig row choice. For steepest edge we keep an updated list + of infeasibilities (actually squares). + On easy problems we don't need full scan - just + pick first reasonable. + + One problem is how to tackle degeneracy and accuracy. At present + I am using the modification of costs which I put in OSL and some + of what I think is the dual analog of Gill et al. + I am still not sure of the exact details. + + The flow of dual is three while loops as follows: + + while (not finished) { + + while (not clean solution) { + + Factorize and/or clean up solution by flipping variables so + dual feasible. If looks finished check fake dual bounds. + Repeat until status is iterating (-1) or finished (0,1,2) + + } + + while (status==-1) { + + Iterate until no pivot in or out or time to re-factorize. + + Flow is: + + choose pivot row (outgoing variable). if none then + we are primal feasible so looks as if done but we need to + break and check bounds etc. + + Get pivot row in tableau + + Choose incoming column. If we don't find one then we look + primal infeasible so break and check bounds etc. (Also the + pivot tolerance is larger after any iterations so that may be + reason) + + If we do find incoming column, we may have to adjust costs to + keep going forwards (anti-degeneracy). Check pivot will be stable + and if unstable throw away iteration and break to re-factorize. + If minor error re-factorize after iteration. + + Update everything (this may involve flipping variables to stay + dual feasible. + + } + + } + + TODO's (or maybe not) + + At present we never check we are going forwards. I overdid that in + OSL so will try and make a last resort. + + Needs partial scan pivot out option. + + May need other anti-degeneracy measures, especially if we try and use + loose tolerances as a way to solve in fewer iterations. + + I like idea of dynamic scaling. This gives opportunity to decouple + different implications of scaling for accuracy, iteration count and + feasibility tolerance. + + for use of exotic parameter startFinishoptions see Clpsimplex.hpp + */ + + int dual(int ifValuesPass, int startFinishOptions = 0); + /** For strong branching. On input lower and upper are new bounds + while on output they are change in objective function values + (>1.0e50 infeasible). + Return code is 0 if nothing interesting, -1 if infeasible both + ways and +1 if infeasible one way (check values to see which one(s)) + Solutions are filled in as well - even down, odd up - also + status and number of iterations + */ + int strongBranching(int numberVariables, const int * variables, + double * newLower, double * newUpper, + double ** outputSolution, + int * outputStatus, int * outputIterations, + bool stopOnFirstInfeasible = true, + bool alwaysFinish = false, + int startFinishOptions = 0); + /// This does first part of StrongBranching + ClpFactorization * setupForStrongBranching(char * arrays, int numberRows, + int numberColumns, bool solveLp = false); + /// This cleans up after strong branching + void cleanupAfterStrongBranching(ClpFactorization * factorization); + //@} + + /**@name Functions used in dual */ + //@{ + /** This has the flow between re-factorizations + Broken out for clarity and will be used by strong branching + + Reasons to come out: + -1 iterations etc + -2 inaccuracy + -3 slight inaccuracy (and done iterations) + +0 looks optimal (might be unbounded - but we will investigate) + +1 looks infeasible + +3 max iterations + + If givenPi not NULL then in values pass + */ + int whileIterating(double * & givenPi, int ifValuesPass); + /** The duals are updated by the given arrays. + Returns number of infeasibilities. + After rowArray and columnArray will just have those which + have been flipped. + Variables may be flipped between bounds to stay dual feasible. + The output vector has movement of primal + solution (row length array) */ + int updateDualsInDual(CoinIndexedVector * rowArray, + CoinIndexedVector * columnArray, + CoinIndexedVector * outputArray, + double theta, + double & objectiveChange, + bool fullRecompute); + /** The duals are updated by the given arrays. + This is in values pass - so no changes to primal is made + */ + void updateDualsInValuesPass(CoinIndexedVector * rowArray, + CoinIndexedVector * columnArray, + double theta); + /** While updateDualsInDual sees what effect is of flip + this does actual flipping. + */ + void flipBounds(CoinIndexedVector * rowArray, + CoinIndexedVector * columnArray); + /** + Row array has row part of pivot row + Column array has column part. + This chooses pivot column. + Spare arrays are used to save pivots which will go infeasible + We will check for basic so spare array will never overflow. + If necessary will modify costs + For speed, we may need to go to a bucket approach when many + variables are being flipped. + Returns best possible pivot value + */ + double dualColumn(CoinIndexedVector * rowArray, + CoinIndexedVector * columnArray, + CoinIndexedVector * spareArray, + CoinIndexedVector * spareArray2, + double accpetablePivot, + CoinBigIndex * dubiousWeights); + /// Does first bit of dualColumn + int dualColumn0(const CoinIndexedVector * rowArray, + const CoinIndexedVector * columnArray, + CoinIndexedVector * spareArray, + double acceptablePivot, + double & upperReturn, double &bestReturn, double & badFree); + /** + Row array has row part of pivot row + Column array has column part. + This sees what is best thing to do in dual values pass + if sequenceIn==sequenceOut can change dual on chosen row and leave variable in basis + */ + void checkPossibleValuesMove(CoinIndexedVector * rowArray, + CoinIndexedVector * columnArray, + double acceptablePivot); + /** + Row array has row part of pivot row + Column array has column part. + This sees what is best thing to do in branch and bound cleanup + If sequenceIn_ < 0 then can't do anything + */ + void checkPossibleCleanup(CoinIndexedVector * rowArray, + CoinIndexedVector * columnArray, + double acceptablePivot); + /** + This sees if we can move duals in dual values pass. + This is done before any pivoting + */ + void doEasyOnesInValuesPass(double * givenReducedCosts); + /** + Chooses dual pivot row + Would be faster with separate region to scan + and will have this (with square of infeasibility) when steepest + For easy problems we can just choose one of the first rows we look at + + If alreadyChosen >=0 then in values pass and that row has been + selected + */ + void dualRow(int alreadyChosen); + /** Checks if any fake bounds active - if so returns number and modifies + updatedDualBound_ and everything. + Free variables will be left as free + Returns number of bounds changed if >=0 + Returns -1 if not initialize and no effect + Fills in changeVector which can be used to see if unbounded + and cost of change vector + If 2 sets to original (just changed) + */ + int changeBounds(int initialize, CoinIndexedVector * outputArray, + double & changeCost); + /** As changeBounds but just changes new bounds for a single variable. + Returns true if change */ + bool changeBound( int iSequence); + /// Restores bound to original bound + void originalBound(int iSequence); + /** Checks if tentative optimal actually means unbounded in dual + Returns -3 if not, 2 if is unbounded */ + int checkUnbounded(CoinIndexedVector * ray, CoinIndexedVector * spare, + double changeCost); + /** Refactorizes if necessary + Checks if finished. Updates status. + lastCleaned refers to iteration at which some objective/feasibility + cleaning too place. + + type - 0 initial so set up save arrays etc + - 1 normal -if good update save + - 2 restoring from saved + */ + void statusOfProblemInDual(int & lastCleaned, int type, + double * givenDjs, ClpDataSave & saveData, + int ifValuesPass); + /** Perturbs problem (method depends on perturbation()) + returns nonzero if should go to dual */ + int perturb(); + /** Fast iterations. Misses out a lot of initialization. + Normally stops on maximum iterations, first re-factorization + or tentative optimum. If looks interesting then continues as + normal. Returns 0 if finished properly, 1 otherwise. + */ + int fastDual(bool alwaysFinish = false); + /** Checks number of variables at fake bounds. This is used by fastDual + so can exit gracefully before end */ + int numberAtFakeBound(); + + /** Pivot in a variable and choose an outgoing one. Assumes dual + feasible - will not go through a reduced cost. Returns step length in theta + Return codes as before but -1 means no acceptable pivot + */ + int pivotResultPart1(); + /** Get next free , -1 if none */ + int nextSuperBasic(); + /** Startup part of dual (may be extended to other algorithms) + returns 0 if good, 1 if bad */ + int startupSolve(int ifValuesPass, double * saveDuals, int startFinishOptions); + void finishSolve(int startFinishOptions); + void gutsOfDual(int ifValuesPass, double * & saveDuals, int initialStatus, + ClpDataSave & saveData); + //int dual2(int ifValuesPass,int startFinishOptions=0); + void resetFakeBounds(int type); + + //@} +}; +#endif diff --git a/thirdparty/windows/include/coin/ClpSimplexNonlinear.hpp b/thirdparty/windows/include/coin/ClpSimplexNonlinear.hpp new file mode 100644 index 0000000..6c1088b --- /dev/null +++ b/thirdparty/windows/include/coin/ClpSimplexNonlinear.hpp @@ -0,0 +1,117 @@ +/* $Id: ClpSimplexNonlinear.hpp 2025 2014-03-19 12:49:55Z 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). +/* + Authors + + John Forrest + + */ +#ifndef ClpSimplexNonlinear_H +#define ClpSimplexNonlinear_H + +class ClpNonlinearInfo; +class ClpQuadraticObjective; +class ClpConstraint; + +#include "ClpSimplexPrimal.hpp" + +/** This solves non-linear LPs using the primal simplex method + + It inherits from ClpSimplexPrimal. It has no data of its own and + is never created - only cast from a ClpSimplexPrimal object at algorithm time. + If needed create new class and pass around + +*/ + +class ClpSimplexNonlinear : public ClpSimplexPrimal { + +public: + + /**@name Description of algorithm */ + //@{ + /** Primal algorithms for reduced gradient + At present we have two algorithms: + + */ + /// A reduced gradient method. + int primal(); + /** Primal algorithm for quadratic + Using a semi-trust region approach as for pooling problem + This is in because I have it lying around + */ + int primalSLP(int numberPasses, double deltaTolerance, + int otherOptions=0); + /// May use a cut approach for solving any LP + int primalDualCuts(char * rowsIn, int startUp, int algorithm); + /** Primal algorithm for nonlinear constraints + Using a semi-trust region approach as for pooling problem + This is in because I have it lying around + + */ + int primalSLP(int numberConstraints, ClpConstraint ** constraints, + int numberPasses, double deltaTolerance); + + /** Creates direction vector. note longArray is long enough + for rows and columns. If numberNonBasic 0 then is updated + otherwise mode is ignored and those are used. + Norms are only for those > 1.0e3*dualTolerance + If mode is nonzero then just largest dj */ + void directionVector (CoinIndexedVector * longArray, + CoinIndexedVector * spare1, CoinIndexedVector * spare2, + int mode, + double & normFlagged, double & normUnflagged, + int & numberNonBasic); + /// Main part. + int whileIterating (int & pivotMode); + /** + longArray has direction + pivotMode - + 0 - use all dual infeasible variables + 1 - largest dj + while >= 10 trying startup phase + Returns 0 - can do normal iteration (basis change) + 1 - no basis change + 2 - if wants singleton + 3 - if time to re-factorize + If sequenceIn_ >=0 then that will be incoming variable + */ + int pivotColumn(CoinIndexedVector * longArray, + CoinIndexedVector * rowArray, + CoinIndexedVector * columnArray, + CoinIndexedVector * spare, + int & pivotMode, + double & solutionError, + double * array1); + /** Refactorizes if necessary + Checks if finished. Updates status. + lastCleaned refers to iteration at which some objective/feasibility + cleaning too place. + + type - 0 initial so set up save arrays etc + - 1 normal -if good update save + - 2 restoring from saved + */ + void statusOfProblemInPrimal(int & lastCleaned, int type, + ClpSimplexProgress * progress, + bool doFactorization, + double & bestObjectiveWhenFlagged); + /** Do last half of an iteration. + Return codes + Reasons to come out normal mode + -1 normal + -2 factorize now - good iteration + -3 slight inaccuracy - refactorize - iteration done + -4 inaccuracy - refactorize - no iteration + -5 something flagged - go round again + +2 looks unbounded + +3 max iterations (iteration done) + + */ + int pivotNonlinearResult(); + //@} + +}; +#endif + diff --git a/thirdparty/windows/include/coin/ClpSimplexOther.hpp b/thirdparty/windows/include/coin/ClpSimplexOther.hpp new file mode 100644 index 0000000..c5014ec --- /dev/null +++ b/thirdparty/windows/include/coin/ClpSimplexOther.hpp @@ -0,0 +1,277 @@ +/* $Id: ClpSimplexOther.hpp 2070 2014-11-18 11:12:54Z 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). +/* + Authors + + John Forrest + + */ +#ifndef ClpSimplexOther_H +#define ClpSimplexOther_H + +#include "ClpSimplex.hpp" + +/** This is for Simplex stuff which is neither dual nor primal + + It inherits from ClpSimplex. It has no data of its own and + is never created - only cast from a ClpSimplex object at algorithm time. + +*/ + +class ClpSimplexOther : public ClpSimplex { + +public: + + /**@name Methods */ + //@{ + /** Dual ranging. + This computes increase/decrease in cost for each given variable and corresponding + sequence numbers which would change basis. Sequence numbers are 0..numberColumns + and numberColumns.. for artificials/slacks. + For non-basic variables the information is trivial to compute and the change in cost is just minus the + reduced cost and the sequence number will be that of the non-basic variables. + For basic variables a ratio test is between the reduced costs for non-basic variables + and the row of the tableau corresponding to the basic variable. + The increase/decrease value is always >= 0.0 + + Up to user to provide correct length arrays where each array is of length numberCheck. + which contains list of variables for which information is desired. All other + arrays will be filled in by function. If fifth entry in which is variable 7 then fifth entry in output arrays + will be information for variable 7. + + If valueIncrease/Decrease not NULL (both must be NULL or both non NULL) then these are filled with + the value of variable if such a change in cost were made (the existing bounds are ignored) + + When here - guaranteed optimal + */ + void dualRanging(int numberCheck, const int * which, + double * costIncrease, int * sequenceIncrease, + double * costDecrease, int * sequenceDecrease, + double * valueIncrease = NULL, double * valueDecrease = NULL); + /** Primal ranging. + This computes increase/decrease in value for each given variable and corresponding + sequence numbers which would change basis. Sequence numbers are 0..numberColumns + and numberColumns.. for artificials/slacks. + This should only be used for non-basic variabls as otherwise information is pretty useless + For basic variables the sequence number will be that of the basic variables. + + Up to user to provide correct length arrays where each array is of length numberCheck. + which contains list of variables for which information is desired. All other + arrays will be filled in by function. If fifth entry in which is variable 7 then fifth entry in output arrays + will be information for variable 7. + + When here - guaranteed optimal + */ + void primalRanging(int numberCheck, const int * which, + double * valueIncrease, int * sequenceIncrease, + double * valueDecrease, int * sequenceDecrease); + /** Parametrics + This is an initial slow version. + The code uses current bounds + theta * change (if change array not NULL) + and similarly for objective. + It starts at startingTheta and returns ending theta in endingTheta. + If reportIncrement 0.0 it will report on any movement + If reportIncrement >0.0 it will report at startingTheta+k*reportIncrement. + If it can not reach input endingTheta return code will be 1 for infeasible, + 2 for unbounded, if error on ranges -1, otherwise 0. + Normal report is just theta and objective but + if event handler exists it may do more + On exit endingTheta is maximum reached (can be used for next startingTheta) + */ + int parametrics(double startingTheta, double & endingTheta, double reportIncrement, + const double * changeLowerBound, const double * changeUpperBound, + const double * changeLowerRhs, const double * changeUpperRhs, + const double * changeObjective); + /** Version of parametrics which reads from file + See CbcClpParam.cpp for details of format + Returns -2 if unable to open file */ + int parametrics(const char * dataFile); + /** Parametrics + This is an initial slow version. + The code uses current bounds + theta * change (if change array not NULL) + It starts at startingTheta and returns ending theta in endingTheta. + If it can not reach input endingTheta return code will be 1 for infeasible, + 2 for unbounded, if error on ranges -1, otherwise 0. + Event handler may do more + On exit endingTheta is maximum reached (can be used for next startingTheta) + */ + int parametrics(double startingTheta, double & endingTheta, + const double * changeLowerBound, const double * changeUpperBound, + const double * changeLowerRhs, const double * changeUpperRhs); + int parametricsObj(double startingTheta, double & endingTheta, + const double * changeObjective); + /// Finds best possible pivot + double bestPivot(bool justColumns=false); + typedef struct { + double startingTheta; + double endingTheta; + double maxTheta; + double acceptableMaxTheta; // if this far then within tolerances + double * lowerChange; // full array of lower bound changes + int * lowerList; // list of lower bound changes + double * upperChange; // full array of upper bound changes + int * upperList; // list of upper bound changes + char * markDone; // mark which ones looked at + int * backwardBasic; // from sequence to pivot row + int * lowerActive; + double * lowerGap; + double * lowerCoefficient; + int * upperActive; + double * upperGap; + double * upperCoefficient; + int unscaledChangesOffset; + bool firstIteration; // so can update rhs for accuracy + } parametricsData; + +private: + /** Parametrics - inner loop + This first attempt is when reportIncrement non zero and may + not report endingTheta correctly + If it can not reach input endingTheta return code will be 1 for infeasible, + 2 for unbounded, otherwise 0. + Normal report is just theta and objective but + if event handler exists it may do more + */ + int parametricsLoop(parametricsData & paramData, double reportIncrement, + const double * changeLower, const double * changeUpper, + const double * changeObjective, ClpDataSave & data, + bool canTryQuick); + int parametricsLoop(parametricsData & paramData, + ClpDataSave & data,bool canSkipFactorization=false); + int parametricsObjLoop(parametricsData & paramData, + ClpDataSave & data,bool canSkipFactorization=false); + /** Refactorizes if necessary + Checks if finished. Updates status. + + type - 0 initial so set up save arrays etc + - 1 normal -if good update save + - 2 restoring from saved + */ + void statusOfProblemInParametrics(int type, ClpDataSave & saveData); + void statusOfProblemInParametricsObj(int type, ClpDataSave & saveData); + /** This has the flow between re-factorizations + + Reasons to come out: + -1 iterations etc + -2 inaccuracy + -3 slight inaccuracy (and done iterations) + +0 looks optimal (might be unbounded - but we will investigate) + +1 looks infeasible + +3 max iterations + */ + int whileIterating(parametricsData & paramData, double reportIncrement, + const double * changeObjective); + /** Computes next theta and says if objective or bounds (0= bounds, 1 objective, -1 none). + theta is in theta_. + type 1 bounds, 2 objective, 3 both. + */ + int nextTheta(int type, double maxTheta, parametricsData & paramData, + const double * changeObjective); + int whileIteratingObj(parametricsData & paramData); + int nextThetaObj(double maxTheta, parametricsData & paramData); + /// Restores bound to original bound + void originalBound(int iSequence, double theta, const double * changeLower, + const double * changeUpper); + /// Compute new rowLower_ etc (return negative if infeasible - otherwise largest change) + double computeRhsEtc(parametricsData & paramData); + /// Redo lower_ from rowLower_ etc + void redoInternalArrays(); + /** + Row array has row part of pivot row + Column array has column part. + This is used in dual ranging + */ + void checkDualRatios(CoinIndexedVector * rowArray, + CoinIndexedVector * columnArray, + double & costIncrease, int & sequenceIncrease, double & alphaIncrease, + double & costDecrease, int & sequenceDecrease, double & alphaDecrease); + /** + Row array has pivot column + This is used in primal ranging + */ + void checkPrimalRatios(CoinIndexedVector * rowArray, + int direction); + /// Returns new value of whichOther when whichIn enters basis + double primalRanging1(int whichIn, int whichOther); + +public: + /** Write the basis in MPS format to the specified file. + If writeValues true writes values of structurals + (and adds VALUES to end of NAME card) + + Row and column names may be null. + formatType is + <ul> + <li> 0 - normal + <li> 1 - extra accuracy + <li> 2 - IEEE hex (later) + </ul> + + Returns non-zero on I/O error + */ + int writeBasis(const char *filename, + bool writeValues = false, + int formatType = 0) const; + /// Read a basis from the given filename + int readBasis(const char *filename); + /** Creates dual of a problem if looks plausible + (defaults will always create model) + fractionRowRanges is fraction of rows allowed to have ranges + fractionColumnRanges is fraction of columns allowed to have ranges + */ + ClpSimplex * dualOfModel(double fractionRowRanges = 1.0, double fractionColumnRanges = 1.0) const; + /** Restores solution from dualized problem + non-zero return code indicates minor problems + */ + int restoreFromDual(const ClpSimplex * dualProblem, + bool checkAccuracy=false); + /** Sets solution in dualized problem + non-zero return code indicates minor problems + */ + int setInDual(ClpSimplex * dualProblem); + /** Does very cursory presolve. + rhs is numberRows, whichRows is 3*numberRows and whichColumns is 2*numberColumns. + */ + ClpSimplex * crunch(double * rhs, int * whichRows, int * whichColumns, + int & nBound, bool moreBounds = false, bool tightenBounds = false); + /** After very cursory presolve. + rhs is numberRows, whichRows is 3*numberRows and whichColumns is 2*numberColumns. + */ + void afterCrunch(const ClpSimplex & small, + const int * whichRows, const int * whichColumns, + int nBound); + /** Returns gub version of model or NULL + whichRows has to be numberRows + whichColumns has to be numberRows+numberColumns */ + ClpSimplex * gubVersion(int * whichRows, int * whichColumns, + int neededGub, + int factorizationFrequency=50); + /// Sets basis from original + void setGubBasis(ClpSimplex &original,const int * whichRows, + const int * whichColumns); + /// Restores basis to original + void getGubBasis(ClpSimplex &original,const int * whichRows, + const int * whichColumns) const; + /// Quick try at cleaning up duals if postsolve gets wrong + void cleanupAfterPostsolve(); + /** Tightens integer bounds - returns number tightened or -1 if infeasible + */ + int tightenIntegerBounds(double * rhsSpace); + /** Expands out all possible combinations for a knapsack + If buildObj NULL then just computes space needed - returns number elements + On entry numberOutput is maximum allowed, on exit it is number needed or + -1 (as will be number elements) if maximum exceeded. numberOutput will have at + least space to return values which reconstruct input. + Rows returned will be original rows but no entries will be returned for + any rows all of whose entries are in knapsack. So up to user to allow for this. + If reConstruct >=0 then returns number of entrie which make up item "reConstruct" + in expanded knapsack. Values in buildRow and buildElement; + */ + int expandKnapsack(int knapsackRow, int & numberOutput, + double * buildObj, CoinBigIndex * buildStart, + int * buildRow, double * buildElement, int reConstruct = -1) const; + //@} +}; +#endif diff --git a/thirdparty/windows/include/coin/ClpSimplexPrimal.hpp b/thirdparty/windows/include/coin/ClpSimplexPrimal.hpp new file mode 100644 index 0000000..d78e54e --- /dev/null +++ b/thirdparty/windows/include/coin/ClpSimplexPrimal.hpp @@ -0,0 +1,244 @@ +/* $Id: ClpSimplexPrimal.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). +/* + Authors + + John Forrest + + */ +#ifndef ClpSimplexPrimal_H +#define ClpSimplexPrimal_H + +#include "ClpSimplex.hpp" + +/** This solves LPs using the primal simplex method + + It inherits from ClpSimplex. It has no data of its own and + is never created - only cast from a ClpSimplex object at algorithm time. + +*/ + +class ClpSimplexPrimal : public ClpSimplex { + +public: + + /**@name Description of algorithm */ + //@{ + /** Primal algorithm + + Method + + It tries to be a single phase approach with a weight of 1.0 being + given to getting optimal and a weight of infeasibilityCost_ being + given to getting primal feasible. In this version I have tried to + be clever in a stupid way. The idea of fake bounds in dual + seems to work so the primal analogue would be that of getting + bounds on reduced costs (by a presolve approach) and using + these for being above or below feasible region. I decided to waste + memory and keep these explicitly. This allows for non-linear + costs! I have not tested non-linear costs but will be glad + to do something if a reasonable example is provided. + + The code is designed to take advantage of sparsity so arrays are + seldom zeroed out from scratch or gone over in their entirety. + The only exception is a full scan to find incoming variable for + Dantzig row choice. For steepest edge we keep an updated list + of dual infeasibilities (actually squares). + On easy problems we don't need full scan - just + pick first reasonable. This method has not been coded. + + One problem is how to tackle degeneracy and accuracy. At present + I am using the modification of costs which I put in OSL and which was + extended by Gill et al. I am still not sure whether we will also + need explicit perturbation. + + The flow of primal is three while loops as follows: + + while (not finished) { + + while (not clean solution) { + + Factorize and/or clean up solution by changing bounds so + primal feasible. If looks finished check fake primal bounds. + Repeat until status is iterating (-1) or finished (0,1,2) + + } + + while (status==-1) { + + Iterate until no pivot in or out or time to re-factorize. + + Flow is: + + choose pivot column (incoming variable). if none then + we are primal feasible so looks as if done but we need to + break and check bounds etc. + + Get pivot column in tableau + + Choose outgoing row. If we don't find one then we look + primal unbounded so break and check bounds etc. (Also the + pivot tolerance is larger after any iterations so that may be + reason) + + If we do find outgoing row, we may have to adjust costs to + keep going forwards (anti-degeneracy). Check pivot will be stable + and if unstable throw away iteration and break to re-factorize. + If minor error re-factorize after iteration. + + Update everything (this may involve changing bounds on + variables to stay primal feasible. + + } + + } + + TODO's (or maybe not) + + At present we never check we are going forwards. I overdid that in + OSL so will try and make a last resort. + + Needs partial scan pivot in option. + + May need other anti-degeneracy measures, especially if we try and use + loose tolerances as a way to solve in fewer iterations. + + I like idea of dynamic scaling. This gives opportunity to decouple + different implications of scaling for accuracy, iteration count and + feasibility tolerance. + + for use of exotic parameter startFinishoptions see Clpsimplex.hpp + */ + + int primal(int ifValuesPass = 0, int startFinishOptions = 0); + //@} + + /**@name For advanced users */ + //@{ + /// Do not change infeasibility cost and always say optimal + void alwaysOptimal(bool onOff); + bool alwaysOptimal() const; + /** Normally outgoing variables can go out to slightly negative + values (but within tolerance) - this is to help stability and + and degeneracy. This can be switched off + */ + void exactOutgoing(bool onOff); + bool exactOutgoing() const; + //@} + + /**@name Functions used in primal */ + //@{ + /** This has the flow between re-factorizations + + Returns a code to say where decision to exit was made + Problem status set to: + + -2 re-factorize + -4 Looks optimal/infeasible + -5 Looks unbounded + +3 max iterations + + valuesOption has original value of valuesPass + */ + int whileIterating(int valuesOption); + + /** Do last half of an iteration. This is split out so people can + force incoming variable. If solveType_ is 2 then this may + re-factorize while normally it would exit to re-factorize. + Return codes + Reasons to come out (normal mode/user mode): + -1 normal + -2 factorize now - good iteration/ NA + -3 slight inaccuracy - refactorize - iteration done/ same but factor done + -4 inaccuracy - refactorize - no iteration/ NA + -5 something flagged - go round again/ pivot not possible + +2 looks unbounded + +3 max iterations (iteration done) + + With solveType_ ==2 this should + Pivot in a variable and choose an outgoing one. Assumes primal + feasible - will not go through a bound. Returns step length in theta + Returns ray in ray_ + */ + int pivotResult(int ifValuesPass = 0); + + + /** The primals are updated by the given array. + Returns number of infeasibilities. + After rowArray will have cost changes for use next iteration + */ + int updatePrimalsInPrimal(CoinIndexedVector * rowArray, + double theta, + double & objectiveChange, + int valuesPass); + /** + Row array has pivot column + This chooses pivot row. + Rhs array is used for distance to next bound (for speed) + For speed, we may need to go to a bucket approach when many + variables go through bounds + If valuesPass non-zero then compute dj for direction + */ + void primalRow(CoinIndexedVector * rowArray, + CoinIndexedVector * rhsArray, + CoinIndexedVector * spareArray, + int valuesPass); + /** + Chooses primal pivot column + updateArray has cost updates (also use pivotRow_ from last iteration) + Would be faster with separate region to scan + and will have this (with square of infeasibility) when steepest + For easy problems we can just choose one of the first columns we look at + */ + void primalColumn(CoinIndexedVector * updateArray, + CoinIndexedVector * spareRow1, + CoinIndexedVector * spareRow2, + CoinIndexedVector * spareColumn1, + CoinIndexedVector * spareColumn2); + + /** Checks if tentative optimal actually means unbounded in primal + Returns -3 if not, 2 if is unbounded */ + int checkUnbounded(CoinIndexedVector * ray, CoinIndexedVector * spare, + double changeCost); + /** Refactorizes if necessary + Checks if finished. Updates status. + lastCleaned refers to iteration at which some objective/feasibility + cleaning too place. + + type - 0 initial so set up save arrays etc + - 1 normal -if good update save + - 2 restoring from saved + saveModel is normally NULL but may not be if doing Sprint + */ + void statusOfProblemInPrimal(int & lastCleaned, int type, + ClpSimplexProgress * progress, + bool doFactorization, + int ifValuesPass, + ClpSimplex * saveModel = NULL); + /// Perturbs problem (method depends on perturbation()) + void perturb(int type); + /// Take off effect of perturbation and say whether to try dual + bool unPerturb(); + /// Unflag all variables and return number unflagged + int unflag(); + /** Get next superbasic -1 if none, + Normal type is 1 + If type is 3 then initializes sorted list + if 2 uses list. + */ + int nextSuperBasic(int superBasicType, CoinIndexedVector * columnArray); + + /// Create primal ray + void primalRay(CoinIndexedVector * rowArray); + /// Clears all bits and clears rowArray[1] etc + void clearAll(); + + /// Sort of lexicographic resolve + int lexSolve(); + + //@} +}; +#endif + diff --git a/thirdparty/windows/include/coin/ClpSolve.hpp b/thirdparty/windows/include/coin/ClpSolve.hpp new file mode 100644 index 0000000..280e33d --- /dev/null +++ b/thirdparty/windows/include/coin/ClpSolve.hpp @@ -0,0 +1,446 @@ +/* $Id: ClpSolve.hpp 2078 2015-01-05 12:39:49Z forrest $ */ +// 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 Forrest + + */ +#ifndef ClpSolve_H +#define ClpSolve_H + +/** + This is a very simple class to guide algorithms. It is used to tidy up + passing parameters to initialSolve and maybe for output from that + +*/ + +class ClpSolve { + +public: + + /** enums for solve function */ + enum SolveType { + useDual = 0, + usePrimal, + usePrimalorSprint, + useBarrier, + useBarrierNoCross, + automatic, + tryDantzigWolfe, + tryBenders, + notImplemented + }; + enum PresolveType { + presolveOn = 0, + presolveOff, + presolveNumber, + presolveNumberCost + }; + + /**@name Constructors and destructor and copy */ + //@{ + /// Default constructor + ClpSolve ( ); + /// Constructor when you really know what you are doing + ClpSolve ( SolveType method, PresolveType presolveType, + int numberPasses, int options[6], + int extraInfo[6], int independentOptions[3]); + /// Generates code for above constructor + void generateCpp(FILE * fp); + /// Copy constructor. + ClpSolve(const ClpSolve &); + /// Assignment operator. This copies the data + ClpSolve & operator=(const ClpSolve & rhs); + /// Destructor + ~ClpSolve ( ); + //@} + + /**@name Functions most useful to user */ + //@{ + /** Special options - bits + 0 4 - use crash (default allslack in dual, idiot in primal) + 8 - all slack basis in primal + 2 16 - switch off interrupt handling + 3 32 - do not try and make plus minus one matrix + 64 - do not use sprint even if problem looks good + */ + /** which translation is: + which: + 0 - startup in Dual (nothing if basis exists).: + 0 - no basis + 1 - crash + 2 - use initiative about idiot! but no crash + 1 - startup in Primal (nothing if basis exists): + 0 - use initiative + 1 - use crash + 2 - use idiot and look at further info + 3 - use sprint and look at further info + 4 - use all slack + 5 - use initiative but no idiot + 6 - use initiative but no sprint + 7 - use initiative but no crash + 8 - do allslack or idiot + 9 - do allslack or sprint + 10 - slp before + 11 - no nothing and primal(0) + 2 - interrupt handling - 0 yes, 1 no (for threadsafe) + 3 - whether to make +- 1matrix - 0 yes, 1 no + 4 - for barrier + 0 - dense cholesky + 1 - Wssmp allowing some long columns + 2 - Wssmp not allowing long columns + 3 - Wssmp using KKT + 4 - Using Florida ordering + 8 - bit set to do scaling + 16 - set to be aggressive with gamma/delta? + 32 - Use KKT + 5 - for presolve + 1 - switch off dual stuff + 6 - extra switches + + */ + void setSpecialOption(int which, int value, int extraInfo = -1); + int getSpecialOption(int which) const; + + /// Solve types + void setSolveType(SolveType method, int extraInfo = -1); + SolveType getSolveType(); + + // Presolve types + void setPresolveType(PresolveType amount, int extraInfo = -1); + PresolveType getPresolveType(); + int getPresolvePasses() const; + /// Extra info for idiot (or sprint) + int getExtraInfo(int which) const; + /** Say to return at once if infeasible, + default is to solve */ + void setInfeasibleReturn(bool trueFalse); + inline bool infeasibleReturn() const { + return independentOptions_[0] != 0; + } + /// Whether we want to do dual part of presolve + inline bool doDual() const { + return (independentOptions_[1] & 1) == 0; + } + inline void setDoDual(bool doDual_) { + if (doDual_) independentOptions_[1] &= ~1; + else independentOptions_[1] |= 1; + } + /// Whether we want to do singleton part of presolve + inline bool doSingleton() const { + return (independentOptions_[1] & 2) == 0; + } + inline void setDoSingleton(bool doSingleton_) { + if (doSingleton_) independentOptions_[1] &= ~2; + else independentOptions_[1] |= 2; + } + /// Whether we want to do doubleton part of presolve + inline bool doDoubleton() const { + return (independentOptions_[1] & 4) == 0; + } + inline void setDoDoubleton(bool doDoubleton_) { + if (doDoubleton_) independentOptions_[1] &= ~4; + else independentOptions_[1] |= 4; + } + /// Whether we want to do tripleton part of presolve + inline bool doTripleton() const { + return (independentOptions_[1] & 8) == 0; + } + inline void setDoTripleton(bool doTripleton_) { + if (doTripleton_) independentOptions_[1] &= ~8; + else independentOptions_[1] |= 8; + } + /// Whether we want to do tighten part of presolve + inline bool doTighten() const { + return (independentOptions_[1] & 16) == 0; + } + inline void setDoTighten(bool doTighten_) { + if (doTighten_) independentOptions_[1] &= ~16; + else independentOptions_[1] |= 16; + } + /// Whether we want to do forcing part of presolve + inline bool doForcing() const { + return (independentOptions_[1] & 32) == 0; + } + inline void setDoForcing(bool doForcing_) { + if (doForcing_) independentOptions_[1] &= ~32; + else independentOptions_[1] |= 32; + } + /// Whether we want to do impliedfree part of presolve + inline bool doImpliedFree() const { + return (independentOptions_[1] & 64) == 0; + } + inline void setDoImpliedFree(bool doImpliedfree) { + if (doImpliedfree) independentOptions_[1] &= ~64; + else independentOptions_[1] |= 64; + } + /// Whether we want to do dupcol part of presolve + inline bool doDupcol() const { + return (independentOptions_[1] & 128) == 0; + } + inline void setDoDupcol(bool doDupcol_) { + if (doDupcol_) independentOptions_[1] &= ~128; + else independentOptions_[1] |= 128; + } + /// Whether we want to do duprow part of presolve + inline bool doDuprow() const { + return (independentOptions_[1] & 256) == 0; + } + inline void setDoDuprow(bool doDuprow_) { + if (doDuprow_) independentOptions_[1] &= ~256; + else independentOptions_[1] |= 256; + } + /// Whether we want to do singleton column part of presolve + inline bool doSingletonColumn() const { + return (independentOptions_[1] & 512) == 0; + } + inline void setDoSingletonColumn(bool doSingleton_) { + if (doSingleton_) independentOptions_[1] &= ~512; + else independentOptions_[1] |= 512; + } + /// Whether we want to kill small substitutions + inline bool doKillSmall() const { + return (independentOptions_[1] & 8192) == 0; + } + inline void setDoKillSmall(bool doKill) { + if (doKill) independentOptions_[1] &= ~8192; + else independentOptions_[1] |= 8192; + } + /// Set whole group + inline int presolveActions() const { + return independentOptions_[1] & 0xffff; + } + inline void setPresolveActions(int action) { + independentOptions_[1] = (independentOptions_[1] & 0xffff0000) | (action & 0xffff); + } + /// Largest column for substitution (normally 3) + inline int substitution() const { + return independentOptions_[2]; + } + inline void setSubstitution(int value) { + independentOptions_[2] = value; + } + inline void setIndependentOption(int type,int value) { + independentOptions_[type] = value; + } + inline int independentOption(int type) const { + return independentOptions_[type]; + } + //@} + +////////////////// data ////////////////// +private: + + /**@name data. + */ + //@{ + /// Solve type + SolveType method_; + /// Presolve type + PresolveType presolveType_; + /// Amount of presolve + int numberPasses_; + /// Options - last is switch for OsiClp + int options_[7]; + /// Extra information + int extraInfo_[7]; + /** Extra algorithm dependent options + 0 - if set return from clpsolve if infeasible + 1 - To be copied over to presolve options + 2 - max substitution level + If Dantzig Wolfe/benders 0 is number blocks, 2 is #passes (notional) + */ + int independentOptions_[3]; + //@} +}; + +/// For saving extra information to see if looping. +class ClpSimplexProgress { + +public: + + + /**@name Constructors and destructor and copy */ + //@{ + /// Default constructor + ClpSimplexProgress ( ); + + /// Constructor from model + ClpSimplexProgress ( ClpSimplex * model ); + + /// Copy constructor. + ClpSimplexProgress(const ClpSimplexProgress &); + + /// Assignment operator. This copies the data + ClpSimplexProgress & operator=(const ClpSimplexProgress & rhs); + /// Destructor + ~ClpSimplexProgress ( ); + /// Resets as much as possible + void reset(); + /// Fill from model + void fillFromModel ( ClpSimplex * model ); + + //@} + + /**@name Check progress */ + //@{ + /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken, + >=0 if give up and use as problem status + */ + int looping ( ); + /// Start check at beginning of whileIterating + void startCheck(); + /// Returns cycle length in whileIterating + int cycle(int in, int out, int wayIn, int wayOut); + + /// Returns previous objective (if -1) - current if (0) + double lastObjective(int back = 1) const; + /// Set real primal infeasibility and move back + void setInfeasibility(double value); + /// Returns real primal infeasibility (if -1) - current if (0) + double lastInfeasibility(int back = 1) const; + /// Returns number of primal infeasibilities (if -1) - current if (0) + int numberInfeasibilities(int back = 1) const; + /// Modify objective e.g. if dual infeasible in dual + void modifyObjective(double value); + /// Returns previous iteration number (if -1) - current if (0) + int lastIterationNumber(int back = 1) const; + /// clears all iteration numbers (to switch off panic) + void clearIterationNumbers(); + /// Odd state + inline void newOddState() { + oddState_ = - oddState_ - 1; + } + inline void endOddState() { + oddState_ = abs(oddState_); + } + inline void clearOddState() { + oddState_ = 0; + } + inline int oddState() const { + return oddState_; + } + /// number of bad times + inline int badTimes() const { + return numberBadTimes_; + } + inline void clearBadTimes() { + numberBadTimes_ = 0; + } + /// number of really bad times + inline int reallyBadTimes() const { + return numberReallyBadTimes_; + } + inline void incrementReallyBadTimes() { + numberReallyBadTimes_++; + } + /// number of times flagged + inline int timesFlagged() const { + return numberTimesFlagged_; + } + inline void clearTimesFlagged() { + numberTimesFlagged_ = 0; + } + inline void incrementTimesFlagged() { + numberTimesFlagged_++; + } + + //@} + /**@name Data */ +#define CLP_PROGRESS 5 + //#define CLP_PROGRESS_WEIGHT 10 + //@{ + /// Objective values + double objective_[CLP_PROGRESS]; + /// Sum of infeasibilities for algorithm + double infeasibility_[CLP_PROGRESS]; + /// Sum of real primal infeasibilities for primal + double realInfeasibility_[CLP_PROGRESS]; +#ifdef CLP_PROGRESS_WEIGHT + /// Objective values for weights + double objectiveWeight_[CLP_PROGRESS_WEIGHT]; + /// Sum of infeasibilities for algorithm for weights + double infeasibilityWeight_[CLP_PROGRESS_WEIGHT]; + /// Sum of real primal infeasibilities for primal for weights + double realInfeasibilityWeight_[CLP_PROGRESS_WEIGHT]; + /// Drop for weights + double drop_; + /// Best? for weights + double best_; +#endif + /// Initial weight for weights + double initialWeight_; +#define CLP_CYCLE 12 + /// For cycle checking + //double obj_[CLP_CYCLE]; + int in_[CLP_CYCLE]; + int out_[CLP_CYCLE]; + char way_[CLP_CYCLE]; + /// Pointer back to model so we can get information + ClpSimplex * model_; + /// Number of infeasibilities + int numberInfeasibilities_[CLP_PROGRESS]; + /// Iteration number at which occurred + int iterationNumber_[CLP_PROGRESS]; +#ifdef CLP_PROGRESS_WEIGHT + /// Number of infeasibilities for weights + int numberInfeasibilitiesWeight_[CLP_PROGRESS_WEIGHT]; + /// Iteration number at which occurred for weights + int iterationNumberWeight_[CLP_PROGRESS_WEIGHT]; +#endif + /// Number of times checked (so won't stop too early) + int numberTimes_; + /// Number of times it looked like loop + int numberBadTimes_; + /// Number really bad times + int numberReallyBadTimes_; + /// Number of times no iterations as flagged + int numberTimesFlagged_; + /// If things are in an odd state + int oddState_; + //@} +}; + +#include "ClpConfig.h" +#if CLP_HAS_ABC +#include "AbcCommon.hpp" +/// For saving extra information to see if looping. +class AbcSimplexProgress : public ClpSimplexProgress { + +public: + + + /**@name Constructors and destructor and copy */ + //@{ + /// Default constructor + AbcSimplexProgress ( ); + + /// Constructor from model + AbcSimplexProgress ( ClpSimplex * model ); + + /// Copy constructor. + AbcSimplexProgress(const AbcSimplexProgress &); + + /// Assignment operator. This copies the data + AbcSimplexProgress & operator=(const AbcSimplexProgress & rhs); + /// Destructor + ~AbcSimplexProgress ( ); + + //@} + + /**@name Check progress */ + //@{ + /** Returns -1 if okay, -n+1 (n number of times bad) if bad but action taken, + >=0 if give up and use as problem status + */ + int looping ( ); + + //@} + /**@name Data */ + //@} +}; +#endif +#endif diff --git a/thirdparty/windows/include/coin/Clp_C_Interface.h b/thirdparty/windows/include/coin/Clp_C_Interface.h new file mode 100644 index 0000000..b91b2d2 --- /dev/null +++ b/thirdparty/windows/include/coin/Clp_C_Interface.h @@ -0,0 +1,525 @@ +/* $Id: Clp_C_Interface.h 2019 2014-01-31 05:18:01Z stefan $ */ +/* + Copyright (C) 2002, 2003 International Business Machines Corporation + and others. All Rights Reserved. + + This code is licensed under the terms of the Eclipse Public License (EPL). +*/ +#ifndef ClpSimplexC_H +#define ClpSimplexC_H + +/* include all defines and ugly stuff */ +#include "Coin_C_defines.h" + +#if defined (CLP_EXTERN_C) +typedef struct { + ClpSolve options; +} Clp_Solve; +#else +typedef void Clp_Solve; +#endif + +/** This is a first "C" interface to Clp. + It has similarities to the OSL V3 interface + and only has most common functions +*/ + +#ifdef __cplusplus +extern "C" { +#endif + + /**@name Version info + * + * A Clp library has a version number of the form <major>.<minor>.<release>, + * where each of major, minor, and release are nonnegative integers. + * For a checkout of the Clp stable branch, release is 9999. + * For a checkout of the Clp development branch, major, minor, and release are 9999. + */ + /*@{*/ + /** Clp library version number as string. */ + COINLIBAPI const char* COINLINKAGE Clp_Version(void); + /** Major number of Clp library version. */ + COINLIBAPI int COINLINKAGE Clp_VersionMajor(void); + /** Minor number of Clp library version. */ + COINLIBAPI int COINLINKAGE Clp_VersionMinor(void); + /** Release number of Clp library version. */ + COINLIBAPI int COINLINKAGE Clp_VersionRelease(void); + /*@}*/ + + /**@name Constructors and destructor + These do not have an exact analogue in C++. + The user does not need to know structure of Clp_Simplex or Clp_Solve. + + For (almost) all Clp_* functions outside this group there is an exact C++ + analogue created by taking the first parameter out, removing the Clp_ + from name and applying the method to an object of type ClpSimplex. + + Similarly, for all ClpSolve_* functions there is an exact C++ + analogue created by taking the first parameter out, removing the ClpSolve_ + from name and applying the method to an object of type ClpSolve. + */ + /*@{*/ + + /** Default constructor */ + COINLIBAPI Clp_Simplex * COINLINKAGE Clp_newModel(void); + /** Destructor */ + COINLIBAPI void COINLINKAGE Clp_deleteModel(Clp_Simplex * model); + /** Default constructor */ + COINLIBAPI Clp_Solve * COINLINKAGE ClpSolve_new(); + /** Destructor */ + COINLIBAPI void COINLINKAGE ClpSolve_delete(Clp_Solve * solve); + /*@}*/ + + /**@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 NULL then the + following values are the default: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>rowub</code>: all rows have upper bound infinity + <li> <code>rowlb</code>: all rows have lower bound -infinity + <li> <code>obj</code>: all variables have 0 objective coefficient + </ul> + */ + /** Just like the other loadProblem() method except that the matrix is + given in a standard column major ordered format (without gaps). */ + COINLIBAPI void COINLINKAGE Clp_loadProblem (Clp_Simplex * model, 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); + + /* read quadratic part of the objective (the matrix part) */ + COINLIBAPI void COINLINKAGE + Clp_loadQuadraticObjective(Clp_Simplex * model, + const int numberColumns, + const CoinBigIndex * start, + const int * column, + const double * element); + /** Read an mps file from the given filename */ + COINLIBAPI int COINLINKAGE Clp_readMps(Clp_Simplex * model, const char *filename, + int keepNames, + int ignoreErrors); + /** Copy in integer informations */ + COINLIBAPI void COINLINKAGE Clp_copyInIntegerInformation(Clp_Simplex * model, const char * information); + /** Drop integer informations */ + COINLIBAPI void COINLINKAGE Clp_deleteIntegerInformation(Clp_Simplex * model); + /** Resizes rim part of model */ + COINLIBAPI void COINLINKAGE Clp_resize (Clp_Simplex * model, int newNumberRows, int newNumberColumns); + /** Deletes rows */ + COINLIBAPI void COINLINKAGE Clp_deleteRows(Clp_Simplex * model, int number, const int * which); + /** Add rows */ + COINLIBAPI void COINLINKAGE Clp_addRows(Clp_Simplex * model, int number, const double * rowLower, + const double * rowUpper, + const int * rowStarts, const int * columns, + const double * elements); + + /** Deletes columns */ + COINLIBAPI void COINLINKAGE Clp_deleteColumns(Clp_Simplex * model, int number, const int * which); + /** Add columns */ + COINLIBAPI void COINLINKAGE Clp_addColumns(Clp_Simplex * model, int number, const double * columnLower, + const double * columnUpper, + const double * objective, + const int * columnStarts, const int * rows, + const double * elements); + /** Change row lower bounds */ + COINLIBAPI void COINLINKAGE Clp_chgRowLower(Clp_Simplex * model, const double * rowLower); + /** Change row upper bounds */ + COINLIBAPI void COINLINKAGE Clp_chgRowUpper(Clp_Simplex * model, const double * rowUpper); + /** Change column lower bounds */ + COINLIBAPI void COINLINKAGE Clp_chgColumnLower(Clp_Simplex * model, const double * columnLower); + /** Change column upper bounds */ + COINLIBAPI void COINLINKAGE Clp_chgColumnUpper(Clp_Simplex * model, const double * columnUpper); + /** Change objective coefficients */ + COINLIBAPI void COINLINKAGE Clp_chgObjCoefficients(Clp_Simplex * model, const double * objIn); + /** Drops names - makes lengthnames 0 and names empty */ + COINLIBAPI void COINLINKAGE Clp_dropNames(Clp_Simplex * model); + /** Copies in names */ + COINLIBAPI void COINLINKAGE Clp_copyNames(Clp_Simplex * model, const char * const * rowNames, + const char * const * columnNames); + + /*@}*/ + /**@name gets and sets - you will find some synonyms at the end of this file */ + /*@{*/ + /** Number of rows */ + COINLIBAPI int COINLINKAGE Clp_numberRows(Clp_Simplex * model); + /** Number of columns */ + COINLIBAPI int COINLINKAGE Clp_numberColumns(Clp_Simplex * model); + /** Primal tolerance to use */ + COINLIBAPI double COINLINKAGE Clp_primalTolerance(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setPrimalTolerance(Clp_Simplex * model, double value) ; + /** Dual tolerance to use */ + COINLIBAPI double COINLINKAGE Clp_dualTolerance(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setDualTolerance(Clp_Simplex * model, double value) ; + /** Dual objective limit */ + COINLIBAPI double COINLINKAGE Clp_dualObjectiveLimit(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setDualObjectiveLimit(Clp_Simplex * model, double value); + /** Objective offset */ + COINLIBAPI double COINLINKAGE Clp_objectiveOffset(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setObjectiveOffset(Clp_Simplex * model, double value); + /** Fills in array with problem name */ + COINLIBAPI void COINLINKAGE Clp_problemName(Clp_Simplex * model, int maxNumberCharacters, char * array); + /* Sets problem name. Must have \0 at end. */ + COINLIBAPI int COINLINKAGE + Clp_setProblemName(Clp_Simplex * model, int maxNumberCharacters, char * array); + /** Number of iterations */ + COINLIBAPI int COINLINKAGE Clp_numberIterations(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setNumberIterations(Clp_Simplex * model, int numberIterations); + /** Maximum number of iterations */ + COINLIBAPI int maximumIterations(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setMaximumIterations(Clp_Simplex * model, int value); + /** Maximum time in seconds (from when set called) */ + COINLIBAPI double COINLINKAGE Clp_maximumSeconds(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setMaximumSeconds(Clp_Simplex * model, double value); + /** Returns true if hit maximum iterations (or time) */ + COINLIBAPI int COINLINKAGE Clp_hitMaximumIterations(Clp_Simplex * model); + /** Status of problem: + 0 - optimal + 1 - primal infeasible + 2 - dual infeasible + 3 - stopped on iterations etc + 4 - stopped due to errors + */ + COINLIBAPI int COINLINKAGE Clp_status(Clp_Simplex * model); + /** Set problem status */ + COINLIBAPI void COINLINKAGE Clp_setProblemStatus(Clp_Simplex * model, int problemStatus); + /** Secondary status of problem - may get extended + 0 - none + 1 - primal infeasible because dual limit reached + 2 - scaled problem optimal - unscaled has primal infeasibilities + 3 - scaled problem optimal - unscaled has dual infeasibilities + 4 - scaled problem optimal - unscaled has both dual and primal infeasibilities + */ + COINLIBAPI int COINLINKAGE Clp_secondaryStatus(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setSecondaryStatus(Clp_Simplex * model, int status); + /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */ + COINLIBAPI double COINLINKAGE Clp_optimizationDirection(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setOptimizationDirection(Clp_Simplex * model, double value); + /** Primal row solution */ + COINLIBAPI double * COINLINKAGE Clp_primalRowSolution(Clp_Simplex * model); + /** Primal column solution */ + COINLIBAPI double * COINLINKAGE Clp_primalColumnSolution(Clp_Simplex * model); + /** Dual row solution */ + COINLIBAPI double * COINLINKAGE Clp_dualRowSolution(Clp_Simplex * model); + /** Reduced costs */ + COINLIBAPI double * COINLINKAGE Clp_dualColumnSolution(Clp_Simplex * model); + /** Row lower */ + COINLIBAPI double* COINLINKAGE Clp_rowLower(Clp_Simplex * model); + /** Row upper */ + COINLIBAPI double* COINLINKAGE Clp_rowUpper(Clp_Simplex * model); + /** Objective */ + COINLIBAPI double * COINLINKAGE Clp_objective(Clp_Simplex * model); + /** Column Lower */ + COINLIBAPI double * COINLINKAGE Clp_columnLower(Clp_Simplex * model); + /** Column Upper */ + COINLIBAPI double * COINLINKAGE Clp_columnUpper(Clp_Simplex * model); + /** Number of elements in matrix */ + COINLIBAPI int COINLINKAGE Clp_getNumElements(Clp_Simplex * model); + /* Column starts in matrix */ + COINLIBAPI const CoinBigIndex * COINLINKAGE Clp_getVectorStarts(Clp_Simplex * model); + /* Row indices in matrix */ + COINLIBAPI const int * COINLINKAGE Clp_getIndices(Clp_Simplex * model); + /* Column vector lengths in matrix */ + COINLIBAPI const int * COINLINKAGE Clp_getVectorLengths(Clp_Simplex * model); + /* Element values in matrix */ + COINLIBAPI const double * COINLINKAGE Clp_getElements(Clp_Simplex * model); + /** Objective value */ + COINLIBAPI double COINLINKAGE Clp_objectiveValue(Clp_Simplex * model); + /** Integer information */ + COINLIBAPI char * COINLINKAGE Clp_integerInformation(Clp_Simplex * model); + /** Gives Infeasibility ray. + * + * Use Clp_freeRay to free the returned array. + * + * @return infeasibility ray, or NULL returned if none/wrong. + */ + COINLIBAPI double * COINLINKAGE Clp_infeasibilityRay(Clp_Simplex * model); + /** Gives ray in which the problem is unbounded. + * + * Use Clp_freeRay to free the returned array. + * + * @return unbounded ray, or NULL returned if none/wrong. + */ + COINLIBAPI double * COINLINKAGE Clp_unboundedRay(Clp_Simplex * model); + /** Frees a infeasibility or unbounded ray. */ + COINLIBAPI void COINLINKAGE Clp_freeRay(Clp_Simplex * model, double * ray); + /** See if status array exists (partly for OsiClp) */ + COINLIBAPI int COINLINKAGE Clp_statusExists(Clp_Simplex * model); + /** Return address of status array (char[numberRows+numberColumns]) */ + COINLIBAPI unsigned char * COINLINKAGE Clp_statusArray(Clp_Simplex * model); + /** Copy in status vector */ + COINLIBAPI void COINLINKAGE Clp_copyinStatus(Clp_Simplex * model, const unsigned char * statusArray); + /* status values are as in ClpSimplex.hpp i.e. 0 - free, 1 basic, 2 at upper, + 3 at lower, 4 superbasic, (5 fixed) */ + /* Get variable basis info */ + COINLIBAPI int COINLINKAGE Clp_getColumnStatus(Clp_Simplex * model, int sequence); + /* Get row basis info */ + COINLIBAPI int COINLINKAGE Clp_getRowStatus(Clp_Simplex * model, int sequence); + /* Set variable basis info (and value if at bound) */ + COINLIBAPI void COINLINKAGE Clp_setColumnStatus(Clp_Simplex * model, + int sequence, int value); + /* Set row basis info (and value if at bound) */ + COINLIBAPI void COINLINKAGE Clp_setRowStatus(Clp_Simplex * model, + int sequence, int value); + + /** User pointer for whatever reason */ + COINLIBAPI void COINLINKAGE Clp_setUserPointer (Clp_Simplex * model, void * pointer); + COINLIBAPI void * COINLINKAGE Clp_getUserPointer (Clp_Simplex * model); + /*@}*/ + /**@name Message handling. Call backs are handled by ONE function */ + /*@{*/ + /** Pass in Callback function. + Message numbers up to 1000000 are Clp, Coin ones have 1000000 added */ + COINLIBAPI void COINLINKAGE Clp_registerCallBack(Clp_Simplex * model, + clp_callback userCallBack); + /** Unset Callback function */ + COINLIBAPI void COINLINKAGE Clp_clearCallBack(Clp_Simplex * model); + /** 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 + */ + COINLIBAPI void COINLINKAGE Clp_setLogLevel(Clp_Simplex * model, int value); + COINLIBAPI int COINLINKAGE Clp_logLevel(Clp_Simplex * model); + /** length of names (0 means no names0 */ + COINLIBAPI int COINLINKAGE Clp_lengthNames(Clp_Simplex * model); + /** Fill in array (at least lengthNames+1 long) with a row name */ + COINLIBAPI void COINLINKAGE Clp_rowName(Clp_Simplex * model, int iRow, char * name); + /** Fill in array (at least lengthNames+1 long) with a column name */ + COINLIBAPI void COINLINKAGE Clp_columnName(Clp_Simplex * model, int iColumn, char * name); + + /*@}*/ + + + /**@name Functions most useful to user */ + /*@{*/ + /** General solve algorithm which can do presolve. + See ClpSolve.hpp for options + */ + COINLIBAPI int COINLINKAGE Clp_initialSolve(Clp_Simplex * model); + /** Pass solve options. (Exception to direct analogue rule) */ + COINLIBAPI int COINLINKAGE Clp_initialSolveWithOptions(Clp_Simplex * model, Clp_Solve *); + /** Dual initial solve */ + COINLIBAPI int COINLINKAGE Clp_initialDualSolve(Clp_Simplex * model); + /** Primal initial solve */ + COINLIBAPI int COINLINKAGE Clp_initialPrimalSolve(Clp_Simplex * model); + /** Barrier initial solve */ + COINLIBAPI int COINLINKAGE Clp_initialBarrierSolve(Clp_Simplex * model); + /** Barrier initial solve, no crossover */ + COINLIBAPI int COINLINKAGE Clp_initialBarrierNoCrossSolve(Clp_Simplex * model); + /** Dual algorithm - see ClpSimplexDual.hpp for method */ + COINLIBAPI int COINLINKAGE Clp_dual(Clp_Simplex * model, int ifValuesPass); + /** Primal algorithm - see ClpSimplexPrimal.hpp for method */ + COINLIBAPI int COINLINKAGE Clp_primal(Clp_Simplex * model, int ifValuesPass); +#ifndef SLIM_CLP + /** Solve the problem with the idiot code */ + COINLIBAPI void COINLINKAGE Clp_idiot(Clp_Simplex * model, int tryhard); +#endif + /** Sets or unsets scaling, 0 -off, 1 equilibrium, 2 geometric, 3, auto, 4 dynamic(later) */ + COINLIBAPI void COINLINKAGE Clp_scaling(Clp_Simplex * model, int mode); + /** Gets scalingFlag */ + COINLIBAPI int COINLINKAGE Clp_scalingFlag(Clp_Simplex * model); + /** Crash - at present just aimed at dual, returns + -2 if dual preferred and crash basis created + -1 if dual preferred and all slack basis preferred + 0 if basis going in was not all slack + 1 if primal preferred and all slack basis preferred + 2 if primal preferred and crash basis created. + + if gap between bounds <="gap" variables can be flipped + + If "pivot" is + 0 No pivoting (so will just be choice of algorithm) + 1 Simple pivoting e.g. gub + 2 Mini iterations + */ + COINLIBAPI int COINLINKAGE Clp_crash(Clp_Simplex * model, double gap, int pivot); + /*@}*/ + + + /**@name most useful gets and sets */ + /*@{*/ + /** If problem is primal feasible */ + COINLIBAPI int COINLINKAGE Clp_primalFeasible(Clp_Simplex * model); + /** If problem is dual feasible */ + COINLIBAPI int COINLINKAGE Clp_dualFeasible(Clp_Simplex * model); + /** Dual bound */ + COINLIBAPI double COINLINKAGE Clp_dualBound(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setDualBound(Clp_Simplex * model, double value); + /** Infeasibility cost */ + COINLIBAPI double COINLINKAGE Clp_infeasibilityCost(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setInfeasibilityCost(Clp_Simplex * model, double value); + /** Perturbation: + 50 - switch on perturbation + 100 - auto perturb if takes too long (1.0e-6 largest nonzero) + 101 - we are perturbed + 102 - don't try perturbing again + default is 100 + others are for playing + */ + COINLIBAPI int COINLINKAGE Clp_perturbation(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setPerturbation(Clp_Simplex * model, int value); + /** Current (or last) algorithm */ + COINLIBAPI int COINLINKAGE Clp_algorithm(Clp_Simplex * model); + /** Set algorithm */ + COINLIBAPI void COINLINKAGE Clp_setAlgorithm(Clp_Simplex * model, int value); + /** Sum of dual infeasibilities */ + COINLIBAPI double COINLINKAGE Clp_sumDualInfeasibilities(Clp_Simplex * model); + /** Number of dual infeasibilities */ + COINLIBAPI int COINLINKAGE Clp_numberDualInfeasibilities(Clp_Simplex * model); + /** Sum of primal infeasibilities */ + COINLIBAPI double COINLINKAGE Clp_sumPrimalInfeasibilities(Clp_Simplex * model); + /** Number of primal infeasibilities */ + COINLIBAPI int COINLINKAGE Clp_numberPrimalInfeasibilities(Clp_Simplex * model); + /** Save model to file, returns 0 if success. This is designed for + use outside algorithms so does not save iterating arrays etc. + It does not save any messaging information. + Does not save scaling values. + It does not know about all types of virtual functions. + */ + COINLIBAPI int COINLINKAGE Clp_saveModel(Clp_Simplex * model, const char * fileName); + /** Restore model from file, returns 0 if success, + deletes current model */ + COINLIBAPI int COINLINKAGE Clp_restoreModel(Clp_Simplex * model, const char * fileName); + + /** Just check solution (for external use) - sets sum of + infeasibilities etc */ + COINLIBAPI void COINLINKAGE Clp_checkSolution(Clp_Simplex * model); + /*@}*/ + + /******************** End of most useful part **************/ + /**@name gets and sets - some synonyms */ + /*@{*/ + /** Number of rows */ + COINLIBAPI int COINLINKAGE Clp_getNumRows(Clp_Simplex * model); + /** Number of columns */ + COINLIBAPI int COINLINKAGE Clp_getNumCols(Clp_Simplex * model); + /** Number of iterations */ + COINLIBAPI int COINLINKAGE Clp_getIterationCount(Clp_Simplex * model); + /** Are there a numerical difficulties? */ + COINLIBAPI int COINLINKAGE Clp_isAbandoned(Clp_Simplex * model); + /** Is optimality proven? */ + COINLIBAPI int COINLINKAGE Clp_isProvenOptimal(Clp_Simplex * model); + /** Is primal infeasiblity proven? */ + COINLIBAPI int COINLINKAGE Clp_isProvenPrimalInfeasible(Clp_Simplex * model); + /** Is dual infeasiblity proven? */ + COINLIBAPI int COINLINKAGE Clp_isProvenDualInfeasible(Clp_Simplex * model); + /** Is the given primal objective limit reached? */ + COINLIBAPI int COINLINKAGE Clp_isPrimalObjectiveLimitReached(Clp_Simplex * model) ; + /** Is the given dual objective limit reached? */ + COINLIBAPI int COINLINKAGE Clp_isDualObjectiveLimitReached(Clp_Simplex * model) ; + /** Iteration limit reached? */ + COINLIBAPI int COINLINKAGE Clp_isIterationLimitReached(Clp_Simplex * model); + /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */ + COINLIBAPI double COINLINKAGE Clp_getObjSense(Clp_Simplex * model); + /** Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore */ + COINLIBAPI void COINLINKAGE Clp_setObjSense(Clp_Simplex * model, double objsen); + /** Primal row solution */ + COINLIBAPI const double * COINLINKAGE Clp_getRowActivity(Clp_Simplex * model); + /** Primal column solution */ + COINLIBAPI const double * COINLINKAGE Clp_getColSolution(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setColSolution(Clp_Simplex * model, const double * input); + /** Dual row solution */ + COINLIBAPI const double * COINLINKAGE Clp_getRowPrice(Clp_Simplex * model); + /** Reduced costs */ + COINLIBAPI const double * COINLINKAGE Clp_getReducedCost(Clp_Simplex * model); + /** Row lower */ + COINLIBAPI const double* COINLINKAGE Clp_getRowLower(Clp_Simplex * model); + /** Row upper */ + COINLIBAPI const double* COINLINKAGE Clp_getRowUpper(Clp_Simplex * model); + /** Objective */ + COINLIBAPI const double * COINLINKAGE Clp_getObjCoefficients(Clp_Simplex * model); + /** Column Lower */ + COINLIBAPI const double * COINLINKAGE Clp_getColLower(Clp_Simplex * model); + /** Column Upper */ + COINLIBAPI const double * COINLINKAGE Clp_getColUpper(Clp_Simplex * model); + /** Objective value */ + COINLIBAPI double COINLINKAGE Clp_getObjValue(Clp_Simplex * model); + /** Print model for debugging purposes */ + COINLIBAPI void COINLINKAGE Clp_printModel(Clp_Simplex * model, const char * prefix); + /* Small element value - elements less than this set to zero, + default is 1.0e-20 */ + COINLIBAPI double COINLINKAGE Clp_getSmallElementValue(Clp_Simplex * model); + COINLIBAPI void COINLINKAGE Clp_setSmallElementValue(Clp_Simplex * model, double value); + /*@}*/ + + + /**@name Get and set ClpSolve options + */ + /*@{*/ + COINLIBAPI void COINLINKAGE ClpSolve_setSpecialOption(Clp_Solve *, int which, int value, int extraInfo); + COINLIBAPI int COINLINKAGE ClpSolve_getSpecialOption(Clp_Solve *, int which); + + /** method: (see ClpSolve::SolveType) + 0 - dual simplex + 1 - primal simplex + 2 - primal or sprint + 3 - barrier + 4 - barrier no crossover + 5 - automatic + 6 - not implemented + -- pass extraInfo == -1 for default behavior */ + COINLIBAPI void COINLINKAGE ClpSolve_setSolveType(Clp_Solve *, int method, int extraInfo); + COINLIBAPI int COINLINKAGE ClpSolve_getSolveType(Clp_Solve *); + + /** amount: (see ClpSolve::PresolveType) + 0 - presolve on + 1 - presolve off + 2 - presolve number + 3 - presolve number cost + -- pass extraInfo == -1 for default behavior */ + COINLIBAPI void COINLINKAGE ClpSolve_setPresolveType(Clp_Solve *, int amount, int extraInfo); + COINLIBAPI int COINLINKAGE ClpSolve_getPresolveType(Clp_Solve *); + + COINLIBAPI int COINLINKAGE ClpSolve_getPresolvePasses(Clp_Solve *); + COINLIBAPI int COINLINKAGE ClpSolve_getExtraInfo(Clp_Solve *, int which); + COINLIBAPI void COINLINKAGE ClpSolve_setInfeasibleReturn(Clp_Solve *, int trueFalse); + COINLIBAPI int COINLINKAGE ClpSolve_infeasibleReturn(Clp_Solve *); + + COINLIBAPI int COINLINKAGE ClpSolve_doDual(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoDual(Clp_Solve *, int doDual); + + COINLIBAPI int COINLINKAGE ClpSolve_doSingleton(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoSingleton(Clp_Solve *, int doSingleton); + + COINLIBAPI int COINLINKAGE ClpSolve_doDoubleton(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoDoubleton(Clp_Solve *, int doDoubleton); + + COINLIBAPI int COINLINKAGE ClpSolve_doTripleton(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoTripleton(Clp_Solve *, int doTripleton); + + COINLIBAPI int COINLINKAGE ClpSolve_doTighten(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoTighten(Clp_Solve *, int doTighten); + + COINLIBAPI int COINLINKAGE ClpSolve_doForcing(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoForcing(Clp_Solve *, int doForcing); + + COINLIBAPI int COINLINKAGE ClpSolve_doImpliedFree(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoImpliedFree(Clp_Solve *, int doImpliedFree); + + COINLIBAPI int COINLINKAGE ClpSolve_doDupcol(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoDupcol(Clp_Solve *, int doDupcol); + + COINLIBAPI int COINLINKAGE ClpSolve_doDuprow(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoDuprow(Clp_Solve *, int doDuprow); + + COINLIBAPI int COINLINKAGE ClpSolve_doSingletonColumn(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setDoSingletonColumn(Clp_Solve *, int doSingleton); + + COINLIBAPI int COINLINKAGE ClpSolve_presolveActions(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setPresolveActions(Clp_Solve *, int action); + + COINLIBAPI int COINLINKAGE ClpSolve_substitution(Clp_Solve *); + COINLIBAPI void COINLINKAGE ClpSolve_setSubstitution(Clp_Solve *, int value); + + /*@}*/ +#ifdef __cplusplus +} +#endif +#endif diff --git a/thirdparty/windows/include/coin/CoinAlloc.hpp b/thirdparty/windows/include/coin/CoinAlloc.hpp new file mode 100644 index 0000000..8f6b08c --- /dev/null +++ b/thirdparty/windows/include/coin/CoinAlloc.hpp @@ -0,0 +1,176 @@ +/* $Id: CoinAlloc.hpp 1438 2011-06-09 18:14:12Z stefan $ */ +// 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 CoinAlloc_hpp +#define CoinAlloc_hpp + +#include "CoinUtilsConfig.h" +#include <cstdlib> + +#if !defined(COINUTILS_MEMPOOL_MAXPOOLED) +# define COINUTILS_MEMPOOL_MAXPOOLED -1 +#endif + +#if (COINUTILS_MEMPOOL_MAXPOOLED >= 0) + +#ifndef COINUTILS_MEMPOOL_ALIGNMENT +#define COINUTILS_MEMPOOL_ALIGNMENT 16 +#endif + +/* Note: + This memory pool implementation assumes that sizeof(size_t) and + sizeof(void*) are both <= COINUTILS_MEMPOOL_ALIGNMENT. + Choosing an alignment of 4 will cause segfault on 64-bit platforms and may + lead to bad performance on 32-bit platforms. So 8 is a mnimum recommended + alignment. Probably 16 does not waste too much space either and may be even + better for performance. One must play with it. +*/ + +//############################################################################# + +#if (COINUTILS_MEMPOOL_ALIGNMENT == 16) +static const std::size_t CoinAllocPtrShift = 4; +static const std::size_t CoinAllocRoundMask = ~((std::size_t)15); +#elif (COINUTILS_MEMPOOL_ALIGNMENT == 8) +static const std::size_t CoinAllocPtrShift = 3; +static const std::size_t CoinAllocRoundMask = ~((std::size_t)7); +#else +#error "COINUTILS_MEMPOOL_ALIGNMENT must be defined as 8 or 16 (or this code needs to be changed :-)" +#endif + +//############################################################################# + +#ifndef COIN_MEMPOOL_SAVE_BLOCKHEADS +# define COIN_MEMPOOL_SAVE_BLOCKHEADS 0 +#endif + +//############################################################################# + +class CoinMempool +{ +private: +#if (COIN_MEMPOOL_SAVE_BLOCKHEADS == 1) + char** block_heads; + std::size_t block_num; + std::size_t max_block_num; +#endif +#if defined(COINUTILS_PTHREADS) && (COINUTILS_PTHREAD == 1) + pthread_mutex_t mutex_; +#endif + int last_block_size_; + char* first_free_; + const std::size_t entry_size_; + +private: + CoinMempool(const CoinMempool&); + CoinMempool& operator=(const CoinMempool&); + +private: + char* allocate_new_block(); + inline void lock_mutex() { +#if defined(COINUTILS_PTHREADS) && (COINUTILS_PTHREAD == 1) + pthread_mutex_lock(&mutex_); +#endif + } + inline void unlock_mutex() { +#if defined(COINUTILS_PTHREADS) && (COINUTILS_PTHREAD == 1) + pthread_mutex_unlock(&mutex_); +#endif + } + +public: + CoinMempool(std::size_t size = 0); + ~CoinMempool(); + + char* alloc(); + inline void dealloc(char *p) + { + char** pp = (char**)p; + lock_mutex(); + *pp = first_free_; + first_free_ = p; + unlock_mutex(); + } +}; + +//############################################################################# + +/** A memory pool allocator. + + If a request arrives for allocating \c n bytes then it is first + rounded up to the nearest multiple of \c sizeof(void*) (this is \c + n_roundup), then one more \c sizeof(void*) is added to this + number. If the result is no more than maxpooled_ then + the appropriate pool is used to get a chunk of memory, if not, + then malloc is used. In either case, the size of the allocated + chunk is written into the first \c sizeof(void*) bytes and a + pointer pointing afterwards is returned. +*/ + +class CoinAlloc +{ +private: + CoinMempool* pool_; + int maxpooled_; +public: + CoinAlloc(); + ~CoinAlloc() {} + + inline void* alloc(const std::size_t n) + { + if (maxpooled_ <= 0) { + return std::malloc(n); + } + char *p = NULL; + const std::size_t to_alloc = + ((n+COINUTILS_MEMPOOL_ALIGNMENT-1) & CoinAllocRoundMask) + + COINUTILS_MEMPOOL_ALIGNMENT; + CoinMempool* pool = NULL; + if (maxpooled_ > 0 && to_alloc >= (size_t)maxpooled_) { + p = static_cast<char*>(std::malloc(to_alloc)); + if (p == NULL) throw std::bad_alloc(); + } else { + pool = pool_ + (to_alloc >> CoinAllocPtrShift); + p = pool->alloc(); + } + *((CoinMempool**)p) = pool; + return static_cast<void*>(p+COINUTILS_MEMPOOL_ALIGNMENT); + } + + inline void dealloc(void* p) + { + if (maxpooled_ <= 0) { + std::free(p); + return; + } + if (p) { + char* base = static_cast<char*>(p)-COINUTILS_MEMPOOL_ALIGNMENT; + CoinMempool* pool = *((CoinMempool**)base); + if (!pool) { + std::free(base); + } else { + pool->dealloc(base); + } + } + } +}; + +extern CoinAlloc CoinAllocator; + +//############################################################################# + +#if defined(COINUTILS_MEMPOOL_OVERRIDE_NEW) && (COINUTILS_MEMPOOL_OVERRIDE_NEW == 1) +void* operator new(std::size_t size) throw (std::bad_alloc); +void* operator new[](std::size_t) throw (std::bad_alloc); +void operator delete(void*) throw(); +void operator delete[](void*) throw(); +void* operator new(std::size_t, const std::nothrow_t&) throw(); +void* operator new[](std::size_t, const std::nothrow_t&) throw(); +void operator delete(void*, const std::nothrow_t&) throw(); +void operator delete[](void*, const std::nothrow_t&) throw(); +#endif + +#endif /*(COINUTILS_MEMPOOL_MAXPOOLED >= 0)*/ +#endif diff --git a/thirdparty/windows/include/coin/CoinBuild.hpp b/thirdparty/windows/include/coin/CoinBuild.hpp new file mode 100644 index 0000000..770c269 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinBuild.hpp @@ -0,0 +1,149 @@ +/* $Id: CoinBuild.hpp 1416 2011-04-17 09:57:29Z stefan $ */ +// 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 CoinBuild_H +#define CoinBuild_H + + +#include "CoinPragma.hpp" +#include "CoinTypes.hpp" +#include "CoinFinite.hpp" + + +/** + In many cases it is natural to build a model by adding one row at a time. In Coin this + is inefficient so this class gives some help. An instance of CoinBuild can be built up + more efficiently and then added to the Clp/OsiModel in one go. + + It may be more efficient to have fewer arrays and re-allocate them but this should + give a large gain over addRow. + + I have now extended it to columns. + +*/ + +class CoinBuild { + +public: + /**@name Useful methods */ + //@{ + /// add a row + void addRow(int numberInRow, const int * columns, + const double * elements, double rowLower=-COIN_DBL_MAX, + double rowUpper=COIN_DBL_MAX); + /// add a column + void addColumn(int numberInColumn, const int * rows, + const double * elements, + double columnLower=0.0, + double columnUpper=COIN_DBL_MAX, double objectiveValue=0.0); + /// add a column + inline void addCol(int numberInColumn, const int * rows, + const double * elements, + double columnLower=0.0, + double columnUpper=COIN_DBL_MAX, double objectiveValue=0.0) + { addColumn(numberInColumn, rows, elements, columnLower, columnUpper, objectiveValue);} + /// Return number of rows or maximum found so far + inline int numberRows() const + { return (type_==0) ? numberItems_ : numberOther_;} + /// Return number of columns or maximum found so far + inline int numberColumns() const + { return (type_==1) ? numberItems_ : numberOther_;} + /// Return number of elements + inline CoinBigIndex numberElements() const + { return numberElements_;} + /** Returns number of elements in a row and information in row + */ + int row(int whichRow, double & rowLower, double & rowUpper, + const int * & indices, const double * & elements) const; + /** Returns number of elements in current row and information in row + Used as rows may be stored in a chain + */ + int currentRow(double & rowLower, double & rowUpper, + const int * & indices, const double * & elements) const; + /// Set current row + void setCurrentRow(int whichRow); + /// Returns current row number + int currentRow() const; + /** Returns number of elements in a column and information in column + */ + int column(int whichColumn, + double & columnLower, double & columnUpper,double & objectiveValue, + const int * & indices, const double * & elements) const; + /** Returns number of elements in current column and information in column + Used as columns may be stored in a chain + */ + int currentColumn( double & columnLower, double & columnUpper,double & objectiveValue, + const int * & indices, const double * & elements) const; + /// Set current column + void setCurrentColumn(int whichColumn); + /// Returns current column number + int currentColumn() const; + /// Returns type + inline int type() const + { return type_;} + //@} + + + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + CoinBuild(); + /** Constructor with type 0==for addRow, 1== for addColumn. */ + CoinBuild(int type); + /** Destructor */ + ~CoinBuild(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + CoinBuild(const CoinBuild&); + /// = + CoinBuild& operator=(const CoinBuild&); + //@} +private: + /// Set current + void setMutableCurrent(int which) const; + /// add a item + void addItem(int numberInItem, const int * indices, + const double * elements, + double itemLower, + double itemUpper, double objectiveValue); + /** Returns number of elements in a item and information in item + */ + int item(int whichItem, + double & itemLower, double & itemUpper,double & objectiveValue, + const int * & indices, const double * & elements) const; + /** Returns number of elements in current item and information in item + Used as items may be stored in a chain + */ + int currentItem( double & itemLower, double & itemUpper,double & objectiveValue, + const int * & indices, const double * & elements) const; + /// Set current item + void setCurrentItem(int whichItem); + /// Returns current item number + int currentItem() const; + +private: + /**@name Data members */ + //@{ + /// Current number of items + int numberItems_; + /// Current number of other dimension i.e. Columns if addRow (i.e. max) + int numberOther_; + /// Current number of elements + CoinBigIndex numberElements_; + /// Current item pointer + mutable double * currentItem_; + /// First item pointer + double * firstItem_; + /// Last item pointer + double * lastItem_; + /// Type of build - 0 for row, 1 for column, -1 unset + int type_; + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/CoinDenseFactorization.hpp b/thirdparty/windows/include/coin/CoinDenseFactorization.hpp new file mode 100644 index 0000000..3ba7528 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinDenseFactorization.hpp @@ -0,0 +1,419 @@ +/* $Id: CoinDenseFactorization.hpp 1759 2014-11-18 11:07:23Z forrest $ */ +// 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). + + +/* + Authors + + John Forrest + + */ +#ifndef CoinDenseFactorization_H +#define CoinDenseFactorization_H + +#include <iostream> +#include <string> +#include <cassert> +#include "CoinTypes.hpp" +#include "CoinIndexedVector.hpp" +#include "CoinFactorization.hpp" +#if COIN_FACTORIZATION_DENSE_CODE == 2 +#undef COIN_FACTORIZATION_DENSE_CODE +#endif +class CoinPackedMatrix; +/// Abstract base class which also has some scalars so can be used from Dense or Simp +class CoinOtherFactorization { + +public: + + /**@name Constructors and destructor and copy */ + //@{ + /// Default constructor + CoinOtherFactorization ( ); + /// Copy constructor + CoinOtherFactorization ( const CoinOtherFactorization &other); + + /// Destructor + virtual ~CoinOtherFactorization ( ); + /// = copy + CoinOtherFactorization & operator = ( const CoinOtherFactorization & other ); + + /// Clone + virtual CoinOtherFactorization * clone() const = 0; + //@} + + /**@name general stuff such as status */ + //@{ + /// Returns status + inline int status ( ) const { + return status_; + } + /// Sets status + inline void setStatus ( int value) + { status_=value; } + /// Returns number of pivots since factorization + inline int pivots ( ) const { + return numberPivots_; + } + /// Sets number of pivots since factorization + inline void setPivots ( int value ) + { numberPivots_=value; } + /// Set number of Rows after factorization + inline void setNumberRows(int value) + { numberRows_ = value; } + /// Number of Rows after factorization + inline int numberRows ( ) const { + return numberRows_; + } + /// Total number of columns in factorization + inline int numberColumns ( ) const { + return numberColumns_; + } + /// Number of good columns in factorization + inline int numberGoodColumns ( ) const { + return numberGoodU_; + } + /// Allows change of pivot accuracy check 1.0 == none >1.0 relaxed + inline void relaxAccuracyCheck(double value) + { relaxCheck_ = value;} + inline double getAccuracyCheck() const + { return relaxCheck_;} + /// Maximum number of pivots between factorizations + inline int maximumPivots ( ) const { + return maximumPivots_ ; + } + /// Set maximum pivots + virtual void maximumPivots ( int value ); + + /// Pivot tolerance + inline double pivotTolerance ( ) const { + return pivotTolerance_ ; + } + void pivotTolerance ( double value ); + /// Zero tolerance + inline double zeroTolerance ( ) const { + return zeroTolerance_ ; + } + void zeroTolerance ( double value ); +#ifndef COIN_FAST_CODE + /// Whether slack value is +1 or -1 + inline double slackValue ( ) const { + return slackValue_ ; + } + void slackValue ( double value ); +#endif + /// Returns array to put basis elements in + virtual CoinFactorizationDouble * elements() const; + /// Returns pivot row + virtual int * pivotRow() const; + /// Returns work area + virtual CoinFactorizationDouble * workArea() const; + /// Returns int work area + virtual int * intWorkArea() const; + /// Number of entries in each row + virtual int * numberInRow() const; + /// Number of entries in each column + virtual int * numberInColumn() const; + /// Returns array to put basis starts in + virtual CoinBigIndex * starts() const; + /// Returns permute back + virtual int * permuteBack() const; + /** Get solve mode e.g. 0 C++ code, 1 Lapack, 2 choose + If 4 set then values pass + if 8 set then has iterated + */ + inline int solveMode() const + { return solveMode_ ;} + /** Set solve mode e.g. 0 C++ code, 1 Lapack, 2 choose + If 4 set then values pass + if 8 set then has iterated + */ + inline void setSolveMode(int value) + { solveMode_ = value;} + /// Returns true if wants tableauColumn in replaceColumn + virtual bool wantsTableauColumn() const; + /** Useful information for factorization + 0 - iteration number + whereFrom is 0 for factorize and 1 for replaceColumn + */ + virtual void setUsefulInformation(const int * info,int whereFrom); + /// Get rid of all memory + virtual void clearArrays() {} + //@} + /**@name virtual general stuff such as permutation */ + //@{ + /// Returns array to put basis indices in + virtual int * indices() const = 0; + /// Returns permute in + virtual int * permute() const = 0; + /// Total number of elements in factorization + virtual int numberElements ( ) const = 0; + //@} + /**@name Do factorization - public */ + //@{ + /// Gets space for a factorization + virtual void getAreas ( int numberRows, + int numberColumns, + CoinBigIndex maximumL, + CoinBigIndex maximumU ) = 0; + + /// PreProcesses column ordered copy of basis + virtual void preProcess ( ) = 0; + /** Does most of factorization returning status + 0 - OK + -99 - needs more memory + -1 - singular - use numberGoodColumns and redo + */ + virtual int factor ( ) = 0; + /// Does post processing on valid factorization - putting variables on correct rows + virtual void postProcess(const int * sequence, int * pivotVariable) = 0; + /// Makes a non-singular basis by replacing variables + virtual void makeNonSingular(int * sequence, int numberColumns) = 0; + //@} + + /**@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 */ + virtual int replaceColumn ( CoinIndexedVector * regionSparse, + int pivotRow, + double pivotCheck , + bool checkBeforeModifying=false, + double acceptablePivot=1.0e-8)=0; + //@} + + /**@name various uses of factorization (return code number elements) + which user may want to know about */ + //@{ + /** Updates one column (FTRAN) from regionSparse2 + Tries to do FT update + number returned is negative if no room + regionSparse starts as zero and is zero at end. + Note - if regionSparse2 packed on input - will be packed on output + */ + virtual int updateColumnFT ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2, + bool noPermute=false) = 0; + /** This version has same effect as above with FTUpdate==false + so number returned is always >=0 */ + virtual int updateColumn ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2, + bool noPermute=false) const = 0; + /// does FTRAN on two columns + virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1, + CoinIndexedVector * regionSparse2, + CoinIndexedVector * regionSparse3, + bool noPermute=false) = 0; + /** Updates one column (BTRAN) from regionSparse2 + regionSparse starts as zero and is zero at end + Note - if regionSparse2 packed on input - will be packed on output + */ + virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2) const = 0; + //@} + +////////////////// data ////////////////// +protected: + + /**@name data */ + //@{ + /// Pivot tolerance + double pivotTolerance_; + /// Zero tolerance + double zeroTolerance_; +#ifndef COIN_FAST_CODE + /// Whether slack value is +1 or -1 + double slackValue_; +#else +#ifndef slackValue_ +#define slackValue_ -1.0 +#endif +#endif + /// Relax check on accuracy in replaceColumn + double relaxCheck_; + /// Number of elements after factorization + CoinBigIndex factorElements_; + /// Number of Rows in factorization + int numberRows_; + /// Number of Columns in factorization + int numberColumns_; + /// Number factorized in U (not row singletons) + int numberGoodU_; + /// Maximum number of pivots before factorization + int maximumPivots_; + /// Number pivots since last factorization + int numberPivots_; + /// Status of factorization + int status_; + /// Maximum rows ever (i.e. use to copy arrays etc) + int maximumRows_; + /// Maximum length of iterating area + CoinBigIndex maximumSpace_; + /// Pivot row + int * pivotRow_; + /** Elements of factorization and updates + length is maxR*maxR+maxSpace + will always be long enough so can have nR*nR ints in maxSpace + */ + CoinFactorizationDouble * elements_; + /// Work area of numberRows_ + CoinFactorizationDouble * workArea_; + /** Solve mode e.g. 0 C++ code, 1 Lapack, 2 choose + If 4 set then values pass + if 8 set then has iterated + */ + int solveMode_; + //@} +}; +/** This deals with Factorization and Updates + This is a simple dense version so other people can write a better one + + I am assuming that 32 bits is enough for number of rows or columns, but CoinBigIndex + may be redefined to get 64 bits. + */ + + + +class CoinDenseFactorization : public CoinOtherFactorization { + friend void CoinDenseFactorizationUnitTest( const std::string & mpsDir ); + +public: + + /**@name Constructors and destructor and copy */ + //@{ + /// Default constructor + CoinDenseFactorization ( ); + /// Copy constructor + CoinDenseFactorization ( const CoinDenseFactorization &other); + + /// Destructor + virtual ~CoinDenseFactorization ( ); + /// = copy + CoinDenseFactorization & operator = ( const CoinDenseFactorization & other ); + /// Clone + virtual CoinOtherFactorization * clone() const ; + //@} + + /**@name Do factorization - public */ + //@{ + /// Gets space for a factorization + virtual void getAreas ( int numberRows, + int numberColumns, + CoinBigIndex maximumL, + CoinBigIndex maximumU ); + + /// PreProcesses column ordered copy of basis + virtual void preProcess ( ); + /** Does most of factorization returning status + 0 - OK + -99 - needs more memory + -1 - singular - use numberGoodColumns and redo + */ + virtual int factor ( ); + /// Does post processing on valid factorization - putting variables on correct rows + virtual void postProcess(const int * sequence, int * pivotVariable); + /// Makes a non-singular basis by replacing variables + virtual void makeNonSingular(int * sequence, int numberColumns); + //@} + + /**@name general stuff such as number of elements */ + //@{ + /// Total number of elements in factorization + virtual inline int numberElements ( ) const { + return numberRows_*(numberColumns_+numberPivots_); + } + /// Returns maximum absolute value in factorization + double maximumCoefficient() const; + //@} + + /**@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 */ + virtual int replaceColumn ( CoinIndexedVector * regionSparse, + 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 regionSparse2 + Tries to do FT update + number returned is negative if no room + regionSparse starts as zero and is zero at end. + Note - if regionSparse2 packed on input - will be packed on output + */ + virtual inline int updateColumnFT ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2, + bool = false) + { return updateColumn(regionSparse,regionSparse2);} + /** This version has same effect as above with FTUpdate==false + so number returned is always >=0 */ + virtual int updateColumn ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2, + bool noPermute=false) const; + /// does FTRAN on two columns + virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1, + CoinIndexedVector * regionSparse2, + CoinIndexedVector * regionSparse3, + bool noPermute=false); + /** Updates one column (BTRAN) from regionSparse2 + regionSparse starts as zero and is zero at end + Note - if regionSparse2 packed on input - will be packed on output + */ + virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2) const; + //@} + /// *** Below this user may not want to know about + + /**@name various uses of factorization + which user may not want to know about (left over from my LP code) */ + //@{ + /// Get rid of all memory + inline void clearArrays() + { gutsOfDestructor();} + /// Returns array to put basis indices in + virtual inline int * indices() const + { return reinterpret_cast<int *> (elements_+numberRows_*numberRows_);} + /// Returns permute in + virtual inline int * permute() const + { return NULL;/*pivotRow_*/;} + //@} + + /// The real work of desstructor + void gutsOfDestructor(); + /// The real work of constructor + void gutsOfInitialize(); + /// The real work of copy + void gutsOfCopy(const CoinDenseFactorization &other); + + //@} +protected: + /** Returns accuracy status of replaceColumn + returns 0=OK, 1=Probably OK, 2=singular */ + int checkPivot(double saveFromU, double oldPivot) const; +////////////////// data ////////////////// +protected: + + /**@name data */ + //@{ + //@} +}; +#endif diff --git a/thirdparty/windows/include/coin/CoinDenseVector.hpp b/thirdparty/windows/include/coin/CoinDenseVector.hpp new file mode 100644 index 0000000..77ff9af --- /dev/null +++ b/thirdparty/windows/include/coin/CoinDenseVector.hpp @@ -0,0 +1,383 @@ +/* $Id: CoinDenseVector.hpp 1372 2011-01-03 23:31:00Z 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 CoinDenseVector_H +#define CoinDenseVector_H + +#if defined(_MSC_VER) +// Turn off compiler warning about long names +# pragma warning(disable:4786) +#endif + +#include <cassert> +#include <cstdlib> +#include <cmath> +#include "CoinHelperFunctions.hpp" + +//############################################################################# +/** A function that tests the methods in the CoinDenseVector 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. */ + template <typename T> void + CoinDenseVectorUnitTest(T dummy); + +//############################################################################# +/** Dense Vector + +Stores a dense (or expanded) vector of floating point values. +Type of vector elements is controlled by templating. +(Some working quantities such as accumulated sums +are explicitly declared of type double). This allows the +components of the vector integer, single or double precision. + +Here is a sample usage: +@verbatim + const int ne = 4; + double el[ne] = { 10., 40., 1., 50. } + + // Create vector and set its value + CoinDenseVector<double> r(ne,el); + + // access each element + assert( r.getElements()[0]==10. ); + assert( r.getElements()[1]==40. ); + assert( r.getElements()[2]== 1. ); + assert( r.getElements()[3]==50. ); + + // Test for equality + CoinDenseVector<double> r1; + r1=r; + + // Add dense vectors. + // Similarly for subtraction, multiplication, + // and division. + CoinDenseVector<double> add = r + r1; + assert( add[0] == 10.+10. ); + assert( add[1] == 40.+40. ); + assert( add[2] == 1.+ 1. ); + assert( add[3] == 50.+50. ); + + assert( r.sum() == 10.+40.+1.+50. ); +@endverbatim +*/ +template <typename T> class CoinDenseVector { +private: + /**@name Private member data */ + //@{ + /// Size of element vector + int nElements_; + ///Vector elements + T * elements_; + //@} + +public: + /**@name Get methods. */ + //@{ + /// Get the size + inline int getNumElements() const { return nElements_; } + inline int size() const { return nElements_; } + /// Get element values + inline const T * getElements() const { return elements_; } + /// Get element values + inline T * getElements() { return elements_; } + //@} + + //------------------------------------------------------------------- + // Set indices and elements + //------------------------------------------------------------------- + /**@name Set methods */ + //@{ + /// Reset the vector (i.e. set all elemenets to zero) + void clear(); + /** Assignment operator */ + CoinDenseVector & operator=(const CoinDenseVector &); + /** Member of array operator */ + T & operator[](int index) const; + + /** Set vector size, and elements. + Size is the length of the elements vector. + The element vector is copied into this class instance's + member data. */ + void setVector(int size, const T * elems); + + + /** Elements set to have the same scalar value */ + void setConstant(int size, T elems); + + + /** Set an existing element in the dense vector + The first argument is the "index" into the elements() array + */ + void setElement(int index, T element); + /** Resize the dense vector to be the first newSize elements. + If length is decreased, vector is truncated. If increased + new entries, set to new default element */ + void resize(int newSize, T fill=T()); + + /** Append a dense vector to this dense vector */ + void append(const CoinDenseVector &); + //@} + + /**@name norms, sum and scale */ + //@{ + /// 1-norm of vector + inline T oneNorm() const { + T norm = 0; + for (int i=0; i<nElements_; i++) + norm += CoinAbs(elements_[i]); + return norm; + } + /// 2-norm of vector + inline double twoNorm() const { + double norm = 0.; + for (int i=0; i<nElements_; i++) + norm += elements_[i] * elements_[i]; + // std namespace removed because it was causing a compile + // problem with Microsoft Visual C++ + return /*std::*/sqrt(norm); + } + /// infinity-norm of vector + inline T infNorm() const { + T norm = 0; + for (int i=0; i<nElements_; i++) + norm = CoinMax(norm, CoinAbs(elements_[i])); + return norm; + } + /// sum of vector elements + inline T sum() const { + T sume = 0; + for (int i=0; i<nElements_; i++) + sume += elements_[i]; + return sume; + } + /// scale vector elements + inline void scale(T factor) { + for (int i=0; i<nElements_; i++) + elements_[i] *= factor; + return; + } + //@} + + /**@name Arithmetic operators. */ + //@{ + /// add <code>value</code> to every entry + void operator+=(T value); + /// subtract <code>value</code> from every entry + void operator-=(T value); + /// multiply every entry by <code>value</code> + void operator*=(T value); + /// divide every entry by <code>value</code> + void operator/=(T value); + //@} + + /**@name Constructors and destructors */ + //@{ + /** Default constructor */ + CoinDenseVector(); + /** Alternate Constructors - set elements to vector of Ts */ + CoinDenseVector(int size, const T * elems); + /** Alternate Constructors - set elements to same scalar value */ + CoinDenseVector(int size, T element=T()); + /** Copy constructors */ + CoinDenseVector(const CoinDenseVector &); + + /** Destructor */ + ~CoinDenseVector (); + //@} + +private: + /**@name Private methods */ + //@{ + /// Copy internal data + void gutsOfSetVector(int size, const T * elems); + /// Set all elements to a given value + void gutsOfSetConstant(int size, T value); + //@} +}; + +//############################################################################# + +/**@name Arithmetic operators on dense vectors. + + <strong>NOTE</strong>: Because these methods return an object (they can't + return a reference, though they could return a pointer...) they are + <em>very</em> inefficient... + */ +//@{ +/// Return the sum of two dense vectors +template <typename T> inline +CoinDenseVector<T> operator+(const CoinDenseVector<T>& op1, + const CoinDenseVector<T>& op2){ + assert(op1.size() == op2.size()); + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + const T *elements2 = op2.getElements(); + T *elements3 = op3.getElements(); + for(int i=0; i<size; i++) + elements3[i] = elements1[i] + elements2[i]; + return op3; +} + +/// Return the difference of two dense vectors +template <typename T> inline +CoinDenseVector<T> operator-(const CoinDenseVector<T>& op1, + const CoinDenseVector<T>& op2){ + assert(op1.size() == op2.size()); + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + const T *elements2 = op2.getElements(); + T *elements3 = op3.getElements(); + for(int i=0; i<size; i++) + elements3[i] = elements1[i] - elements2[i]; + return op3; +} + + +/// Return the element-wise product of two dense vectors +template <typename T> inline +CoinDenseVector<T> operator*(const CoinDenseVector<T>& op1, + const CoinDenseVector<T>& op2){ + assert(op1.size() == op2.size()); + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + const T *elements2 = op2.getElements(); + T *elements3 = op3.getElements(); + for(int i=0; i<size; i++) + elements3[i] = elements1[i] * elements2[i]; + return op3; +} + +/// Return the element-wise ratio of two dense vectors +template <typename T> inline +CoinDenseVector<T> operator/(const CoinDenseVector<T>& op1, + const CoinDenseVector<T>& op2){ + assert(op1.size() == op2.size()); + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + const T *elements2 = op2.getElements(); + T *elements3 = op3.getElements(); + for(int i=0; i<size; i++) + elements3[i] = elements1[i] / elements2[i]; + return op3; +} +//@} + +/**@name Arithmetic operators on dense vector and a constant. + These functions create a dense vector as a result. That dense vector will + have the same indices as <code>op1</code> and the specified operation is + done entry-wise with the given value. */ +//@{ +/// Return the sum of a dense vector and a constant +template <typename T> inline +CoinDenseVector<T> operator+(const CoinDenseVector<T>& op1, T value){ + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + T *elements3 = op3.getElements(); + double dvalue = value; + for(int i=0; i<size; i++) + elements3[i] = elements1[i] + dvalue; + return op3; +} + +/// Return the difference of a dense vector and a constant +template <typename T> inline +CoinDenseVector<T> operator-(const CoinDenseVector<T>& op1, T value){ + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + T *elements3 = op3.getElements(); + double dvalue = value; + for(int i=0; i<size; i++) + elements3[i] = elements1[i] - dvalue; + return op3; +} + +/// Return the element-wise product of a dense vector and a constant +template <typename T> inline +CoinDenseVector<T> operator*(const CoinDenseVector<T>& op1, T value){ + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + T *elements3 = op3.getElements(); + double dvalue = value; + for(int i=0; i<size; i++) + elements3[i] = elements1[i] * dvalue; + return op3; +} + +/// Return the element-wise ratio of a dense vector and a constant +template <typename T> inline +CoinDenseVector<T> operator/(const CoinDenseVector<T>& op1, T value){ + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + T *elements3 = op3.getElements(); + double dvalue = value; + for(int i=0; i<size; i++) + elements3[i] = elements1[i] / dvalue; + return op3; +} + +/// Return the sum of a constant and a dense vector +template <typename T> inline +CoinDenseVector<T> operator+(T value, const CoinDenseVector<T>& op1){ + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + T *elements3 = op3.getElements(); + double dvalue = value; + for(int i=0; i<size; i++) + elements3[i] = elements1[i] + dvalue; + return op3; +} + +/// Return the difference of a constant and a dense vector +template <typename T> inline +CoinDenseVector<T> operator-(T value, const CoinDenseVector<T>& op1){ + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + T *elements3 = op3.getElements(); + double dvalue = value; + for(int i=0; i<size; i++) + elements3[i] = dvalue - elements1[i]; + return op3; +} + +/// Return the element-wise product of a constant and a dense vector +template <typename T> inline +CoinDenseVector<T> operator*(T value, const CoinDenseVector<T>& op1){ + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + T *elements3 = op3.getElements(); + double dvalue = value; + for(int i=0; i<size; i++) + elements3[i] = elements1[i] * dvalue; + return op3; +} + +/// Return the element-wise ratio of a a constant and dense vector +template <typename T> inline +CoinDenseVector<T> operator/(T value, const CoinDenseVector<T>& op1){ + int size = op1.size(); + CoinDenseVector<T> op3(size); + const T *elements1 = op1.getElements(); + T *elements3 = op3.getElements(); + double dvalue = value; + for(int i=0; i<size; i++) + elements3[i] = dvalue / elements1[i]; + return op3; +} +//@} + +#endif diff --git a/thirdparty/windows/include/coin/CoinDistance.hpp b/thirdparty/windows/include/coin/CoinDistance.hpp new file mode 100644 index 0000000..acaa908 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinDistance.hpp @@ -0,0 +1,48 @@ +/* $Id: CoinDistance.hpp 1372 2011-01-03 23:31:00Z lou $ */ +// 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 CoinDistance_H +#define CoinDistance_H + +#include <iterator> + +//------------------------------------------------------------------- +// +// Attempt to provide an std::distance function +// that will work on multiple platforms +// +//------------------------------------------------------------------- + +/** CoinDistance + +This is the Coin implementation of the std::function that is +designed to work on multiple platforms. +*/ +template <class ForwardIterator, class Distance> +void coinDistance(ForwardIterator first, ForwardIterator last, + Distance& n) +{ +#if defined(__SUNPRO_CC) + n = 0; + std::distance(first,last,n); +#else + n = std::distance(first,last); +#endif +} + +template <class ForwardIterator> +size_t coinDistance(ForwardIterator first, ForwardIterator last) +{ + size_t retVal; +#if defined(__SUNPRO_CC) + retVal = 0; + std::distance(first,last,retVal); +#else + retVal = std::distance(first,last); +#endif + return retVal; +} + +#endif diff --git a/thirdparty/windows/include/coin/CoinError.hpp b/thirdparty/windows/include/coin/CoinError.hpp new file mode 100644 index 0000000..704cfea --- /dev/null +++ b/thirdparty/windows/include/coin/CoinError.hpp @@ -0,0 +1,257 @@ +/* $Id: CoinError.hpp 1372 2011-01-03 23:31:00Z lou $ */ +// 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 CoinError_H +#define CoinError_H + +#include <string> +#include <iostream> +#include <cassert> +#include <cstring> + +#include "CoinUtilsConfig.h" +#include "CoinPragma.hpp" + +/** A function to block the popup windows that windows creates when the code + crashes */ +void WindowsErrorPopupBlocker(); + +//------------------------------------------------------------------- +// +// Error class used to throw exceptions +// +// Errors contain: +// +//------------------------------------------------------------------- + +/** Error Class thrown by an exception + +This class is used when exceptions are thrown. +It contains: + <ul> + <li>message text + <li>name of method throwing exception + <li>name of class throwing exception or hint + <li>name of file if assert + <li>line number + </ul> + For asserts class=> optional hint +*/ +class CoinError { + friend void CoinErrorUnitTest(); + +private: + CoinError() + : + message_(), + method_(), + class_(), + file_(), + lineNumber_() + { + // nothing to do here + } + +public: + + //------------------------------------------------------------------- + // Get methods + //------------------------------------------------------------------- + /**@name Get error attributes */ + //@{ + /// get message text + inline const std::string & message() const + { return message_; } + /// get name of method instantiating error + inline const std::string & methodName() const + { return method_; } + /// get name of class instantiating error (or hint for assert) + inline const std::string & className() const + { return class_; } + /// get name of file for assert + inline const std::string & fileName() const + { return file_; } + /// get line number of assert (-1 if not assert) + inline int lineNumber() const + { return lineNumber_; } + /// Just print (for asserts) + inline void print(bool doPrint = true) const + { + if (! doPrint) + return; + if (lineNumber_<0) { + std::cout<<message_<<" in "<<class_<<"::"<<method_<<std::endl; + } else { + std::cout<<file_<<":"<<lineNumber_<<" method "<<method_ + <<" : assertion \'"<<message_<<"\' failed."<<std::endl; + if(class_!="") + std::cout<<"Possible reason: "<<class_<<std::endl; + } + } + //@} + + + /**@name Constructors and destructors */ + //@{ + /// Alternate Constructor + CoinError ( + std::string message__, + std::string methodName__, + std::string className__, + std::string fileName_ = std::string(), + int line = -1) + : + message_(message__), + method_(methodName__), + class_(className__), + file_(fileName_), + lineNumber_(line) + { + print(printErrors_); + } + + /// Copy constructor + CoinError (const CoinError & source) + : + message_(source.message_), + method_(source.method_), + class_(source.class_), + file_(source.file_), + lineNumber_(source.lineNumber_) + { + // nothing to do here + } + + /// Assignment operator + CoinError & operator=(const CoinError& rhs) + { + if (this != &rhs) { + message_=rhs.message_; + method_=rhs.method_; + class_=rhs.class_; + file_=rhs.file_; + lineNumber_ = rhs.lineNumber_; + } + return *this; + } + + /// Destructor + virtual ~CoinError () + { + // nothing to do here + } + //@} + +private: + + /**@name Private member data */ + //@{ + /// message test + std::string message_; + /// method name + std::string method_; + /// class name or hint + std::string class_; + /// file name + std::string file_; + /// Line number + int lineNumber_; + //@} + +public: + /// Whether to print every error + static bool printErrors_; +}; + +#ifndef __STRING +#define __STRING(x) #x +#endif + +#ifndef __GNUC_PREREQ +# define __GNUC_PREREQ(maj, min) (0) +#endif + +#ifndef COIN_ASSERT +# define CoinAssertDebug(expression) assert(expression) +# define CoinAssertDebugHint(expression,hint) assert(expression) +# define CoinAssert(expression) assert(expression) +# define CoinAssertHint(expression,hint) assert(expression) +#else +# ifdef NDEBUG +# define CoinAssertDebug(expression) {} +# define CoinAssertDebugHint(expression,hint) {} +# else +# if defined(__GNUC__) && __GNUC_PREREQ(2, 6) +# define CoinAssertDebug(expression) { \ + if (!(expression)) { \ + throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \ + "", __FILE__, __LINE__); \ + } \ + } +# define CoinAssertDebugHint(expression,hint) { \ + if (!(expression)) { \ + throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \ + hint, __FILE__,__LINE__); \ + } \ + } +# else +# define CoinAssertDebug(expression) { \ + if (!(expression)) { \ + throw CoinError(__STRING(expression), "", \ + "", __FILE__,__LINE__); \ + } \ + } +# define CoinAssertDebugHint(expression,hint) { \ + if (!(expression)) { \ + throw CoinError(__STRING(expression), "", \ + hint, __FILE__,__LINE__); \ + } \ + } +# endif +# endif +# if defined(__GNUC__) && __GNUC_PREREQ(2, 6) +# define CoinAssert(expression) { \ + if (!(expression)) { \ + throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \ + "", __FILE__, __LINE__); \ + } \ + } +# define CoinAssertHint(expression,hint) { \ + if (!(expression)) { \ + throw CoinError(__STRING(expression), __PRETTY_FUNCTION__, \ + hint, __FILE__,__LINE__); \ + } \ + } +# else +# define CoinAssert(expression) { \ + if (!(expression)) { \ + throw CoinError(__STRING(expression), "", \ + "", __FILE__,__LINE__); \ + } \ + } +# define CoinAssertHint(expression,hint) { \ + if (!(expression)) { \ + throw CoinError(__STRING(expression), "", \ + hint, __FILE__,__LINE__); \ + } \ + } +# endif +#endif + + +//############################################################################# +/** A function that tests the methods in the CoinError 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 +CoinErrorUnitTest(); + +#ifdef __LINE__ +#define CoinErrorFL(x, y, z) CoinError((x), (y), (z), __FILE__, __LINE__) +#endif + +#endif diff --git a/thirdparty/windows/include/coin/CoinFactorization.hpp b/thirdparty/windows/include/coin/CoinFactorization.hpp new file mode 100644 index 0000000..0a532bf --- /dev/null +++ b/thirdparty/windows/include/coin/CoinFactorization.hpp @@ -0,0 +1,2044 @@ +/* $Id: CoinFactorization.hpp 1767 2015-01-05 12:36:13Z 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). + +/* + Authors + + John Forrest + + */ +#ifndef CoinFactorization_H +#define CoinFactorization_H +//#define COIN_ONE_ETA_COPY 100 + +#include <iostream> +#include <string> +#include <cassert> +#include <cstdio> +#include <cmath> +#include "CoinTypes.hpp" +#include "CoinIndexedVector.hpp" + +class CoinPackedMatrix; +/** This deals with Factorization and Updates + + This class started with a parallel simplex code I was writing in the + mid 90's. The need for parallelism led to many complications and + I have simplified as much as I could to get back to this. + + I was aiming at problems where I might get speed-up so I was looking at dense + problems or ones with structure. This led to permuting input and output + vectors and to increasing the number of rows each rank-one update. This is + still in as a minor overhead. + + I have also put in handling for hyper-sparsity. I have taken out + all outer loop unrolling, dense matrix handling and most of the + book-keeping for slacks. Also I always use FTRAN approach to updating + even if factorization fairly dense. All these could improve performance. + + I blame some of the coding peculiarities on the history of the code + but mostly it is just because I can't do elegant code (or useful + comments). + + I am assuming that 32 bits is enough for number of rows or columns, but CoinBigIndex + may be redefined to get 64 bits. + */ + + +class CoinFactorization { + friend void CoinFactorizationUnitTest( const std::string & mpsDir ); + +public: + + /**@name Constructors and destructor and copy */ + //@{ + /// Default constructor + CoinFactorization ( ); + /// Copy constructor + CoinFactorization ( const CoinFactorization &other); + + /// Destructor + ~CoinFactorization ( ); + /// Delete all stuff (leaves as after CoinFactorization()) + void almostDestructor(); + /// Debug show object (shows one representation) + void show_self ( ) const; + /// Debug - save on file - 0 if no error + int saveFactorization (const char * file ) const; + /** Debug - restore from file - 0 if no error on file. + If factor true then factorizes as if called from ClpFactorization + */ + int restoreFactorization (const char * file , bool factor=false) ; + /// Debug - sort so can compare + void sort ( ) const; + /// = copy + CoinFactorization & operator = ( const CoinFactorization & other ); + //@} + + /**@name Do 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 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 ( const CoinPackedMatrix & matrix, + int rowIsBasic[], int columnIsBasic[] , + double areaFactor = 0.0 ); + /** When given as triplets. + Actually does factorization. maximumL is guessed maximum size of L part of + final factorization, maximumU of U part. These are multiplied by + areaFactor which can be computed by user or internally. + Arrays are copied in. I could add flag to delete arrays to save a + bit of memory. + If status okay, permutation has pivot rows - this is only needed + If status is singular, then basic variables have pivot row + and ones thrown out have -1 + returns 0 -okay, -1 singular, -99 memory */ + int factorize ( int numberRows, + int numberColumns, + CoinBigIndex numberElements, + CoinBigIndex maximumL, + CoinBigIndex maximumU, + const int indicesRow[], + const int indicesColumn[], const double elements[] , + int permutation[], + double areaFactor = 0.0); + /** Two part version for maximum flexibility + This part creates arrays for user to fill. + estimateNumberElements is safe estimate of number + returns 0 -okay, -99 memory */ + int factorizePart1 ( int numberRows, + int numberColumns, + CoinBigIndex estimateNumberElements, + int * indicesRow[], + int * indicesColumn[], + CoinFactorizationDouble * elements[], + double areaFactor = 0.0); + /** This is part two of factorization + Arrays belong to factorization and were returned by part 1 + If status okay, permutation has pivot rows - this is only needed + If status is singular, then basic variables have pivot row + and ones thrown out have -1 + returns 0 -okay, -1 singular, -99 memory */ + int factorizePart2 (int permutation[],int exactNumberElements); + /// Condition number - product of pivots after factorization + double conditionNumber() const; + + //@} + + /**@name general stuff such as permutation or status */ + //@{ + /// Returns status + inline int status ( ) const { + return status_; + } + /// Sets status + inline void setStatus ( int value) + { status_=value; } + /// Returns number of pivots since factorization + inline int pivots ( ) const { + return numberPivots_; + } + /// Sets number of pivots since factorization + inline void setPivots ( int value ) + { numberPivots_=value; } + /// Returns address of permute region + inline int *permute ( ) const { + return permute_.array(); + } + /// Returns address of pivotColumn region (also used for permuting) + inline int *pivotColumn ( ) const { + return pivotColumn_.array(); + } + /// Returns address of pivot region + inline CoinFactorizationDouble *pivotRegion ( ) const { + return pivotRegion_.array(); + } + /// Returns address of permuteBack region + inline int *permuteBack ( ) const { + return permuteBack_.array(); + } + /// Returns address of lastRow region + inline int *lastRow ( ) const { + return lastRow_.array(); + } + /** Returns address of pivotColumnBack region (also used for permuting) + Now uses firstCount to save memory allocation */ + inline int *pivotColumnBack ( ) const { + //return firstCount_.array(); + return pivotColumnBack_.array(); + } + /// Start of each row in L + inline CoinBigIndex * startRowL() const + { return startRowL_.array();} + + /// Start of each column in L + inline CoinBigIndex * startColumnL() const + { return startColumnL_.array();} + + /// Index of column in row for L + inline int * indexColumnL() const + { return indexColumnL_.array();} + + /// Row indices of L + inline int * indexRowL() const + { return indexRowL_.array();} + + /// Elements in L (row copy) + inline CoinFactorizationDouble * elementByRowL() const + { return elementByRowL_.array();} + + /// Number of Rows after iterating + inline int numberRowsExtra ( ) const { + return numberRowsExtra_; + } + /// Set number of Rows after factorization + inline void setNumberRows(int value) + { numberRows_ = value; } + /// Number of Rows after factorization + inline int numberRows ( ) const { + return numberRows_; + } + /// Number in L + inline CoinBigIndex numberL() const + { return numberL_;} + + /// Base of L + inline CoinBigIndex baseL() const + { return baseL_;} + /// Maximum of Rows after iterating + inline int maximumRowsExtra ( ) const { + return maximumRowsExtra_; + } + /// Total number of columns in factorization + inline int numberColumns ( ) const { + return numberColumns_; + } + /// Total number of elements in factorization + inline int numberElements ( ) const { + return totalElements_; + } + /// Length of FT vector + inline int numberForrestTomlin ( ) const { + return numberInColumn_.array()[numberColumnsExtra_]; + } + /// Number of good columns in factorization + inline int numberGoodColumns ( ) const { + return numberGoodU_; + } + /// Whether larger areas needed + inline double areaFactor ( ) const { + return areaFactor_; + } + inline void areaFactor ( double value ) { + areaFactor_=value; + } + /// Returns areaFactor but adjusted for dense + double adjustedAreaFactor() const; + /// Allows change of pivot accuracy check 1.0 == none >1.0 relaxed + inline void relaxAccuracyCheck(double value) + { relaxCheck_ = value;} + inline double getAccuracyCheck() const + { return relaxCheck_;} + /// Level of detail of messages + inline int messageLevel ( ) const { + return messageLevel_ ; + } + void messageLevel ( int value ); + /// Maximum number of pivots between factorizations + inline int maximumPivots ( ) const { + return maximumPivots_ ; + } + void maximumPivots ( int value ); + + /// Gets dense threshold + inline int denseThreshold() const + { return denseThreshold_;} + /// Sets dense threshold + inline void setDenseThreshold(int value) + { denseThreshold_ = value;} + /// Pivot tolerance + inline double pivotTolerance ( ) const { + return pivotTolerance_ ; + } + void pivotTolerance ( double value ); + /// Zero tolerance + inline double zeroTolerance ( ) const { + return zeroTolerance_ ; + } + void zeroTolerance ( double value ); +#ifndef COIN_FAST_CODE + /// Whether slack value is +1 or -1 + inline double slackValue ( ) const { + return slackValue_ ; + } + void slackValue ( double value ); +#endif + /// Returns maximum absolute value in factorization + double maximumCoefficient() const; + /// true if Forrest Tomlin update, false if PFI + inline bool forrestTomlin() const + { return doForrestTomlin_;} + inline void setForrestTomlin(bool value) + { doForrestTomlin_=value;} + /// True if FT update and space + inline bool spaceForForrestTomlin() const + { + CoinBigIndex start = startColumnU_.array()[maximumColumnsExtra_]; + CoinBigIndex space = lengthAreaU_ - ( start + numberRowsExtra_ ); + return (space>=0)&&doForrestTomlin_; + } + //@} + + /**@name some simple stuff */ + //@{ + + /// Returns number of dense rows + inline int numberDense() const + { return numberDense_;} + + /// Returns number in U area + inline CoinBigIndex numberElementsU ( ) const { + return lengthU_; + } + /// Setss number in U area + inline void setNumberElementsU(CoinBigIndex value) + { lengthU_ = value; } + /// Returns length of U area + inline CoinBigIndex lengthAreaU ( ) const { + return lengthAreaU_; + } + /// Returns number in L area + inline CoinBigIndex numberElementsL ( ) const { + return lengthL_; + } + /// Returns length of L area + inline CoinBigIndex lengthAreaL ( ) const { + return lengthAreaL_; + } + /// Returns number in R area + inline CoinBigIndex numberElementsR ( ) const { + return lengthR_; + } + /// Number of compressions done + inline CoinBigIndex numberCompressions() const + { return numberCompressions_;} + /// Number of entries in each row + inline int * numberInRow() const + { return numberInRow_.array();} + /// Number of entries in each column + inline int * numberInColumn() const + { return numberInColumn_.array();} + /// Elements of U + inline CoinFactorizationDouble * elementU() const + { return elementU_.array();} + /// Row indices of U + inline int * indexRowU() const + { return indexRowU_.array();} + /// Start of each column in U + inline CoinBigIndex * startColumnU() const + { return startColumnU_.array();} + /// Maximum number of Columns after iterating + inline int maximumColumnsExtra() + { return maximumColumnsExtra_;} + /** L to U bias + 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias + */ + inline int biasLU() const + { return biasLU_;} + inline void setBiasLU(int value) + { biasLU_=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 + { return persistenceFlag_;} + void setPersistenceFlag(int value); + //@} + + /**@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 ( CoinIndexedVector * regionSparse, + int pivotRow, + double pivotCheck , + bool checkBeforeModifying=false, + double acceptablePivot=1.0e-8); + /** Combines BtranU and delete elements + If deleted is NULL then delete elements + otherwise store where elements are + */ + void replaceColumnU ( CoinIndexedVector * regionSparse, + CoinBigIndex * deleted, + int internalPivotRow); +#ifdef ABC_USE_COIN_FACTORIZATION + /** returns empty fake vector carved out of existing + later - maybe use associated arrays */ + CoinIndexedVector * fakeVector(CoinIndexedVector * vector, + int already=0) const; + void deleteFakeVector(CoinIndexedVector * vector, + CoinIndexedVector * fakeVector) const; + /** Checks if can replace one Column to basis, + returns update alpha + Fills in region for use later + partial update already in U */ + double checkReplacePart1 ( CoinIndexedVector * regionSparse, + int pivotRow); + /** Checks if can replace one Column to basis, + returns update alpha + Fills in region for use later + partial update in vector */ + double checkReplacePart1 ( CoinIndexedVector * regionSparse, + CoinIndexedVector * partialUpdate, + int pivotRow); + /** Checks if can replace one Column in basis, + returns 0=OK, 1=Probably OK, 2=singular, 3=no room, 5 max pivots */ + int checkReplacePart2 ( int pivotRow, + double btranAlpha, + double ftranAlpha, + double ftAlpha, + double acceptablePivot = 1.0e-8); + /** Replaces one Column to basis, + partial update already in U */ + void replaceColumnPart3 ( CoinIndexedVector * regionSparse, + int pivotRow, + double alpha ); + /** Replaces one Column to basis, + partial update in vector */ + void replaceColumnPart3 ( CoinIndexedVector * regionSparse, + CoinIndexedVector * partialUpdate, + int pivotRow, + double alpha ); + /** Updates one column (FTRAN) from regionSparse2 + Tries to do FT update + number returned is negative if no room + regionSparse starts as zero and is zero at end. + Note - if regionSparse2 packed on input - will be packed on output + long regions + */ + int updateColumnFT ( CoinIndexedVector & regionSparse); + int updateColumnFTPart1 ( CoinIndexedVector & regionSparse) ; + void updateColumnFTPart2 ( CoinIndexedVector & regionSparse) ; + /** Updates one column (FTRAN) - long region + Tries to do FT update + puts partial update in vector */ + void updateColumnFT ( CoinIndexedVector & regionSparseFT, + CoinIndexedVector & partialUpdate, + int which); + /** Updates one column (FTRAN) long region */ + int updateColumn ( CoinIndexedVector & regionSparse) const; + /** Updates one column (FTRAN) from regionFT + Tries to do FT update + number returned is negative if no room. + Also updates regionOther - long region*/ + int updateTwoColumnsFT ( CoinIndexedVector & regionSparseFT, + CoinIndexedVector & regionSparseOther); + /** Updates one column (BTRAN) - long region*/ + int updateColumnTranspose ( CoinIndexedVector & regionSparse) const; + /** Updates one column (FTRAN) - long region */ + void updateColumnCpu ( CoinIndexedVector & regionSparse,int whichCpu) const; + /** Updates one column (BTRAN) - long region */ + void updateColumnTransposeCpu ( CoinIndexedVector & regionSparse,int whichCpu) const; + /** Updates one full column (FTRAN) - long region */ + void updateFullColumn ( CoinIndexedVector & regionSparse) const; + /** Updates one full column (BTRAN) - long region */ + void updateFullColumnTranspose ( CoinIndexedVector & regionSparse) const; + /** Updates one column for dual steepest edge weights (FTRAN) - long region */ + void updateWeights ( CoinIndexedVector & regionSparse) const; + /// Returns true if wants tableauColumn in replaceColumn + inline bool wantsTableauColumn() const + {return false;} + /// Pivot tolerance + inline double minimumPivotTolerance ( ) const { + return pivotTolerance_ ; + } + inline void minimumPivotTolerance ( double value ) + { pivotTolerance(value);} + /// Says parallel + inline void setParallelMode(int value) + { parallelMode_=value;} + /// Sets solve mode + inline void setSolveMode(int value) + { parallelMode_ &= 3;parallelMode_ |= (value<<2);} + /// Sets solve mode + inline int solveMode() const + { return parallelMode_ >> 2;} + /// Update partial Ftran by R update + void updatePartialUpdate(CoinIndexedVector & partialUpdate); + /// Makes a non-singular basis by replacing variables + void makeNonSingular(int * COIN_RESTRICT sequence); +#endif + //@} + + /**@name various uses of factorization (return code number elements) + which user may want to know about */ + //@{ + /** Updates one column (FTRAN) from regionSparse2 + Tries to do FT update + number returned is negative if no room + regionSparse starts as zero and is zero at end. + Note - if regionSparse2 packed on input - will be packed on output + */ + int updateColumnFT ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2); + /** This version has same effect as above with FTUpdate==false + so number returned is always >=0 */ + 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) ; + /** Updates one column (BTRAN) from regionSparse2 + regionSparse starts as zero and is zero at end + Note - if regionSparse2 packed on input - will be packed on output + */ + int updateColumnTranspose ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2) const; + /** makes a row copy of L for speed and to allow very sparse problems */ + void goSparse(); + /** get sparse threshold */ + inline int sparseThreshold ( ) const + { return sparseThreshold_;} + /** set sparse threshold */ + void sparseThreshold ( int value ); + //@} + /// *** Below this user may not want to know about + + /**@name various uses of factorization (return code number elements) + which user may not want to know about (left over from my LP code) */ + //@{ + /// Get rid of all memory + inline void clearArrays() + { gutsOfDestructor();} + //@} + + /**@name various updates - none of which have been written! */ + //@{ + + /** Adds given elements to Basis and updates factorization, + can increase size of basis. Returns rank */ + int add ( CoinBigIndex numberElements, + int indicesRow[], + int indicesColumn[], double elements[] ); + + /** Adds one Column to basis, + can increase size of basis. Returns rank */ + int addColumn ( CoinBigIndex numberElements, + int indicesRow[], double elements[] ); + + /** Adds one Row to basis, + can increase size of basis. Returns rank */ + int addRow ( CoinBigIndex numberElements, + int indicesColumn[], double elements[] ); + + /// Deletes one Column from basis, returns rank + int deleteColumn ( int Row ); + /// Deletes one Row from basis, returns rank + int deleteRow ( int Row ); + + /** Replaces one Row in basis, + At present assumes just a singleton on row is in basis + returns 0=OK, 1=Probably OK, 2=singular, 3 no space */ + int replaceRow ( int whichRow, int numberElements, + const int indicesColumn[], const double elements[] ); + /// Takes out all entries for given rows + void emptyRows(int numberToEmpty, const int which[]); + //@} + /**@name used by ClpFactorization */ + /// See if worth going sparse + void checkSparse(); + /// For statistics +#if 0 //def CLP_FACTORIZATION_INSTRUMENT + inline bool collectStatistics() const + { return collectStatistics_;} + /// For statistics + inline void setCollectStatistics(bool onOff) const + { collectStatistics_ = onOff;} +#else + inline bool collectStatistics() const + { return true;} + /// For statistics + inline void setCollectStatistics(bool onOff) const + { } +#endif + /// The real work of constructors etc 0 just scalars, 1 bit normal + void gutsOfDestructor(int type=1); + /// 1 bit - tolerances etc, 2 more, 4 dummy arrays + void gutsOfInitialize(int type); + void gutsOfCopy(const CoinFactorization &other); + + /// Reset all sparsity etc statistics + void resetStatistics(); + + + //@} + + /**@name used by factorization */ + /// Gets space for a factorization, called by constructors + void getAreas ( int numberRows, + int numberColumns, + CoinBigIndex maximumL, + CoinBigIndex maximumU ); + + /** PreProcesses raw triplet data. + state is 0 - triplets, 1 - some counts etc , 2 - .. */ + void preProcess ( int state, + int possibleDuplicates = -1 ); + /// Does most of factorization + int factor ( ); +protected: + /** Does sparse phase of factorization + return code is <0 error, 0= finished */ + int factorSparse ( ); + /** Does sparse phase of factorization (for smaller problems) + return code is <0 error, 0= finished */ + int factorSparseSmall ( ); + /** Does sparse phase of factorization (for larger problems) + return code is <0 error, 0= finished */ + int factorSparseLarge ( ); + /** Does dense phase of factorization + return code is <0 error, 0= finished */ + int factorDense ( ); + + /// Pivots when just one other row so faster? + bool pivotOneOtherRow ( int pivotRow, + int pivotColumn ); + /// Does one pivot on Row Singleton in factorization + bool pivotRowSingleton ( int pivotRow, + int pivotColumn ); + /// Does one pivot on Column Singleton in factorization + bool pivotColumnSingleton ( int pivotRow, + int pivotColumn ); + + /** Gets space for one Column with given length, + may have to do compression (returns True if successful), + also moves existing vector, + extraNeeded is over and above present */ + bool getColumnSpace ( int iColumn, + int extraNeeded ); + + /** Reorders U so contiguous and in order (if there is space) + Returns true if it could */ + bool reorderU(); + /** getColumnSpaceIterateR. Gets space for one extra R element in Column + may have to do compression (returns true) + also moves existing vector */ + bool getColumnSpaceIterateR ( int iColumn, double value, + int iRow); + /** getColumnSpaceIterate. Gets space for one extra U element in Column + may have to do compression (returns true) + also moves existing vector. + Returns -1 if no memory or where element was put + Used by replaceRow (turns off R version) */ + CoinBigIndex getColumnSpaceIterate ( int iColumn, double value, + int iRow); + /** Gets space for one Row with given length, + may have to do compression (returns True if successful), + also moves existing vector */ + bool getRowSpace ( int iRow, int extraNeeded ); + + /** Gets space for one Row with given length while iterating, + may have to do compression (returns True if successful), + also moves existing vector */ + bool getRowSpaceIterate ( int iRow, + int extraNeeded ); + /// Checks that row and column copies look OK + void checkConsistency ( ); + /// Adds a link in chain of equal counts + inline void addLink ( int index, int count ) { + int *nextCount = nextCount_.array(); + int *firstCount = firstCount_.array(); + int *lastCount = lastCount_.array(); + int next = firstCount[count]; + lastCount[index] = -2 - count; + if ( next < 0 ) { + //first with that count + firstCount[count] = index; + nextCount[index] = -1; + } else { + firstCount[count] = index; + nextCount[index] = next; + lastCount[next] = index; + }} + /// Deletes a link in chain of equal counts + inline void deleteLink ( int index ) { + int *nextCount = nextCount_.array(); + int *firstCount = firstCount_.array(); + int *lastCount = lastCount_.array(); + int next = nextCount[index]; + int last = lastCount[index]; + if ( last >= 0 ) { + nextCount[last] = next; + } else { + int count = -last - 2; + + firstCount[count] = next; + } + if ( next >= 0 ) { + lastCount[next] = last; + } + nextCount[index] = -2; + lastCount[index] = -2; + return; + } + /// Separate out links with same row/column count + void separateLinks(int count,bool rowsFirst); + /// Cleans up at end of factorization + void cleanup ( ); + + /// Updates part of column (FTRANL) + void updateColumnL ( CoinIndexedVector * region, int * indexIn ) const; + /// Updates part of column (FTRANL) when densish + void updateColumnLDensish ( CoinIndexedVector * region, int * indexIn ) const; + /// Updates part of column (FTRANL) when sparse + void updateColumnLSparse ( CoinIndexedVector * region, int * indexIn ) const; + /// Updates part of column (FTRANL) when sparsish + void updateColumnLSparsish ( CoinIndexedVector * region, int * indexIn ) const; + + /// Updates part of column (FTRANR) without FT update + void updateColumnR ( CoinIndexedVector * region ) const; + /** Updates part of column (FTRANR) with FT update. + Also stores update after L and R */ + void updateColumnRFT ( CoinIndexedVector * region, int * indexIn ); + + /// Updates part of column (FTRANU) + void updateColumnU ( CoinIndexedVector * region, int * indexIn) const; + + /// Updates part of column (FTRANU) when sparse + void updateColumnUSparse ( CoinIndexedVector * regionSparse, + int * indexIn) const; + /// Updates part of column (FTRANU) when sparsish + void updateColumnUSparsish ( CoinIndexedVector * regionSparse, + int * indexIn) const; + /// Updates part of column (FTRANU) + int updateColumnUDensish ( double * COIN_RESTRICT region, + int * COIN_RESTRICT regionIndex) const; + /// Updates part of 2 columns (FTRANU) real work + void updateTwoColumnsUDensish ( + int & numberNonZero1, + double * COIN_RESTRICT region1, + int * COIN_RESTRICT index1, + int & numberNonZero2, + double * COIN_RESTRICT region2, + int * COIN_RESTRICT index2) const; + /// Updates part of column PFI (FTRAN) (after rest) + void updateColumnPFI ( CoinIndexedVector * regionSparse) const; + /// Permutes back at end of updateColumn + void permuteBack ( CoinIndexedVector * regionSparse, + CoinIndexedVector * outVector) const; + + /// Updates part of column transpose PFI (BTRAN) (before rest) + void updateColumnTransposePFI ( CoinIndexedVector * region) const; + /** Updates part of column transpose (BTRANU), + assumes index is sorted i.e. region is correct */ + void updateColumnTransposeU ( CoinIndexedVector * region, + int smallestIndex) const; + /** Updates part of column transpose (BTRANU) when sparsish, + assumes index is sorted i.e. region is correct */ + void updateColumnTransposeUSparsish ( CoinIndexedVector * region, + int smallestIndex) const; + /** Updates part of column transpose (BTRANU) when densish, + assumes index is sorted i.e. region is correct */ + void updateColumnTransposeUDensish ( CoinIndexedVector * region, + int smallestIndex) const; + /** Updates part of column transpose (BTRANU) when sparse, + assumes index is sorted i.e. region is correct */ + void updateColumnTransposeUSparse ( CoinIndexedVector * region) const; + /** Updates part of column transpose (BTRANU) by column + assumes index is sorted i.e. region is correct */ + void updateColumnTransposeUByColumn ( CoinIndexedVector * region, + int smallestIndex) const; + + /// Updates part of column transpose (BTRANR) + void updateColumnTransposeR ( CoinIndexedVector * region ) const; + /// Updates part of column transpose (BTRANR) when dense + void updateColumnTransposeRDensish ( CoinIndexedVector * region ) const; + /// Updates part of column transpose (BTRANR) when sparse + void updateColumnTransposeRSparse ( CoinIndexedVector * region ) const; + + /// Updates part of column transpose (BTRANL) + void updateColumnTransposeL ( CoinIndexedVector * region ) const; + /// Updates part of column transpose (BTRANL) when densish by column + void updateColumnTransposeLDensish ( CoinIndexedVector * region ) const; + /// Updates part of column transpose (BTRANL) when densish by row + void updateColumnTransposeLByRow ( CoinIndexedVector * region ) const; + /// Updates part of column transpose (BTRANL) when sparsish by row + void updateColumnTransposeLSparsish ( CoinIndexedVector * region ) const; + /// Updates part of column transpose (BTRANL) when sparse (by Row) + void updateColumnTransposeLSparse ( CoinIndexedVector * region ) const; +public: + /** Replaces one Column to basis for PFI + returns 0=OK, 1=Probably OK, 2=singular, 3=no room. + In this case region is not empty - it is incoming variable (updated) + */ + int replaceColumnPFI ( CoinIndexedVector * regionSparse, + int pivotRow, double alpha); +protected: + /** Returns accuracy status of replaceColumn + returns 0=OK, 1=Probably OK, 2=singular */ + int checkPivot(double saveFromU, double oldPivot) const; + /********************************* START LARGE TEMPLATE ********/ +#ifdef INT_IS_8 +#define COINFACTORIZATION_BITS_PER_INT 64 +#define COINFACTORIZATION_SHIFT_PER_INT 6 +#define COINFACTORIZATION_MASK_PER_INT 0x3f +#else +#define COINFACTORIZATION_BITS_PER_INT 32 +#define COINFACTORIZATION_SHIFT_PER_INT 5 +#define COINFACTORIZATION_MASK_PER_INT 0x1f +#endif + template <class T> inline bool + pivot ( int pivotRow, + int pivotColumn, + CoinBigIndex pivotRowPosition, + CoinBigIndex pivotColumnPosition, + CoinFactorizationDouble work[], + unsigned int workArea2[], + int increment2, + T markRow[] , + int largeInteger) +{ + int *indexColumnU = indexColumnU_.array(); + CoinBigIndex *startColumnU = startColumnU_.array(); + int *numberInColumn = numberInColumn_.array(); + CoinFactorizationDouble *elementU = elementU_.array(); + int *indexRowU = indexRowU_.array(); + CoinBigIndex *startRowU = startRowU_.array(); + int *numberInRow = numberInRow_.array(); + CoinFactorizationDouble *elementL = elementL_.array(); + int *indexRowL = indexRowL_.array(); + int *saveColumn = saveColumn_.array(); + int *nextRow = nextRow_.array(); + int *lastRow = lastRow_.array() ; + + //store pivot columns (so can easily compress) + int numberInPivotRow = numberInRow[pivotRow] - 1; + CoinBigIndex startColumn = startColumnU[pivotColumn]; + int numberInPivotColumn = numberInColumn[pivotColumn] - 1; + CoinBigIndex endColumn = startColumn + numberInPivotColumn + 1; + int put = 0; + CoinBigIndex startRow = startRowU[pivotRow]; + CoinBigIndex endRow = startRow + numberInPivotRow + 1; + + if ( pivotColumnPosition < 0 ) { + for ( pivotColumnPosition = startRow; pivotColumnPosition < endRow; pivotColumnPosition++ ) { + int iColumn = indexColumnU[pivotColumnPosition]; + if ( iColumn != pivotColumn ) { + saveColumn[put++] = iColumn; + } else { + break; + } + } + } else { + for (CoinBigIndex i = startRow ; i < pivotColumnPosition ; i++ ) { + saveColumn[put++] = indexColumnU[i]; + } + } + assert (pivotColumnPosition<endRow); + assert (indexColumnU[pivotColumnPosition]==pivotColumn); + pivotColumnPosition++; + for ( ; pivotColumnPosition < endRow; pivotColumnPosition++ ) { + saveColumn[put++] = indexColumnU[pivotColumnPosition]; + } + //take out this bit of indexColumnU + int next = nextRow[pivotRow]; + int last = lastRow[pivotRow]; + + nextRow[last] = next; + lastRow[next] = last; + nextRow[pivotRow] = numberGoodU_; //use for permute + lastRow[pivotRow] = -2; + numberInRow[pivotRow] = 0; + //store column in L, compress in U and take column out + CoinBigIndex l = lengthL_; + + if ( l + numberInPivotColumn > lengthAreaL_ ) { + //need more memory + if ((messageLevel_&4)!=0) + printf("more memory needed in middle of invert\n"); + return false; + } + //l+=currentAreaL_->elementByColumn-elementL; + CoinBigIndex lSave = l; + + CoinBigIndex * startColumnL = startColumnL_.array(); + startColumnL[numberGoodL_] = l; //for luck and first time + numberGoodL_++; + startColumnL[numberGoodL_] = l + numberInPivotColumn; + lengthL_ += numberInPivotColumn; + if ( pivotRowPosition < 0 ) { + for ( pivotRowPosition = startColumn; pivotRowPosition < endColumn; pivotRowPosition++ ) { + int iRow = indexRowU[pivotRowPosition]; + if ( iRow != pivotRow ) { + indexRowL[l] = iRow; + elementL[l] = elementU[pivotRowPosition]; + markRow[iRow] = static_cast<T>(l - lSave); + l++; + //take out of row list + CoinBigIndex start = startRowU[iRow]; + CoinBigIndex end = start + numberInRow[iRow]; + CoinBigIndex where = start; + + while ( indexColumnU[where] != pivotColumn ) { + where++; + } /* endwhile */ +#if DEBUG_COIN + if ( where >= end ) { + abort ( ); + } +#endif + indexColumnU[where] = indexColumnU[end - 1]; + numberInRow[iRow]--; + } else { + break; + } + } + } else { + CoinBigIndex i; + + for ( i = startColumn; i < pivotRowPosition; i++ ) { + int iRow = indexRowU[i]; + + markRow[iRow] = static_cast<T>(l - lSave); + indexRowL[l] = iRow; + elementL[l] = elementU[i]; + l++; + //take out of row list + CoinBigIndex start = startRowU[iRow]; + CoinBigIndex end = start + numberInRow[iRow]; + CoinBigIndex where = start; + + while ( indexColumnU[where] != pivotColumn ) { + where++; + } /* endwhile */ +#if DEBUG_COIN + if ( where >= end ) { + abort ( ); + } +#endif + indexColumnU[where] = indexColumnU[end - 1]; + numberInRow[iRow]--; + assert (numberInRow[iRow]>=0); + } + } + assert (pivotRowPosition<endColumn); + assert (indexRowU[pivotRowPosition]==pivotRow); + CoinFactorizationDouble pivotElement = elementU[pivotRowPosition]; + CoinFactorizationDouble pivotMultiplier = 1.0 / pivotElement; + + pivotRegion_.array()[numberGoodU_] = pivotMultiplier; + pivotRowPosition++; + for ( ; pivotRowPosition < endColumn; pivotRowPosition++ ) { + int iRow = indexRowU[pivotRowPosition]; + + markRow[iRow] = static_cast<T>(l - lSave); + indexRowL[l] = iRow; + elementL[l] = elementU[pivotRowPosition]; + l++; + //take out of row list + CoinBigIndex start = startRowU[iRow]; + CoinBigIndex end = start + numberInRow[iRow]; + CoinBigIndex where = start; + + while ( indexColumnU[where] != pivotColumn ) { + where++; + } /* endwhile */ +#if DEBUG_COIN + if ( where >= end ) { + abort ( ); + } +#endif + indexColumnU[where] = indexColumnU[end - 1]; + numberInRow[iRow]--; + assert (numberInRow[iRow]>=0); + } + markRow[pivotRow] = static_cast<T>(largeInteger); + //compress pivot column (move pivot to front including saved) + numberInColumn[pivotColumn] = 0; + //use end of L for temporary space + int *indexL = &indexRowL[lSave]; + CoinFactorizationDouble *multipliersL = &elementL[lSave]; + + //adjust + int j; + + for ( j = 0; j < numberInPivotColumn; j++ ) { + multipliersL[j] *= pivotMultiplier; + } + //zero out fill + CoinBigIndex iErase; + for ( iErase = 0; iErase < increment2 * numberInPivotRow; + iErase++ ) { + workArea2[iErase] = 0; + } + CoinBigIndex added = numberInPivotRow * numberInPivotColumn; + unsigned int *temp2 = workArea2; + int * nextColumn = nextColumn_.array(); + + //pack down and move to work + int jColumn; + for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) { + int iColumn = saveColumn[jColumn]; + CoinBigIndex startColumn = startColumnU[iColumn]; + CoinBigIndex endColumn = startColumn + numberInColumn[iColumn]; + int iRow = indexRowU[startColumn]; + CoinFactorizationDouble value = elementU[startColumn]; + double largest; + CoinBigIndex put = startColumn; + CoinBigIndex positionLargest = -1; + CoinFactorizationDouble thisPivotValue = 0.0; + + //compress column and find largest not updated + bool checkLargest; + int mark = markRow[iRow]; + + if ( mark == largeInteger+1 ) { + largest = fabs ( value ); + positionLargest = put; + put++; + checkLargest = false; + } else { + //need to find largest + largest = 0.0; + checkLargest = true; + if ( mark != largeInteger ) { + //will be updated + work[mark] = value; + int word = mark >> COINFACTORIZATION_SHIFT_PER_INT; + int bit = mark & COINFACTORIZATION_MASK_PER_INT; + + temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts + added--; + } else { + thisPivotValue = value; + } + } + CoinBigIndex i; + for ( i = startColumn + 1; i < endColumn; i++ ) { + iRow = indexRowU[i]; + value = elementU[i]; + int mark = markRow[iRow]; + + if ( mark == largeInteger+1 ) { + //keep + indexRowU[put] = iRow; + elementU[put] = value; + if ( checkLargest ) { + double absValue = fabs ( value ); + + if ( absValue > largest ) { + largest = absValue; + positionLargest = put; + } + } + put++; + } else if ( mark != largeInteger ) { + //will be updated + work[mark] = value; + int word = mark >> COINFACTORIZATION_SHIFT_PER_INT; + int bit = mark & COINFACTORIZATION_MASK_PER_INT; + + temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts + added--; + } else { + thisPivotValue = value; + } + } + //slot in pivot + elementU[put] = elementU[startColumn]; + indexRowU[put] = indexRowU[startColumn]; + if ( positionLargest == startColumn ) { + positionLargest = put; //follow if was largest + } + put++; + elementU[startColumn] = thisPivotValue; + indexRowU[startColumn] = pivotRow; + //clean up counts + startColumn++; + numberInColumn[iColumn] = put - startColumn; + int * numberInColumnPlus = numberInColumnPlus_.array(); + numberInColumnPlus[iColumn]++; + startColumnU[iColumn]++; + //how much space have we got + int next = nextColumn[iColumn]; + CoinBigIndex space; + + space = startColumnU[next] - put - numberInColumnPlus[next]; + //assume no zero elements + if ( numberInPivotColumn > space ) { + //getColumnSpace also moves fixed part + if ( !getColumnSpace ( iColumn, numberInPivotColumn ) ) { + return false; + } + //redo starts + if (positionLargest >= 0) + positionLargest = positionLargest + startColumnU[iColumn] - startColumn; + startColumn = startColumnU[iColumn]; + put = startColumn + numberInColumn[iColumn]; + } + double tolerance = zeroTolerance_; + + int *nextCount = nextCount_.array(); + for ( j = 0; j < numberInPivotColumn; j++ ) { + value = work[j] - thisPivotValue * multipliersL[j]; + double absValue = fabs ( value ); + + if ( absValue > tolerance ) { + work[j] = 0.0; + assert (put<lengthAreaU_); + elementU[put] = value; + indexRowU[put] = indexL[j]; + if ( absValue > largest ) { + largest = absValue; + positionLargest = put; + } + put++; + } else { + work[j] = 0.0; + added--; + int word = j >> COINFACTORIZATION_SHIFT_PER_INT; + int bit = j & COINFACTORIZATION_MASK_PER_INT; + + if ( temp2[word] & ( 1 << bit ) ) { + //take out of row list + iRow = indexL[j]; + CoinBigIndex start = startRowU[iRow]; + CoinBigIndex end = start + numberInRow[iRow]; + CoinBigIndex where = start; + + while ( indexColumnU[where] != iColumn ) { + where++; + } /* endwhile */ +#if DEBUG_COIN + if ( where >= end ) { + abort ( ); + } +#endif + indexColumnU[where] = indexColumnU[end - 1]; + numberInRow[iRow]--; + } else { + //make sure won't be added + int word = j >> COINFACTORIZATION_SHIFT_PER_INT; + int bit = j & COINFACTORIZATION_MASK_PER_INT; + + temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts + } + } + } + numberInColumn[iColumn] = put - startColumn; + //move largest + if ( positionLargest >= 0 ) { + value = elementU[positionLargest]; + iRow = indexRowU[positionLargest]; + elementU[positionLargest] = elementU[startColumn]; + indexRowU[positionLargest] = indexRowU[startColumn]; + elementU[startColumn] = value; + indexRowU[startColumn] = iRow; + } + //linked list for column + if ( nextCount[iColumn + numberRows_] != -2 ) { + //modify linked list + deleteLink ( iColumn + numberRows_ ); + addLink ( iColumn + numberRows_, numberInColumn[iColumn] ); + } + temp2 += increment2; + } + //get space for row list + unsigned int *putBase = workArea2; + int bigLoops = numberInPivotColumn >> COINFACTORIZATION_SHIFT_PER_INT; + int i = 0; + + // do linked lists and update counts + while ( bigLoops ) { + bigLoops--; + int bit; + for ( bit = 0; bit < COINFACTORIZATION_BITS_PER_INT; i++, bit++ ) { + unsigned int *putThis = putBase; + int iRow = indexL[i]; + + //get space + int number = 0; + int jColumn; + + for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) { + unsigned int test = *putThis; + + putThis += increment2; + test = 1 - ( ( test >> bit ) & 1 ); + number += test; + } + int next = nextRow[iRow]; + CoinBigIndex space; + + space = startRowU[next] - startRowU[iRow]; + number += numberInRow[iRow]; + if ( space < number ) { + if ( !getRowSpace ( iRow, number ) ) { + return false; + } + } + // now do + putThis = putBase; + next = nextRow[iRow]; + number = numberInRow[iRow]; + CoinBigIndex end = startRowU[iRow] + number; + int saveIndex = indexColumnU[startRowU[next]]; + + //add in + for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) { + unsigned int test = *putThis; + + putThis += increment2; + test = 1 - ( ( test >> bit ) & 1 ); + indexColumnU[end] = saveColumn[jColumn]; + end += test; + } + //put back next one in case zapped + indexColumnU[startRowU[next]] = saveIndex; + markRow[iRow] = static_cast<T>(largeInteger+1); + number = end - startRowU[iRow]; + numberInRow[iRow] = number; + deleteLink ( iRow ); + addLink ( iRow, number ); + } + putBase++; + } /* endwhile */ + int bit; + + for ( bit = 0; i < numberInPivotColumn; i++, bit++ ) { + unsigned int *putThis = putBase; + int iRow = indexL[i]; + + //get space + int number = 0; + int jColumn; + + for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) { + unsigned int test = *putThis; + + putThis += increment2; + test = 1 - ( ( test >> bit ) & 1 ); + number += test; + } + int next = nextRow[iRow]; + CoinBigIndex space; + + space = startRowU[next] - startRowU[iRow]; + number += numberInRow[iRow]; + if ( space < number ) { + if ( !getRowSpace ( iRow, number ) ) { + return false; + } + } + // now do + putThis = putBase; + next = nextRow[iRow]; + number = numberInRow[iRow]; + CoinBigIndex end = startRowU[iRow] + number; + int saveIndex; + + saveIndex = indexColumnU[startRowU[next]]; + + //add in + for ( jColumn = 0; jColumn < numberInPivotRow; jColumn++ ) { + unsigned int test = *putThis; + + putThis += increment2; + test = 1 - ( ( test >> bit ) & 1 ); + + indexColumnU[end] = saveColumn[jColumn]; + end += test; + } + indexColumnU[startRowU[next]] = saveIndex; + markRow[iRow] = static_cast<T>(largeInteger+1); + number = end - startRowU[iRow]; + numberInRow[iRow] = number; + deleteLink ( iRow ); + addLink ( iRow, number ); + } + markRow[pivotRow] = static_cast<T>(largeInteger+1); + //modify linked list for pivots + deleteLink ( pivotRow ); + deleteLink ( pivotColumn + numberRows_ ); + totalElements_ += added; + return true; +} + + /********************************* END LARGE TEMPLATE ********/ + //@} +////////////////// data ////////////////// +protected: + + /**@name data */ + //@{ + /// Pivot tolerance + double pivotTolerance_; + /// Zero tolerance + double zeroTolerance_; +#ifndef COIN_FAST_CODE + /// Whether slack value is +1 or -1 + double slackValue_; +#else +#ifndef slackValue_ +#define slackValue_ -1.0 +#endif +#endif + /// How much to multiply areas by + double areaFactor_; + /// Relax check on accuracy in replaceColumn + double relaxCheck_; + /// Number of Rows in factorization + int numberRows_; + /// Number of Rows after iterating + int numberRowsExtra_; + /// Maximum number of Rows after iterating + int maximumRowsExtra_; + /// Number of Columns in factorization + int numberColumns_; + /// Number of Columns after iterating + int numberColumnsExtra_; + /// Maximum number of Columns after iterating + int maximumColumnsExtra_; + /// Number factorized in U (not row singletons) + int numberGoodU_; + /// Number factorized in L + int numberGoodL_; + /// Maximum number of pivots before factorization + int maximumPivots_; + /// Number pivots since last factorization + int numberPivots_; + /// Number of elements in U (to go) + /// or while iterating total overall + CoinBigIndex totalElements_; + /// Number of elements after factorization + CoinBigIndex factorElements_; + /// Pivot order for each Column + CoinIntArrayWithLength pivotColumn_; + /// Permutation vector for pivot row order + CoinIntArrayWithLength permute_; + /// DePermutation vector for pivot row order + CoinIntArrayWithLength permuteBack_; + /// Inverse Pivot order for each Column + CoinIntArrayWithLength pivotColumnBack_; + /// Status of factorization + int status_; + + /** 0 - no increasing rows - no permutations, + 1 - no increasing rows but permutations + 2 - increasing rows + - taken out as always 2 */ + //int increasingRows_; + + /// Number of trials before rejection + int numberTrials_; + /// Start of each Row as pointer + CoinBigIndexArrayWithLength startRowU_; + + /// Number in each Row + CoinIntArrayWithLength numberInRow_; + + /// Number in each Column + CoinIntArrayWithLength numberInColumn_; + + /// Number in each Column including pivoted + CoinIntArrayWithLength numberInColumnPlus_; + + /** First Row/Column with count of k, + can tell which by offset - Rows then Columns */ + CoinIntArrayWithLength firstCount_; + + /// Next Row/Column with count + CoinIntArrayWithLength nextCount_; + + /// Previous Row/Column with count + CoinIntArrayWithLength lastCount_; + + /// Next Column in memory order + CoinIntArrayWithLength nextColumn_; + + /// Previous Column in memory order + CoinIntArrayWithLength lastColumn_; + + /// Next Row in memory order + CoinIntArrayWithLength nextRow_; + + /// Previous Row in memory order + CoinIntArrayWithLength lastRow_; + + /// Columns left to do in a single pivot + CoinIntArrayWithLength saveColumn_; + + /// Marks rows to be updated + CoinIntArrayWithLength markRow_; + + /// Detail in messages + int messageLevel_; + + /// Larger of row and column size + int biggerDimension_; + + /// Base address for U (may change) + CoinIntArrayWithLength indexColumnU_; + + /// Pivots for L + CoinIntArrayWithLength pivotRowL_; + + /// Inverses of pivot values + CoinFactorizationDoubleArrayWithLength pivotRegion_; + + /// Number of slacks at beginning of U + int numberSlacks_; + + /// Number in U + int numberU_; + + /// Maximum space used in U + CoinBigIndex maximumU_; + + /// Base of U is always 0 + //int baseU_; + + /// Length of U + CoinBigIndex lengthU_; + + /// Length of area reserved for U + CoinBigIndex lengthAreaU_; + +/// Elements of U + CoinFactorizationDoubleArrayWithLength elementU_; + +/// Row indices of U + CoinIntArrayWithLength indexRowU_; + +/// Start of each column in U + CoinBigIndexArrayWithLength startColumnU_; + +/// Converts rows to columns in U + CoinBigIndexArrayWithLength convertRowToColumnU_; + + /// Number in L + CoinBigIndex numberL_; + +/// Base of L + CoinBigIndex baseL_; + + /// Length of L + CoinBigIndex lengthL_; + + /// Length of area reserved for L + CoinBigIndex lengthAreaL_; + + /// Elements of L + CoinFactorizationDoubleArrayWithLength elementL_; + + /// Row indices of L + CoinIntArrayWithLength indexRowL_; + + /// Start of each column in L + CoinBigIndexArrayWithLength startColumnL_; + + /// true if Forrest Tomlin update, false if PFI + bool doForrestTomlin_; + + /// Number in R + int numberR_; + + /// Length of R stuff + CoinBigIndex lengthR_; + + /// length of area reserved for R + CoinBigIndex lengthAreaR_; + + /// Elements of R + CoinFactorizationDouble *elementR_; + + /// Row indices for R + int *indexRowR_; + + /// Start of columns for R + CoinBigIndexArrayWithLength startColumnR_; + + /// Dense area + double * denseArea_; + + /// Dense area - actually used (for alignment etc) + double * denseAreaAddress_; + + /// Dense permutation + int * densePermute_; + + /// Number of dense rows + int numberDense_; + + /// Dense threshold + int denseThreshold_; + + /// First work area + CoinFactorizationDoubleArrayWithLength workArea_; + + /// Second work area + CoinUnsignedIntArrayWithLength workArea2_; + + /// Number of compressions done + CoinBigIndex numberCompressions_; + +public: + /// Below are all to collect + mutable double ftranCountInput_; + mutable double ftranCountAfterL_; + mutable double ftranCountAfterR_; + mutable double ftranCountAfterU_; + mutable double btranCountInput_; + mutable double btranCountAfterU_; + mutable double btranCountAfterR_; + mutable double btranCountAfterL_; + + /// We can roll over factorizations + mutable int numberFtranCounts_; + mutable int numberBtranCounts_; + + /// While these are average ratios collected over last period + double ftranAverageAfterL_; + double ftranAverageAfterR_; + double ftranAverageAfterU_; + double btranAverageAfterU_; + double btranAverageAfterR_; + double btranAverageAfterL_; +protected: + + /// For statistics +#if 0 + mutable bool collectStatistics_; +#else +#define collectStatistics_ 1 +#endif + + /// Below this use sparse technology - if 0 then no L row copy + int sparseThreshold_; + + /// And one for "sparsish" + int sparseThreshold2_; + + /// Start of each row in L + CoinBigIndexArrayWithLength startRowL_; + + /// Index of column in row for L + CoinIntArrayWithLength indexColumnL_; + + /// Elements in L (row copy) + CoinFactorizationDoubleArrayWithLength elementByRowL_; + + /// Sparse regions + mutable CoinIntArrayWithLength sparse_; + /** L to U bias + 0 - U bias, 1 - some U bias, 2 some L bias, 3 L bias + */ + int biasLU_; + /** 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 + */ + int persistenceFlag_; +#ifdef ABC_USE_COIN_FACTORIZATION + /// Says if parallel + int parallelMode_; +#endif + //@} +}; +// Dense coding +#ifdef COIN_HAS_LAPACK +#ifndef COIN_FACTORIZATION_DENSE_CODE +#define COIN_FACTORIZATION_DENSE_CODE 1 +#endif +#endif +#ifdef COIN_FACTORIZATION_DENSE_CODE +/* Type of Fortran integer translated into C */ +#ifndef ipfint +//typedef ipfint FORTRAN_INTEGER_TYPE ; +typedef int ipfint; +typedef const int cipfint; +#endif +#endif +#endif +// Extra for ugly include +#ifdef UGLY_COIN_FACTOR_CODING +#define FAC_UNSET (FAC_SET+1) +{ + goodPivot=false; + //store pivot columns (so can easily compress) + CoinBigIndex startColumnThis = startColumn[iPivotColumn]; + CoinBigIndex endColumn = startColumnThis + numberDoColumn + 1; + int put = 0; + CoinBigIndex startRowThis = startRow[iPivotRow]; + CoinBigIndex endRow = startRowThis + numberDoRow + 1; + if ( pivotColumnPosition < 0 ) { + for ( pivotColumnPosition = startRowThis; pivotColumnPosition < endRow; pivotColumnPosition++ ) { + int iColumn = indexColumn[pivotColumnPosition]; + if ( iColumn != iPivotColumn ) { + saveColumn[put++] = iColumn; + } else { + break; + } + } + } else { + for (CoinBigIndex i = startRowThis ; i < pivotColumnPosition ; i++ ) { + saveColumn[put++] = indexColumn[i]; + } + } + assert (pivotColumnPosition<endRow); + assert (indexColumn[pivotColumnPosition]==iPivotColumn); + pivotColumnPosition++; + for ( ; pivotColumnPosition < endRow; pivotColumnPosition++ ) { + saveColumn[put++] = indexColumn[pivotColumnPosition]; + } + //take out this bit of indexColumn + int next = nextRow[iPivotRow]; + int last = lastRow[iPivotRow]; + + nextRow[last] = next; + lastRow[next] = last; + nextRow[iPivotRow] = numberGoodU_; //use for permute + lastRow[iPivotRow] = -2; + numberInRow[iPivotRow] = 0; + //store column in L, compress in U and take column out + CoinBigIndex l = lengthL_; + // **** HORRID coding coming up but a goto seems best! + { + if ( l + numberDoColumn > lengthAreaL_ ) { + //need more memory + if ((messageLevel_&4)!=0) + printf("more memory needed in middle of invert\n"); + goto BAD_PIVOT; + } + //l+=currentAreaL_->elementByColumn-elementL; + CoinBigIndex lSave = l; + + CoinBigIndex * startColumnL = startColumnL_.array(); + startColumnL[numberGoodL_] = l; //for luck and first time + numberGoodL_++; + startColumnL[numberGoodL_] = l + numberDoColumn; + lengthL_ += numberDoColumn; + if ( pivotRowPosition < 0 ) { + for ( pivotRowPosition = startColumnThis; pivotRowPosition < endColumn; pivotRowPosition++ ) { + int iRow = indexRow[pivotRowPosition]; + if ( iRow != iPivotRow ) { + indexRowL[l] = iRow; + elementL[l] = element[pivotRowPosition]; + markRow[iRow] = l - lSave; + l++; + //take out of row list + CoinBigIndex start = startRow[iRow]; + CoinBigIndex end = start + numberInRow[iRow]; + CoinBigIndex where = start; + + while ( indexColumn[where] != iPivotColumn ) { + where++; + } /* endwhile */ +#if DEBUG_COIN + if ( where >= end ) { + abort ( ); + } +#endif + indexColumn[where] = indexColumn[end - 1]; + numberInRow[iRow]--; + } else { + break; + } + } + } else { + CoinBigIndex i; + + for ( i = startColumnThis; i < pivotRowPosition; i++ ) { + int iRow = indexRow[i]; + + markRow[iRow] = l - lSave; + indexRowL[l] = iRow; + elementL[l] = element[i]; + l++; + //take out of row list + CoinBigIndex start = startRow[iRow]; + CoinBigIndex end = start + numberInRow[iRow]; + CoinBigIndex where = start; + + while ( indexColumn[where] != iPivotColumn ) { + where++; + } /* endwhile */ +#if DEBUG_COIN + if ( where >= end ) { + abort ( ); + } +#endif + indexColumn[where] = indexColumn[end - 1]; + numberInRow[iRow]--; + assert (numberInRow[iRow]>=0); + } + } + assert (pivotRowPosition<endColumn); + assert (indexRow[pivotRowPosition]==iPivotRow); + CoinFactorizationDouble pivotElement = element[pivotRowPosition]; + CoinFactorizationDouble pivotMultiplier = 1.0 / pivotElement; + + pivotRegion_.array()[numberGoodU_] = pivotMultiplier; + pivotRowPosition++; + for ( ; pivotRowPosition < endColumn; pivotRowPosition++ ) { + int iRow = indexRow[pivotRowPosition]; + + markRow[iRow] = l - lSave; + indexRowL[l] = iRow; + elementL[l] = element[pivotRowPosition]; + l++; + //take out of row list + CoinBigIndex start = startRow[iRow]; + CoinBigIndex end = start + numberInRow[iRow]; + CoinBigIndex where = start; + + while ( indexColumn[where] != iPivotColumn ) { + where++; + } /* endwhile */ +#if DEBUG_COIN + if ( where >= end ) { + abort ( ); + } +#endif + indexColumn[where] = indexColumn[end - 1]; + numberInRow[iRow]--; + assert (numberInRow[iRow]>=0); + } + markRow[iPivotRow] = FAC_SET; + //compress pivot column (move pivot to front including saved) + numberInColumn[iPivotColumn] = 0; + //use end of L for temporary space + int *indexL = &indexRowL[lSave]; + CoinFactorizationDouble *multipliersL = &elementL[lSave]; + + //adjust + int j; + + for ( j = 0; j < numberDoColumn; j++ ) { + multipliersL[j] *= pivotMultiplier; + } + //zero out fill + CoinBigIndex iErase; + for ( iErase = 0; iErase < increment2 * numberDoRow; + iErase++ ) { + workArea2[iErase] = 0; + } + CoinBigIndex added = numberDoRow * numberDoColumn; + unsigned int *temp2 = workArea2; + int * nextColumn = nextColumn_.array(); + + //pack down and move to work + int jColumn; + for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) { + int iColumn = saveColumn[jColumn]; + CoinBigIndex startColumnThis = startColumn[iColumn]; + CoinBigIndex endColumn = startColumnThis + numberInColumn[iColumn]; + int iRow = indexRow[startColumnThis]; + CoinFactorizationDouble value = element[startColumnThis]; + double largest; + CoinBigIndex put = startColumnThis; + CoinBigIndex positionLargest = -1; + CoinFactorizationDouble thisPivotValue = 0.0; + + //compress column and find largest not updated + bool checkLargest; + int mark = markRow[iRow]; + + if ( mark == FAC_UNSET ) { + largest = fabs ( value ); + positionLargest = put; + put++; + checkLargest = false; + } else { + //need to find largest + largest = 0.0; + checkLargest = true; + if ( mark != FAC_SET ) { + //will be updated + workArea[mark] = value; + int word = mark >> COINFACTORIZATION_SHIFT_PER_INT; + int bit = mark & COINFACTORIZATION_MASK_PER_INT; + + temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts + added--; + } else { + thisPivotValue = value; + } + } + CoinBigIndex i; + for ( i = startColumnThis + 1; i < endColumn; i++ ) { + iRow = indexRow[i]; + value = element[i]; + int mark = markRow[iRow]; + + if ( mark == FAC_UNSET ) { + //keep + indexRow[put] = iRow; + element[put] = value; + if ( checkLargest ) { + double absValue = fabs ( value ); + + if ( absValue > largest ) { + largest = absValue; + positionLargest = put; + } + } + put++; + } else if ( mark != FAC_SET ) { + //will be updated + workArea[mark] = value; + int word = mark >> COINFACTORIZATION_SHIFT_PER_INT; + int bit = mark & COINFACTORIZATION_MASK_PER_INT; + + temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts + added--; + } else { + thisPivotValue = value; + } + } + //slot in pivot + element[put] = element[startColumnThis]; + indexRow[put] = indexRow[startColumnThis]; + if ( positionLargest == startColumnThis ) { + positionLargest = put; //follow if was largest + } + put++; + element[startColumnThis] = thisPivotValue; + indexRow[startColumnThis] = iPivotRow; + //clean up counts + startColumnThis++; + numberInColumn[iColumn] = put - startColumnThis; + int * numberInColumnPlus = numberInColumnPlus_.array(); + numberInColumnPlus[iColumn]++; + startColumn[iColumn]++; + //how much space have we got + int next = nextColumn[iColumn]; + CoinBigIndex space; + + space = startColumn[next] - put - numberInColumnPlus[next]; + //assume no zero elements + if ( numberDoColumn > space ) { + //getColumnSpace also moves fixed part + if ( !getColumnSpace ( iColumn, numberDoColumn ) ) { + goto BAD_PIVOT; + } + //redo starts + positionLargest = positionLargest + startColumn[iColumn] - startColumnThis; + startColumnThis = startColumn[iColumn]; + put = startColumnThis + numberInColumn[iColumn]; + } + double tolerance = zeroTolerance_; + + int *nextCount = nextCount_.array(); + for ( j = 0; j < numberDoColumn; j++ ) { + value = workArea[j] - thisPivotValue * multipliersL[j]; + double absValue = fabs ( value ); + + if ( absValue > tolerance ) { + workArea[j] = 0.0; + element[put] = value; + indexRow[put] = indexL[j]; + if ( absValue > largest ) { + largest = absValue; + positionLargest = put; + } + put++; + } else { + workArea[j] = 0.0; + added--; + int word = j >> COINFACTORIZATION_SHIFT_PER_INT; + int bit = j & COINFACTORIZATION_MASK_PER_INT; + + if ( temp2[word] & ( 1 << bit ) ) { + //take out of row list + iRow = indexL[j]; + CoinBigIndex start = startRow[iRow]; + CoinBigIndex end = start + numberInRow[iRow]; + CoinBigIndex where = start; + + while ( indexColumn[where] != iColumn ) { + where++; + } /* endwhile */ +#if DEBUG_COIN + if ( where >= end ) { + abort ( ); + } +#endif + indexColumn[where] = indexColumn[end - 1]; + numberInRow[iRow]--; + } else { + //make sure won't be added + int word = j >> COINFACTORIZATION_SHIFT_PER_INT; + int bit = j & COINFACTORIZATION_MASK_PER_INT; + + temp2[word] = temp2[word] | ( 1 << bit ); //say already in counts + } + } + } + numberInColumn[iColumn] = put - startColumnThis; + //move largest + if ( positionLargest >= 0 ) { + value = element[positionLargest]; + iRow = indexRow[positionLargest]; + element[positionLargest] = element[startColumnThis]; + indexRow[positionLargest] = indexRow[startColumnThis]; + element[startColumnThis] = value; + indexRow[startColumnThis] = iRow; + } + //linked list for column + if ( nextCount[iColumn + numberRows_] != -2 ) { + //modify linked list + deleteLink ( iColumn + numberRows_ ); + addLink ( iColumn + numberRows_, numberInColumn[iColumn] ); + } + temp2 += increment2; + } + //get space for row list + unsigned int *putBase = workArea2; + int bigLoops = numberDoColumn >> COINFACTORIZATION_SHIFT_PER_INT; + int i = 0; + + // do linked lists and update counts + while ( bigLoops ) { + bigLoops--; + int bit; + for ( bit = 0; bit < COINFACTORIZATION_BITS_PER_INT; i++, bit++ ) { + unsigned int *putThis = putBase; + int iRow = indexL[i]; + + //get space + int number = 0; + int jColumn; + + for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) { + unsigned int test = *putThis; + + putThis += increment2; + test = 1 - ( ( test >> bit ) & 1 ); + number += test; + } + int next = nextRow[iRow]; + CoinBigIndex space; + + space = startRow[next] - startRow[iRow]; + number += numberInRow[iRow]; + if ( space < number ) { + if ( !getRowSpace ( iRow, number ) ) { + goto BAD_PIVOT; + } + } + // now do + putThis = putBase; + next = nextRow[iRow]; + number = numberInRow[iRow]; + CoinBigIndex end = startRow[iRow] + number; + int saveIndex = indexColumn[startRow[next]]; + + //add in + for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) { + unsigned int test = *putThis; + + putThis += increment2; + test = 1 - ( ( test >> bit ) & 1 ); + indexColumn[end] = saveColumn[jColumn]; + end += test; + } + //put back next one in case zapped + indexColumn[startRow[next]] = saveIndex; + markRow[iRow] = FAC_UNSET; + number = end - startRow[iRow]; + numberInRow[iRow] = number; + deleteLink ( iRow ); + addLink ( iRow, number ); + } + putBase++; + } /* endwhile */ + int bit; + + for ( bit = 0; i < numberDoColumn; i++, bit++ ) { + unsigned int *putThis = putBase; + int iRow = indexL[i]; + + //get space + int number = 0; + int jColumn; + + for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) { + unsigned int test = *putThis; + + putThis += increment2; + test = 1 - ( ( test >> bit ) & 1 ); + number += test; + } + int next = nextRow[iRow]; + CoinBigIndex space; + + space = startRow[next] - startRow[iRow]; + number += numberInRow[iRow]; + if ( space < number ) { + if ( !getRowSpace ( iRow, number ) ) { + goto BAD_PIVOT; + } + } + // now do + putThis = putBase; + next = nextRow[iRow]; + number = numberInRow[iRow]; + CoinBigIndex end = startRow[iRow] + number; + int saveIndex; + + saveIndex = indexColumn[startRow[next]]; + + //add in + for ( jColumn = 0; jColumn < numberDoRow; jColumn++ ) { + unsigned int test = *putThis; + + putThis += increment2; + test = 1 - ( ( test >> bit ) & 1 ); + + indexColumn[end] = saveColumn[jColumn]; + end += test; + } + indexColumn[startRow[next]] = saveIndex; + markRow[iRow] = FAC_UNSET; + number = end - startRow[iRow]; + numberInRow[iRow] = number; + deleteLink ( iRow ); + addLink ( iRow, number ); + } + markRow[iPivotRow] = FAC_UNSET; + //modify linked list for pivots + deleteLink ( iPivotRow ); + deleteLink ( iPivotColumn + numberRows_ ); + totalElements_ += added; + goodPivot= true; + // **** UGLY UGLY UGLY + } + BAD_PIVOT: + + ; +} +#undef FAC_UNSET +#endif diff --git a/thirdparty/windows/include/coin/CoinFileIO.hpp b/thirdparty/windows/include/coin/CoinFileIO.hpp new file mode 100644 index 0000000..20be1a9 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinFileIO.hpp @@ -0,0 +1,166 @@ +/* $Id: CoinFileIO.hpp 1439 2011-06-13 16:31:21Z stefan $ */ +// Copyright (C) 2005, COIN-OR. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef CoinFileIO_H +#define CoinFileIO_H + +#include <string> + +/// Base class for FileIO classes. +class CoinFileIOBase +{ +public: + /// Constructor. + /// @param fileName The name of the file used by this object. + CoinFileIOBase (const std::string &fileName); + + /// Destructor. + ~CoinFileIOBase (); + + /// Return the name of the file used by this object. + const char *getFileName () const; + + /// Return the method of reading being used + inline std::string getReadType () const + { return readType_.c_str();} +protected: + std::string readType_; +private: + CoinFileIOBase (); + CoinFileIOBase (const CoinFileIOBase &); + + std::string fileName_; +}; + +/// Abstract base class for file input classes. +class CoinFileInput: public CoinFileIOBase +{ +public: + /// indicates whether CoinFileInput supports gzip'ed files + static bool haveGzipSupport(); + /// indicates whether CoinFileInput supports bzip2'ed files + static bool haveBzip2Support(); + + /// Factory method, that creates a CoinFileInput (more precisely + /// a subclass of it) for the file specified. This method reads the + /// first few bytes of the file and determines if this is a compressed + /// or a plain file and returns the correct subclass to handle it. + /// If the file does not exist or uses a compression not compiled in + /// an exception is thrown. + /// @param fileName The file that should be read. + static CoinFileInput *create (const std::string &fileName); + + /// Constructor (don't use this, use the create method instead). + /// @param fileName The name of the file used by this object. + CoinFileInput (const std::string &fileName); + + /// Destructor. + virtual ~CoinFileInput (); + + /// Read a block of data from the file, similar to fread. + /// @param buffer Address of a buffer to store the data into. + /// @param size Number of bytes to read (buffer should be large enough). + /// @return Number of bytes read. + virtual int read (void *buffer, int size) = 0; + + /// Reads up to (size-1) characters an stores them into the buffer, + /// similar to fgets. + /// Reading ends, when EOF or a newline occurs or (size-1) characters have + /// been read. The resulting string is terminated with '\0'. If reading + /// ends due to an encoutered newline, the '\n' is put into the buffer, + /// before the '\0' is appended. + /// @param buffer The buffer to put the string into. + /// @param size The size of the buffer in characters. + /// @return buffer on success, or 0 if no characters have been read. + virtual char *gets (char *buffer, int size) = 0; +}; + +/// Abstract base class for file output classes. +class CoinFileOutput: public CoinFileIOBase +{ +public: + + /// The compression method. + enum Compression { + COMPRESS_NONE = 0, ///< No compression. + COMPRESS_GZIP = 1, ///< gzip compression. + COMPRESS_BZIP2 = 2 ///< bzip2 compression. + }; + + /// Returns whether the specified compression method is supported + /// (i.e. was compiled into COIN). + static bool compressionSupported (Compression compression); + + /// Factory method, that creates a CoinFileOutput (more precisely + /// a subclass of it) for the file specified. If the compression method + /// is not supported an exception is thrown (so use compressionSupported + /// first, if this is a problem). The reason for not providing direct + /// access to the subclasses (and using such a method instead) is that + /// depending on the build configuration some of the classes are not + /// available (or functional). This way we can handle all required ifdefs + /// here instead of polluting other files. + /// @param fileName The file that should be read. + /// @param compression Compression method used. + static CoinFileOutput *create (const std::string &fileName, + Compression compression); + + /// Constructor (don't use this, use the create method instead). + /// @param fileName The name of the file used by this object. + CoinFileOutput (const std::string &fileName); + + /// Destructor. + virtual ~CoinFileOutput (); + + /// Write a block of data to the file, similar to fwrite. + /// @param buffer Address of a buffer containing the data to be written. + /// @param size Number of bytes to write. + /// @return Number of bytes written. + virtual int write (const void * buffer, int size) = 0; + + /// Write a string to the file (like fputs). + /// Just as with fputs no trailing newline is inserted! + /// The terminating '\0' is not written to the file. + /// The default implementation determines the length of the string + /// and calls write on it. + /// @param s The zero terminated string to be written. + /// @return true on success, false on error. + virtual bool puts (const char *s); + + /// Convenience method: just a 'puts(s.c_str())'. + inline bool puts (const std::string &s) + { + return puts (s.c_str ()); + } +}; + +/*! \relates CoinFileInput + \brief Test if the given string looks like an absolute file path + + The criteria are: + - unix: string begins with `/' + - windows: string begins with `\' or with `drv:' (drive specifier) +*/ +bool fileAbsPath (const std::string &path) ; + +/*! \relates CoinFileInput + \brief Test if the file is readable, using likely versions of the file + name, and return the name that worked. + + The file name is constructed from \p name using the following rules: + <ul> + <li> An absolute path is not modified. + <li> If the name begins with `~', an attempt is made to replace `~' + with the value of the environment variable HOME. + <li> If a default prefix (\p dfltPrefix) is provided, it is + prepended to the name. + </ul> + If the constructed file name cannot be opened, and CoinUtils was built + with support for compressed files, fileCoinReadable will try any + standard extensions for supported compressed files. + + The value returned in \p name is the file name that actually worked. +*/ +bool fileCoinReadable(std::string &name, + const std::string &dfltPrefix = std::string("")); +#endif diff --git a/thirdparty/windows/include/coin/CoinFinite.hpp b/thirdparty/windows/include/coin/CoinFinite.hpp new file mode 100644 index 0000000..71b5b65 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinFinite.hpp @@ -0,0 +1,34 @@ +/* $Id: CoinFinite.hpp 1762 2014-12-29 20:37:12Z tkr $ */ +// 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). + +/* Defines COIN_DBL_MAX and relatives and provides CoinFinite and CoinIsnan. */ + +#ifndef CoinFinite_H +#define CoinFinite_H + +#include <limits> + +//============================================================================= +// Smallest positive double value and Plus infinity (double and int) + +#if 1 +const double COIN_DBL_MIN = (std::numeric_limits<double>::min)(); +const double COIN_DBL_MAX = (std::numeric_limits<double>::max)(); +const int COIN_INT_MAX = (std::numeric_limits<int>::max)(); +const double COIN_INT_MAX_AS_DOUBLE = (std::numeric_limits<int>::max)(); +#else +#define COIN_DBL_MIN (std::numeric_limits<double>::min()) +#define COIN_DBL_MAX (std::numeric_limits<double>::max()) +#define COIN_INT_MAX (std::numeric_limits<int>::max()) +#define COIN_INT_MAX_AS_DOUBLE (std::numeric_limits<int>::max()) +#endif + +/** checks if a double value is finite (not infinity and not NaN) */ +extern bool CoinFinite(double val); + +/** checks if a double value is not a number */ +extern bool CoinIsnan(double val); + +#endif diff --git a/thirdparty/windows/include/coin/CoinFloatEqual.hpp b/thirdparty/windows/include/coin/CoinFloatEqual.hpp new file mode 100644 index 0000000..d5edfff --- /dev/null +++ b/thirdparty/windows/include/coin/CoinFloatEqual.hpp @@ -0,0 +1,177 @@ +/* $Id: CoinFloatEqual.hpp 1416 2011-04-17 09:57:29Z 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 CoinFloatEqual_H +#define CoinFloatEqual_H + +#include <algorithm> +#include <cmath> + +#include "CoinFinite.hpp" + +/*! \file CoinFloatEqual.hpp + \brief Function objects for testing equality of real numbers. + + Two objects are provided; one tests for equality to an absolute tolerance, + one to a scaled tolerance. The tests will handle IEEE floating point, but + note that infinity == infinity. Mathematicians are rolling in their graves, + but this matches the behaviour for the common practice of using + <code>DBL_MAX</code> (<code>numeric_limits<double>::max()</code>, or similar + large finite number) as infinity. + + <p> + Example usage: + @verbatim + double d1 = 3.14159 ; + double d2 = d1 ; + double d3 = d1+.0001 ; + + CoinAbsFltEq eq1 ; + CoinAbsFltEq eq2(.001) ; + + assert( eq1(d1,d2) ) ; + assert( !eq1(d1,d3) ) ; + assert( eq2(d1,d3) ) ; + @endverbatim + CoinRelFltEq follows the same pattern. */ + +/*! \brief Equality to an absolute tolerance + + Operands are considered equal if their difference is within an epsilon ; + the test does not consider the relative magnitude of the operands. +*/ + +class CoinAbsFltEq +{ + public: + + //! Compare function + + inline bool operator() (const double f1, const double f2) const + + { if (CoinIsnan(f1) || CoinIsnan(f2)) return false ; + if (f1 == f2) return true ; + return (fabs(f1-f2) < epsilon_) ; } + + /*! \name Constructors and destructors */ + //@{ + + /*! \brief Default constructor + + Default tolerance is 1.0e-10. + */ + + CoinAbsFltEq () : epsilon_(1.e-10) {} + + //! Alternate constructor with epsilon as a parameter + + CoinAbsFltEq (const double epsilon) : epsilon_(epsilon) {} + + //! Destructor + + virtual ~CoinAbsFltEq () {} + + //! Copy constructor + + CoinAbsFltEq (const CoinAbsFltEq& src) : epsilon_(src.epsilon_) {} + + //! Assignment + + CoinAbsFltEq& operator= (const CoinAbsFltEq& rhs) + + { if (this != &rhs) epsilon_ = rhs.epsilon_ ; + return (*this) ; } + + //@} + + private: + + /*! \name Private member data */ + //@{ + + //! Equality tolerance. + + double epsilon_ ; + + //@} + +} ; + + + +/*! \brief Equality to a scaled tolerance + + Operands are considered equal if their difference is within a scaled + epsilon calculated as epsilon_*(1+CoinMax(|f1|,|f2|)). +*/ + +class CoinRelFltEq +{ + public: + + //! Compare function + + inline bool operator() (const double f1, const double f2) const + + { if (CoinIsnan(f1) || CoinIsnan(f2)) return false ; + if (f1 == f2) return true ; + if (!CoinFinite(f1) || !CoinFinite(f2)) return false ; + + double tol = (fabs(f1)>fabs(f2))?fabs(f1):fabs(f2) ; + + return (fabs(f1-f2) <= epsilon_*(1+tol)) ; } + + /*! \name Constructors and destructors */ + //@{ + +#ifndef COIN_FLOAT + /*! Default constructor + + Default tolerance is 1.0e-10. + */ + CoinRelFltEq () : epsilon_(1.e-10) {} +#else + /*! Default constructor + + Default tolerance is 1.0e-6. + */ + CoinRelFltEq () : epsilon_(1.e-6) {} ; // as float +#endif + + //! Alternate constructor with epsilon as a parameter + + CoinRelFltEq (const double epsilon) : epsilon_(epsilon) {} + + //! Destructor + + virtual ~CoinRelFltEq () {} + + //! Copy constructor + + CoinRelFltEq (const CoinRelFltEq & src) : epsilon_(src.epsilon_) {} + + //! Assignment + + CoinRelFltEq& operator= (const CoinRelFltEq& rhs) + + { if (this != &rhs) epsilon_ = rhs.epsilon_ ; + return (*this) ; } + + //@} + +private: + + /*! \name Private member data */ + //@{ + + //! Base equality tolerance + + double epsilon_ ; + + //@} + +} ; + +#endif diff --git a/thirdparty/windows/include/coin/CoinHelperFunctions.hpp b/thirdparty/windows/include/coin/CoinHelperFunctions.hpp new file mode 100644 index 0000000..3409bbc --- /dev/null +++ b/thirdparty/windows/include/coin/CoinHelperFunctions.hpp @@ -0,0 +1,1111 @@ +/* $Id: CoinHelperFunctions.hpp 1679 2013-12-05 11:27:45Z 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 CoinHelperFunctions_H +#define CoinHelperFunctions_H + +#include "CoinUtilsConfig.h" + +#if defined(_MSC_VER) +# include <direct.h> +# include <cctype> +# define getcwd _getcwd +# include <cctype> +#else +# include <unistd.h> +#endif +//#define USE_MEMCPY + +#include <cstdlib> +#include <cstdio> +#include <algorithm> +#include "CoinTypes.hpp" +#include "CoinError.hpp" + +// 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 + +//############################################################################# + +/** This helper function copies an array to another location using Duff's + device (for a speedup of ~2). The arrays are given by pointers to their + first entries and by the size of the source array. Overlapping arrays are + handled correctly. */ + +template <class T> inline void +CoinCopyN(register const T* from, const int size, register T* to) +{ + if (size == 0 || from == to) + return; + +#ifndef NDEBUG + if (size < 0) + throw CoinError("trying to copy negative number of entries", + "CoinCopyN", ""); +#endif + + register int n = (size + 7) / 8; + if (to > from) { + register const T* downfrom = from + size; + register T* downto = to + size; + // Use Duff's device to copy + switch (size % 8) { + case 0: do{ *--downto = *--downfrom; + case 7: *--downto = *--downfrom; + case 6: *--downto = *--downfrom; + case 5: *--downto = *--downfrom; + case 4: *--downto = *--downfrom; + case 3: *--downto = *--downfrom; + case 2: *--downto = *--downfrom; + case 1: *--downto = *--downfrom; + }while(--n>0); + } + } else { + // Use Duff's device to copy + --from; + --to; + switch (size % 8) { + case 0: do{ *++to = *++from; + case 7: *++to = *++from; + case 6: *++to = *++from; + case 5: *++to = *++from; + case 4: *++to = *++from; + case 3: *++to = *++from; + case 2: *++to = *++from; + case 1: *++to = *++from; + }while(--n>0); + } + } +} + +//----------------------------------------------------------------------------- + +/** This helper function copies an array to another location using Duff's + device (for a speedup of ~2). The source array is given by its first and + "after last" entry; the target array is given by its first entry. + Overlapping arrays are handled correctly. + + All of the various CoinCopyN variants use an int for size. On 64-bit + architectures, the address diff last-first will be a 64-bit quantity. + Given that everything else uses an int, I'm going to choose to kick + the difference down to int. -- lh, 100823 -- +*/ +template <class T> inline void +CoinCopy(register const T* first, register const T* last, register T* to) +{ + CoinCopyN(first, static_cast<int>(last-first), to); +} + +//----------------------------------------------------------------------------- + +/** This helper function copies an array to another location. The two arrays + must not overlap (otherwise an exception is thrown). For speed 8 entries + are copied at a time. The arrays are given by pointers to their first + entries and by the size of the source array. + + Note JJF - the speed claim seems to be false on IA32 so I have added + CoinMemcpyN which can be used for atomic data */ +template <class T> inline void +CoinDisjointCopyN(register const T* from, const int size, register T* to) +{ +#ifndef _MSC_VER + if (size == 0 || from == to) + return; + +#ifndef NDEBUG + if (size < 0) + throw CoinError("trying to copy negative number of entries", + "CoinDisjointCopyN", ""); +#endif + +#if 0 + /* There is no point to do this test. If to and from are from different + blocks then dist is undefined, so this can crash correct code. It's + better to trust the user that the arrays are really disjoint. */ + const long dist = to - from; + if (-size < dist && dist < size) + throw CoinError("overlapping arrays", "CoinDisjointCopyN", ""); +#endif + + for (register int n = size / 8; n > 0; --n, from += 8, to += 8) { + to[0] = from[0]; + to[1] = from[1]; + to[2] = from[2]; + to[3] = from[3]; + to[4] = from[4]; + to[5] = from[5]; + to[6] = from[6]; + to[7] = from[7]; + } + switch (size % 8) { + case 7: to[6] = from[6]; + case 6: to[5] = from[5]; + case 5: to[4] = from[4]; + case 4: to[3] = from[3]; + case 3: to[2] = from[2]; + case 2: to[1] = from[1]; + case 1: to[0] = from[0]; + case 0: break; + } +#else + CoinCopyN(from, size, to); +#endif +} + +//----------------------------------------------------------------------------- + +/** This helper function copies an array to another location. The two arrays + must not overlap (otherwise an exception is thrown). For speed 8 entries + are copied at a time. The source array is given by its first and "after + last" entry; the target array is given by its first entry. */ +template <class T> inline void +CoinDisjointCopy(register const T* first, register const T* last, + register T* to) +{ + CoinDisjointCopyN(first, static_cast<int>(last - first), to); +} + +//----------------------------------------------------------------------------- + +/*! \brief Return an array of length \p size filled with input from \p array, + or null if \p array is null. +*/ + +template <class T> inline T* +CoinCopyOfArray( const T * array, const int size) +{ + if (array) { + T * arrayNew = new T[size]; + std::memcpy(arrayNew,array,size*sizeof(T)); + return arrayNew; + } else { + return NULL; + } +} + + +/*! \brief Return an array of length \p size filled with first copySize from \p array, + or null if \p array is null. +*/ + +template <class T> inline T* +CoinCopyOfArrayPartial( const T * array, const int size,const int copySize) +{ + if (array||size) { + T * arrayNew = new T[size]; + assert (copySize<=size); + std::memcpy(arrayNew,array,copySize*sizeof(T)); + return arrayNew; + } else { + return NULL; + } +} + +/*! \brief Return an array of length \p size filled with input from \p array, + or filled with (scalar) \p value if \p array is null +*/ + +template <class T> inline T* +CoinCopyOfArray( const T * array, const int size, T value) +{ + T * arrayNew = new T[size]; + if (array) { + std::memcpy(arrayNew,array,size*sizeof(T)); + } else { + int i; + for (i=0;i<size;i++) + arrayNew[i] = value; + } + return arrayNew; +} + + +/*! \brief Return an array of length \p size filled with input from \p array, + or filled with zero if \p array is null +*/ + +template <class T> inline T* +CoinCopyOfArrayOrZero( const T * array , const int size) +{ + T * arrayNew = new T[size]; + if (array) { + std::memcpy(arrayNew,array,size*sizeof(T)); + } else { + std::memset(arrayNew,0,size*sizeof(T)); + } + return arrayNew; +} + + +//----------------------------------------------------------------------------- + +/** This helper function copies an array to another location. The two arrays + must not overlap (otherwise an exception is thrown). For speed 8 entries + are copied at a time. The arrays are given by pointers to their first + entries and by the size of the source array. + + Note JJF - the speed claim seems to be false on IA32 so I have added + alternative coding if USE_MEMCPY defined*/ +#ifndef COIN_USE_RESTRICT +template <class T> inline void +CoinMemcpyN(register const T* from, const int size, register T* to) +{ +#ifndef _MSC_VER +#ifdef USE_MEMCPY + // Use memcpy - seems a lot faster on Intel with gcc +#ifndef NDEBUG + // Some debug so check + if (size < 0) + throw CoinError("trying to copy negative number of entries", + "CoinMemcpyN", ""); + +#if 0 + /* There is no point to do this test. If to and from are from different + blocks then dist is undefined, so this can crash correct code. It's + better to trust the user that the arrays are really disjoint. */ + const long dist = to - from; + if (-size < dist && dist < size) + throw CoinError("overlapping arrays", "CoinMemcpyN", ""); +#endif +#endif + std::memcpy(to,from,size*sizeof(T)); +#else + if (size == 0 || from == to) + return; + +#ifndef NDEBUG + if (size < 0) + throw CoinError("trying to copy negative number of entries", + "CoinMemcpyN", ""); +#endif + +#if 0 + /* There is no point to do this test. If to and from are from different + blocks then dist is undefined, so this can crash correct code. It's + better to trust the user that the arrays are really disjoint. */ + const long dist = to - from; + if (-size < dist && dist < size) + throw CoinError("overlapping arrays", "CoinMemcpyN", ""); +#endif + + for (register int n = size / 8; n > 0; --n, from += 8, to += 8) { + to[0] = from[0]; + to[1] = from[1]; + to[2] = from[2]; + to[3] = from[3]; + to[4] = from[4]; + to[5] = from[5]; + to[6] = from[6]; + to[7] = from[7]; + } + switch (size % 8) { + case 7: to[6] = from[6]; + case 6: to[5] = from[5]; + case 5: to[4] = from[4]; + case 4: to[3] = from[3]; + case 3: to[2] = from[2]; + case 2: to[1] = from[1]; + case 1: to[0] = from[0]; + case 0: break; + } +#endif +#else + CoinCopyN(from, size, to); +#endif +} +#else +template <class T> inline void +CoinMemcpyN(const T * COIN_RESTRICT from, int size, T* COIN_RESTRICT to) +{ +#ifdef USE_MEMCPY + std::memcpy(to,from,size*sizeof(T)); +#else + T * COIN_RESTRICT put = to; + const T * COIN_RESTRICT get = from; + for ( ; 0<size ; --size) + *put++ = *get++; +#endif +} +#endif + +//----------------------------------------------------------------------------- + +/** This helper function copies an array to another location. The two arrays + must not overlap (otherwise an exception is thrown). For speed 8 entries + are copied at a time. The source array is given by its first and "after + last" entry; the target array is given by its first entry. */ +template <class T> inline void +CoinMemcpy(register const T* first, register const T* last, + register T* to) +{ + CoinMemcpyN(first, static_cast<int>(last - first), to); +} + +//############################################################################# + +/** This helper function fills an array with a given value. For speed 8 entries + are filled at a time. The array is given by a pointer to its first entry + and its size. + + Note JJF - the speed claim seems to be false on IA32 so I have added + CoinZero to allow for memset. */ +template <class T> inline void +CoinFillN(register T* to, const int size, register const T value) +{ + if (size == 0) + return; + +#ifndef NDEBUG + if (size < 0) + throw CoinError("trying to fill negative number of entries", + "CoinFillN", ""); +#endif +#if 1 + for (register int n = size / 8; n > 0; --n, to += 8) { + to[0] = value; + to[1] = value; + to[2] = value; + to[3] = value; + to[4] = value; + to[5] = value; + to[6] = value; + to[7] = value; + } + switch (size % 8) { + case 7: to[6] = value; + case 6: to[5] = value; + case 5: to[4] = value; + case 4: to[3] = value; + case 3: to[2] = value; + case 2: to[1] = value; + case 1: to[0] = value; + case 0: break; + } +#else + // Use Duff's device to fill + register int n = (size + 7) / 8; + --to; + switch (size % 8) { + case 0: do{ *++to = value; + case 7: *++to = value; + case 6: *++to = value; + case 5: *++to = value; + case 4: *++to = value; + case 3: *++to = value; + case 2: *++to = value; + case 1: *++to = value; + }while(--n>0); + } +#endif +} + +//----------------------------------------------------------------------------- + +/** This helper function fills an array with a given value. For speed 8 + entries are filled at a time. The array is given by its first and "after + last" entry. */ +template <class T> inline void +CoinFill(register T* first, register T* last, const T value) +{ + CoinFillN(first, last - first, value); +} + +//############################################################################# + +/** This helper function fills an array with zero. For speed 8 entries + are filled at a time. The array is given by a pointer to its first entry + and its size. + + Note JJF - the speed claim seems to be false on IA32 so I have allowed + for memset as an alternative */ +template <class T> inline void +CoinZeroN(register T* to, const int size) +{ +#ifdef USE_MEMCPY + // Use memset - seems faster on Intel with gcc +#ifndef NDEBUG + // Some debug so check + if (size < 0) + throw CoinError("trying to fill negative number of entries", + "CoinZeroN", ""); +#endif + memset(to,0,size*sizeof(T)); +#else + if (size == 0) + return; + +#ifndef NDEBUG + if (size < 0) + throw CoinError("trying to fill negative number of entries", + "CoinZeroN", ""); +#endif +#if 1 + for (register int n = size / 8; n > 0; --n, to += 8) { + to[0] = 0; + to[1] = 0; + to[2] = 0; + to[3] = 0; + to[4] = 0; + to[5] = 0; + to[6] = 0; + to[7] = 0; + } + switch (size % 8) { + case 7: to[6] = 0; + case 6: to[5] = 0; + case 5: to[4] = 0; + case 4: to[3] = 0; + case 3: to[2] = 0; + case 2: to[1] = 0; + case 1: to[0] = 0; + case 0: break; + } +#else + // Use Duff's device to fill + register int n = (size + 7) / 8; + --to; + switch (size % 8) { + case 0: do{ *++to = 0; + case 7: *++to = 0; + case 6: *++to = 0; + case 5: *++to = 0; + case 4: *++to = 0; + case 3: *++to = 0; + case 2: *++to = 0; + case 1: *++to = 0; + }while(--n>0); + } +#endif +#endif +} +/// This Debug helper function checks an array is all zero +inline void +CoinCheckDoubleZero(double * to, const int size) +{ + int n=0; + for (int j=0;j<size;j++) { + if (to[j]) + n++; + } + if (n) { + printf("array of length %d should be zero has %d nonzero\n",size,n); + } +} +/// This Debug helper function checks an array is all zero +inline void +CoinCheckIntZero(int * to, const int size) +{ + int n=0; + for (int j=0;j<size;j++) { + if (to[j]) + n++; + } + if (n) { + printf("array of length %d should be zero has %d nonzero\n",size,n); + } +} + +//----------------------------------------------------------------------------- + +/** This helper function fills an array with a given value. For speed 8 + entries are filled at a time. The array is given by its first and "after + last" entry. */ +template <class T> inline void +CoinZero(register T* first, register T* last) +{ + CoinZeroN(first, last - first); +} + +//############################################################################# + +/** Returns strdup or NULL if original NULL */ +inline char * CoinStrdup(const char * name) +{ + char* dup = NULL; + if (name) { + const int len = static_cast<int>(strlen(name)); + dup = static_cast<char*>(malloc(len+1)); + CoinMemcpyN(name, len, dup); + dup[len] = 0; + } + return dup; +} + +//############################################################################# + +/** Return the larger (according to <code>operator<()</code> of the arguments. + This function was introduced because for some reason compiler tend to + handle the <code>max()</code> function differently. */ +template <class T> inline T +CoinMax(register const T x1, register const T x2) +{ + return (x1 > x2) ? x1 : x2; +} + +//----------------------------------------------------------------------------- + +/** Return the smaller (according to <code>operator<()</code> of the arguments. + This function was introduced because for some reason compiler tend to + handle the min() function differently. */ +template <class T> inline T +CoinMin(register const T x1, register const T x2) +{ + return (x1 < x2) ? x1 : x2; +} + +//----------------------------------------------------------------------------- + +/** Return the absolute value of the argument. This function was introduced + because for some reason compiler tend to handle the abs() function + differently. */ +template <class T> inline T +CoinAbs(const T value) +{ + return value<0 ? -value : value; +} + +//############################################################################# + +/** This helper function tests whether the entries of an array are sorted + according to operator<. The array is given by a pointer to its first entry + and by its size. */ +template <class T> inline bool +CoinIsSorted(register const T* first, const int size) +{ + if (size == 0) + return true; + +#ifndef NDEBUG + if (size < 0) + throw CoinError("negative number of entries", "CoinIsSorted", ""); +#endif +#if 1 + // size1 is the number of comparisons to be made + const int size1 = size - 1; + for (register int n = size1 / 8; n > 0; --n, first += 8) { + if (first[8] < first[7]) return false; + if (first[7] < first[6]) return false; + if (first[6] < first[5]) return false; + if (first[5] < first[4]) return false; + if (first[4] < first[3]) return false; + if (first[3] < first[2]) return false; + if (first[2] < first[1]) return false; + if (first[1] < first[0]) return false; + } + + switch (size1 % 8) { + case 7: if (first[7] < first[6]) return false; + case 6: if (first[6] < first[5]) return false; + case 5: if (first[5] < first[4]) return false; + case 4: if (first[4] < first[3]) return false; + case 3: if (first[3] < first[2]) return false; + case 2: if (first[2] < first[1]) return false; + case 1: if (first[1] < first[0]) return false; + case 0: break; + } +#else + register const T* next = first; + register const T* last = first + size; + for (++next; next != last; first = next, ++next) + if (*next < *first) + return false; +#endif + return true; +} + +//----------------------------------------------------------------------------- + +/** This helper function tests whether the entries of an array are sorted + according to operator<. The array is given by its first and "after + last" entry. */ +template <class T> inline bool +CoinIsSorted(register const T* first, register const T* last) +{ + return CoinIsSorted(first, static_cast<int>(last - first)); +} + +//############################################################################# + +/** This helper function fills an array with the values init, init+1, init+2, + etc. For speed 8 entries are filled at a time. The array is given by a + pointer to its first entry and its size. */ +template <class T> inline void +CoinIotaN(register T* first, const int size, register T init) +{ + if (size == 0) + return; + +#ifndef NDEBUG + if (size < 0) + throw CoinError("negative number of entries", "CoinIotaN", ""); +#endif +#if 1 + for (register int n = size / 8; n > 0; --n, first += 8, init += 8) { + first[0] = init; + first[1] = init + 1; + first[2] = init + 2; + first[3] = init + 3; + first[4] = init + 4; + first[5] = init + 5; + first[6] = init + 6; + first[7] = init + 7; + } + switch (size % 8) { + case 7: first[6] = init + 6; + case 6: first[5] = init + 5; + case 5: first[4] = init + 4; + case 4: first[3] = init + 3; + case 3: first[2] = init + 2; + case 2: first[1] = init + 1; + case 1: first[0] = init; + case 0: break; + } +#else + // Use Duff's device to fill + register int n = (size + 7) / 8; + --first; + --init; + switch (size % 8) { + case 0: do{ *++first = ++init; + case 7: *++first = ++init; + case 6: *++first = ++init; + case 5: *++first = ++init; + case 4: *++first = ++init; + case 3: *++first = ++init; + case 2: *++first = ++init; + case 1: *++first = ++init; + }while(--n>0); + } +#endif +} + +//----------------------------------------------------------------------------- + +/** This helper function fills an array with the values init, init+1, init+2, + etc. For speed 8 entries are filled at a time. The array is given by its + first and "after last" entry. */ +template <class T> inline void +CoinIota(T* first, const T* last, T init) +{ + CoinIotaN(first, last-first, init); +} + +//############################################################################# + +/** This helper function deletes certain entries from an array. The array is + given by pointers to its first and "after last" entry (first two + arguments). The positions of the entries to be deleted are given in the + integer array specified by the last two arguments (again, first and "after + last" entry). */ +template <class T> inline T * +CoinDeleteEntriesFromArray(register T * arrayFirst, register T * arrayLast, + const int * firstDelPos, const int * lastDelPos) +{ + int delNum = static_cast<int>(lastDelPos - firstDelPos); + if (delNum == 0) + return arrayLast; + + if (delNum < 0) + throw CoinError("trying to delete negative number of entries", + "CoinDeleteEntriesFromArray", ""); + + int * delSortedPos = NULL; + if (! (CoinIsSorted(firstDelPos, lastDelPos) && + std::adjacent_find(firstDelPos, lastDelPos) == lastDelPos)) { + // the positions of the to be deleted is either not sorted or not unique + delSortedPos = new int[delNum]; + CoinDisjointCopy(firstDelPos, lastDelPos, delSortedPos); + std::sort(delSortedPos, delSortedPos + delNum); + delNum = static_cast<int>(std::unique(delSortedPos, + delSortedPos+delNum) - delSortedPos); + } + const int * delSorted = delSortedPos ? delSortedPos : firstDelPos; + + const int last = delNum - 1; + int size = delSorted[0]; + for (int i = 0; i < last; ++i) { + const int copyFirst = delSorted[i] + 1; + const int copyLast = delSorted[i+1]; + CoinCopy(arrayFirst + copyFirst, arrayFirst + copyLast, + arrayFirst + size); + size += copyLast - copyFirst; + } + const int copyFirst = delSorted[last] + 1; + const int copyLast = static_cast<int>(arrayLast - arrayFirst); + CoinCopy(arrayFirst + copyFirst, arrayFirst + copyLast, + arrayFirst + size); + size += copyLast - copyFirst; + + if (delSortedPos) + delete[] delSortedPos; + + return arrayFirst + size; +} + +//############################################################################# + +#define COIN_OWN_RANDOM_32 + +#if defined COIN_OWN_RANDOM_32 +/* Thanks to Stefano Gliozzi for providing an operating system + independent random number generator. */ + +/*! \brief Return a random number between 0 and 1 + + A platform-independent linear congruential generator. For a given seed, the + generated sequence is always the same regardless of the (32-bit) + architecture. This allows to build & test in different environments, getting + in most cases the same optimization path. + + Set \p isSeed to true and supply an integer seed to set the seed + (vid. #CoinSeedRandom) + + \todo Anyone want to volunteer an upgrade for 64-bit architectures? +*/ +inline double CoinDrand48 (bool isSeed = false, unsigned int seed = 1) +{ + static unsigned int last = 123456; + if (isSeed) { + last = seed; + } else { + last = 1664525*last+1013904223; + return ((static_cast<double> (last))/4294967296.0); + } + return (0.0); +} + +/// Set the seed for the random number generator +inline void CoinSeedRandom(int iseed) +{ + CoinDrand48(true, iseed); +} + +#else // COIN_OWN_RANDOM_32 + +#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN32__) + +/// Return a random number between 0 and 1 +inline double CoinDrand48() { return rand() / (double) RAND_MAX; } +/// Set the seed for the random number generator +inline void CoinSeedRandom(int iseed) { srand(iseed + 69822); } + +#else + +/// Return a random number between 0 and 1 +inline double CoinDrand48() { return drand48(); } +/// Set the seed for the random number generator +inline void CoinSeedRandom(int iseed) { srand48(iseed + 69822); } + +#endif + +#endif // COIN_OWN_RANDOM_32 + +//############################################################################# + +/** This function figures out whether file names should contain slashes or + backslashes as directory separator */ +inline char CoinFindDirSeparator() +{ + int size = 1000; + char* buf = 0; + while (true) { + buf = new char[size]; + if (getcwd(buf, size)) + break; + delete[] buf; + buf = 0; + size = 2*size; + } + // if first char is '/' then it's unix and the dirsep is '/'. otherwise we + // assume it's dos and the dirsep is '\' + char dirsep = buf[0] == '/' ? '/' : '\\'; + delete[] buf; + return dirsep; +} +//############################################################################# + +inline int CoinStrNCaseCmp(const char* s0, const char* s1, + const size_t len) +{ + for (size_t i = 0; i < len; ++i) { + if (s0[i] == 0) { + return s1[i] == 0 ? 0 : -1; + } + if (s1[i] == 0) { + return 1; + } + const int c0 = std::tolower(s0[i]); + const int c1 = std::tolower(s1[i]); + if (c0 < c1) + return -1; + if (c0 > c1) + return 1; + } + return 0; +} + +//############################################################################# + +/// Swap the arguments. +template <class T> inline void CoinSwap (T &x, T &y) +{ + T t = x; + x = y; + y = t; +} + +//############################################################################# + +/** This helper function copies an array to file + Returns 0 if OK, 1 if bad write. +*/ + +template <class T> inline int +CoinToFile( const T* array, CoinBigIndex size, FILE * fp) +{ + CoinBigIndex numberWritten; + if (array&&size) { + numberWritten = + static_cast<CoinBigIndex>(fwrite(&size,sizeof(int),1,fp)); + if (numberWritten!=1) + return 1; + numberWritten = + static_cast<CoinBigIndex>(fwrite(array,sizeof(T),size_t(size),fp)); + if (numberWritten!=size) + return 1; + } else { + size = 0; + numberWritten = + static_cast<CoinBigIndex>(fwrite(&size,sizeof(int),1,fp)); + if (numberWritten!=1) + return 1; + } + return 0; +} + +//############################################################################# + +/** This helper function copies an array from file and creates with new. + Passed in array is ignored i.e. not deleted. + But if NULL and size does not match and newSize 0 then leaves as NULL and 0 + Returns 0 if OK, 1 if bad read, 2 if size did not match. +*/ + +template <class T> inline int +CoinFromFile( T* &array, CoinBigIndex size, FILE * fp, CoinBigIndex & newSize) +{ + CoinBigIndex numberRead; + numberRead = + static_cast<CoinBigIndex>(fread(&newSize,sizeof(int),1,fp)); + if (numberRead!=1) + return 1; + int returnCode=0; + if (size!=newSize&&(newSize||array)) + returnCode=2; + if (newSize) { + array = new T [newSize]; + numberRead = + static_cast<CoinBigIndex>(fread(array,sizeof(T),newSize,fp)); + if (numberRead!=newSize) + returnCode=1; + } else { + array = NULL; + } + return returnCode; +} + +//############################################################################# + +/// Cube Root +#if 0 +inline double CoinCbrt(double x) +{ +#if defined(_MSC_VER) + return pow(x,(1./3.)); +#else + return cbrt(x); +#endif +} +#endif + +//----------------------------------------------------------------------------- + +/// This helper returns "sizeof" as an int +#define CoinSizeofAsInt(type) (static_cast<int>(sizeof(type))) +/// This helper returns "strlen" as an int +inline int +CoinStrlenAsInt(const char * string) +{ + return static_cast<int>(strlen(string)); +} + +/** Class for thread specific random numbers +*/ +#if defined COIN_OWN_RANDOM_32 +class CoinThreadRandom { +public: + /**@name Constructors, destructor */ + + //@{ + /** Default constructor. */ + CoinThreadRandom() + { seed_=12345678;} + /** Constructor wih seed. */ + CoinThreadRandom(int seed) + { + seed_ = seed; + } + /** Destructor */ + ~CoinThreadRandom() {} + // Copy + CoinThreadRandom(const CoinThreadRandom & rhs) + { seed_ = rhs.seed_;} + // Assignment + CoinThreadRandom& operator=(const CoinThreadRandom & rhs) + { + if (this != &rhs) { + seed_ = rhs.seed_; + } + return *this; + } + + //@} + + /**@name Sets/gets */ + + //@{ + /** Set seed. */ + inline void setSeed(int seed) + { + seed_ = seed; + } + /** Get seed. */ + inline unsigned int getSeed() const + { + return seed_; + } + /// return a random number + inline double randomDouble() const + { + double retVal; + seed_ = 1664525*(seed_)+1013904223; + retVal = ((static_cast<double> (seed_))/4294967296.0); + return retVal; + } + /// make more random (i.e. for startup) + inline void randomize(int n=0) + { + if (!n) + n=seed_ & 255; + for (int i=0;i<n;i++) + randomDouble(); + } + //@} + + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Current seed + mutable unsigned int seed_; + //@} +}; +#else +class CoinThreadRandom { +public: + /**@name Constructors, destructor */ + + //@{ + /** Default constructor. */ + CoinThreadRandom() + { seed_[0]=50000;seed_[1]=40000;seed_[2]=30000;} + /** Constructor wih seed. */ + CoinThreadRandom(const unsigned short seed[3]) + { memcpy(seed_,seed,3*sizeof(unsigned short));} + /** Constructor wih seed. */ + CoinThreadRandom(int seed) + { + union { int i[2]; unsigned short int s[4];} put; + put.i[0]=seed; + put.i[1]=seed; + memcpy(seed_,put.s,3*sizeof(unsigned short)); + } + /** Destructor */ + ~CoinThreadRandom() {} + // Copy + CoinThreadRandom(const CoinThreadRandom & rhs) + { memcpy(seed_,rhs.seed_,3*sizeof(unsigned short));} + // Assignment + CoinThreadRandom& operator=(const CoinThreadRandom & rhs) + { + if (this != &rhs) { + memcpy(seed_,rhs.seed_,3*sizeof(unsigned short)); + } + return *this; + } + + //@} + + /**@name Sets/gets */ + + //@{ + /** Set seed. */ + inline void setSeed(const unsigned short seed[3]) + { memcpy(seed_,seed,3*sizeof(unsigned short));} + /** Set seed. */ + inline void setSeed(int seed) + { + union { int i[2]; unsigned short int s[4];} put; + put.i[0]=seed; + put.i[1]=seed; + memcpy(seed_,put.s,3*sizeof(unsigned short)); + } + /// return a random number + inline double randomDouble() const + { + double retVal; +#if defined(_MSC_VER) || defined(__MINGW32__) || defined(__CYGWIN32__) + retVal=rand(); + retVal=retVal/(double) RAND_MAX; +#else + retVal = erand48(seed_); +#endif + return retVal; + } + /// make more random (i.e. for startup) + inline void randomize(int n=0) + { + if (!n) { + n=seed_[0]+seed_[1]+seed_[2]; + n &= 255; + } + for (int i=0;i<n;i++) + randomDouble(); + } + //@} + + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Current seed + mutable unsigned short seed_[3]; + //@} +}; +#endif +#ifndef COIN_DETAIL +#define COIN_DETAIL_PRINT(s) {} +#else +#define COIN_DETAIL_PRINT(s) s +#endif +#endif diff --git a/thirdparty/windows/include/coin/CoinIndexedVector.hpp b/thirdparty/windows/include/coin/CoinIndexedVector.hpp new file mode 100644 index 0000000..9c386c5 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinIndexedVector.hpp @@ -0,0 +1,1164 @@ +/* $Id: CoinIndexedVector.hpp 1767 2015-01-05 12:36:13Z 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 CoinIndexedVector_H +#define CoinIndexedVector_H + +#if defined(_MSC_VER) +// Turn off compiler warning about long names +# pragma warning(disable:4786) +#endif + +#include <map> +#include "CoinFinite.hpp" +#ifndef CLP_NO_VECTOR +#include "CoinPackedVectorBase.hpp" +#endif +#include "CoinSort.hpp" +#include "CoinHelperFunctions.hpp" +#include <cassert> + +#ifndef COIN_FLOAT +#define COIN_INDEXED_TINY_ELEMENT 1.0e-50 +#define COIN_INDEXED_REALLY_TINY_ELEMENT 1.0e-100 +#else +#define COIN_INDEXED_TINY_ELEMENT 1.0e-35 +#define COIN_INDEXED_REALLY_TINY_ELEMENT 1.0e-39 +#endif + +/** Indexed Vector + +This stores values unpacked but apart from that is a bit like CoinPackedVector. +It is designed to be lightweight in normal use. + +It now has a "packed" mode when it is even more like CoinPackedVector + +Indices array has capacity_ extra chars which are zeroed and can +be used for any purpose - but must be re-zeroed + +Stores vector of indices and associated element values. +Supports sorting of indices. + +Does not support negative indices. + +Does NOT support testing for duplicates + +*** getElements is no longer supported + +Here is a sample usage: +@verbatim + const int ne = 4; + int inx[ne] = { 1, 4, 0, 2 } + double el[ne] = { 10., 40., 1., 50. } + + // Create vector and set its valuex1 + CoinIndexedVector r(ne,inx,el); + + // access as a full storage vector + assert( r[ 0]==1. ); + assert( r[ 1]==10.); + assert( r[ 2]==50.); + assert( r[ 3]==0. ); + assert( r[ 4]==40.); + + // sort Elements in increasing order + r.sortIncrElement(); + + // access each index and element + assert( r.getIndices ()[0]== 0 ); + assert( r.getIndices ()[1]== 1 ); + assert( r.getIndices ()[2]== 4 ); + assert( r.getIndices ()[3]== 2 ); + + // access as a full storage vector + assert( r[ 0]==1. ); + assert( r[ 1]==10.); + assert( r[ 2]==50.); + assert( r[ 3]==0. ); + assert( r[ 4]==40.); + + // Tests for equality and equivalence + CoinIndexedVector r1; + r1=r; + assert( r==r1 ); + assert( r.equivalent(r1) ); + r.sortIncrElement(); + assert( r!=r1 ); + assert( r.equivalent(r1) ); + + // Add indexed vectors. + // Similarly for subtraction, multiplication, + // and division. + CoinIndexedVector add = r + r1; + assert( add[0] == 1.+ 1. ); + assert( add[1] == 10.+10. ); + assert( add[2] == 50.+50. ); + assert( add[3] == 0.+ 0. ); + assert( add[4] == 40.+40. ); + + assert( r.sum() == 10.+40.+1.+50. ); +@endverbatim +*/ +class CoinIndexedVector { + friend void CoinIndexedVectorUnitTest(); + +public: + /**@name Get methods. */ + //@{ + /// Get the size + inline int getNumElements() const { return nElements_; } + /// Get indices of elements + inline const int * getIndices() const { return indices_; } + /// Get element values + // ** No longer supported virtual const double * getElements() const ; + /// Get indices of elements + inline int * getIndices() { return indices_; } + /** Get the vector as a dense vector. This is normal storage method. + The user should not not delete [] this. + */ + inline double * denseVector() const { return elements_; } + /// For very temporary use when user needs to borrow a dense vector + inline void setDenseVector(double * array) + { elements_ = array;} + /// For very temporary use when user needs to borrow an index vector + inline void setIndexVector(int * array) + { indices_ = array;} + /** Access the i'th element of the full storage vector. + */ + double & operator[](int i) const; + + //@} + + //------------------------------------------------------------------- + // Set indices and elements + //------------------------------------------------------------------- + /**@name Set methods */ + //@{ + /// Set the size + inline void setNumElements(int value) { nElements_ = value; + if (!nElements_) packedMode_=false;} + /// Reset the vector (as if were just created an empty vector). This leaves arrays! + void clear(); + /// Reset the vector (as if were just created an empty vector) + void empty(); + /** Assignment operator. */ + CoinIndexedVector & operator=(const CoinIndexedVector &); +#ifndef CLP_NO_VECTOR + /** Assignment operator from a CoinPackedVectorBase. <br> + <strong>NOTE</strong>: This assumes no duplicates */ + CoinIndexedVector & operator=(const CoinPackedVectorBase & rhs); +#endif + /** Copy the contents of one vector into another. If multiplier is 1 + It is the equivalent of = but if vectors are same size does + not re-allocate memory just clears and copies */ + void copy(const CoinIndexedVector & rhs, double multiplier=1.0); + + /** Borrow ownership of the arguments to this vector. + Size is the length of the unpacked elements vector. */ + void borrowVector(int size, int numberIndices, int* inds, double* elems); + + /** Return ownership of the arguments to this vector. + State after is empty . + */ + void returnVector(); + + /** Set vector numberIndices, indices, and elements. + NumberIndices is the length of both the indices and elements vectors. + The indices and elements vectors are copied into this class instance's + member data. Assumed to have no duplicates */ + void setVector(int numberIndices, const int * inds, const double * elems); + + /** Set vector size, indices, and elements. + Size is the length of the unpacked elements vector. + The indices and elements vectors are copied into this class instance's + member data. We do not check for duplicate indices */ + void setVector(int size, int numberIndices, const int * inds, const double * elems); + + /** Elements set to have the same scalar value */ + void setConstant(int size, const int * inds, double elems); + + /** Indices are not specified and are taken to be 0,1,...,size-1 */ + void setFull(int size, const double * elems); + + /** Set an existing element in the indexed vector + The first argument is the "index" into the elements() array + */ + void setElement(int index, double element); + + /// Insert an element into the vector + void insert(int index, double element); + /// Insert a nonzero element into the vector + inline void quickInsert(int index, double element) + { + assert (!elements_[index]); + indices_[nElements_++] = index; + assert (nElements_<=capacity_); + elements_[index] = element; + } + /** Insert or if exists add an element into the vector + Any resulting zero elements will be made tiny */ + void add(int index, double element); + /** Insert or if exists add an element into the vector + Any resulting zero elements will be made tiny. + This version does no checking */ + inline void quickAdd(int index, double element) + { + if (elements_[index]) { + element += elements_[index]; + if ((element > 0 ? element : -element) >= COIN_INDEXED_TINY_ELEMENT) { + elements_[index] = element; + } else { + elements_[index] = 1.0e-100; + } + } else if ((element > 0 ? element : -element) >= COIN_INDEXED_TINY_ELEMENT) { + indices_[nElements_++] = index; + assert (nElements_<=capacity_); + elements_[index] = element; + } + } + /** Insert or if exists add an element into the vector + Any resulting zero elements will be made tiny. + This knows element is nonzero + This version does no checking */ + inline void quickAddNonZero(int index, double element) + { + assert (element); + if (elements_[index]) { + element += elements_[index]; + if ((element > 0 ? element : -element) >= COIN_INDEXED_TINY_ELEMENT) { + elements_[index] = element; + } else { + elements_[index] = COIN_DBL_MIN; + } + } else { + indices_[nElements_++] = index; + assert (nElements_<=capacity_); + elements_[index] = element; + } + } + /** Makes nonzero tiny. + This version does no checking */ + inline void zero(int index) + { + if (elements_[index]) + elements_[index] = COIN_DBL_MIN; + } + /** set all small values to zero and return number remaining + - < tolerance => 0.0 */ + int clean(double tolerance); + /// Same but packs down + int cleanAndPack(double tolerance); + /// Same but packs down and is safe (i.e. if order is odd) + int cleanAndPackSafe(double tolerance); + /// Mark as packed + inline void setPacked() + { packedMode_ = true;} +#ifndef NDEBUG + /// For debug check vector is clear i.e. no elements + void checkClear(); + /// For debug check vector is clean i.e. elements match indices + void checkClean(); +#else + inline void checkClear() {}; + inline void checkClean() {}; +#endif + /// Scan dense region and set up indices (returns number found) + int scan(); + /** Scan dense region from start to < end and set up indices + returns number found + */ + int scan(int start, int end); + /** Scan dense region and set up indices (returns number found). + Only ones >= tolerance */ + int scan(double tolerance); + /** Scan dense region from start to < end and set up indices + returns number found. Only >= tolerance + */ + int scan(int start, int end, double tolerance); + /// These are same but pack down + int scanAndPack(); + int scanAndPack(int start, int end); + int scanAndPack(double tolerance); + int scanAndPack(int start, int end, double tolerance); + /// Create packed array + void createPacked(int number, const int * indices, + const double * elements); + /// Create unpacked array + void createUnpacked(int number, const int * indices, + const double * elements); + /// Create unpacked singleton + void createOneUnpackedElement(int index, double element); + /// This is mainly for testing - goes from packed to indexed + void expand(); +#ifndef CLP_NO_VECTOR + /// Append a CoinPackedVector to the end + void append(const CoinPackedVectorBase & caboose); +#endif + /// Append a CoinIndexedVector to the end (with extra space) + void append(const CoinIndexedVector & caboose); + /// Append a CoinIndexedVector to the end and modify indices + void append(CoinIndexedVector & other,int adjustIndex,bool zapElements=false); + + /// Swap values in positions i and j of indices and elements + void swap(int i, int j); + + /// Throw away all entries in rows >= newSize + void truncate(int newSize); + /// Print out + void print() const; + //@} + /**@name Arithmetic operators. */ + //@{ + /// add <code>value</code> to every entry + void operator+=(double value); + /// subtract <code>value</code> from every entry + void operator-=(double value); + /// multiply every entry by <code>value</code> + void operator*=(double value); + /// divide every entry by <code>value</code> (** 0 vanishes) + void operator/=(double value); + //@} + + /**@name Comparison operators on two indexed vectors */ + //@{ +#ifndef CLP_NO_VECTOR + /** Equal. Returns true if vectors have same length and corresponding + element of each vector is equal. */ + bool operator==(const CoinPackedVectorBase & rhs) const; + /// Not equal + bool operator!=(const CoinPackedVectorBase & rhs) const; +#endif + /** Equal. Returns true if vectors have same length and corresponding + element of each vector is equal. */ + bool operator==(const CoinIndexedVector & rhs) const; + /// Not equal + bool operator!=(const CoinIndexedVector & rhs) const; + /// Equal with a tolerance (returns -1 or position of inequality). + int isApproximatelyEqual(const CoinIndexedVector & rhs, double tolerance=1.0e-8) const; + //@} + + /**@name Index methods */ + //@{ + /// Get value of maximum index + int getMaxIndex() const; + /// Get value of minimum index + int getMinIndex() const; + //@} + + + /**@name Sorting */ + //@{ + /** Sort the indexed storage vector (increasing indices). */ + void sort() + { std::sort(indices_,indices_+nElements_); } + + void sortIncrIndex() + { std::sort(indices_,indices_+nElements_); } + + void sortDecrIndex(); + + void sortIncrElement(); + + void sortDecrElement(); + void sortPacked(); + + //@} + + //############################################################################# + + /**@name Arithmetic operators on packed vectors. + + <strong>NOTE</strong>: These methods operate on those positions where at + least one of the arguments has a value listed. At those positions the + appropriate operation is executed, Otherwise the result of the operation is + considered 0.<br> + <strong>NOTE 2</strong>: Because these methods return an object (they can't + return a reference, though they could return a pointer...) they are + <em>very</em> inefficient... + */ +//@{ +/// Return the sum of two indexed vectors +CoinIndexedVector operator+( + const CoinIndexedVector& op2); + +/// Return the difference of two indexed vectors +CoinIndexedVector operator-( + const CoinIndexedVector& op2); + +/// Return the element-wise product of two indexed vectors +CoinIndexedVector operator*( + const CoinIndexedVector& op2); + +/// Return the element-wise ratio of two indexed vectors (0.0/0.0 => 0.0) (0 vanishes) +CoinIndexedVector operator/( + const CoinIndexedVector& op2); +/// The sum of two indexed vectors +void operator+=(const CoinIndexedVector& op2); + +/// The difference of two indexed vectors +void operator-=( const CoinIndexedVector& op2); + +/// The element-wise product of two indexed vectors +void operator*=(const CoinIndexedVector& op2); + +/// The element-wise ratio of two indexed vectors (0.0/0.0 => 0.0) (0 vanishes) +void operator/=(const CoinIndexedVector& op2); +//@} + + /**@name Memory usage */ + //@{ + /** Reserve space. + If one knows the eventual size of the indexed vector, + then it may be more efficient to reserve the space. + */ + void reserve(int n); + /** capacity returns the size which could be accomodated without + having to reallocate storage. + */ + inline int capacity() const { return capacity_; } + inline void setCapacity(int value) + { capacity_ = value; } + /// Sets packed mode + inline void setPackedMode(bool yesNo) + { packedMode_=yesNo;} + /// Gets packed mode + inline bool packedMode() const + { return packedMode_;} + //@} + + /**@name Constructors and destructors */ + //@{ + /** Default constructor */ + CoinIndexedVector(); + /** Alternate Constructors - set elements to vector of doubles */ + CoinIndexedVector(int size, const int * inds, const double * elems); + /** Alternate Constructors - set elements to same scalar value */ + CoinIndexedVector(int size, const int * inds, double element); + /** Alternate Constructors - construct full storage with indices 0 through + size-1. */ + CoinIndexedVector(int size, const double * elements); + /** Alternate Constructors - just size */ + CoinIndexedVector(int size); + /** Copy constructor. */ + CoinIndexedVector(const CoinIndexedVector &); + /** Copy constructor.2 */ + CoinIndexedVector(const CoinIndexedVector *); +#ifndef CLP_NO_VECTOR + /** Copy constructor <em>from a PackedVectorBase</em>. */ + CoinIndexedVector(const CoinPackedVectorBase & rhs); +#endif + /** Destructor */ + ~CoinIndexedVector (); + //@} + +private: + /**@name Private methods */ + //@{ + /// Copy internal data + void gutsOfSetVector(int size, + const int * inds, const double * elems); + void gutsOfSetVector(int size, int numberIndices, + const int * inds, const double * elems); + void gutsOfSetPackedVector(int size, int numberIndices, + const int * inds, const double * elems); + /// + void gutsOfSetConstant(int size, + const int * inds, double value); + //@} + +protected: + /**@name Private member data */ + //@{ + /// Vector indices + int * indices_; + ///Vector elements + double * elements_; + /// Size of indices and packed elements vectors + int nElements_; + /// Amount of memory allocated for indices_, and elements_. + int capacity_; + /// Offset to get where new allocated array + int offset_; + /// If true then is operating in packed mode + bool packedMode_; + //@} +}; + +//############################################################################# +/** A function that tests the methods in the CoinIndexedVector 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 +CoinIndexedVectorUnitTest(); +/** Pointer with length in bytes + + This has a pointer to an array and the number of bytes in array. + If number of bytes==-1 then + CoinConditionalNew deletes existing pointer and returns new pointer + of correct size (and number bytes still -1). + CoinConditionalDelete deletes existing pointer and NULLs it. + So behavior is as normal (apart from New deleting pointer which will have + no effect with good coding practices. + If number of bytes >=0 then + CoinConditionalNew just returns existing pointer if array big enough + otherwise deletes existing pointer, allocates array with spare 1%+64 bytes + and updates number of bytes + CoinConditionalDelete sets number of bytes = -size-2 and then array + returns NULL +*/ +class CoinArrayWithLength { + +public: + /**@name Get methods. */ + //@{ + /// Get the size + inline int getSize() const + { return size_; } + /// Get the size + inline int rawSize() const + { return size_; } + /// See if persistence already on + inline bool switchedOn() const + { return size_!=-1; } + /// Get the capacity (just read it) + inline int capacity() const + { return (size_>-2) ? size_ : (-size_)-2; } + /// Set the capacity to >=0 if <=-2 + inline void setCapacity() + { if (size_<=-2) size_ = (-size_)-2; } + /// Get Array + inline const char * array() const + { return (size_>-2) ? array_ : NULL; } + //@} + + /**@name Set methods */ + //@{ + /// Set the size + inline void setSize(int value) + { size_ = value; } + /// Set the size to -1 + inline void switchOff() + { size_ = -1; } + /// Set the size to -2 and alignment + inline void switchOn(int alignment=3) + { size_ = -2; alignment_=alignment;} + /// Does what is needed to set persistence + void setPersistence(int flag,int currentLength); + /// Zero out array + void clear(); + /// Swaps memory between two members + void swap(CoinArrayWithLength & other); + /// Extend a persistent array keeping data (size in bytes) + void extend(int newSize); + //@} + + /**@name Condition methods */ + //@{ + /// Conditionally gets new array + char * conditionalNew(long sizeWanted); + /// Conditionally deletes + void conditionalDelete(); + //@} + + /**@name Constructors and destructors */ + //@{ + /** Default constructor - NULL*/ + inline CoinArrayWithLength() + : array_(NULL),size_(-1),offset_(0),alignment_(0) + { } + /** Alternate Constructor - length in bytes - size_ -1 */ + inline CoinArrayWithLength(int size) + : size_(-1),offset_(0),alignment_(0) + { array_=new char [size];} + /** Alternate Constructor - length in bytes + mode - 0 size_ set to size + mode>0 size_ set to size and zeroed + if size<=0 just does alignment + If abs(mode) >2 then align on that as power of 2 + */ + CoinArrayWithLength(int size, int mode); + /** Copy constructor. */ + CoinArrayWithLength(const CoinArrayWithLength & rhs); + /** Copy constructor.2 */ + CoinArrayWithLength(const CoinArrayWithLength * rhs); + /** Assignment operator. */ + CoinArrayWithLength& operator=(const CoinArrayWithLength & rhs); + /** Assignment with length (if -1 use internal length) */ + void copy(const CoinArrayWithLength & rhs, int numberBytes=-1); + /** Assignment with length - does not copy */ + void allocate(const CoinArrayWithLength & rhs, int numberBytes); + /** Destructor */ + ~CoinArrayWithLength (); + /// Get array with alignment + void getArray(int size); + /// Really get rid of array with alignment + void reallyFreeArray(); + /// Get enough space (if more needed then do at least needed) + void getCapacity(int numberBytes,int numberIfNeeded=-1); + //@} + +protected: + /**@name Private member data */ + //@{ + /// Array + char * array_; + /// Size of array in bytes + CoinBigIndex size_; + /// Offset of array + int offset_; + /// Alignment wanted (power of 2) + int alignment_; + //@} +}; +/// double * version + +class CoinDoubleArrayWithLength : public CoinArrayWithLength { + +public: + /**@name Get methods. */ + //@{ + /// Get the size + inline int getSize() const + { return size_/CoinSizeofAsInt(double); } + /// Get Array + inline double * array() const + { return reinterpret_cast<double *> ((size_>-2) ? array_ : NULL); } + //@} + + /**@name Set methods */ + //@{ + /// Set the size + inline void setSize(int value) + { size_ = value*CoinSizeofAsInt(double); } + //@} + + /**@name Condition methods */ + //@{ + /// Conditionally gets new array + inline double * conditionalNew(int sizeWanted) + { return reinterpret_cast<double *> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> ((sizeWanted)*CoinSizeofAsInt(double)) : -1)); } + //@} + + /**@name Constructors and destructors */ + //@{ + /** Default constructor - NULL*/ + inline CoinDoubleArrayWithLength() + { array_=NULL; size_=-1;} + /** Alternate Constructor - length in bytes - size_ -1 */ + inline CoinDoubleArrayWithLength(int size) + { array_=new char [size*CoinSizeofAsInt(double)]; size_=-1;} + /** Alternate Constructor - length in bytes + mode - 0 size_ set to size + 1 size_ set to size and zeroed + */ + inline CoinDoubleArrayWithLength(int size, int mode) + : CoinArrayWithLength(size*CoinSizeofAsInt(double),mode) {} + /** Copy constructor. */ + inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength & rhs) + : CoinArrayWithLength(rhs) {} + /** Copy constructor.2 */ + inline CoinDoubleArrayWithLength(const CoinDoubleArrayWithLength * rhs) + : CoinArrayWithLength(rhs) {} + /** Assignment operator. */ + inline CoinDoubleArrayWithLength& operator=(const CoinDoubleArrayWithLength & rhs) + { CoinArrayWithLength::operator=(rhs); return *this;} + //@} +}; +/// CoinFactorizationDouble * version + +class CoinFactorizationDoubleArrayWithLength : public CoinArrayWithLength { + +public: + /**@name Get methods. */ + //@{ + /// Get the size + inline int getSize() const + { return size_/CoinSizeofAsInt(CoinFactorizationDouble); } + /// Get Array + inline CoinFactorizationDouble * array() const + { return reinterpret_cast<CoinFactorizationDouble *> ((size_>-2) ? array_ : NULL); } + //@} + + /**@name Set methods */ + //@{ + /// Set the size + inline void setSize(int value) + { size_ = value*CoinSizeofAsInt(CoinFactorizationDouble); } + //@} + + /**@name Condition methods */ + //@{ + /// Conditionally gets new array + inline CoinFactorizationDouble * conditionalNew(int sizeWanted) + { return reinterpret_cast<CoinFactorizationDouble *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(CoinFactorizationDouble)) : -1)); } + //@} + + /**@name Constructors and destructors */ + //@{ + /** Default constructor - NULL*/ + inline CoinFactorizationDoubleArrayWithLength() + { array_=NULL; size_=-1;} + /** Alternate Constructor - length in bytes - size_ -1 */ + inline CoinFactorizationDoubleArrayWithLength(int size) + { array_=new char [size*CoinSizeofAsInt(CoinFactorizationDouble)]; size_=-1;} + /** Alternate Constructor - length in bytes + mode - 0 size_ set to size + 1 size_ set to size and zeroed + */ + inline CoinFactorizationDoubleArrayWithLength(int size, int mode) + : CoinArrayWithLength(size*CoinSizeofAsInt(CoinFactorizationDouble),mode) {} + /** Copy constructor. */ + inline CoinFactorizationDoubleArrayWithLength(const CoinFactorizationDoubleArrayWithLength & rhs) + : CoinArrayWithLength(rhs) {} + /** Copy constructor.2 */ + inline CoinFactorizationDoubleArrayWithLength(const CoinFactorizationDoubleArrayWithLength * rhs) + : CoinArrayWithLength(rhs) {} + /** Assignment operator. */ + inline CoinFactorizationDoubleArrayWithLength& operator=(const CoinFactorizationDoubleArrayWithLength & rhs) + { CoinArrayWithLength::operator=(rhs); return *this;} + //@} +}; +/// CoinFactorizationLongDouble * version + +class CoinFactorizationLongDoubleArrayWithLength : public CoinArrayWithLength { + +public: + /**@name Get methods. */ + //@{ + /// Get the size + inline int getSize() const + { return size_/CoinSizeofAsInt(long double); } + /// Get Array + inline long double * array() const + { return reinterpret_cast<long double *> ((size_>-2) ? array_ : NULL); } + //@} + + /**@name Set methods */ + //@{ + /// Set the size + inline void setSize(int value) + { size_ = value*CoinSizeofAsInt(long double); } + //@} + + /**@name Condition methods */ + //@{ + /// Conditionally gets new array + inline long double * conditionalNew(int sizeWanted) + { return reinterpret_cast<long double *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(long double)) : -1)); } + //@} + + /**@name Constructors and destructors */ + //@{ + /** Default constructor - NULL*/ + inline CoinFactorizationLongDoubleArrayWithLength() + { array_=NULL; size_=-1;} + /** Alternate Constructor - length in bytes - size_ -1 */ + inline CoinFactorizationLongDoubleArrayWithLength(int size) + { array_=new char [size*CoinSizeofAsInt(long double)]; size_=-1;} + /** Alternate Constructor - length in bytes + mode - 0 size_ set to size + 1 size_ set to size and zeroed + */ + inline CoinFactorizationLongDoubleArrayWithLength(int size, int mode) + : CoinArrayWithLength(size*CoinSizeofAsInt(long double),mode) {} + /** Copy constructor. */ + inline CoinFactorizationLongDoubleArrayWithLength(const CoinFactorizationLongDoubleArrayWithLength & rhs) + : CoinArrayWithLength(rhs) {} + /** Copy constructor.2 */ + inline CoinFactorizationLongDoubleArrayWithLength(const CoinFactorizationLongDoubleArrayWithLength * rhs) + : CoinArrayWithLength(rhs) {} + /** Assignment operator. */ + inline CoinFactorizationLongDoubleArrayWithLength& operator=(const CoinFactorizationLongDoubleArrayWithLength & rhs) + { CoinArrayWithLength::operator=(rhs); return *this;} + //@} +}; +/// int * version + +class CoinIntArrayWithLength : public CoinArrayWithLength { + +public: + /**@name Get methods. */ + //@{ + /// Get the size + inline int getSize() const + { return size_/CoinSizeofAsInt(int); } + /// Get Array + inline int * array() const + { return reinterpret_cast<int *> ((size_>-2) ? array_ : NULL); } + //@} + + /**@name Set methods */ + //@{ + /// Set the size + inline void setSize(int value) + { size_ = value*CoinSizeofAsInt(int); } + //@} + + /**@name Condition methods */ + //@{ + /// Conditionally gets new array + inline int * conditionalNew(int sizeWanted) + { return reinterpret_cast<int *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(int)) : -1)); } + //@} + + /**@name Constructors and destructors */ + //@{ + /** Default constructor - NULL*/ + inline CoinIntArrayWithLength() + { array_=NULL; size_=-1;} + /** Alternate Constructor - length in bytes - size_ -1 */ + inline CoinIntArrayWithLength(int size) + { array_=new char [size*CoinSizeofAsInt(int)]; size_=-1;} + /** Alternate Constructor - length in bytes + mode - 0 size_ set to size + 1 size_ set to size and zeroed + */ + inline CoinIntArrayWithLength(int size, int mode) + : CoinArrayWithLength(size*CoinSizeofAsInt(int),mode) {} + /** Copy constructor. */ + inline CoinIntArrayWithLength(const CoinIntArrayWithLength & rhs) + : CoinArrayWithLength(rhs) {} + /** Copy constructor.2 */ + inline CoinIntArrayWithLength(const CoinIntArrayWithLength * rhs) + : CoinArrayWithLength(rhs) {} + /** Assignment operator. */ + inline CoinIntArrayWithLength& operator=(const CoinIntArrayWithLength & rhs) + { CoinArrayWithLength::operator=(rhs); return *this;} + //@} +}; +/// CoinBigIndex * version + +class CoinBigIndexArrayWithLength : public CoinArrayWithLength { + +public: + /**@name Get methods. */ + //@{ + /// Get the size + inline int getSize() const + { return size_/CoinSizeofAsInt(CoinBigIndex); } + /// Get Array + inline CoinBigIndex * array() const + { return reinterpret_cast<CoinBigIndex *> ((size_>-2) ? array_ : NULL); } + //@} + + /**@name Set methods */ + //@{ + /// Set the size + inline void setSize(int value) + { size_ = value*CoinSizeofAsInt(CoinBigIndex); } + //@} + + /**@name Condition methods */ + //@{ + /// Conditionally gets new array + inline CoinBigIndex * conditionalNew(int sizeWanted) + { return reinterpret_cast<CoinBigIndex *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(CoinBigIndex)) : -1)); } + //@} + + /**@name Constructors and destructors */ + //@{ + /** Default constructor - NULL*/ + inline CoinBigIndexArrayWithLength() + { array_=NULL; size_=-1;} + /** Alternate Constructor - length in bytes - size_ -1 */ + inline CoinBigIndexArrayWithLength(int size) + { array_=new char [size*CoinSizeofAsInt(CoinBigIndex)]; size_=-1;} + /** Alternate Constructor - length in bytes + mode - 0 size_ set to size + 1 size_ set to size and zeroed + */ + inline CoinBigIndexArrayWithLength(int size, int mode) + : CoinArrayWithLength(size*CoinSizeofAsInt(CoinBigIndex),mode) {} + /** Copy constructor. */ + inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength & rhs) + : CoinArrayWithLength(rhs) {} + /** Copy constructor.2 */ + inline CoinBigIndexArrayWithLength(const CoinBigIndexArrayWithLength * rhs) + : CoinArrayWithLength(rhs) {} + /** Assignment operator. */ + inline CoinBigIndexArrayWithLength& operator=(const CoinBigIndexArrayWithLength & rhs) + { CoinArrayWithLength::operator=(rhs); return *this;} + //@} +}; +/// unsigned int * version + +class CoinUnsignedIntArrayWithLength : public CoinArrayWithLength { + +public: + /**@name Get methods. */ + //@{ + /// Get the size + inline int getSize() const + { return size_/CoinSizeofAsInt(unsigned int); } + /// Get Array + inline unsigned int * array() const + { return reinterpret_cast<unsigned int *> ((size_>-2) ? array_ : NULL); } + //@} + + /**@name Set methods */ + //@{ + /// Set the size + inline void setSize(int value) + { size_ = value*CoinSizeofAsInt(unsigned int); } + //@} + + /**@name Condition methods */ + //@{ + /// Conditionally gets new array + inline unsigned int * conditionalNew(int sizeWanted) + { return reinterpret_cast<unsigned int *> (CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> (( sizeWanted)*CoinSizeofAsInt(unsigned int)) : -1)); } + //@} + + /**@name Constructors and destructors */ + //@{ + /** Default constructor - NULL*/ + inline CoinUnsignedIntArrayWithLength() + { array_=NULL; size_=-1;} + /** Alternate Constructor - length in bytes - size_ -1 */ + inline CoinUnsignedIntArrayWithLength(int size) + { array_=new char [size*CoinSizeofAsInt(unsigned int)]; size_=-1;} + /** Alternate Constructor - length in bytes + mode - 0 size_ set to size + 1 size_ set to size and zeroed + */ + inline CoinUnsignedIntArrayWithLength(int size, int mode) + : CoinArrayWithLength(size*CoinSizeofAsInt(unsigned int),mode) {} + /** Copy constructor. */ + inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength & rhs) + : CoinArrayWithLength(rhs) {} + /** Copy constructor.2 */ + inline CoinUnsignedIntArrayWithLength(const CoinUnsignedIntArrayWithLength * rhs) + : CoinArrayWithLength(rhs) {} + /** Assignment operator. */ + inline CoinUnsignedIntArrayWithLength& operator=(const CoinUnsignedIntArrayWithLength & rhs) + { CoinArrayWithLength::operator=(rhs); return *this;} + //@} +}; +/// void * version + +class CoinVoidStarArrayWithLength : public CoinArrayWithLength { + +public: + /**@name Get methods. */ + //@{ + /// Get the size + inline int getSize() const + { return size_/CoinSizeofAsInt(void *); } + /// Get Array + inline void ** array() const + { return reinterpret_cast<void **> ((size_>-2) ? array_ : NULL); } + //@} + + /**@name Set methods */ + //@{ + /// Set the size + inline void setSize(int value) + { size_ = value*CoinSizeofAsInt(void *); } + //@} + + /**@name Condition methods */ + //@{ + /// Conditionally gets new array + inline void ** conditionalNew(int sizeWanted) + { return reinterpret_cast<void **> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> ((sizeWanted)*CoinSizeofAsInt(void *)) : -1)); } + //@} + + /**@name Constructors and destructors */ + //@{ + /** Default constructor - NULL*/ + inline CoinVoidStarArrayWithLength() + { array_=NULL; size_=-1;} + /** Alternate Constructor - length in bytes - size_ -1 */ + inline CoinVoidStarArrayWithLength(int size) + { array_=new char [size*CoinSizeofAsInt(void *)]; size_=-1;} + /** Alternate Constructor - length in bytes + mode - 0 size_ set to size + 1 size_ set to size and zeroed + */ + inline CoinVoidStarArrayWithLength(int size, int mode) + : CoinArrayWithLength(size*CoinSizeofAsInt(void *),mode) {} + /** Copy constructor. */ + inline CoinVoidStarArrayWithLength(const CoinVoidStarArrayWithLength & rhs) + : CoinArrayWithLength(rhs) {} + /** Copy constructor.2 */ + inline CoinVoidStarArrayWithLength(const CoinVoidStarArrayWithLength * rhs) + : CoinArrayWithLength(rhs) {} + /** Assignment operator. */ + inline CoinVoidStarArrayWithLength& operator=(const CoinVoidStarArrayWithLength & rhs) + { CoinArrayWithLength::operator=(rhs); return *this;} + //@} +}; +/// arbitrary version + +class CoinArbitraryArrayWithLength : public CoinArrayWithLength { + +public: + /**@name Get methods. */ + //@{ + /// Get the size + inline int getSize() const + { return size_/lengthInBytes_; } + /// Get Array + inline void ** array() const + { return reinterpret_cast<void **> ((size_>-2) ? array_ : NULL); } + //@} + + /**@name Set methods */ + //@{ + /// Set the size + inline void setSize(int value) + { size_ = value*lengthInBytes_; } + //@} + + /**@name Condition methods */ + //@{ + /// Conditionally gets new array + inline char * conditionalNew(int length, int sizeWanted) + { lengthInBytes_=length;return reinterpret_cast<char *> ( CoinArrayWithLength::conditionalNew(sizeWanted>=0 ? static_cast<long> + ((sizeWanted)*lengthInBytes_) : -1)); } + //@} + + /**@name Constructors and destructors */ + //@{ + /** Default constructor - NULL*/ + inline CoinArbitraryArrayWithLength(int length=1) + { array_=NULL; size_=-1;lengthInBytes_=length;} + /** Alternate Constructor - length in bytes - size_ -1 */ + inline CoinArbitraryArrayWithLength(int length, int size) + { array_=new char [size*length]; size_=-1; lengthInBytes_=length;} + /** Alternate Constructor - length in bytes + mode - 0 size_ set to size + 1 size_ set to size and zeroed + */ + inline CoinArbitraryArrayWithLength(int length, int size, int mode) + : CoinArrayWithLength(size*length,mode) {lengthInBytes_=length;} + /** Copy constructor. */ + inline CoinArbitraryArrayWithLength(const CoinArbitraryArrayWithLength & rhs) + : CoinArrayWithLength(rhs) {} + /** Copy constructor.2 */ + inline CoinArbitraryArrayWithLength(const CoinArbitraryArrayWithLength * rhs) + : CoinArrayWithLength(rhs) {} + /** Assignment operator. */ + inline CoinArbitraryArrayWithLength& operator=(const CoinArbitraryArrayWithLength & rhs) + { CoinArrayWithLength::operator=(rhs); return *this;} + //@} + +protected: + /**@name Private member data */ + //@{ + /// Length in bytes + int lengthInBytes_; + //@} +}; +class CoinPartitionedVector : public CoinIndexedVector { + +public: +#ifndef COIN_PARTITIONS +#define COIN_PARTITIONS 8 +#endif + /**@name Get methods. */ + //@{ + /// Get the size of a partition + inline int getNumElements(int partition) const { assert (partition<COIN_PARTITIONS); + return numberElementsPartition_[partition]; } + /// Get number of partitions + inline int getNumPartitions() const + { return numberPartitions_; } + /// Get the size + inline int getNumElements() const { return nElements_; } + /// Get starts + inline int startPartition(int partition) const { assert (partition<=COIN_PARTITIONS); + return startPartition_[partition]; } + /// Get starts + inline const int * startPartitions() const + { return startPartition_; } + //@} + + //------------------------------------------------------------------- + // Set indices and elements + //------------------------------------------------------------------- + /**@name Set methods */ + //@{ + /// Set the size of a partition + inline void setNumElementsPartition(int partition, int value) { assert (partition<COIN_PARTITIONS); + if (numberPartitions_) numberElementsPartition_[partition]=value; } + /// Set the size of a partition (just for a tiny while) + inline void setTempNumElementsPartition(int partition, int value) { assert (partition<COIN_PARTITIONS); + numberElementsPartition_[partition]=value; } + /// Add up number of elements in partitions + void computeNumberElements(); + /// Add up number of elements in partitions and pack and get rid of partitions + void compact(); + /** Reserve space. + */ + void reserve(int n); + /// Setup partitions (needs end as well) + void setPartitions(int number,const int * starts); + /// Reset the vector (as if were just created an empty vector). Gets rid of partitions + void clearAndReset(); + /// Reset the vector (as if were just created an empty vector). Keeps partitions + void clearAndKeep(); + /// Clear a partition. + void clearPartition(int partition); +#ifndef NDEBUG + /// For debug check vector is clear i.e. no elements + void checkClear(); + /// For debug check vector is clean i.e. elements match indices + void checkClean(); +#else + inline void checkClear() {}; + inline void checkClean() {}; +#endif + /// Scan dense region and set up indices (returns number found) + int scan(int partition, double tolerance=0.0); + /** Scan dense region from start to < end and set up indices + returns number found + */ + /// Print out + void print() const; + //@} + + /**@name Sorting */ + //@{ + /** Sort the indexed storage vector (increasing indices). */ + void sort(); + //@} + + /**@name Constructors and destructors (not all wriiten) */ + //@{ + /** Default constructor */ + CoinPartitionedVector(); + /** Alternate Constructors - set elements to vector of doubles */ + CoinPartitionedVector(int size, const int * inds, const double * elems); + /** Alternate Constructors - set elements to same scalar value */ + CoinPartitionedVector(int size, const int * inds, double element); + /** Alternate Constructors - construct full storage with indices 0 through + size-1. */ + CoinPartitionedVector(int size, const double * elements); + /** Alternate Constructors - just size */ + CoinPartitionedVector(int size); + /** Copy constructor. */ + CoinPartitionedVector(const CoinPartitionedVector &); + /** Copy constructor.2 */ + CoinPartitionedVector(const CoinPartitionedVector *); + /** Assignment operator. */ + CoinPartitionedVector & operator=(const CoinPartitionedVector &); + /** Destructor */ + ~CoinPartitionedVector (); + //@} +protected: + /**@name Private member data */ + //@{ + /// Starts + int startPartition_[COIN_PARTITIONS+1]; + /// Size of indices in a partition + int numberElementsPartition_[COIN_PARTITIONS]; + /// Number of partitions (0 means off) + int numberPartitions_; + //@} +}; +#endif diff --git a/thirdparty/windows/include/coin/CoinLpIO.hpp b/thirdparty/windows/include/coin/CoinLpIO.hpp new file mode 100644 index 0000000..43c0e20 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinLpIO.hpp @@ -0,0 +1,805 @@ +/* $Id: CoinLpIO.hpp 1749 2014-10-24 20:00:14Z tkr $ */ +// Last edit: 11/5/08 +// +// Name: CoinLpIO.hpp; Support for Lp files +// Author: Francois Margot +// Tepper School of Business +// Carnegie Mellon University, Pittsburgh, PA 15213 +// email: fmargot@andrew.cmu.edu +// Date: 12/28/03 +//----------------------------------------------------------------------------- +// Copyright (C) 2003, Francois Margot, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef CoinLpIO_H +#define CoinLpIO_H + +#include <cstdio> + +#include "CoinPackedMatrix.hpp" +#include "CoinMessage.hpp" +class CoinSet; + +const int MAX_OBJECTIVES = 2; + +typedef int COINColumnIndex; + + /** Class to read and write Lp files + + Lp file format: + +/ this is a comment <BR> +\ this too <BR> + Min<BR> + obj: x0 + x1 + 3 x2 - 4.5 xyr + 1 <BR> + s.t. <BR> + cons1: x0 - x2 - 2.3 x4 <= 4.2 / this is another comment <BR> + c2: x1 + x2 >= 1 <BR> + cc: x1 + x2 + xyr = 2 <BR> + Bounds <BR> + 0 <= x1 <= 3 <BR> + 1 >= x2 <BR> + x3 = 1 <BR> + -2 <= x4 <= Inf <BR> + xyr free <BR> + Integers <BR> + x0 <BR> + Generals <BR> + x1 xyr <BR> + Binaries <BR> + x2 <BR> + End + +Notes: <UL> + <LI> Keywords are: Min, Max, Minimize, Maximize, s.t., Subject To, + Bounds, Integers, Generals, Binaries, End, Free, Inf. + <LI> Keywords are not case sensitive and may be in plural or singular form. + They should not be used as objective, row or column names. + <LI> Bounds, Integers, Generals, Binaries sections are optional. + <LI> Generals and Integers are synonymous. + <LI> Bounds section (if any) must come before Integers, Generals, and + Binaries sections. + <LI> Row names must be followed by ':' without blank space. + Row names are optional. If row names are present, + they must be distinct (if the k-th constraint has no given name, its name + is set automatically to "consk" for k=0,...,). + For valid row names, see the method is_invalid_name(). + <LI> Column names must be followed by a blank space. They must be distinct. + For valid column names, see the method is_invalid_name(). + <LI> Multiple objectives may be specified, but when there are multiple + objectives, they must have names (to indicate where each one starts). + <LI> The objective function names must be followed by ':' without blank space. + If there is a single objective, the objective function name is optional. + If no name is given, the name is set to "obj" by default. + For valid objective function names, see the method is_invalid_name(). + <LI> Ranged constraints are written as two constraints. + If a name is given for a ranged constraint, the upper bound constraint + has that name and the lower bound constraint has that name with "_low" + as suffix. This should be kept in mind when assigning names to ranged + constraint, as the resulting name must be distinct from all the other + names and be considered valid by the method is_invalid_name(). + <LI> At most one term related to any single variable may appear in the + objective function; if more than one term are present, only the last + one is taken into account. + At most one constant term may appear in the objective function; + if present, it must appear last. + <LI> Default bounds are 0 for lower bound and +infinity for upper bound. + <LI> Free variables get default lower bound -infinity and + default upper bound +infinity. Writing "x0 Free" in an + LP file means "set lower bound on x0 to -infinity". + <LI> If more than one upper (resp. lower) bound on a variable appears in + the Bounds section, the last one is the one taken into + account. The bounds for a binary variable are set to 0/1 only if this + bound is stronger than the bound obtained from the Bounds section. + <LI> Numbers larger than DBL_MAX (or larger than 1e+400) in the input file + might crash the code. + <LI> A comment must start with '\' or '/'. That symbol must either be + the first character of a line or be preceded by a blank space. The + comment ends at the end of the + line. Comments are skipped while reading an Lp file and they may be + inserted anywhere. +</UL> +*/ +class CoinLpIO { + friend void CoinLpIOUnitTest(const std::string & lpDir); +public: + + /**@name Constructor and Destructor */ + //@{ + /// Default Constructor + CoinLpIO(); + + /// Does the heavy lifting for destruct and assignment. + void gutsOfDestructor(); + + /// Does the heavy lifting for copy and assignment + void gutsOfCopy(const CoinLpIO &); + + /// assignment operator + CoinLpIO & operator = (const CoinLpIO& rhs) ; + + /// Copy constructor + CoinLpIO (const CoinLpIO &); + + /// Destructor + ~CoinLpIO(); + + /** Free the vector previous_names_[section] and set + card_previous_names_[section] to 0. + section = 0 for row names, + section = 1 for column names. + */ + void freePreviousNames(const int section); + + /// Free all memory (except memory related to hash tables and objName_). + void freeAll(); + //@} + + /** A quick inlined function to convert from lb/ub style constraint + definition to sense/rhs/range style */ + inline void + convertBoundToSense(const double lower, const double upper, + char& sense, double& right, double& range) const; + + /**@name Queries */ + //@{ + + /// Get the problem name + const char * getProblemName() const; + + /// Set problem name + void setProblemName(const char *name); + + /// Get number of columns + int getNumCols() const; + + /// Get number of rows + int getNumRows() const; + + /// Get number of nonzero elements + int getNumElements() const; + + /// Get pointer to array[getNumCols()] of column lower bounds + const double * getColLower() const; + + /// Get pointer to array[getNumCols()] of column upper bounds + const double * getColUpper() const; + + /// Get pointer to array[getNumRows()] of row lower bounds + const double * getRowLower() const; + + /// Get pointer to array[getNumRows()] of row upper bounds + const double * getRowUpper() const; + /** Get pointer to array[getNumRows()] of constraint senses. + <ul> + <li>'L': <= constraint + <li>'E': = constraint + <li>'G': >= constraint + <li>'R': ranged constraint + <li>'N': free constraint + </ul> + */ + const char * getRowSense() const; + + /** Get pointer to array[getNumRows()] of constraint right-hand sides. + + Given constraints with upper (rowupper) and/or lower (rowlower) bounds, + the constraint right-hand side (rhs) is set as + <ul> + <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i] + <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i] + <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i] + <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0 + </ul> + */ + const double * getRightHandSide() const; + + /** Get pointer to array[getNumRows()] of row ranges. + + Given constraints with upper (rowupper) and/or lower (rowlower) bounds, + the constraint range (rowrange) is set as + <ul> + <li> if rowsense()[i] == 'R' then + rowrange()[i] == rowupper()[i] - rowlower()[i] + <li> if rowsense()[i] != 'R' then + rowrange()[i] is 0.0 + </ul> + Put another way, only ranged constraints have a nontrivial value for + rowrange. + */ + const double * getRowRange() const; + + /// Get pointer to array[getNumCols()] of objective function coefficients + const int getNumObjectives() const; + + /// Get pointer to array[getNumCols()] of objective function coefficients + const double * getObjCoefficients() const; + + /// Get pointer to array[getNumCols()] of objective function coefficients for objective j + const double * getObjCoefficients(int j) const; + + /// Get pointer to row-wise copy of the coefficient matrix + const CoinPackedMatrix * getMatrixByRow() const; + + /// Get pointer to column-wise copy of the coefficient matrix + const CoinPackedMatrix * getMatrixByCol() const; + + /// Get objective function name + const char * getObjName() const; + + /// Get objective function name for objective j + const char * getObjName(int j) const; + + /// Get pointer to array[*card_prev] of previous row names. + /// The value of *card_prev might be different than getNumRows()+1 if + /// non distinct + /// row names were present or if no previous names were saved or if + /// the object was holding a different problem before. + void getPreviousRowNames(char const * const * prev, + int *card_prev) const; + + /// Get pointer to array[*card_prev] of previous column names. + /// The value of *card_prev might be different than getNumCols() if non + /// distinct column names were present of if no previous names were saved, + /// or if the object was holding a different problem before. + void getPreviousColNames(char const * const * prev, + int *card_prev) const; + + /// Get pointer to array[getNumRows()+1] of row names, including + /// objective function name as last entry. + char const * const * getRowNames() const; + + /// Get pointer to array[getNumCols()] of column names + char const * const *getColNames() const; + + /// Return the row name for the specified index. + /// Return the objective function name if index = getNumRows(). + /// Return 0 if the index is out of range or if row names are not defined. + const char * rowName(int index) const; + + /// Return the column name for the specified index. + /// Return 0 if the index is out of range or if column names are not + /// defined. + const char * columnName(int index) const; + + /// Return the index for the specified row name. + /// Return getNumRows() for the objective function name. + /// Return -1 if the name is not found. + int rowIndex(const char * name) const; + + /// Return the index for the specified column name. + /// Return -1 if the name is not found. + int columnIndex(const char * name) const; + + ///Returns the (constant) objective offset + double objectiveOffset() const; + + ///Returns the (constant) objective offset for objective j + double objectiveOffset(int j) const; + + /// Set objective offset + inline void setObjectiveOffset(double value) + { objectiveOffset_[0] = value;} + + /// Set objective offset + inline void setObjectiveOffset(double value, int j) + { objectiveOffset_[j] = value;} + + /// Return true if a column is an integer (binary or general + /// integer) variable + bool isInteger(int columnNumber) const; + + /// Get characteristic vector of integer variables + const char * integerColumns() const; + //@} + + /**@name Parameters */ + //@{ + /// Get infinity + double getInfinity() const; + + /// Set infinity. Any number larger is considered infinity. + /// Default: DBL_MAX + void setInfinity(const double); + + /// Get epsilon + double getEpsilon() const; + + /// Set epsilon. + /// Default: 1e-5. + void setEpsilon(const double); + + /// Get numberAcross, the number of monomials to be printed per line + int getNumberAcross() const; + + /// Set numberAcross. + /// Default: 10. + void setNumberAcross(const int); + + /// Get decimals, the number of digits to write after the decimal point + int getDecimals() const; + + /// Set decimals. + /// Default: 5 + void setDecimals(const int); + //@} + + /**@name Public methods */ + //@{ + /** Set the data of the object. + Set it from the coefficient matrix m, the lower bounds + collb, the upper bounds colub, objective function obj_coeff, + integrality vector integrality, lower/upper bounds on the constraints. + The sense of optimization of the objective function is assumed to be + a minimization. + Numbers larger than DBL_MAX (or larger than 1e+400) + might crash the code. There are two version. The second one is for + setting multiple objectives. + */ + void setLpDataWithoutRowAndColNames( + const CoinPackedMatrix& m, + const double* collb, const double* colub, + const double* obj_coeff, + const char* integrality, + const double* rowlb, const double* rowub); + + void setLpDataWithoutRowAndColNames( + const CoinPackedMatrix& m, + const double* collb, const double* colub, + const double* obj_coeff[MAX_OBJECTIVES], + int num_objectives, + const char* integrality, + const double* rowlb, const double* rowub); + + /** Return 0 if buff is a valid name for a row, a column or objective + function, return a positive number otherwise. + If parameter ranged = true, the name is intended for a ranged + constraint. <BR> + Return 1 if the name has more than 100 characters (96 characters + for a ranged constraint name, as "_low" will be added to the name).<BR> + Return 2 if the name starts with a number.<BR> + Return 3 if the name is not built with + the letters a to z, A to Z, the numbers 0 to 9 or the characters + " ! # $ % & ( ) . ; ? @ _ ' ` { } ~ <BR> + Return 4 if the name is a keyword.<BR> + Return 5 if the name is empty or NULL. */ + int is_invalid_name(const char *buff, const bool ranged) const; + + /** Return 0 if each of the card_vnames entries of vnames is a valid name, + return a positive number otherwise. The return value, if not 0, is the + return value of is_invalid_name() for the last invalid name + in vnames. If check_ranged = true, the names are row names and + names for ranged constaints must be checked for additional restrictions + since "_low" will be added to the name if an Lp file is written. + When check_ranged = true, card_vnames must have getNumRows()+1 entries, + with entry vnames[getNumRows()] being the + name of the objective function. + For a description of valid names and return values, see the method + is_invalid_name(). + + This method must not be called with check_ranged = true before + setLpDataWithoutRowAndColNames() has been called, since access + to the indices of all the ranged constraints is required. + */ + int are_invalid_names(char const * const *vnames, + const int card_vnames, + const bool check_ranged) const; + + /// Set objective function name to the default "obj" and row + /// names to the default "cons0", "cons1", ... + void setDefaultRowNames(); + + /// Set column names to the default "x0", "x1", ... + void setDefaultColNames(); + + /** Set the row and column names. + The array rownames must either be NULL or have exactly getNumRows()+1 + distinct entries, + each of them being a valid name (see is_invalid_name()) and the + last entry being the intended name for the objective function. + If rownames is NULL, existing row names and objective function + name are not changed. + If rownames is deemed invalid, default row names and objective function + name are used (see setDefaultRowNames()). The memory location of + array rownames (or its entries) should not be related + to the memory location of the array (or entries) obtained from + getRowNames() or getPreviousRowNames(), as the call to + setLpDataRowAndColNames() modifies the corresponding arrays. + Unpredictable results + are obtained if this requirement is ignored. + + Similar remarks apply to the array colnames, which must either be + NULL or have exactly getNumCols() entries. + */ + void setLpDataRowAndColNames(char const * const * const rownames, + char const * const * const colnames); + + /** Write the data in Lp format in the file with name filename. + Coefficients with value less than epsilon away from an integer value + are written as integers. + Write at most numberAcross monomials on a line. + Write non integer numbers with decimals digits after the decimal point. + Write objective function name and row names if useRowNames = true. + + Ranged constraints are written as two constraints. + If row names are used, the upper bound constraint has the + name of the original ranged constraint and the + lower bound constraint has for name the original name with + "_low" as suffix. If doing so creates two identical row names, + default row names are used (see setDefaultRowNames()). + */ + int writeLp(const char *filename, + const double epsilon, + const int numberAcross, + const int decimals, + const bool useRowNames = true); + + /** Write the data in Lp format in the file pointed to by the paramater fp. + Coefficients with value less than epsilon away from an integer value + are written as integers. + Write at most numberAcross monomials on a line. + Write non integer numbers with decimals digits after the decimal point. + Write objective function name and row names if useRowNames = true. + + Ranged constraints are written as two constraints. + If row names are used, the upper bound constraint has the + name of the original ranged constraint and the + lower bound constraint has for name the original name with + "_low" as suffix. If doing so creates two identical row names, + default row names are used (see setDefaultRowNames()). + */ + int writeLp(FILE *fp, + const double epsilon, + const int numberAcross, + const int decimals, + const bool useRowNames = true); + + /// Write the data in Lp format in the file with name filename. + /// Write objective function name and row names if useRowNames = true. + int writeLp(const char *filename, const bool useRowNames = true); + + /// Write the data in Lp format in the file pointed to by the parameter fp. + /// Write objective function name and row names if useRowNames = true. + int writeLp(FILE *fp, const bool useRowNames = true); + + /// Read the data in Lp format from the file with name filename, using + /// the given value for epsilon. If the original problem is + /// a maximization problem, the objective function is immediadtly + /// flipped to get a minimization problem. + void readLp(const char *filename, const double epsilon); + + /// Read the data in Lp format from the file with name filename. + /// If the original problem is + /// a maximization problem, the objective function is immediadtly + /// flipped to get a minimization problem. + void readLp(const char *filename); + + /// Read the data in Lp format from the file stream, using + /// the given value for epsilon. + /// If the original problem is + /// a maximization problem, the objective function is immediadtly + /// flipped to get a minimization problem. + void readLp(FILE *fp, const double epsilon); + + /// Read the data in Lp format from the file stream. + /// If the original problem is + /// a maximization problem, the objective function is immediadtly + /// flipped to get a minimization problem. + void readLp(FILE *fp); + + /// Dump the data. Low level method for debugging. + void print() const; + + /// Load in SOS stuff + void loadSOS(int numberSets,const CoinSet * sets); + + /// Load in SOS stuff + void loadSOS(int numberSets,const CoinSet ** sets); + + /// Number of SOS sets + inline int numberSets() const + { return numberSets_;} + + /// Set information + inline CoinSet ** setInformation() const + { return set_;} + //@} +/**@name Message handling */ +//@{ + /** Pass in Message handler + + Supply a custom message handler. It will not be destroyed when the + CoinMpsIO object is destroyed. + */ + void passInMessageHandler(CoinMessageHandler * handler); + + /// Set the language for messages. + void newLanguage(CoinMessages::Language language); + + /// Set the language for messages. + inline void setLanguage(CoinMessages::Language language) {newLanguage(language);} + + /// Return the message handler + inline CoinMessageHandler * messageHandler() const {return handler_;} + + /// Return the messages + inline CoinMessages messages() {return messages_;} + /// Return the messages pointer + inline CoinMessages * messagesPointer() {return & messages_;} +//@} + +protected: + /// Problem name + char * problemName_; + + /// Message handler + CoinMessageHandler * handler_; + /** Flag to say if the message handler is the default handler. + + If true, the handler will be destroyed when the CoinMpsIO + object is destroyed; if false, it will not be destroyed. + */ + bool defaultHandler_; + /// Messages + CoinMessages messages_; + + /// Number of rows + int numberRows_; + + /// Number of columns + int numberColumns_; + + /// Number of elements + int numberElements_; + + /// Pointer to column-wise copy of problem matrix coefficients. + mutable CoinPackedMatrix *matrixByColumn_; + + /// Pointer to row-wise copy of problem matrix coefficients. + CoinPackedMatrix *matrixByRow_; + + /// Pointer to dense vector of row lower bounds + double * rowlower_; + + /// Pointer to dense vector of row upper bounds + double * rowupper_; + + /// Pointer to dense vector of column lower bounds + double * collower_; + + /// Pointer to dense vector of column upper bounds + double * colupper_; + + /// Pointer to dense vector of row rhs + mutable double * rhs_; + + /** Pointer to dense vector of slack variable upper bounds for ranged + constraints (undefined for non-ranged constraints) + */ + mutable double *rowrange_; + + /// Pointer to dense vector of row senses + mutable char * rowsense_; + + /// Pointer to dense vector of objective coefficients + double * objective_[MAX_OBJECTIVES]; + + /// Number of objectives + int num_objectives_; + + /// Constant offset for objective value + double objectiveOffset_[MAX_OBJECTIVES]; + + /// Pointer to dense vector specifying if a variable is continuous + /// (0) or integer (1). + char * integerType_; + + /// Pointer to sets + CoinSet ** set_; + + /// Number of sets + int numberSets_; + + /// Current file name + char * fileName_; + + /// Value to use for infinity + double infinity_; + + /// Value to use for epsilon + double epsilon_; + + /// Number of monomials printed in a row + int numberAcross_; + + /// Number of decimals printed for coefficients + int decimals_; + + /// Objective function name + char *objName_[MAX_OBJECTIVES]; + + /** Row names (including objective function name) + and column names when stopHash() for the corresponding + section was last called or for initial names (deemed invalid) + read from a file.<BR> + section = 0 for row names, + section = 1 for column names. */ + char **previous_names_[2]; + + /// card_previous_names_[section] holds the number of entries in the vector + /// previous_names_[section]. + /// section = 0 for row names, + /// section = 1 for column names. + int card_previous_names_[2]; + + /// Row names (including objective function name) + /// and column names (linked to Hash tables). + /// section = 0 for row names, + /// section = 1 for column names. + char **names_[2]; + + typedef struct { + int index, next; + } CoinHashLink; + + /// Maximum number of entries in a hash table section. + /// section = 0 for row names, + /// section = 1 for column names. + int maxHash_[2]; + + /// Number of entries in a hash table section. + /// section = 0 for row names, + /// section = 1 for column names. + int numberHash_[2]; + + /// Hash tables with two sections. + /// section = 0 for row names (including objective function name), + /// section = 1 for column names. + mutable CoinHashLink *hash_[2]; + + /// Build the hash table for the given names. The parameter number is + /// the cardinality of parameter names. Remove duplicate names. + /// + /// section = 0 for row names, + /// section = 1 for column names. + void startHash(char const * const * const names, + const COINColumnIndex number, + int section); + + /// Delete hash storage. If section = 0, it also frees objName_. + /// section = 0 for row names, + /// section = 1 for column names. + void stopHash(int section); + + /// Return the index of the given name, return -1 if the name is not found. + /// Return getNumRows() for the objective function name. + /// section = 0 for row names (including objective function name), + /// section = 1 for column names. + COINColumnIndex findHash(const char *name, int section) const; + + /// Insert thisName in the hash table if not present yet; does nothing + /// if the name is already in. + /// section = 0 for row names, + /// section = 1 for column names. + void insertHash(const char *thisName, int section); + + /// Write a coefficient. + /// print_1 = 0 : do not print the value 1. + void out_coeff(FILE *fp, double v, int print_1) const; + + /// Locate the objective function. + /// Return 1 if found the keyword "Minimize" or one of its variants, + /// -1 if found keyword "Maximize" or one of its variants. + int find_obj(FILE *fp) const; + + /// Return an integer indicating if the keyword "subject to" or one + /// of its variants has been read. + /// Return 1 if buff is the keyword "s.t" or one of its variants. + /// Return 2 if buff is the keyword "subject" or one of its variants. + /// Return 0 otherwise. + int is_subject_to(const char *buff) const; + + /// Return 1 if the first character of buff is a number. + /// Return 0 otherwise. + int first_is_number(const char *buff) const; + + /// Return 1 if the first character of buff is '/' or '\'. + /// Return 0 otherwise. + int is_comment(const char *buff) const; + + /// Read the file fp until buff contains an end of line + void skip_comment(char *buff, FILE *fp) const; + + /// Put in buff the next string that is not part of a comment + void scan_next(char *buff, FILE *fp) const; + + /// Return 1 if buff is the keyword "free" or one of its variants. + /// Return 0 otherwise. + int is_free(const char *buff) const; + + /// Return 1 if buff is the keyword "inf" or one of its variants. + /// Return 0 otherwise. + int is_inf(const char *buff) const; + + /// Return an integer indicating the inequality sense read. + /// Return 0 if buff is '<='. + /// Return 1 if buff is '='. + /// Return 2 if buff is '>='. + /// Return -1 otherwise. + int is_sense(const char *buff) const; + + /// Return an integer indicating if one of the keywords "Bounds", "Integers", + /// "Generals", "Binaries", "Semi-continuous", "Sos", "End", or one + /// of their variants has been read. (note Semi-continuous not coded) + /// Return 1 if buff is the keyword "Bounds" or one of its variants. + /// Return 2 if buff is the keyword "Integers" or "Generals" or one of their + /// variants. + /// Return 3 if buff is the keyword "Binaries" or one of its variants. + /// Return 4 if buff is the keyword "Semi-continuous" or one of its variants. + /// Return 5 if buff is the keyword "Sos" or one of its variants. + /// Return 6 if buff is the keyword "End" or one of its variants. + /// Return 0 otherwise. + int is_keyword(const char *buff) const; + + /// Read a monomial of the objective function. + /// Return 1 if "subject to" or one of its variants has been read. + int read_monom_obj(FILE *fp, double *coeff, char **name, int *cnt, + char **obj_name, int *num_objectives, int *obj_starts); + + /// Read a monomial of a constraint. + /// Return a positive number if the sense of the inequality has been + /// read (see method is_sense() for the return code). + /// Return -1 otherwise. + int read_monom_row(FILE *fp, char *start_str, double *coeff, char **name, + int cnt_coeff) const; + + /// Reallocate vectors related to number of coefficients. + void realloc_coeff(double **coeff, char ***colNames, int *maxcoeff) const; + + /// Reallocate vectors related to rows. + void realloc_row(char ***rowNames, int **start, double **rhs, + double **rowlow, double **rowup, int *maxrow) const; + + /// Reallocate vectors related to columns. + void realloc_col(double **collow, double **colup, char **is_int, + int *maxcol) const; + + /// Read a constraint. + void read_row(FILE *fp, char *buff, double **pcoeff, char ***pcolNames, + int *cnt_coeff, int *maxcoeff, + double *rhs, double *rowlow, double *rowup, + int *cnt_row, double inf) const; + + /** Check that current objective name and all row names are distinct + including row names obtained by adding "_low" for ranged constraints. + If there is a conflict in the names, they are replaced by default + row names (see setDefaultRowNames()). + + This method must not be called before + setLpDataWithoutRowAndColNames() has been called, since access + to the indices of all the ranged constraints is required. + + This method must not be called before + setLpDataRowAndColNames() has been called, since access + to all the row names is required. + */ + void checkRowNames(); + + /** Check that current column names are distinct. + If not, they are replaced by default + column names (see setDefaultColNames()). + + This method must not be called before + setLpDataRowAndColNames() has been called, since access + to all the column names is required. + */ + void checkColNames(); + +}; + +void +CoinLpIOUnitTest(const std::string& lpDir); + + +#endif diff --git a/thirdparty/windows/include/coin/CoinMessage.hpp b/thirdparty/windows/include/coin/CoinMessage.hpp new file mode 100644 index 0000000..cfdcd49 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinMessage.hpp @@ -0,0 +1,96 @@ +/* $Id: CoinMessage.hpp 1691 2014-03-19 12:43:56Z 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 CoinMessage_H +#define CoinMessage_H + +#if defined(_MSC_VER) +// Turn off compiler warning about long names +# pragma warning(disable:4786) +#endif + +/*! \file + + This file contains the enum for the standard set of Coin messages and a + class definition whose sole purpose is to supply a constructor. The text + ot the messages is defined in CoinMessage.cpp, + + CoinMessageHandler.hpp contains the generic facilities for message + handling. +*/ + +#include "CoinMessageHandler.hpp" + +/*! \brief Symbolic names for the standard set of COIN messages */ + +enum COIN_Message +{ + COIN_MPS_LINE=0, + COIN_MPS_STATS, + COIN_MPS_ILLEGAL, + COIN_MPS_BADIMAGE, + COIN_MPS_DUPOBJ, + COIN_MPS_DUPROW, + COIN_MPS_NOMATCHROW, + COIN_MPS_NOMATCHCOL, + COIN_MPS_FILE, + COIN_MPS_BADFILE1, + COIN_MPS_BADFILE2, + COIN_MPS_EOF, + COIN_MPS_RETURNING, + COIN_MPS_CHANGED, + COIN_SOLVER_MPS, + COIN_PRESOLVE_COLINFEAS, + COIN_PRESOLVE_ROWINFEAS, + COIN_PRESOLVE_COLUMNBOUNDA, + COIN_PRESOLVE_COLUMNBOUNDB, + COIN_PRESOLVE_NONOPTIMAL, + COIN_PRESOLVE_STATS, + COIN_PRESOLVE_INFEAS, + COIN_PRESOLVE_UNBOUND, + COIN_PRESOLVE_INFEASUNBOUND, + COIN_PRESOLVE_INTEGERMODS, + COIN_PRESOLVE_POSTSOLVE, + COIN_PRESOLVE_NEEDS_CLEANING, + COIN_PRESOLVE_PASS, +# if PRESOLVE_DEBUG + COIN_PRESOLDBG_FIRSTCHECK, + COIN_PRESOLDBG_RCOSTACC, + COIN_PRESOLDBG_RCOSTSTAT, + COIN_PRESOLDBG_STATSB, + COIN_PRESOLDBG_DUALSTAT, +# endif + COIN_GENERAL_INFO, + COIN_GENERAL_INFO2, + COIN_GENERAL_WARNING, + COIN_DUMMY_END +}; + + +/*! \class CoinMessage + \brief The standard set of Coin messages + + This class provides convenient access to the standard set of Coin messages. + In a nutshell, it's a CoinMessages object with a constructor that + preloads the standard Coin messages. +*/ + +class CoinMessage : public CoinMessages { + +public: + + /**@name Constructors etc */ + //@{ + /*! \brief Constructor + + Build a CoinMessages object and load it with the standard set of + Coin messages. + */ + CoinMessage(Language language=us_en); + //@} + +}; + +#endif diff --git a/thirdparty/windows/include/coin/CoinMessageHandler.hpp b/thirdparty/windows/include/coin/CoinMessageHandler.hpp new file mode 100644 index 0000000..7922630 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinMessageHandler.hpp @@ -0,0 +1,666 @@ +/* $Id: CoinMessageHandler.hpp 1514 2011-12-10 23:35:23Z 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 CoinMessageHandler_H +#define CoinMessageHandler_H + +#include "CoinUtilsConfig.h" +#include "CoinPragma.hpp" + +#include <iostream> +#include <cstdio> +#include <string> +#include <vector> + +/** \file CoinMessageHandler.hpp + \brief This is a first attempt at a message handler. + + The COIN Project is in favo(u)r of multi-language support. This implementation + of a message handler tries to make it as lightweight as possible in the sense + that only a subset of messages need to be defined --- the rest default to US + English. + + The default handler at present just prints to stdout or to a FILE pointer + + \todo + This needs to be worked over for correct operation with ISO character codes. +*/ + +/* + I (jjf) am strongly in favo(u)r of language support for an open + source project, but I have tried to make it as lightweight as + possible in the sense that only a subset of messages need to be + defined - the rest default to US English. There will be different + sets of messages for each component - so at present there is a + Clp component and a Coin component. + + Because messages are only used in a controlled environment and have no + impact on code and are tested by other tests I have included tests such + as language and derivation in other unit tests. +*/ +/* + Where there are derived classes I (jjf) have started message numbers at 1001. +*/ + + +/** \brief Class for one massaged message. + + A message consists of a text string with formatting codes (#message_), + an integer identifier (#externalNumber_) which also determines the severity + level (#severity_) of the message, and a detail (logging) level (#detail_). + + CoinOneMessage is just a container to hold this information. The + interpretation is set by CoinMessageHandler, which see. + */ + +class CoinOneMessage { + +public: + /**@name Constructors etc */ + //@{ + /** Default constructor. */ + CoinOneMessage(); + /** Normal constructor */ + CoinOneMessage(int externalNumber, char detail, + const char * message); + /** Destructor */ + ~CoinOneMessage(); + /** The copy constructor */ + CoinOneMessage(const CoinOneMessage&); + /** assignment operator. */ + CoinOneMessage& operator=(const CoinOneMessage&); + //@} + + /**@name Useful stuff */ + //@{ + /// Replace message text (<i>e.g.</i>, text in a different language) + void replaceMessage(const char * message); + //@} + + /**@name Get and set methods */ + //@{ + /** Get message ID number */ + inline int externalNumber() const + {return externalNumber_;} + /** \brief Set message ID number + + In the default CoinMessageHandler, this number is printed in the message + prefix and is used to determine the message severity level. + */ + inline void setExternalNumber(int number) + {externalNumber_=number;} + /// Severity + inline char severity() const + {return severity_;} + /// Set detail level + inline void setDetail(int level) + {detail_=static_cast<char> (level);} + /// Get detail level + inline int detail() const + {return detail_;} + /// Return the message text + inline char * message() const + {return message_;} + //@} + + /**@name member data */ + //@{ + /// number to print out (also determines severity) + int externalNumber_; + /// Will only print if detail matches + char detail_; + /// Severity + char severity_; + /// Messages (in correct language) (not all 400 may exist) + mutable char message_[400]; + //@} +}; + +/** \brief Class to hold and manipulate an array of massaged messages. + + Note that the message index used to reference a message in the array of + messages is completely distinct from the external ID number stored with the + message. +*/ + +class CoinMessages { + +public: + /** \brief Supported languages + + These are the languages that are supported. At present only + us_en is serious and the rest are for testing. + */ + enum Language { + us_en = 0, + uk_en, + it + }; + + /**@name Constructors etc */ + //@{ + /** Constructor with number of messages. */ + CoinMessages(int numberMessages=0); + /** Destructor */ + ~CoinMessages(); + /** The copy constructor */ + CoinMessages(const CoinMessages&); + /** assignment operator. */ + CoinMessages& operator=(const CoinMessages&); + //@} + + /**@name Useful stuff */ + //@{ + /*! \brief Installs a new message in the specified index position + + Any existing message is replaced, and a copy of the specified message is + installed. + */ + void addMessage(int messageNumber, const CoinOneMessage & message); + /*! \brief Replaces the text of the specified message + + Any existing text is deleted and the specified text is copied into the + specified message. + */ + void replaceMessage(int messageNumber, const char * message); + /** Language. Need to think about iso codes */ + inline Language language() const + {return language_;} + /** Set language */ + void setLanguage(Language newlanguage) + {language_ = newlanguage;} + /// Change detail level for one message + void setDetailMessage(int newLevel, int messageNumber); + /** \brief Change detail level for several messages + + messageNumbers is expected to contain the indices of the messages to be + changed. + If numberMessages >= 10000 or messageNumbers is NULL, the detail level + is changed on all messages. + */ + void setDetailMessages(int newLevel, int numberMessages, + int * messageNumbers); + /** Change detail level for all messages with low <= ID number < high */ + void setDetailMessages(int newLevel, int low, int high); + + /// Returns class + inline int getClass() const + { return class_;} + /// Moves to compact format + void toCompact(); + /// Moves from compact format + void fromCompact(); + //@} + + /**@name member data */ + //@{ + /// Number of messages + int numberMessages_; + /// Language + Language language_; + /// Source (null-terminated string, maximum 4 characters). + char source_[5]; + /// Class - see later on before CoinMessageHandler + int class_; + /** Length of fake CoinOneMessage array. + First you get numberMessages_ pointers which point to stuff + */ + int lengthMessages_; + /// Messages + CoinOneMessage ** message_; + //@} +}; + +// for convenience eol +enum CoinMessageMarker { + CoinMessageEol = 0, + CoinMessageNewline = 1 +}; + +/** Base class for message handling + + The default behavior is described here: messages are printed, and (if the + severity is sufficiently high) execution will be aborted. Inherit and + redefine the methods #print and #checkSeverity to augment the behaviour. + + Messages can be printed with or without a prefix; the prefix will consist + of a source string, the external ID number, and a letter code, + <i>e.g.</i>, Clp6024W. + A prefix makes the messages look less nimble but is very useful + for "grep" <i>etc</i>. + + <h3> Usage </h3> + + The general approach to using the COIN messaging facility is as follows: + <ul> + <li> Define your messages. For each message, you must supply an external + ID number, a log (detail) level, and a format string. Typically, you + define a convenience structure for this, something that's easy to + use to create an array of initialised message definitions at compile + time. + <li> Create a CoinMessages object, sized to accommodate the number of + messages you've defined. (Incremental growth will happen if + necessary as messages are loaded, but it's inefficient.) + <li> Load the messages into the CoinMessages object. Typically this + entails creating a CoinOneMessage object for each message and + passing it as a parameter to CoinMessages::addMessage(). You specify + the message's internal ID as the other parameter to addMessage. + <li> Create and use a CoinMessageHandler object to print messages. + </ul> + See, for example, CoinMessage.hpp and CoinMessage.cpp for an example of + the first three steps. `Format codes' below has a simple example of + printing a message. + + <h3> External ID numbers and severity </h3> + + CoinMessageHandler assumes the following relationship between the + external ID number of a message and the severity of the message: + \li <3000 are informational ('I') + \li <6000 warnings ('W') + \li <9000 non-fatal errors ('E') + \li >=9000 aborts the program (after printing the message) ('S') + + <h3> Log (detail) levels </h3> + + The default behaviour is that a message will print if its detail level + is less than or equal to the handler's log level. If all you want to + do is set a single log level for the handler, use #setLogLevel(int). + + If you want to get fancy, here's how it really works: There's an array, + #logLevels_, which you can manipulate with #setLogLevel(int,int). Each + entry logLevels_[i] specifies the log level for messages of class i (see + CoinMessages::class_). If logLevels_[0] is set to the magic number -1000 + you get the simple behaviour described above, whatever the class of the + messages. If logLevels_[0] is set to a valid log level (>= 0), then + logLevels_[i] really is the log level for messages of class i. + + <h3> Format codes </h3> + + CoinMessageHandler can print integers (normal, long, and long long), + doubles, characters, and strings. See the descriptions of the + various << operators. + + When processing a standard message with a format string, the formatting + codes specified in the format string will be passed to the sprintf + function, along with the argument. When generating a message with no + format string, each << operator uses a simple format code appropriate for + its argument. Consult the documentation for the standard printf facility + for further information on format codes. + + The special format code `%?' provides a hook to enable or disable + printing. For each `%?' code, there must be a corresponding call to + printing(bool). This provides a way to define optional parts in + messages, delineated by the code `%?' in the format string. Printing can + be suppressed for these optional parts, but any operands must still be + supplied. For example, given the message string + \verbatim + "A message with%? an optional integer %d and%? a double %g." + \endverbatim + installed in CoinMessages \c exampleMsgs with index 5, and + \c CoinMessageHandler \c hdl, the code + \code + hdl.message(5,exampleMsgs) ; + hdl.printing(true) << 42 ; + hdl.printing(true) << 53.5 << CoinMessageEol ; + \endcode + will print + \verbatim + A message with an optional integer 42 and a double 53.5. + \endverbatim + while + \code + hdl.message(5,exampleMsgs) ; + hdl.printing(false) << 42 ; + hdl.printing(true) << 53.5 << CoinMessageEol ; + \endcode + will print + \verbatim + A message with a double 53.5. + \endverbatim + + For additional examples of usage, see CoinMessageHandlerUnitTest in + CoinMessageHandlerTest.cpp. +*/ + +class CoinMessageHandler { + +friend bool CoinMessageHandlerUnitTest () ; + +public: + /**@name Virtual methods that the derived classes may provide */ + //@{ + /** Print message, return 0 normally. + */ + virtual int print() ; + /** Check message severity - if too bad then abort + */ + virtual void checkSeverity() ; + //@} + + /**@name Constructors etc */ + //@{ + /// Constructor + CoinMessageHandler(); + /// Constructor to put to file pointer (won't be closed) + CoinMessageHandler(FILE *fp); + /** Destructor */ + virtual ~CoinMessageHandler(); + /** The copy constructor */ + CoinMessageHandler(const CoinMessageHandler&); + /** Assignment operator. */ + CoinMessageHandler& operator=(const CoinMessageHandler&); + /// Clone + virtual CoinMessageHandler * clone() const; + //@} + /**@name Get and set methods */ + //@{ + /// Get detail level of a message. + inline int detail(int messageNumber, const CoinMessages &normalMessage) const + { return normalMessage.message_[messageNumber]->detail();} + /** Get current log (detail) level. */ + inline int logLevel() const + { return logLevel_;} + /** \brief Set current log (detail) level. + + If the log level is equal or greater than the detail level of a message, + the message will be printed. A rough convention for the amount of output + expected is + - 0 - none + - 1 - minimal + - 2 - normal low + - 3 - normal high + - 4 - verbose + + Please assign log levels to messages accordingly. Log levels of 8 and + above (8,16,32, <i>etc</i>.) are intended for selective debugging. + The logical AND of the log level specified in the message and the current + log level is used to determine if the message is printed. (In other words, + you're using individual bits to determine which messages are printed.) + */ + void setLogLevel(int value); + /** Get alternative log level. */ + inline int logLevel(int which) const + { return logLevels_[which];} + /*! \brief Set alternative log level value. + + Can be used to store alternative log level information within the handler. + */ + void setLogLevel(int which, int value); + + /// Set the number of significant digits for printing floating point numbers + void setPrecision(unsigned int new_precision); + /// Current number of significant digits for printing floating point numbers + inline int precision() { return (g_precision_) ; } + + /// Switch message prefix on or off. + void setPrefix(bool yesNo); + /// Current setting for printing message prefix. + bool prefix() const; + /*! \brief Values of double fields already processed. + + As the parameter for a double field is processed, the value is saved + and can be retrieved using this function. + */ + inline double doubleValue(int position) const + { return doubleValue_[position];} + /*! \brief Number of double fields already processed. + + Incremented each time a field of type double is processed. + */ + inline int numberDoubleFields() const + {return static_cast<int>(doubleValue_.size());} + /*! \brief Values of integer fields already processed. + + As the parameter for a integer field is processed, the value is saved + and can be retrieved using this function. + */ + inline int intValue(int position) const + { return longValue_[position];} + /*! \brief Number of integer fields already processed. + + Incremented each time a field of type integer is processed. + */ + inline int numberIntFields() const + {return static_cast<int>(longValue_.size());} + /*! \brief Values of char fields already processed. + + As the parameter for a char field is processed, the value is saved + and can be retrieved using this function. + */ + inline char charValue(int position) const + { return charValue_[position];} + /*! \brief Number of char fields already processed. + + Incremented each time a field of type char is processed. + */ + inline int numberCharFields() const + {return static_cast<int>(charValue_.size());} + /*! \brief Values of string fields already processed. + + As the parameter for a string field is processed, the value is saved + and can be retrieved using this function. + */ + inline std::string stringValue(int position) const + { return stringValue_[position];} + /*! \brief Number of string fields already processed. + + Incremented each time a field of type string is processed. + */ + inline int numberStringFields() const + {return static_cast<int>(stringValue_.size());} + + /// Current message + inline CoinOneMessage currentMessage() const + {return currentMessage_;} + /// Source of current message + inline std::string currentSource() const + {return source_;} + /// Output buffer + inline const char * messageBuffer() const + {return messageBuffer_;} + /// Highest message number (indicates any errors) + inline int highestNumber() const + {return highestNumber_;} + /// Get current file pointer + inline FILE * filePointer() const + { return fp_;} + /// Set new file pointer + inline void setFilePointer(FILE * fp) + { fp_ = fp;} + //@} + + /**@name Actions to create a message */ + //@{ + /*! \brief Start a message + + Look up the specified message. A prefix will be generated if enabled. + The message will be printed if the current log level is equal or greater + than the log level of the message. + */ + CoinMessageHandler &message(int messageNumber, + const CoinMessages &messages) ; + + /*! \brief Start or continue a message + + With detail = -1 (default), does nothing except return a reference to the + handler. (I.e., msghandler.message() << "foo" is precisely equivalent + to msghandler << "foo".) If \p msgDetail is >= 0, is will be used + as the detail level to determine whether the message should print + (assuming class 0). + + This can be used with any of the << operators. One use is to start + a message which will be constructed entirely from scratch. Another + use is continuation of a message after code that interrupts the usual + sequence of << operators. + */ + CoinMessageHandler & message(int detail = -1) ; + + /*! \brief Print a complete message + + Generate a standard prefix and append \c msg `as is'. This is intended as + a transition mechanism. The standard prefix is generated (if enabled), + and \c msg is appended. The message must be ended with a CoinMessageEol + marker. Attempts to add content with << will have no effect. + + The default value of \p detail will not change printing status. If + \p detail is >= 0, it will be used as the detail level to determine + whether the message should print (assuming class 0). + + */ + CoinMessageHandler &message(int externalNumber, const char *source, + const char *msg, + char severity, int detail = -1) ; + + /*! \brief Process an integer parameter value. + + The default format code is `%d'. + */ + CoinMessageHandler & operator<< (int intvalue); +#if COIN_BIG_INDEX==1 + /*! \brief Process a long integer parameter value. + + The default format code is `%ld'. + */ + CoinMessageHandler & operator<< (long longvalue); +#endif +#if COIN_BIG_INDEX==2 + /*! \brief Process a long long integer parameter value. + + The default format code is `%ld'. + */ + CoinMessageHandler & operator<< (long long longvalue); +#endif + /*! \brief Process a double parameter value. + + The default format code is `%d'. + */ + CoinMessageHandler & operator<< (double doublevalue); + /*! \brief Process a STL string parameter value. + + The default format code is `%g'. + */ + CoinMessageHandler & operator<< (const std::string& stringvalue); + /*! \brief Process a char parameter value. + + The default format code is `%s'. + */ + CoinMessageHandler & operator<< (char charvalue); + /*! \brief Process a C-style string parameter value. + + The default format code is `%c'. + */ + CoinMessageHandler & operator<< (const char *stringvalue); + /*! \brief Process a marker. + + The default format code is `%s'. + */ + CoinMessageHandler & operator<< (CoinMessageMarker); + /** Finish (and print) the message. + + Equivalent to using the CoinMessageEol marker. + */ + int finish(); + /*! \brief Enable or disable printing of an optional portion of a message. + + Optional portions of a message are delimited by `%?' markers, and + printing processes one %? marker. If \c onOff is true, the subsequent + portion of the message (to the next %? marker or the end of the format + string) will be printed. If \c onOff is false, printing is suppressed. + Parameters must still be supplied, whether printing is suppressed or not. + See the class documentation for an example. + */ + CoinMessageHandler & printing(bool onOff); + + //@} + + /** Log levels will be by type and will then use type + given in CoinMessage::class_ + + - 0 - Branch and bound code or similar + - 1 - Solver + - 2 - Stuff in Coin directory + - 3 - Cut generators + */ +#define COIN_NUM_LOG 4 +/// Maximum length of constructed message (characters) +#define COIN_MESSAGE_HANDLER_MAX_BUFFER_SIZE 1000 +protected: + /**@name Protected member data */ + //@{ + /// values in message + std::vector<double> doubleValue_; + std::vector<int> longValue_; + std::vector<char> charValue_; + std::vector<std::string> stringValue_; + /// Log level + int logLevel_; + /// Log levels + int logLevels_[COIN_NUM_LOG]; + /// Whether we want prefix (may get more subtle so is int) + int prefix_; + /// Current message + CoinOneMessage currentMessage_; + /// Internal number for use with enums + int internalNumber_; + /// Format string for message (remainder) + char * format_; + /// Output buffer + char messageBuffer_[COIN_MESSAGE_HANDLER_MAX_BUFFER_SIZE]; + /// Position in output buffer + char * messageOut_; + /// Current source of message + std::string source_; + /** 0 - Normal. + 1 - Put in values, move along format, but don't print. + 2 - A complete message was provided; nothing more to do but print + when CoinMessageEol is processed. Any << operators are treated + as noops. + 3 - do nothing except look for CoinMessageEol (i.e., the message + detail level was not sufficient to cause it to print). + */ + int printStatus_; + /// Highest message number (indicates any errors) + int highestNumber_; + /// File pointer + FILE * fp_; + /// Current format for floating point numbers + char g_format_[8]; + /// Current number of significant digits for floating point numbers + int g_precision_ ; + //@} + +private: + + /** The body of the copy constructor and the assignment operator */ + void gutsOfCopy(const CoinMessageHandler &rhs) ; + + /*! \brief Internal function to locate next format code. + + Intended for internal use. Side effects modify the format string. + */ + char *nextPerCent(char *start, const bool initial = false) ; + + /*! \brief Internal printing function. + + Makes it easier to split up print into clean, print and check severity + */ + int internalPrint() ; + + /// Decide if this message should print. + void calcPrintStatus(int msglvl, int msgclass) ; + + +}; + +//############################################################################# +/** A function that tests the methods in the CoinMessageHandler 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. */ +bool +CoinMessageHandlerUnitTest(); + +#endif diff --git a/thirdparty/windows/include/coin/CoinModel.hpp b/thirdparty/windows/include/coin/CoinModel.hpp new file mode 100644 index 0000000..6d1ff5b --- /dev/null +++ b/thirdparty/windows/include/coin/CoinModel.hpp @@ -0,0 +1,1054 @@ +/* $Id: CoinModel.hpp 1691 2014-03-19 12:43:56Z 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 CoinModel_H +#define CoinModel_H + +#include "CoinModelUseful.hpp" +#include "CoinMessageHandler.hpp" +#include "CoinPackedMatrix.hpp" +#include "CoinFinite.hpp" +class CoinBaseModel { + +public: + + + /**@name Constructors, destructor */ + //@{ + /// Default Constructor + CoinBaseModel (); + + /// Copy constructor + CoinBaseModel ( const CoinBaseModel &rhs); + + /// Assignment operator + CoinBaseModel & operator=( const CoinBaseModel& rhs); + + /// Clone + virtual CoinBaseModel * clone() const=0; + + /// Destructor + virtual ~CoinBaseModel () ; + //@} + + /**@name For getting information */ + //@{ + /// Return number of rows + inline int numberRows() const + { return numberRows_;} + /// Return number of columns + inline int numberColumns() const + { return numberColumns_;} + /// Return number of elements + virtual CoinBigIndex numberElements() const = 0; + /** Returns the (constant) objective offset + This is the RHS entry for the objective row + */ + inline double objectiveOffset() const + { return objectiveOffset_;} + /// Set objective offset + inline void setObjectiveOffset(double value) + { objectiveOffset_=value;} + /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore + inline double optimizationDirection() const { + return optimizationDirection_; + } + /// Set direction of optimization (1 - minimize, -1 - maximize, 0 - ignore + inline void setOptimizationDirection(double value) + { optimizationDirection_=value;} + /// Get print level 0 - off, 1 - errors, 2 - more + inline int logLevel() const + { return logLevel_;} + /// Set print level 0 - off, 1 - errors, 2 - more + void setLogLevel(int value); + /// Return the problem name + inline const char * getProblemName() const + { return problemName_.c_str();} + /// Set problem name + void setProblemName(const char *name) ; + /// Set problem name + void setProblemName(const std::string &name) ; + /// Return the row block name + inline const std::string & getRowBlock() const + { return rowBlockName_;} + /// Set row block name + inline void setRowBlock(const std::string &name) + { rowBlockName_ = name;} + /// Return the column block name + inline const std::string & getColumnBlock() const + { return columnBlockName_;} + /// Set column block name + inline void setColumnBlock(const std::string &name) + { columnBlockName_ = name;} + /// Pass in message handler + void setMessageHandler(CoinMessageHandler * handler); + //@} + +protected: + /**@name Data members */ + //@{ + /// Current number of rows + int numberRows_; + /// Current number of columns + int numberColumns_; + /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore + double optimizationDirection_; + /// Objective offset to be passed on + double objectiveOffset_; + /// Problem name + std::string problemName_; + /// Rowblock name + std::string rowBlockName_; + /// Columnblock name + std::string columnBlockName_; + /// Message handler (Passed in) + CoinMessageHandler * handler_; + /// Messages + CoinMessages messages_; + + /** Print level. + I could have gone for full message handling but this should normally + be silent and lightweight. + -1 - use passed in message handler + 0 - no output + 1 - on errors + 2 - more detailed + */ + int logLevel_; + //@} + /// data + +}; + +/** + This is a simple minded model which is stored in a format which makes + it easier to construct and modify but not efficient for algorithms. It has + to be passed across to ClpModel or OsiSolverInterface by addRows, addCol(umn)s + or loadProblem. + + It may have up to four parts - + 1) A matrix of doubles (or strings - see note A) + 2) Column information including integer information and names + 3) Row information including names + 4) Quadratic objective (not implemented - but see A) + + This class is meant to make it more efficient to build a model. It is at + its most efficient when all additions are done as addRow or as addCol but + not mixed. If only 1 and 2 exist then solver.addColumns may be used to pass to solver, + if only 1 and 3 exist then solver.addRows may be used. Otherwise solver.loadProblem + must be used. + + If addRows and addColumns are mixed or if individual elements are set then the + speed will drop to some extent and more memory will be used. + + It is also possible to iterate over existing elements and to access columns and rows + by name. Again each of these use memory and cpu time. However memory is unlikely + to be critical as most algorithms will use much more. + + Notes: + A) Although this could be used to pass nonlinear information around the + only use at present is to have named values e.g. value1 which can then be + set to a value after model is created. I have no idea whether that could + be useful but I thought it might be fun. + Quadratic terms are allowed in strings! A solver could try and use this + if so - the convention is that 0.5* quadratic is stored + + B) This class could be useful for modeling. +*/ + +class CoinModel : public CoinBaseModel { + +public: + /**@name Useful methods for building model */ + //@{ + /** add a row - numberInRow may be zero */ + void addRow(int numberInRow, const int * columns, + const double * elements, double rowLower=-COIN_DBL_MAX, + double rowUpper=COIN_DBL_MAX, const char * name=NULL); + /// add a column - numberInColumn may be zero */ + void addColumn(int numberInColumn, const int * rows, + const double * elements, + double columnLower=0.0, + double columnUpper=COIN_DBL_MAX, double objectiveValue=0.0, + const char * name=NULL, bool isInteger=false); + /// add a column - numberInColumn may be zero */ + inline void addCol(int numberInColumn, const int * rows, + const double * elements, + double columnLower=0.0, + double columnUpper=COIN_DBL_MAX, double objectiveValue=0.0, + const char * name=NULL, bool isInteger=false) + { addColumn(numberInColumn, rows, elements, columnLower, columnUpper, objectiveValue, + name,isInteger);} + /// Sets value for row i and column j + inline void operator() (int i,int j,double value) + { setElement(i,j,value);} + /// Sets value for row i and column j + void setElement(int i,int j,double value) ; + /** Gets sorted row - user must provide enough space + (easiest is allocate number of columns). + If column or element NULL then just returns number + Returns number of elements + */ + int getRow(int whichRow, int * column, double * element); + /** Gets sorted column - user must provide enough space + (easiest is allocate number of rows). + If row or element NULL then just returns number + Returns number of elements + */ + int getColumn(int whichColumn, int * column, double * element); + /// Sets quadratic value for column i and j + void setQuadraticElement(int i,int j,double value) ; + /// Sets value for row i and column j as string + inline void operator() (int i,int j,const char * value) + { setElement(i,j,value);} + /// Sets value for row i and column j as string + void setElement(int i,int j,const char * value) ; + /// Associates a string with a value. Returns string id (or -1 if does not exist) + int associateElement(const char * stringValue, double value); + /** Sets rowLower (if row does not exist then + all rows up to this are defined with default values and no elements) + */ + void setRowLower(int whichRow,double rowLower); + /** Sets rowUpper (if row does not exist then + all rows up to this are defined with default values and no elements) + */ + void setRowUpper(int whichRow,double rowUpper); + /** Sets rowLower and rowUpper (if row does not exist then + all rows up to this are defined with default values and no elements) + */ + void setRowBounds(int whichRow,double rowLower,double rowUpper); + /** Sets name (if row does not exist then + all rows up to this are defined with default values and no elements) + */ + void setRowName(int whichRow,const char * rowName); + /** Sets columnLower (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + void setColumnLower(int whichColumn,double columnLower); + /** Sets columnUpper (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + void setColumnUpper(int whichColumn,double columnUpper); + /** Sets columnLower and columnUpper (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + void setColumnBounds(int whichColumn,double columnLower,double columnUpper); + /** Sets columnObjective (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + void setColumnObjective(int whichColumn,double columnObjective); + /** Sets name (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + void setColumnName(int whichColumn,const char * columnName); + /** Sets integer state (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + void setColumnIsInteger(int whichColumn,bool columnIsInteger); + /** Sets columnObjective (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setObjective(int whichColumn,double columnObjective) + { setColumnObjective( whichColumn, columnObjective);} + /** Sets integer state (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setIsInteger(int whichColumn,bool columnIsInteger) + { setColumnIsInteger( whichColumn, columnIsInteger);} + /** Sets integer (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setInteger(int whichColumn) + { setColumnIsInteger( whichColumn, true);} + /** Sets continuous (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setContinuous(int whichColumn) + { setColumnIsInteger( whichColumn, false);} + /** Sets columnLower (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setColLower(int whichColumn,double columnLower) + { setColumnLower( whichColumn, columnLower);} + /** Sets columnUpper (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setColUpper(int whichColumn,double columnUpper) + { setColumnUpper( whichColumn, columnUpper);} + /** Sets columnLower and columnUpper (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setColBounds(int whichColumn,double columnLower,double columnUpper) + { setColumnBounds( whichColumn, columnLower, columnUpper);} + /** Sets columnObjective (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setColObjective(int whichColumn,double columnObjective) + { setColumnObjective( whichColumn, columnObjective);} + /** Sets name (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setColName(int whichColumn,const char * columnName) + { setColumnName( whichColumn, columnName);} + /** Sets integer (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setColIsInteger(int whichColumn,bool columnIsInteger) + { setColumnIsInteger( whichColumn, columnIsInteger);} + /** Sets rowLower (if row does not exist then + all rows up to this are defined with default values and no elements) + */ + void setRowLower(int whichRow,const char * rowLower); + /** Sets rowUpper (if row does not exist then + all rows up to this are defined with default values and no elements) + */ + void setRowUpper(int whichRow,const char * rowUpper); + /** Sets columnLower (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + void setColumnLower(int whichColumn,const char * columnLower); + /** Sets columnUpper (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + void setColumnUpper(int whichColumn,const char * columnUpper); + /** Sets columnObjective (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + void setColumnObjective(int whichColumn,const char * columnObjective); + /** Sets integer (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + void setColumnIsInteger(int whichColumn,const char * columnIsInteger); + /** Sets columnObjective (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setObjective(int whichColumn,const char * columnObjective) + { setColumnObjective( whichColumn, columnObjective);} + /** Sets integer (if column does not exist then + all columns up to this are defined with default values and no elements) + */ + inline void setIsInteger(int whichColumn,const char * columnIsInteger) + { setColumnIsInteger( whichColumn, columnIsInteger);} + /** Deletes all entries in row and bounds. Will be ignored by + writeMps etc and will be packed down if asked for. */ + void deleteRow(int whichRow); + /** Deletes all entries in column and bounds and objective. Will be ignored by + writeMps etc and will be packed down if asked for. */ + void deleteColumn(int whichColumn); + /** Deletes all entries in column and bounds. If last column the number of columns + will be decremented and true returned. */ + inline void deleteCol(int whichColumn) + { deleteColumn(whichColumn);} + /// Takes element out of matrix - returning position (<0 if not there); + int deleteElement(int row, int column); + /// Takes element out of matrix when position known + void deleteThisElement(int row, int column,int position); + /** Packs down all rows i.e. removes empty rows permanently. Empty rows + have no elements and feasible bounds. returns number of rows deleted. */ + int packRows(); + /** Packs down all columns i.e. removes empty columns permanently. Empty columns + have no elements and no objective. returns number of columns deleted. */ + int packColumns(); + /** Packs down all columns i.e. removes empty columns permanently. Empty columns + have no elements and no objective. returns number of columns deleted. */ + inline int packCols() + { return packColumns();} + /** Packs down all rows and columns. i.e. removes empty rows and columns permanently. + Empty rows have no elements and feasible bounds. + Empty columns have no elements and no objective. + returns number of rows+columns deleted. */ + int pack(); + + /** Sets columnObjective array + */ + void setObjective(int numberColumns,const double * objective) ; + /** Sets columnLower array + */ + void setColumnLower(int numberColumns,const double * columnLower); + /** Sets columnLower array + */ + inline void setColLower(int numberColumns,const double * columnLower) + { setColumnLower( numberColumns, columnLower);} + /** Sets columnUpper array + */ + void setColumnUpper(int numberColumns,const double * columnUpper); + /** Sets columnUpper array + */ + inline void setColUpper(int numberColumns,const double * columnUpper) + { setColumnUpper( numberColumns, columnUpper);} + /** Sets rowLower array + */ + void setRowLower(int numberRows,const double * rowLower); + /** Sets rowUpper array + */ + void setRowUpper(int numberRows,const double * rowUpper); + + /** Write the problem in MPS format to a file with the given filename. + + \param compression can be set to three values to indicate what kind + of file should be written + <ul> + <li> 0: plain text (default) + <li> 1: gzip compressed (.gz is appended to \c filename) + <li> 2: bzip2 compressed (.bz2 is appended to \c filename) (TODO) + </ul> + If the library was not compiled with the requested compression then + writeMps falls back to writing a plain text file. + + \param formatType specifies the precision to used for values in the + MPS file + <ul> + <li> 0: normal precision (default) + <li> 1: extra accuracy + <li> 2: IEEE hex + </ul> + + \param numberAcross specifies whether 1 or 2 (default) values should be + specified on every data line in the MPS file. + + not const as may change model e.g. fill in default bounds + */ + int writeMps(const char *filename, int compression = 0, + int formatType = 0, int numberAcross = 2, bool keepStrings=false) ; + + /** Check two models against each other. Return nonzero if different. + Ignore names if that set. + May modify both models by cleaning up + */ + int differentModel(CoinModel & other, bool ignoreNames); + //@} + + + /**@name For structured models */ + //@{ + /// Pass in CoinPackedMatrix (and switch off element updates) + void passInMatrix(const CoinPackedMatrix & matrix); + /** Convert elements to CoinPackedMatrix (and switch off element updates). + Returns number of errors */ + int convertMatrix(); + /// Return a pointer to CoinPackedMatrix (or NULL) + inline const CoinPackedMatrix * packedMatrix() const + { return packedMatrix_;} + /// Return pointers to original rows (for decomposition) + inline const int * originalRows() const + { return rowType_;} + /// Return pointers to original columns (for decomposition) + inline const int * originalColumns() const + { return columnType_;} + //@} + + + /**@name For getting information */ + //@{ + /// Return number of elements + inline CoinBigIndex numberElements() const + { return numberElements_;} + /// Return elements as triples + inline const CoinModelTriple * elements() const + { return elements_;} + /// Returns value for row i and column j + inline double operator() (int i,int j) const + { return getElement(i,j);} + /// Returns value for row i and column j + double getElement(int i,int j) const; + /// Returns value for row rowName and column columnName + inline double operator() (const char * rowName,const char * columnName) const + { return getElement(rowName,columnName);} + /// Returns value for row rowName and column columnName + double getElement(const char * rowName,const char * columnName) const; + /// Returns quadratic value for columns i and j + double getQuadraticElement(int i,int j) const; + /** Returns value for row i and column j as string. + Returns NULL if does not exist. + Returns "Numeric" if not a string + */ + const char * getElementAsString(int i,int j) const; + /** Returns pointer to element for row i column j. + Only valid until next modification. + NULL if element does not exist */ + double * pointer (int i,int j) const; + /** Returns position in elements for row i column j. + Only valid until next modification. + -1 if element does not exist */ + int position (int i,int j) const; + + + /** Returns first element in given row - index is -1 if none. + Index is given by .index and value by .value + */ + CoinModelLink firstInRow(int whichRow) const ; + /** Returns last element in given row - index is -1 if none. + Index is given by .index and value by .value + */ + CoinModelLink lastInRow(int whichRow) const ; + /** Returns first element in given column - index is -1 if none. + Index is given by .index and value by .value + */ + CoinModelLink firstInColumn(int whichColumn) const ; + /** Returns last element in given column - index is -1 if none. + Index is given by .index and value by .value + */ + CoinModelLink lastInColumn(int whichColumn) const ; + /** Returns next element in current row or column - index is -1 if none. + Index is given by .index and value by .value. + User could also tell because input.next would be NULL + */ + CoinModelLink next(CoinModelLink & current) const ; + /** Returns previous element in current row or column - index is -1 if none. + Index is given by .index and value by .value. + User could also tell because input.previous would be NULL + May not be correct if matrix updated. + */ + CoinModelLink previous(CoinModelLink & current) const ; + /** Returns first element in given quadratic column - index is -1 if none. + Index is given by .index and value by .value + May not be correct if matrix updated. + */ + CoinModelLink firstInQuadraticColumn(int whichColumn) const ; + /** Returns last element in given quadratic column - index is -1 if none. + Index is given by .index and value by .value + */ + CoinModelLink lastInQuadraticColumn(int whichColumn) const ; + /** Gets rowLower (if row does not exist then -COIN_DBL_MAX) + */ + double getRowLower(int whichRow) const ; + /** Gets rowUpper (if row does not exist then +COIN_DBL_MAX) + */ + double getRowUpper(int whichRow) const ; + /** Gets name (if row does not exist then NULL) + */ + const char * getRowName(int whichRow) const ; + inline double rowLower(int whichRow) const + { return getRowLower(whichRow);} + /** Gets rowUpper (if row does not exist then COIN_DBL_MAX) + */ + inline double rowUpper(int whichRow) const + { return getRowUpper(whichRow) ;} + /** Gets name (if row does not exist then NULL) + */ + inline const char * rowName(int whichRow) const + { return getRowName(whichRow);} + /** Gets columnLower (if column does not exist then 0.0) + */ + double getColumnLower(int whichColumn) const ; + /** Gets columnUpper (if column does not exist then COIN_DBL_MAX) + */ + double getColumnUpper(int whichColumn) const ; + /** Gets columnObjective (if column does not exist then 0.0) + */ + double getColumnObjective(int whichColumn) const ; + /** Gets name (if column does not exist then NULL) + */ + const char * getColumnName(int whichColumn) const ; + /** Gets if integer (if column does not exist then false) + */ + bool getColumnIsInteger(int whichColumn) const ; + /** Gets columnLower (if column does not exist then 0.0) + */ + inline double columnLower(int whichColumn) const + { return getColumnLower(whichColumn);} + /** Gets columnUpper (if column does not exist then COIN_DBL_MAX) + */ + inline double columnUpper(int whichColumn) const + { return getColumnUpper(whichColumn) ;} + /** Gets columnObjective (if column does not exist then 0.0) + */ + inline double columnObjective(int whichColumn) const + { return getColumnObjective(whichColumn);} + /** Gets columnObjective (if column does not exist then 0.0) + */ + inline double objective(int whichColumn) const + { return getColumnObjective(whichColumn);} + /** Gets name (if column does not exist then NULL) + */ + inline const char * columnName(int whichColumn) const + { return getColumnName(whichColumn);} + /** Gets if integer (if column does not exist then false) + */ + inline bool columnIsInteger(int whichColumn) const + { return getColumnIsInteger(whichColumn);} + /** Gets if integer (if column does not exist then false) + */ + inline bool isInteger(int whichColumn) const + { return getColumnIsInteger(whichColumn);} + /** Gets columnLower (if column does not exist then 0.0) + */ + inline double getColLower(int whichColumn) const + { return getColumnLower(whichColumn);} + /** Gets columnUpper (if column does not exist then COIN_DBL_MAX) + */ + inline double getColUpper(int whichColumn) const + { return getColumnUpper(whichColumn) ;} + /** Gets columnObjective (if column does not exist then 0.0) + */ + inline double getColObjective(int whichColumn) const + { return getColumnObjective(whichColumn);} + /** Gets name (if column does not exist then NULL) + */ + inline const char * getColName(int whichColumn) const + { return getColumnName(whichColumn);} + /** Gets if integer (if column does not exist then false) + */ + inline bool getColIsInteger(int whichColumn) const + { return getColumnIsInteger(whichColumn);} + /** Gets rowLower (if row does not exist then -COIN_DBL_MAX) + */ + const char * getRowLowerAsString(int whichRow) const ; + /** Gets rowUpper (if row does not exist then +COIN_DBL_MAX) + */ + const char * getRowUpperAsString(int whichRow) const ; + inline const char * rowLowerAsString(int whichRow) const + { return getRowLowerAsString(whichRow);} + /** Gets rowUpper (if row does not exist then COIN_DBL_MAX) + */ + inline const char * rowUpperAsString(int whichRow) const + { return getRowUpperAsString(whichRow) ;} + /** Gets columnLower (if column does not exist then 0.0) + */ + const char * getColumnLowerAsString(int whichColumn) const ; + /** Gets columnUpper (if column does not exist then COIN_DBL_MAX) + */ + const char * getColumnUpperAsString(int whichColumn) const ; + /** Gets columnObjective (if column does not exist then 0.0) + */ + const char * getColumnObjectiveAsString(int whichColumn) const ; + /** Gets if integer (if column does not exist then false) + */ + const char * getColumnIsIntegerAsString(int whichColumn) const ; + /** Gets columnLower (if column does not exist then 0.0) + */ + inline const char * columnLowerAsString(int whichColumn) const + { return getColumnLowerAsString(whichColumn);} + /** Gets columnUpper (if column does not exist then COIN_DBL_MAX) + */ + inline const char * columnUpperAsString(int whichColumn) const + { return getColumnUpperAsString(whichColumn) ;} + /** Gets columnObjective (if column does not exist then 0.0) + */ + inline const char * columnObjectiveAsString(int whichColumn) const + { return getColumnObjectiveAsString(whichColumn);} + /** Gets columnObjective (if column does not exist then 0.0) + */ + inline const char * objectiveAsString(int whichColumn) const + { return getColumnObjectiveAsString(whichColumn);} + /** Gets if integer (if column does not exist then false) + */ + inline const char * columnIsIntegerAsString(int whichColumn) const + { return getColumnIsIntegerAsString(whichColumn);} + /** Gets if integer (if column does not exist then false) + */ + inline const char * isIntegerAsString(int whichColumn) const + { return getColumnIsIntegerAsString(whichColumn);} + /// Row index from row name (-1 if no names or no match) + int row(const char * rowName) const; + /// Column index from column name (-1 if no names or no match) + int column(const char * columnName) const; + /// Returns type + inline int type() const + { return type_;} + /// returns unset value + inline double unsetValue() const + { return -1.23456787654321e-97;} + /// Creates a packed matrix - return number of errors + int createPackedMatrix(CoinPackedMatrix & matrix, + const double * associated); + /** Fills in startPositive and startNegative with counts for +-1 matrix. + If not +-1 then startPositive[0]==-1 otherwise counts and + startPositive[numberColumns]== size + - return number of errors + */ + int countPlusMinusOne(CoinBigIndex * startPositive, CoinBigIndex * startNegative, + const double * associated); + /** Creates +-1 matrix given startPositive and startNegative counts for +-1 matrix. + */ + void createPlusMinusOne(CoinBigIndex * startPositive, CoinBigIndex * startNegative, + int * indices, + const double * associated); + /// Creates copies of various arrays - return number of errors + int createArrays(double * & rowLower, double * & rowUpper, + double * & columnLower, double * & columnUpper, + double * & objective, int * & integerType, + double * & associated); + /// Says if strings exist + inline bool stringsExist() const + { return string_.numberItems()!=0;} + /// Return string array + inline const CoinModelHash * stringArray() const + { return &string_;} + /// Returns associated array + inline double * associatedArray() const + { return associated_;} + /// Return rowLower array + inline double * rowLowerArray() const + { return rowLower_;} + /// Return rowUpper array + inline double * rowUpperArray() const + { return rowUpper_;} + /// Return columnLower array + inline double * columnLowerArray() const + { return columnLower_;} + /// Return columnUpper array + inline double * columnUpperArray() const + { return columnUpper_;} + /// Return objective array + inline double * objectiveArray() const + { return objective_;} + /// Return integerType array + inline int * integerTypeArray() const + { return integerType_;} + /// Return row names array + inline const CoinModelHash * rowNames() const + { return &rowName_;} + /// Return column names array + inline const CoinModelHash * columnNames() const + { return &columnName_;} + /// Reset row names + inline void zapRowNames() + { rowName_=CoinModelHash();} + /// Reset column names + inline void zapColumnNames() + { columnName_=CoinModelHash();} + /// Returns array of 0 or nonzero if can be a cut (or returns NULL) + inline const int * cutMarker() const + { return cut_;} + /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore + inline double optimizationDirection() const { + return optimizationDirection_; + } + /// Set direction of optimization (1 - minimize, -1 - maximize, 0 - ignore + inline void setOptimizationDirection(double value) + { optimizationDirection_=value;} + /// Return pointer to more information + inline void * moreInfo() const + { return moreInfo_;} + /// Set pointer to more information + inline void setMoreInfo(void * info) + { moreInfo_ = info;} + /** Returns which parts of model are set + 1 - matrix + 2 - rhs + 4 - row names + 8 - column bounds and/or objective + 16 - column names + 32 - integer types + */ + int whatIsSet() const; + //@} + + /**@name for block models - matrix will be CoinPackedMatrix */ + //@{ + /*! \brief Load in a problem by copying the arguments. The constraints on + the rows are given by lower and upper bounds. + + If a pointer is 0 then the following values are the default: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>rowub</code>: all rows have upper bound infinity + <li> <code>rowlb</code>: all rows have lower bound -infinity + <li> <code>obj</code>: all variables have 0 objective coefficient + </ul> + + Note that the default values for rowub and rowlb produce the + constraint -infty <= ax <= infty. This is probably not what you want. + */ + void loadBlock (const CoinPackedMatrix& matrix, + const double* collb, const double* colub, + const double* obj, + const double* rowlb, const double* rowub) ; + /*! \brief Load in a problem by copying the arguments. + The constraints on the rows are given by sense/rhs/range triplets. + + If a pointer is 0 then the following values are the default: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>obj</code>: all variables have 0 objective coefficient + <li> <code>rowsen</code>: all rows are >= + <li> <code>rowrhs</code>: all right hand sides are 0 + <li> <code>rowrng</code>: 0 for the ranged rows + </ul> + + Note that the default values for rowsen, rowrhs, and rowrng produce the + constraint ax >= 0. + */ + void loadBlock (const CoinPackedMatrix& matrix, + const double* collb, const double* colub, + const double* obj, + const char* rowsen, const double* rowrhs, + const double* rowrng) ; + + /*! \brief Load in a problem by copying the arguments. The constraint + matrix is is specified with standard column-major + column starts / row indices / coefficients vectors. + The constraints on the rows are given by lower and upper bounds. + + The matrix vectors must be gap-free. Note that <code>start</code> must + have <code>numcols+1</code> entries so that the length of the last column + can be calculated as <code>start[numcols]-start[numcols-1]</code>. + + See the previous loadBlock method using rowlb and rowub for default + argument values. + */ + void loadBlock (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) ; + + /*! \brief Load in a problem by copying the arguments. The constraint + matrix is is specified with standard column-major + column starts / row indices / coefficients vectors. + The constraints on the rows are given by sense/rhs/range triplets. + + The matrix vectors must be gap-free. Note that <code>start</code> must + have <code>numcols+1</code> entries so that the length of the last column + can be calculated as <code>start[numcols]-start[numcols-1]</code>. + + See the previous loadBlock method using sense/rhs/range for default + argument values. + */ + void loadBlock (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 char* rowsen, const double* rowrhs, + const double* rowrng) ; + + //@} + + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + CoinModel(); + /** Constructor with sizes. */ + CoinModel(int firstRows, int firstColumns, int firstElements,bool noNames=false); + /** Read a problem in MPS or GAMS format from the given filename. + */ + CoinModel(const char *fileName, int allowStrings=0); + /** Read a problem from AMPL nl file + NOTE - as I can't work out configure etc the source code is in Cbc_ampl.cpp! + */ + CoinModel( int nonLinear, const char * fileName,const void * info); + /// From arrays + CoinModel(int numberRows, int numberColumns, + const CoinPackedMatrix * matrix, + const double * rowLower, const double * rowUpper, + const double * columnLower, const double * columnUpper, + const double * objective); + /// Clone + virtual CoinBaseModel * clone() const; + + /** Destructor */ + virtual ~CoinModel(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + CoinModel(const CoinModel&); + /// = + CoinModel& operator=(const CoinModel&); + //@} + + /**@name For debug */ + //@{ + /// Checks that links are consistent + void validateLinks() const; + //@} +private: + /// Resize + void resize(int maximumRows, int maximumColumns, int maximumElements); + /// Fill in default row information + void fillRows(int which,bool forceCreation,bool fromAddRow=false); + /// Fill in default column information + void fillColumns(int which,bool forceCreation,bool fromAddColumn=false); + /** Fill in default linked list information (1= row, 2 = column) + Marked as const as list is mutable */ + void fillList(int which, CoinModelLinkedList & list,int type) const ; + /** Create a linked list and synchronize free + type 1 for row 2 for column + Marked as const as list is mutable */ + void createList(int type) const; + /// Adds one string, returns index + int addString(const char * string); + /** Gets a double from a string possibly containing named strings, + returns unset if not found + */ + double getDoubleFromString(CoinYacc & info, const char * string); + /// Frees value memory + void freeStringMemory(CoinYacc & info); +public: + /// Fills in all associated - returning number of errors + int computeAssociated(double * associated); + /** Gets correct form for a quadratic row - user to delete + If row is not quadratic then returns which other variables are involved + with tiny (1.0e-100) elements and count of total number of variables which could not + be put in quadratic form + */ + CoinPackedMatrix * quadraticRow(int rowNumber,double * linear, + int & numberBad) const; + /// Replaces a quadratic row + void replaceQuadraticRow(int rowNumber,const double * linear, const CoinPackedMatrix * quadraticPart); + /** If possible return a model where if all variables marked nonzero are fixed + the problem will be linear. At present may only work if quadratic. + Returns NULL if not possible + */ + CoinModel * reorder(const char * mark) const; + /** Expands out all possible combinations for a knapsack + If buildObj NULL then just computes space needed - returns number elements + On entry numberOutput is maximum allowed, on exit it is number needed or + -1 (as will be number elements) if maximum exceeded. numberOutput will have at + least space to return values which reconstruct input. + Rows returned will be original rows but no entries will be returned for + any rows all of whose entries are in knapsack. So up to user to allow for this. + If reConstruct >=0 then returns number of entrie which make up item "reConstruct" + in expanded knapsack. Values in buildRow and buildElement; + */ + int expandKnapsack(int knapsackRow, int & numberOutput,double * buildObj, CoinBigIndex * buildStart, + int * buildRow, double * buildElement,int reConstruct=-1) const; + /// Sets cut marker array + void setCutMarker(int size,const int * marker); + /// Sets priority array + void setPriorities(int size,const int * priorities); + /// priorities (given for all columns (-1 if not integer) + inline const int * priorities() const + { return priority_;} + /// For decomposition set original row and column indices + void setOriginalIndices(const int * row, const int * column); + +private: + /** Read a problem from AMPL nl file + so not constructor so gdb will work + */ + void gdb( int nonLinear, const char * fileName, const void * info); + /// returns jColumn (-2 if linear term, -1 if unknown) and coefficient + int decodeBit(char * phrase, char * & nextPhrase, double & coefficient, bool ifFirst) const; + /// Aborts with message about packedMatrix + void badType() const; + /**@name Data members */ + //@{ + /// Maximum number of rows + int maximumRows_; + /// Maximum number of columns + int maximumColumns_; + /// Current number of elements + int numberElements_; + /// Maximum number of elements + int maximumElements_; + /// Current number of quadratic elements + int numberQuadraticElements_; + /// Maximum number of quadratic elements + int maximumQuadraticElements_; + /// Row lower + double * rowLower_; + /// Row upper + double * rowUpper_; + /// Row names + CoinModelHash rowName_; + /** Row types. + Has information - at present + bit 0 - rowLower is a string + bit 1 - rowUpper is a string + NOTE - if converted to CoinPackedMatrix - may be indices of + original rows (i.e. when decomposed) + */ + int * rowType_; + /// Objective + double * objective_; + /// Column Lower + double * columnLower_; + /// Column Upper + double * columnUpper_; + /// Column names + CoinModelHash columnName_; + /// Integer information + int * integerType_; + /// Strings + CoinModelHash string_; + /** Column types. + Has information - at present + bit 0 - columnLower is a string + bit 1 - columnUpper is a string + bit 2 - objective is a string + bit 3 - integer setting is a string + NOTE - if converted to CoinPackedMatrix - may be indices of + original columns (i.e. when decomposed) + */ + int * columnType_; + /// If simple then start of each row/column + int * start_; + /// Actual elements + CoinModelTriple * elements_; + /// Actual elements as CoinPackedMatrix + CoinPackedMatrix * packedMatrix_; + /// Hash for elements + mutable CoinModelHash2 hashElements_; + /// Linked list for rows + mutable CoinModelLinkedList rowList_; + /// Linked list for columns + mutable CoinModelLinkedList columnList_; + /// Actual quadratic elements (always linked lists) + CoinModelTriple * quadraticElements_; + /// Hash for quadratic elements + mutable CoinModelHash2 hashQuadraticElements_; + /// Array for sorting indices + int * sortIndices_; + /// Array for sorting elements + double * sortElements_; + /// Size of sort arrays + int sortSize_; + /// Linked list for quadratic rows + mutable CoinModelLinkedList quadraticRowList_; + /// Linked list for quadratic columns + mutable CoinModelLinkedList quadraticColumnList_; + /// Size of associated values + int sizeAssociated_; + /// Associated values + double * associated_; + /// Number of SOS - all these are done in one go e.g. from ampl + int numberSOS_; + /// SOS starts + int * startSOS_; + /// SOS members + int * memberSOS_; + /// SOS type + int * typeSOS_; + /// SOS priority + int * prioritySOS_; + /// SOS reference + double * referenceSOS_; + /// priorities (given for all columns (-1 if not integer) + int * priority_; + /// Nonzero if row is cut - done in one go e.g. from ampl + int * cut_; + /// Pointer to more information + void * moreInfo_; + /** Type of build - + -1 unset, + 0 for row, + 1 for column, + 2 linked. + 3 matrix is CoinPackedMatrix (and at present can't be modified); + */ + mutable int type_; + /// True if no names EVER being used (for users who know what they are doing) + bool noNames_; + /** Links present (could be tested by sizes of objects) + 0 - none, + 1 - row links, + 2 - column links, + 3 - both + */ + mutable int links_; + //@} +}; +/// Just function of single variable x +double getFunctionValueFromString(const char * string, const char * x, double xValue); +/// faster version +double getDoubleFromString(CoinYacc & info, const char * string, const char * x, double xValue); +#endif diff --git a/thirdparty/windows/include/coin/CoinModelUseful.hpp b/thirdparty/windows/include/coin/CoinModelUseful.hpp new file mode 100644 index 0000000..f9eeea3 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinModelUseful.hpp @@ -0,0 +1,441 @@ +/* $Id: CoinModelUseful.hpp 1416 2011-04-17 09:57:29Z stefan $ */ +// 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 CoinModelUseful_H +#define CoinModelUseful_H + + +#include <cstdlib> +#include <cmath> +#include <cassert> +#include <cfloat> +#include <cstring> +#include <cstdio> +#include <iostream> + + +#include "CoinPragma.hpp" + +/** + This is for various structures/classes needed by CoinModel. + + CoinModelLink + CoinModelLinkedList + CoinModelHash +*/ +/// for going through row or column + +class CoinModelLink { + +public: + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + CoinModelLink(); + /** Destructor */ + ~CoinModelLink(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + CoinModelLink(const CoinModelLink&); + /// = + CoinModelLink& operator=(const CoinModelLink&); + //@} + + /**@name Sets and gets method */ + //@{ + /// Get row + inline int row() const + { return row_;} + /// Get column + inline int column() const + { return column_;} + /// Get value + inline double value() const + { return value_;} + /// Get value + inline double element() const + { return value_;} + /// Get position + inline int position() const + { return position_;} + /// Get onRow + inline bool onRow() const + { return onRow_;} + /// Set row + inline void setRow(int row) + { row_=row;} + /// Set column + inline void setColumn(int column) + { column_=column;} + /// Set value + inline void setValue(double value) + { value_=value;} + /// Set value + inline void setElement(double value) + { value_=value;} + /// Set position + inline void setPosition(int position) + { position_=position;} + /// Set onRow + inline void setOnRow(bool onRow) + { onRow_=onRow;} + //@} + +private: + /**@name Data members */ + //@{ + /// Row + int row_; + /// Column + int column_; + /// Value as double + double value_; + /// Position in data + int position_; + /// If on row chain + bool onRow_; + //@} +}; + +/// for linked lists +// for specifying triple +typedef struct { + // top bit is nonzero if string + // rest is row + unsigned int row; + //CoinModelRowIndex row; + int column; + double value; // If string then index into strings +} CoinModelTriple; +inline int rowInTriple(const CoinModelTriple & triple) +{ return triple.row&0x7fffffff;} +inline void setRowInTriple(CoinModelTriple & triple,int iRow) +{ triple.row = iRow|(triple.row&0x80000000);} +inline bool stringInTriple(const CoinModelTriple & triple) +{ return (triple.row&0x80000000)!=0;} +inline void setStringInTriple(CoinModelTriple & triple,bool string) +{ triple.row = (string ? 0x80000000 : 0)|(triple.row&0x7fffffff);} +inline void setRowAndStringInTriple(CoinModelTriple & triple, + int iRow,bool string) +{ triple.row = (string ? 0x80000000 : 0)|iRow;} +/// for names and hashing +// for hashing +typedef struct { + int index, next; +} CoinModelHashLink; + +/* Function type. */ +typedef double (*func_t) (double); + +/// For string evaluation +/* Data type for links in the chain of symbols. */ +struct symrec +{ + char *name; /* name of symbol */ + int type; /* type of symbol: either VAR or FNCT */ + union + { + double var; /* value of a VAR */ + func_t fnctptr; /* value of a FNCT */ + } value; + struct symrec *next; /* link field */ +}; + +typedef struct symrec symrec; + +class CoinYacc { +private: + CoinYacc(const CoinYacc& rhs); + CoinYacc& operator=(const CoinYacc& rhs); + +public: + CoinYacc() : symtable(NULL), symbuf(NULL), length(0), unsetValue(0) {} + ~CoinYacc() + { + if (length) { + free(symbuf); + symbuf = NULL; + } + symrec* s = symtable; + while (s) { + free(s->name); + symtable = s; + s = s->next; + free(symtable); + } + } + +public: + symrec * symtable; + char * symbuf; + int length; + double unsetValue; +}; + +class CoinModelHash { + +public: + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + CoinModelHash(); + /** Destructor */ + ~CoinModelHash(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + CoinModelHash(const CoinModelHash&); + /// = + CoinModelHash& operator=(const CoinModelHash&); + //@} + + /**@name sizing (just increases) */ + //@{ + /// Resize hash (also re-hashs) + void resize(int maxItems,bool forceReHash=false); + /// Number of items i.e. rows if just row names + inline int numberItems() const + { return numberItems_;} + /// Set number of items + void setNumberItems(int number); + /// Maximum number of items + inline int maximumItems() const + { return maximumItems_;} + /// Names + inline const char *const * names() const + { return names_;} + //@} + + /**@name hashing */ + //@{ + /// Returns index or -1 + int hash(const char * name) const; + /// Adds to hash + void addHash(int index, const char * name); + /// Deletes from hash + void deleteHash(int index); + /// Returns name at position (or NULL) + const char * name(int which) const; + /// Returns non const name at position (or NULL) + char * getName(int which) const; + /// Sets name at position (does not create) + void setName(int which,char * name ) ; + /// Validates + void validateHash() const; +private: + /// Returns a hash value + int hashValue(const char * name) const; +public: + //@} +private: + /**@name Data members */ + //@{ + /// Names + char ** names_; + /// hash + CoinModelHashLink * hash_; + /// Number of items + int numberItems_; + /// Maximum number of items + int maximumItems_; + /// Last slot looked at + int lastSlot_; + //@} +}; +/// For int,int hashing +class CoinModelHash2 { + +public: + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + CoinModelHash2(); + /** Destructor */ + ~CoinModelHash2(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + CoinModelHash2(const CoinModelHash2&); + /// = + CoinModelHash2& operator=(const CoinModelHash2&); + //@} + + /**@name sizing (just increases) */ + //@{ + /// Resize hash (also re-hashs) + void resize(int maxItems, const CoinModelTriple * triples,bool forceReHash=false); + /// Number of items + inline int numberItems() const + { return numberItems_;} + /// Set number of items + void setNumberItems(int number); + /// Maximum number of items + inline int maximumItems() const + { return maximumItems_;} + //@} + + /**@name hashing */ + //@{ + /// Returns index or -1 + int hash(int row, int column, const CoinModelTriple * triples) const; + /// Adds to hash + void addHash(int index, int row, int column, const CoinModelTriple * triples); + /// Deletes from hash + void deleteHash(int index, int row, int column); +private: + /// Returns a hash value + int hashValue(int row, int column) const; +public: + //@} +private: + /**@name Data members */ + //@{ + /// hash + CoinModelHashLink * hash_; + /// Number of items + int numberItems_; + /// Maximum number of items + int maximumItems_; + /// Last slot looked at + int lastSlot_; + //@} +}; +class CoinModelLinkedList { + +public: + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + CoinModelLinkedList(); + /** Destructor */ + ~CoinModelLinkedList(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + CoinModelLinkedList(const CoinModelLinkedList&); + /// = + CoinModelLinkedList& operator=(const CoinModelLinkedList&); + //@} + + /**@name sizing (just increases) */ + //@{ + /** Resize list - for row list maxMajor is maximum rows. + */ + void resize(int maxMajor,int maxElements); + /** Create list - for row list maxMajor is maximum rows. + type 0 row list, 1 column list + */ + void create(int maxMajor,int maxElements, + int numberMajor, int numberMinor, + int type, + int numberElements, const CoinModelTriple * triples); + /// Number of major items i.e. rows if just row links + inline int numberMajor() const + { return numberMajor_;} + /// Maximum number of major items i.e. rows if just row links + inline int maximumMajor() const + { return maximumMajor_;} + /// Number of elements + inline int numberElements() const + { return numberElements_;} + /// Maximum number of elements + inline int maximumElements() const + { return maximumElements_;} + /// First on free chain + inline int firstFree() const + { return first_[maximumMajor_];} + /// Last on free chain + inline int lastFree() const + { return last_[maximumMajor_];} + /// First on chain + inline int first(int which) const + { return first_[which];} + /// Last on chain + inline int last(int which) const + { return last_[which];} + /// Next array + inline const int * next() const + { return next_;} + /// Previous array + inline const int * previous() const + { return previous_;} + //@} + + /**@name does work */ + //@{ + /** Adds to list - easy case i.e. add row to row list + Returns where chain starts + */ + int addEasy(int majorIndex, int numberOfElements, const int * indices, + const double * elements, CoinModelTriple * triples, + CoinModelHash2 & hash); + /** Adds to list - hard case i.e. add row to column list + */ + void addHard(int minorIndex, int numberOfElements, const int * indices, + const double * elements, CoinModelTriple * triples, + CoinModelHash2 & hash); + /** Adds to list - hard case i.e. add row to column list + This is when elements have been added to other copy + */ + void addHard(int first, const CoinModelTriple * triples, + int firstFree, int lastFree,const int * nextOther); + /** Deletes from list - same case i.e. delete row from row list + */ + void deleteSame(int which, CoinModelTriple * triples, + CoinModelHash2 & hash, bool zapTriples); + /** Deletes from list - other case i.e. delete row from column list + This is when elements have been deleted from other copy + */ + void updateDeleted(int which, CoinModelTriple * triples, + CoinModelLinkedList & otherList); + /** Deletes one element from Row list + */ + void deleteRowOne(int position, CoinModelTriple * triples, + CoinModelHash2 & hash); + /** Update column list for one element when + one element deleted from row copy + */ + void updateDeletedOne(int position, const CoinModelTriple * triples); + /// Fills first,last with -1 + void fill(int first,int last); + /** Puts in free list from other list */ + void synchronize(CoinModelLinkedList & other); + /// Checks that links are consistent + void validateLinks(const CoinModelTriple * triples) const; + //@} +private: + /**@name Data members */ + //@{ + /// Previous - maximumElements long + int * previous_; + /// Next - maximumElements long + int * next_; + /// First - maximumMajor+1 long (last free element chain) + int * first_; + /// Last - maximumMajor+1 long (last free element chain) + int * last_; + /// Number of major items i.e. rows if just row links + int numberMajor_; + /// Maximum number of major items i.e. rows if just row links + int maximumMajor_; + /// Number of elements + int numberElements_; + /// Maximum number of elements + int maximumElements_; + /// 0 row list, 1 column list + int type_; + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/CoinMpsIO.hpp b/thirdparty/windows/include/coin/CoinMpsIO.hpp new file mode 100644 index 0000000..8f0226a --- /dev/null +++ b/thirdparty/windows/include/coin/CoinMpsIO.hpp @@ -0,0 +1,1056 @@ +/* $Id: CoinMpsIO.hpp 1642 2013-10-16 00:43:14Z 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 CoinMpsIO_H +#define CoinMpsIO_H + +#if defined(_MSC_VER) +// Turn off compiler warning about long names +# pragma warning(disable:4786) +#endif + +#include <vector> +#include <string> + +#include "CoinUtilsConfig.h" +#include "CoinPackedMatrix.hpp" +#include "CoinMessageHandler.hpp" +#include "CoinFileIO.hpp" +class CoinModel; + +/// The following lengths are in decreasing order (for 64 bit etc) +/// Large enough to contain element index +/// This is already defined as CoinBigIndex +/// Large enough to contain column index +typedef int COINColumnIndex; + +/// Large enough to contain row index (or basis) +typedef int COINRowIndex; + +// We are allowing free format - but there is a limit! +// User can override by using CXXFLAGS += -DCOIN_MAX_FIELD_LENGTH=nnn +#ifndef COIN_MAX_FIELD_LENGTH +#define COIN_MAX_FIELD_LENGTH 160 +#endif +#define MAX_CARD_LENGTH 5*COIN_MAX_FIELD_LENGTH+80 + +enum COINSectionType { COIN_NO_SECTION, COIN_NAME_SECTION, COIN_ROW_SECTION, + COIN_COLUMN_SECTION, + COIN_RHS_SECTION, COIN_RANGES_SECTION, COIN_BOUNDS_SECTION, + COIN_ENDATA_SECTION, COIN_EOF_SECTION, COIN_QUADRATIC_SECTION, + COIN_CONIC_SECTION,COIN_QUAD_SECTION,COIN_SOS_SECTION, + COIN_BASIS_SECTION,COIN_UNKNOWN_SECTION +}; + +enum COINMpsType { COIN_N_ROW, COIN_E_ROW, COIN_L_ROW, COIN_G_ROW, + COIN_BLANK_COLUMN, COIN_S1_COLUMN, COIN_S2_COLUMN, COIN_S3_COLUMN, + COIN_INTORG, COIN_INTEND, COIN_SOSEND, COIN_UNSET_BOUND, + COIN_UP_BOUND, COIN_FX_BOUND, COIN_LO_BOUND, COIN_FR_BOUND, + COIN_MI_BOUND, COIN_PL_BOUND, COIN_BV_BOUND, + COIN_UI_BOUND, COIN_LI_BOUND, COIN_BOTH_BOUNDS_SET, + COIN_SC_BOUND, COIN_S1_BOUND, COIN_S2_BOUND, + COIN_BS_BASIS, COIN_XL_BASIS, COIN_XU_BASIS, + COIN_LL_BASIS, COIN_UL_BASIS, COIN_UNKNOWN_MPS_TYPE +}; +class CoinMpsIO; +/// Very simple code for reading MPS data +class CoinMpsCardReader { + +public: + + /**@name Constructor and destructor */ + //@{ + /// Constructor expects file to be open + /// This one takes gzFile if fp null + CoinMpsCardReader ( CoinFileInput *input, CoinMpsIO * reader ); + + /// Destructor + ~CoinMpsCardReader ( ); + //@} + + + /**@name card stuff */ + //@{ + /// Read to next section + COINSectionType readToNextSection ( ); + /// Gets next field and returns section type e.g. COIN_COLUMN_SECTION + COINSectionType nextField ( ); + /** Gets next field for .gms file and returns type. + -1 - EOF + 0 - what we expected (and processed so pointer moves past) + 1 - not what we expected + leading blanks always ignored + input types + 0 - anything - stops on non blank card + 1 - name (in columnname) + 2 - value + 3 - value name pair + 4 - equation type + 5 - ; + */ + int nextGmsField ( int expectedType ); + /// Returns current section type + inline COINSectionType whichSection ( ) const { + return section_; + } + /// Sets current section type + inline void setWhichSection(COINSectionType section ) { + section_=section; + } + /// Sees if free format. + inline bool freeFormat() const + { return freeFormat_;} + /// Sets whether free format. Mainly for blank RHS etc + inline void setFreeFormat(bool yesNo) + { freeFormat_=yesNo;} + /// Only for first field on card otherwise BLANK_COLUMN + /// e.g. COIN_E_ROW + inline COINMpsType mpsType ( ) const { + return mpsType_; + } + /// Reads and cleans card - taking out trailing blanks - return 1 if EOF + int cleanCard(); + /// Returns row name of current field + inline const char *rowName ( ) const { + return rowName_; + } + /// Returns column name of current field + inline const char *columnName ( ) const { + return columnName_; + } + /// Returns value in current field + inline double value ( ) const { + return value_; + } + /// Returns value as string in current field + inline const char *valueString ( ) const { + return valueString_; + } + /// Whole card (for printing) + inline const char *card ( ) const { + return card_; + } + /// Whole card - so we look at it (not const so nextBlankOr will work for gms reader) + inline char *mutableCard ( ) { + return card_; + } + /// set position (again so gms reader will work) + inline void setPosition(char * position) + { position_=position;} + /// get position (again so gms reader will work) + inline char * getPosition() const + { return position_;} + /// Returns card number + inline CoinBigIndex cardNumber ( ) const { + return cardNumber_; + } + /// Returns file input + inline CoinFileInput * fileInput ( ) const { + return input_; + } + /// Sets whether strings allowed + inline void setStringsAllowed() + { stringsAllowed_=true;} + //@} + +////////////////// data ////////////////// +protected: + + /**@name data */ + //@{ + /// Current value + double value_; + /// Current card image + char card_[MAX_CARD_LENGTH]; + /// Current position within card image + char *position_; + /// End of card + char *eol_; + /// Current COINMpsType + COINMpsType mpsType_; + /// Current row name + char rowName_[COIN_MAX_FIELD_LENGTH]; + /// Current column name + char columnName_[COIN_MAX_FIELD_LENGTH]; + /// File input + CoinFileInput *input_; + /// Which section we think we are in + COINSectionType section_; + /// Card number + CoinBigIndex cardNumber_; + /// Whether free format. Just for blank RHS etc + bool freeFormat_; + /// Whether IEEE - 0 no, 1 INTEL, 2 not INTEL + int ieeeFormat_; + /// If all names <= 8 characters then allow embedded blanks + bool eightChar_; + /// MpsIO + CoinMpsIO * reader_; + /// Message handler + CoinMessageHandler * handler_; + /// Messages + CoinMessages messages_; + /// Current element as characters (only if strings allowed) + char valueString_[COIN_MAX_FIELD_LENGTH]; + /// Whether strings allowed + bool stringsAllowed_; + //@} +public: + /**@name methods */ + //@{ + /// type - 0 normal, 1 INTEL IEEE, 2 other IEEE + double osi_strtod(char * ptr, char ** output, int type); + /// remove blanks + static void strcpyAndCompress ( char *to, const char *from ); + /// + static char * nextBlankOr ( char *image ); + /// For strings + double osi_strtod(char * ptr, char ** output); + //@} + +}; + +//############################################################################# +#ifdef USE_SBB +class SbbObject; +class SbbModel; +#endif +/// Very simple class for containing data on set +class CoinSet { + +public: + + /**@name Constructor and destructor */ + //@{ + /// Default constructor + CoinSet ( ); + /// Constructor + CoinSet ( int numberEntries, const int * which); + + /// Copy constructor + CoinSet (const CoinSet &); + + /// Assignment operator + CoinSet & operator=(const CoinSet& rhs); + + /// Destructor + virtual ~CoinSet ( ); + //@} + + + /**@name gets */ + //@{ + /// Returns number of entries + inline int numberEntries ( ) const + { return numberEntries_; } + /// Returns type of set - 1 =SOS1, 2 =SOS2 + inline int setType ( ) const + { return setType_; } + /// Returns list of variables + inline const int * which ( ) const + { return which_; } + /// Returns weights + inline const double * weights ( ) const + { return weights_; } + //@} + +#ifdef USE_SBB + /**@name Use in sbb */ + //@{ + /// returns an object of type SbbObject + virtual SbbObject * sbbObject(SbbModel * model) const + { return NULL;} + //@} +#endif + +////////////////// data ////////////////// +protected: + + /**@name data */ + //@{ + /// Number of entries + int numberEntries_; + /// type of set + int setType_; + /// Which variables are in set + int * which_; + /// Weights + double * weights_; + //@} +}; + +//############################################################################# +/// Very simple class for containing SOS set +class CoinSosSet : public CoinSet{ + +public: + + /**@name Constructor and destructor */ + //@{ + /// Constructor + CoinSosSet ( int numberEntries, const int * which, const double * weights, int type); + + /// Destructor + virtual ~CoinSosSet ( ); + //@} + + +#ifdef USE_SBB + /**@name Use in sbb */ + //@{ + /// returns an object of type SbbObject + virtual SbbObject * sbbObject(SbbModel * model) const ; + //@} +#endif + +////////////////// data ////////////////// +protected: + + /**@name data */ + //@{ + //@} +}; + +//############################################################################# + +/** MPS IO Interface + + This class can be used to read in mps files without a solver. After + reading the file, the CoinMpsIO object contains all relevant data, which + may be more than a particular OsiSolverInterface allows for. Items may + be deleted to allow for flexibility of data storage. + + The implementation makes the CoinMpsIO object look very like a dummy solver, + as the same conventions are used. +*/ + +class CoinMpsIO { + friend void CoinMpsIOUnitTest(const std::string & mpsDir); + +public: + +/** @name Methods to retrieve problem information + + These methods return information about the problem held by the CoinMpsIO + object. + + Querying an object that has no data associated with it result in zeros for + the number of rows and columns, and NULL pointers from the methods that + return vectors. Const pointers returned from any data-query method are + always valid +*/ +//@{ + /// Get number of columns + int getNumCols() const; + + /// Get number of rows + int getNumRows() const; + + /// Get number of nonzero elements + int getNumElements() const; + + /// Get pointer to array[getNumCols()] of column lower bounds + const double * getColLower() const; + + /// Get pointer to array[getNumCols()] of column upper bounds + const double * getColUpper() const; + + /** Get pointer to array[getNumRows()] of constraint senses. + <ul> + <li>'L': <= constraint + <li>'E': = constraint + <li>'G': >= constraint + <li>'R': ranged constraint + <li>'N': free constraint + </ul> + */ + const char * getRowSense() const; + + /** Get pointer to array[getNumRows()] of constraint right-hand sides. + + Given constraints with upper (rowupper) and/or lower (rowlower) bounds, + the constraint right-hand side (rhs) is set as + <ul> + <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i] + <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i] + <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i] + <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0 + </ul> + */ + const double * getRightHandSide() const; + + /** Get pointer to array[getNumRows()] of row ranges. + + Given constraints with upper (rowupper) and/or lower (rowlower) bounds, + the constraint range (rowrange) is set as + <ul> + <li> if rowsense()[i] == 'R' then + rowrange()[i] == rowupper()[i] - rowlower()[i] + <li> if rowsense()[i] != 'R' then + rowrange()[i] is 0.0 + </ul> + Put another way, only range constraints have a nontrivial value for + rowrange. + */ + const double * getRowRange() const; + + /// Get pointer to array[getNumRows()] of row lower bounds + const double * getRowLower() const; + + /// Get pointer to array[getNumRows()] of row upper bounds + const double * getRowUpper() const; + + /// Get pointer to array[getNumCols()] of objective function coefficients + const double * getObjCoefficients() const; + + /// Get pointer to row-wise copy of the coefficient matrix + const CoinPackedMatrix * getMatrixByRow() const; + + /// Get pointer to column-wise copy of the coefficient matrix + const CoinPackedMatrix * getMatrixByCol() const; + + /// Return true if column is a continuous variable + bool isContinuous(int colNumber) const; + + /** Return true if a column is an integer variable + + Note: This function returns true if the the column + is a binary or general integer variable. + */ + bool isInteger(int columnNumber) const; + + /** Returns array[getNumCols()] specifying if a variable is integer. + + At present, simply coded as zero (continuous) and non-zero (integer) + May be extended at a later date. + */ + const char * integerColumns() const; + + /** Returns the row name for the specified index. + + Returns 0 if the index is out of range. + */ + const char * rowName(int index) const; + + /** Returns the column name for the specified index. + + Returns 0 if the index is out of range. + */ + const char * columnName(int index) const; + + /** Returns the index for the specified row name + + Returns -1 if the name is not found. + Returns numberRows for the objective row and > numberRows for + dropped free rows. + */ + int rowIndex(const char * name) const; + + /** Returns the index for the specified column name + + Returns -1 if the name is not found. + */ + int columnIndex(const char * name) const; + + /** Returns the (constant) objective offset + + This is the RHS entry for the objective row + */ + double objectiveOffset() const; + /// Set objective offset + inline void setObjectiveOffset(double value) + { objectiveOffset_=value;} + + /// Return the problem name + const char * getProblemName() const; + + /// Return the objective name + const char * getObjectiveName() const; + + /// Return the RHS vector name + const char * getRhsName() const; + + /// Return the range vector name + const char * getRangeName() const; + + /// Return the bound vector name + const char * getBoundName() const; + /// Number of string elements + inline int numberStringElements() const + { return numberStringElements_;} + /// String element + inline const char * stringElement(int i) const + { return stringElements_[i];} +//@} + + +/** @name Methods to set problem information + + Methods to load a problem into the CoinMpsIO object. +*/ +//@{ + + /// Set the problem data + void setMpsData(const CoinPackedMatrix& m, const double infinity, + const double* collb, const double* colub, + const double* obj, const char* integrality, + const double* rowlb, const double* rowub, + char const * const * const colnames, + char const * const * const rownames); + void setMpsData(const CoinPackedMatrix& m, const double infinity, + const double* collb, const double* colub, + const double* obj, const char* integrality, + const double* rowlb, const double* rowub, + const std::vector<std::string> & colnames, + const std::vector<std::string> & rownames); + void setMpsData(const CoinPackedMatrix& m, const double infinity, + const double* collb, const double* colub, + const double* obj, const char* integrality, + const char* rowsen, const double* rowrhs, + const double* rowrng, + char const * const * const colnames, + char const * const * const rownames); + void setMpsData(const CoinPackedMatrix& m, const double infinity, + const double* collb, const double* colub, + const double* obj, const char* integrality, + const char* rowsen, const double* rowrhs, + const double* rowrng, + const std::vector<std::string> & colnames, + const std::vector<std::string> & rownames); + + /** Pass in an array[getNumCols()] specifying if a variable is integer. + + At present, simply coded as zero (continuous) and non-zero (integer) + May be extended at a later date. + */ + void copyInIntegerInformation(const char * integerInformation); + + /// Set problem name + void setProblemName(const char *name) ; + + /// Set objective name + void setObjectiveName(const char *name) ; + +//@} + +/** @name Parameter set/get methods + + Methods to set and retrieve MPS IO parameters. +*/ + +//@{ + /// Set infinity + void setInfinity(double value); + + /// Get infinity + double getInfinity() const; + + /// Set default upper bound for integer variables + void setDefaultBound(int value); + + /// Get default upper bound for integer variables + int getDefaultBound() const; + /// Whether to allow string elements + inline int allowStringElements() const + { return allowStringElements_;} + /// Whether to allow string elements (0 no, 1 yes, 2 yes and try flip) + inline void setAllowStringElements(int yesNo) + { allowStringElements_ = yesNo;} + /** Small element value - elements less than this set to zero on input + default is 1.0e-14 */ + inline double getSmallElementValue() const + { return smallElement_;} + inline void setSmallElementValue(double value) + { smallElement_=value;} +//@} + + +/** @name Methods for problem input and output + + Methods to read and write MPS format problem files. + + The read and write methods return the number of errors that occurred during + the IO operation, or -1 if no file is opened. + + \note + If the CoinMpsIO class was compiled with support for libz then + readMps will automatically try to append .gz to the file name and open it as + a compressed file if the specified file name cannot be opened. + (Automatic append of the .bz2 suffix when libbz is used is on the TODO list.) + + \todo + Allow for file pointers and positioning +*/ + +//@{ + /// Set the current file name for the CoinMpsIO object + void setFileName(const char * name); + + /// Get the current file name for the CoinMpsIO object + const char * getFileName() const; + + /** Read a problem in MPS format from the given filename. + + Use "stdin" or "-" to read from stdin. + */ + int readMps(const char *filename, const char *extension = "mps"); + + /** Read a problem in MPS format from the given filename. + + Use "stdin" or "-" to read from stdin. + But do sets as well + */ + int readMps(const char *filename, const char *extension , + int & numberSets, CoinSet **& sets); + + /** Read a problem in MPS format from a previously opened file + + More precisely, read a problem using a CoinMpsCardReader object already + associated with this CoinMpsIO object. + + \todo + Provide an interface that will allow a client to associate a + CoinMpsCardReader object with a CoinMpsIO object by setting the + cardReader_ field. + */ + int readMps(); + /// and + int readMps(int & numberSets, CoinSet **& sets); + /** Read a basis in MPS format from the given filename. + If VALUES on NAME card and solution not NULL fills in solution + status values as for CoinWarmStartBasis (but one per char) + -1 file error, 0 normal, 1 has solution values + + Use "stdin" or "-" to read from stdin. + + If sizes of names incorrect - read without names + */ + int readBasis(const char *filename, const char *extension , + double * solution, unsigned char *rowStatus, unsigned char *columnStatus, + const std::vector<std::string> & colnames,int numberColumns, + const std::vector<std::string> & rownames, int numberRows); + + /** Read a problem in GAMS format from the given filename. + + Use "stdin" or "-" to read from stdin. + if convertObjective then massages objective column + */ + int readGms(const char *filename, const char *extension = "gms",bool convertObjective=false); + + /** Read a problem in GAMS format from the given filename. + + Use "stdin" or "-" to read from stdin. + But do sets as well + */ + int readGms(const char *filename, const char *extension , + int & numberSets, CoinSet **& sets); + + /** Read a problem in GAMS format from a previously opened file + + More precisely, read a problem using a CoinMpsCardReader object already + associated with this CoinMpsIO object. + + */ + // Not for now int readGms(); + /// and + int readGms(int & numberSets, CoinSet **& sets); + /** Read a problem in GMPL (subset of AMPL) format from the given filenames. + */ + int readGMPL(const char *modelName, const char * dataName=NULL, bool keepNames=false); + + /** Write the problem in MPS format to a file with the given filename. + + \param compression can be set to three values to indicate what kind + of file should be written + <ul> + <li> 0: plain text (default) + <li> 1: gzip compressed (.gz is appended to \c filename) + <li> 2: bzip2 compressed (.bz2 is appended to \c filename) (TODO) + </ul> + If the library was not compiled with the requested compression then + writeMps falls back to writing a plain text file. + + \param formatType specifies the precision to used for values in the + MPS file + <ul> + <li> 0: normal precision (default) + <li> 1: extra accuracy + <li> 2: IEEE hex + </ul> + + \param numberAcross specifies whether 1 or 2 (default) values should be + specified on every data line in the MPS file. + + \param quadratic specifies quadratic objective to be output + */ + int writeMps(const char *filename, int compression = 0, + int formatType = 0, int numberAcross = 2, + CoinPackedMatrix * quadratic = NULL, + int numberSOS=0,const CoinSet * setInfo=NULL) const; + + /// Return card reader object so can see what last card was e.g. QUADOBJ + inline const CoinMpsCardReader * reader() const + { return cardReader_;} + + /** Read in a quadratic objective from the given filename. + + If filename is NULL (or the same as the currently open file) then + reading continues from the current file. + If not, the file is closed and the specified file is opened. + + Code should be added to + general MPS reader to read this if QSECTION + Data is assumed to be Q and objective is c + 1/2 xT Q x + No assumption is made for symmetry, positive definite, etc. + No check is made for duplicates or non-triangular if checkSymmetry==0. + If 1 checks lower triangular (so off diagonal should be 2*Q) + if 2 makes lower triangular and assumes full Q (but adds off diagonals) + + Arrays should be deleted by delete [] + + Returns number of errors: + <ul> + <li> -1: bad file + <li> -2: no Quadratic section + <li> -3: an empty section + <li> +n: then matching errors etc (symmetry forced) + <li> -4: no matching errors but fails triangular test + (triangularity forced) + </ul> + columnStart is numberColumns+1 long, others numberNonZeros + */ + int readQuadraticMps(const char * filename, + int * &columnStart, int * &column, double * &elements, + int checkSymmetry); + + /** Read in a list of cones from the given filename. + + If filename is NULL (or the same as the currently open file) then + reading continues from the current file. + If not, the file is closed and the specified file is opened. + + Code should be added to + general MPS reader to read this if CSECTION + No checking is done that in unique cone + + Arrays should be deleted by delete [] + + Returns number of errors, -1 bad file, -2 no conic section, + -3 empty section + + columnStart is numberCones+1 long, other number of columns in matrix + + coneType is 1 for QUAD, 2 for RQUAD (numberCones long) +*/ + int readConicMps(const char * filename, + int * &columnStart, int * &column, int * &coneType, int & numberCones); + /// Set whether to move objective from matrix + inline void setConvertObjective(bool trueFalse) + { convertObjective_=trueFalse;} + /// copies in strings from a CoinModel - returns number + int copyStringElements(const CoinModel * model); + //@} + +/** @name Constructors and destructors */ +//@{ + /// Default Constructor + CoinMpsIO(); + + /// Copy constructor + CoinMpsIO (const CoinMpsIO &); + + /// Assignment operator + CoinMpsIO & operator=(const CoinMpsIO& rhs); + + /// Destructor + ~CoinMpsIO (); +//@} + + +/**@name Message handling */ +//@{ + /** Pass in Message handler + + Supply a custom message handler. It will not be destroyed when the + CoinMpsIO object is destroyed. + */ + void passInMessageHandler(CoinMessageHandler * handler); + + /// Set the language for messages. + void newLanguage(CoinMessages::Language language); + + /// Set the language for messages. + inline void setLanguage(CoinMessages::Language language) {newLanguage(language);} + + /// Return the message handler + inline CoinMessageHandler * messageHandler() const {return handler_;} + + /// Return the messages + inline CoinMessages messages() {return messages_;} + /// Return the messages pointer + inline CoinMessages * messagesPointer() {return & messages_;} +//@} + + +/**@name Methods to release storage + + These methods allow the client to reduce the storage used by the CoinMpsIO + object be selectively releasing unneeded problem information. +*/ +//@{ + /** Release all information which can be re-calculated. + + E.g., row sense, copies of rows, hash tables for names. + */ + void releaseRedundantInformation(); + + /// Release all row information (lower, upper) + void releaseRowInformation(); + + /// Release all column information (lower, upper, objective) + void releaseColumnInformation(); + + /// Release integer information + void releaseIntegerInformation(); + + /// Release row names + void releaseRowNames(); + + /// Release column names + void releaseColumnNames(); + + /// Release matrix information + void releaseMatrixInformation(); + //@} + +protected: + +/**@name Miscellaneous helper functions */ + //@{ + + /// Utility method used several times to implement public methods + void + setMpsDataWithoutRowAndColNames( + const CoinPackedMatrix& m, const double infinity, + const double* collb, const double* colub, + const double* obj, const char* integrality, + const double* rowlb, const double* rowub); + void + setMpsDataColAndRowNames( + const std::vector<std::string> & colnames, + const std::vector<std::string> & rownames); + void + setMpsDataColAndRowNames( + char const * const * const colnames, + char const * const * const rownames); + + + /// Does the heavy lifting for destruct and assignment. + void gutsOfDestructor(); + + /// Does the heavy lifting for copy and assignment. + void gutsOfCopy(const CoinMpsIO &); + + /// Clears problem data from the CoinMpsIO object. + void freeAll(); + + + /** A quick inlined function to convert from lb/ub style constraint + definition to sense/rhs/range style */ + inline void + convertBoundToSense(const double lower, const double upper, + char& sense, double& right, double& range) const; + /** A quick inlined function to convert from sense/rhs/range stryle + constraint definition to lb/ub style */ + inline void + convertSenseToBound(const char sense, const double right, + const double range, + double& lower, double& upper) const; + + /** Deal with a filename + + As the name says. + Returns +1 if the file name is new, 0 if it's the same as before + (i.e., matches fileName_), and -1 if there's an error and the file + can't be opened. + Handles automatic append of .gz suffix when compiled with libz. + + \todo + Add automatic append of .bz2 suffix when compiled with libbz. + */ + + int dealWithFileName(const char * filename, const char * extension, + CoinFileInput * &input); + /** Add string to list + iRow==numberRows is objective, nr+1 is lo, nr+2 is up + iColumn==nc is rhs (can't cope with ranges at present) + */ + void addString(int iRow,int iColumn, const char * value); + /// Decode string + void decodeString(int iString, int & iRow, int & iColumn, const char * & value) const; + //@} + + + // for hashing + typedef struct { + int index, next; + } CoinHashLink; + + /**@name Hash table methods */ + //@{ + /// Creates hash list for names (section = 0 for rows, 1 columns) + void startHash ( char **names, const int number , int section ); + /// This one does it when names are already in + void startHash ( int section ) const; + /// Deletes hash storage + void stopHash ( int section ); + /// Finds match using hash, -1 not found + int findHash ( const char *name , int section ) const; + //@} + + /**@name Cached problem information */ + //@{ + /// Problem name + char * problemName_; + + /// Objective row name + char * objectiveName_; + + /// Right-hand side vector name + char * rhsName_; + + /// Range vector name + char * rangeName_; + + /// Bounds vector name + char * boundName_; + + /// Number of rows + int numberRows_; + + /// Number of columns + int numberColumns_; + + /// Number of coefficients + CoinBigIndex numberElements_; + + /// Pointer to dense vector of row sense indicators + mutable char *rowsense_; + + /// Pointer to dense vector of row right-hand side values + mutable double *rhs_; + + /** Pointer to dense vector of slack variable upper bounds for range + constraints (undefined for non-range rows) + */ + mutable double *rowrange_; + + /// Pointer to row-wise copy of problem matrix coefficients. + mutable CoinPackedMatrix *matrixByRow_; + + /// Pointer to column-wise copy of problem matrix coefficients. + CoinPackedMatrix *matrixByColumn_; + + /// Pointer to dense vector of row lower bounds + double * rowlower_; + + /// Pointer to dense vector of row upper bounds + double * rowupper_; + + /// Pointer to dense vector of column lower bounds + double * collower_; + + /// Pointer to dense vector of column upper bounds + double * colupper_; + + /// Pointer to dense vector of objective coefficients + double * objective_; + + /// Constant offset for objective value (i.e., RHS value for OBJ row) + double objectiveOffset_; + + + /** Pointer to dense vector specifying if a variable is continuous + (0) or integer (1). + */ + char * integerType_; + + /** Row and column names + Linked to hash table sections (0 - row names, 1 column names) + */ + char **names_[2]; + //@} + + /** @name Hash tables */ + //@{ + /// Current file name + char * fileName_; + + /// Number of entries in a hash table section + int numberHash_[2]; + + /// Hash tables (two sections, 0 - row names, 1 - column names) + mutable CoinHashLink *hash_[2]; + //@} + + /** @name CoinMpsIO object parameters */ + //@{ + /// Upper bound when no bounds for integers + int defaultBound_; + + /// Value to use for infinity + double infinity_; + /// Small element value + double smallElement_; + + /// Message handler + CoinMessageHandler * handler_; + /** Flag to say if the message handler is the default handler. + + If true, the handler will be destroyed when the CoinMpsIO + object is destroyed; if false, it will not be destroyed. + */ + bool defaultHandler_; + /// Messages + CoinMessages messages_; + /// Card reader + CoinMpsCardReader * cardReader_; + /// If .gms file should it be massaged to move objective + bool convertObjective_; + /// Whether to allow string elements + int allowStringElements_; + /// Maximum number of string elements + int maximumStringElements_; + /// Number of string elements + int numberStringElements_; + /// String elements + char ** stringElements_; + //@} + +}; + +//############################################################################# +/** A function that tests the methods in the CoinMpsIO 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. Also, if this method is compiled with + optimization, the compilation takes 10-15 minutes and the machine pages + (has 256M core memory!)... */ +void +CoinMpsIOUnitTest(const std::string & mpsDir); +// Function to return number in most efficient way +// section is 0 for columns, 1 for rhs,ranges and 2 for bounds +/* formatType is + 0 - normal and 8 character names + 1 - extra accuracy + 2 - IEEE hex - INTEL + 3 - IEEE hex - not INTEL +*/ +void +CoinConvertDouble(int section, int formatType, double value, char outputValue[24]); + +#endif + diff --git a/thirdparty/windows/include/coin/CoinOslFactorization.hpp b/thirdparty/windows/include/coin/CoinOslFactorization.hpp new file mode 100644 index 0000000..0b51b01 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinOslFactorization.hpp @@ -0,0 +1,280 @@ +/* $Id: CoinOslFactorization.hpp 1416 2011-04-17 09:57:29Z stefan $ */ +// Copyright (C) 1987, 2009, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +/* + Authors + + John Forrest + + */ +#ifndef CoinOslFactorization_H +#define CoinOslFactorization_H +#include <iostream> +#include <string> +#include <cassert> +#include "CoinTypes.hpp" +#include "CoinIndexedVector.hpp" +#include "CoinDenseFactorization.hpp" +class CoinPackedMatrix; +/** This deals with Factorization and Updates + This is ripped off from OSL!!!!!!!!! + + I am assuming that 32 bits is enough for number of rows or columns, but CoinBigIndex + may be redefined to get 64 bits. + */ + +typedef struct {int suc, pre;} EKKHlink; +typedef struct _EKKfactinfo { + double drtpiv; + double demark; + double zpivlu; + double zeroTolerance; + double areaFactor; + int *xrsadr; + int *xcsadr; + int *xrnadr; + int *xcnadr; + int *krpadr; + int *kcpadr; + int *mpermu; + int *bitArray; + int * back; + char * nonzero; + double * trueStart; + mutable double *kadrpm; + int *R_etas_index; + int *R_etas_start; + double *R_etas_element; + + int *xecadr; + int *xeradr; + double *xeeadr; + double *xe2adr; + EKKHlink * kp1adr; + EKKHlink * kp2adr; + double * kw1adr; + double * kw2adr; + double * kw3adr; + int * hpivcoR; + int nrow; + int nrowmx; + int firstDoRow; + int firstLRow; + int maxinv; + int nnetas; + int iterin; + int iter0; + int invok; + int nbfinv; + int num_resets; + int nnentl; + int nnentu; +#ifdef CLP_REUSE_ETAS + int save_nnentu; +#endif + int ndenuc; + int npivots; /* use as xpivsq in factorization */ + int kmxeta; + int xnetal; + int first_dense; + int last_dense; + int iterno; + int numberSlacks; + int lastSlack; + int firstNonSlack; + int xnetalval; + int lstart; + int if_sparse_update; + mutable int packedMode; + int switch_off_sparse_update; + int nuspike; + bool rows_ok; /* replaces test using mrstrt[1] */ +#ifdef CLP_REUSE_ETAS + mutable int reintro; +#endif + int nR_etas; + int sortedEta; /* if vector for F-T is sorted */ + int lastEtaCount; + int ifvsol; + int eta_size; + int last_eta_size; + int maxNNetas; +} EKKfactinfo; + +class CoinOslFactorization : public CoinOtherFactorization { + friend void CoinOslFactorizationUnitTest( const std::string & mpsDir ); + +public: + + /**@name Constructors and destructor and copy */ + //@{ + /// Default constructor + CoinOslFactorization ( ); + /// Copy constructor + CoinOslFactorization ( const CoinOslFactorization &other); + + /// Destructor + virtual ~CoinOslFactorization ( ); + /// = copy + CoinOslFactorization & operator = ( const CoinOslFactorization & other ); + /// Clone + virtual CoinOtherFactorization * clone() const ; + //@} + + /**@name Do factorization - public */ + //@{ + /// Gets space for a factorization + virtual void getAreas ( int numberRows, + int numberColumns, + CoinBigIndex maximumL, + CoinBigIndex maximumU ); + + /// PreProcesses column ordered copy of basis + virtual void preProcess ( ); + /** Does most of factorization returning status + 0 - OK + -99 - needs more memory + -1 - singular - use numberGoodColumns and redo + */ + virtual int factor ( ); + /// Does post processing on valid factorization - putting variables on correct rows + virtual void postProcess(const int * sequence, int * pivotVariable); + /// Makes a non-singular basis by replacing variables + virtual void makeNonSingular(int * sequence, int numberColumns); + /** 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 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 ( const CoinPackedMatrix & matrix, + int rowIsBasic[], int columnIsBasic[] , + double areaFactor = 0.0 ); + //@} + + /**@name general stuff such as number of elements */ + //@{ + /// Total number of elements in factorization + virtual inline int numberElements ( ) const { + return numberRows_*(numberColumns_+numberPivots_); + } + /// Returns array to put basis elements in + virtual CoinFactorizationDouble * elements() const; + /// Returns pivot row + virtual int * pivotRow() const; + /// Returns work area + virtual CoinFactorizationDouble * workArea() const; + /// Returns int work area + virtual int * intWorkArea() const; + /// Number of entries in each row + virtual int * numberInRow() const; + /// Number of entries in each column + virtual int * numberInColumn() const; + /// Returns array to put basis starts in + virtual CoinBigIndex * starts() const; + /// Returns permute back + virtual int * permuteBack() const; + /// Returns true if wants tableauColumn in replaceColumn + virtual bool wantsTableauColumn() const; + /** Useful information for factorization + 0 - iteration number + whereFrom is 0 for factorize and 1 for replaceColumn + */ + virtual void setUsefulInformation(const int * info,int whereFrom); + /// Set maximum pivots + virtual void maximumPivots ( int value ); + + /// Returns maximum absolute value in factorization + double maximumCoefficient() const; + /// Condition number - product of pivots after factorization + double conditionNumber() const; + /// Get rid of all memory + virtual void clearArrays(); + //@} + + /**@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 */ + virtual int replaceColumn ( CoinIndexedVector * regionSparse, + 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 regionSparse2 + Tries to do FT update + number returned is negative if no room + regionSparse starts as zero and is zero at end. + Note - if regionSparse2 packed on input - will be packed on output + */ + virtual int updateColumnFT ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2, + bool noPermute=false); + /** This version has same effect as above with FTUpdate==false + so number returned is always >=0 */ + virtual int updateColumn ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2, + bool noPermute=false) const; + /// does FTRAN on two columns + virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1, + CoinIndexedVector * regionSparse2, + CoinIndexedVector * regionSparse3, + bool noPermute=false); + /** Updates one column (BTRAN) from regionSparse2 + regionSparse starts as zero and is zero at end + Note - if regionSparse2 packed on input - will be packed on output + */ + virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2) const; + //@} + /// *** Below this user may not want to know about + + /**@name various uses of factorization + which user may not want to know about (left over from my LP code) */ + //@{ + /// Get rid of all memory + //inline void clearArrays() + //{ gutsOfDestructor();} + /// Returns array to put basis indices in + virtual int * indices() const; + /// Returns permute in + virtual inline int * permute() const + { return NULL;/*pivotRow_*/;} + //@} + + /// The real work of desstructor + void gutsOfDestructor(bool clearFact=true); + /// The real work of constructor + void gutsOfInitialize(bool zapFact=true); + /// The real work of copy + void gutsOfCopy(const CoinOslFactorization &other); + + //@} +protected: + /** Returns accuracy status of replaceColumn + returns 0=OK, 1=Probably OK, 2=singular */ + int checkPivot(double saveFromU, double oldPivot) const; +////////////////// data ////////////////// +protected: + + /**@name data */ + //@{ + /// Osl factorization data + EKKfactinfo factInfo_; + //@} +}; +#endif diff --git a/thirdparty/windows/include/coin/CoinPackedMatrix.hpp b/thirdparty/windows/include/coin/CoinPackedMatrix.hpp new file mode 100644 index 0000000..c6837ac --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPackedMatrix.hpp @@ -0,0 +1,947 @@ +/* $Id: CoinPackedMatrix.hpp 1560 2012-11-24 00:29:01Z lou $ */ +// 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 CoinPackedMatrix_H +#define CoinPackedMatrix_H + +#include "CoinError.hpp" +#include "CoinTypes.hpp" +#ifndef CLP_NO_VECTOR +#include "CoinPackedVectorBase.hpp" +#include "CoinShallowPackedVector.hpp" +#else +class CoinRelFltEq; +#endif + +/** Sparse Matrix Base Class + + This class is intended to represent sparse matrices using row-major + or column-major ordering. The representation is very efficient for + adding, deleting, or retrieving major-dimension vectors. Adding + a minor-dimension vector is less efficient, but can be helped by + providing "extra" space as described in the next paragraph. Deleting + a minor-dimension vector requires inspecting all coefficients in the + matrix. Retrieving a minor-dimension vector would incur the same cost + and is not supported (except in the sense that you can write a loop to + retrieve all coefficients one at a time). Consider physically transposing + the matrix, or keeping a second copy with the other major-vector ordering. + + The sparse represention can be completely compact or it can have "extra" + space available at the end of each major vector. Incorporating extra + space into the sparse matrix representation can improve performance in + cases where new data needs to be inserted into the packed matrix against + the major-vector orientation (e.g, inserting a row into a matrix stored + in column-major order). + + For example if the matrix: + @verbatim + 3 1 0 -2 -1 0 0 -1 + 0 2 1.1 0 0 0 0 0 + 0 0 1 0 0 1 0 0 + 0 0 0 2.8 0 0 -1.2 0 + 5.6 0 0 0 1 0 0 1.9 + + was stored by rows (with no extra space) in + CoinPackedMatrix r then: + r.getElements() returns a vector containing: + 3 1 -2 -1 -1 2 1.1 1 1 2.8 -1.2 5.6 1 1.9 + r.getIndices() returns a vector containing: + 0 1 3 4 7 1 2 2 5 3 6 0 4 7 + r.getVectorStarts() returns a vector containing: + 0 5 7 9 11 14 + r.getNumElements() returns 14. + r.getMajorDim() returns 5. + r.getVectorSize(0) returns 5. + r.getVectorSize(1) returns 2. + r.getVectorSize(2) returns 2. + r.getVectorSize(3) returns 2. + r.getVectorSize(4) returns 3. + + If stored by columns (with no extra space) then: + c.getElements() returns a vector containing: + 3 5.6 1 2 1.1 1 -2 2.8 -1 1 1 -1.2 -1 1.9 + c.getIndices() returns a vector containing: + 0 4 0 1 1 2 0 3 0 4 2 3 0 4 + c.getVectorStarts() returns a vector containing: + 0 2 4 6 8 10 11 12 14 + c.getNumElements() returns 14. + c.getMajorDim() returns 8. + @endverbatim + + Compiling this class with CLP_NO_VECTOR defined will excise all methods + which use CoinPackedVectorBase, CoinPackedVector, or CoinShallowPackedVector + as parameters or return types. + + Compiling this class with COIN_FAST_CODE defined removes index range checks. +*/ +class CoinPackedMatrix { + friend void CoinPackedMatrixUnitTest(); + +public: + + + //--------------------------------------------------------------------------- + /**@name Query members */ + //@{ + /** Return the current setting of the extra gap. */ + inline double getExtraGap() const { return extraGap_; } + /** Return the current setting of the extra major. */ + inline double getExtraMajor() const { return extraMajor_; } + + /** Reserve sufficient space for appending major-ordered vectors. + If create is true, empty columns are created (for column generation) */ + void reserve(const int newMaxMajorDim, const CoinBigIndex newMaxSize, + bool create=false); + /** Clear the data, but do not free any arrays */ + void clear(); + + /** Whether the packed matrix is column major ordered or not. */ + inline bool isColOrdered() const { return colOrdered_; } + + /** Whether the packed matrix has gaps or not. */ + inline bool hasGaps() const { return (size_<start_[majorDim_]) ; } + + /** Number of entries in the packed matrix. */ + inline CoinBigIndex getNumElements() const { return size_; } + + /** Number of columns. */ + inline int getNumCols() const + { return colOrdered_ ? majorDim_ : minorDim_; } + + /** Number of rows. */ + inline int getNumRows() const + { return colOrdered_ ? minorDim_ : majorDim_; } + + /*! \brief A vector containing the elements in the packed matrix. + + Returns #elements_. Note that there might be gaps in this vector, + entries that do not belong to any major-dimension vector. To get + the actual elements one should look at this vector together with + vectorStarts (#start_) and vectorLengths (#length_). + */ + inline const double * getElements() const { return element_; } + + /*! \brief A vector containing the minor indices of the elements in + the packed matrix. + + Returns #index_. 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 (#start_) and vectorLengths (#length_). + */ + inline const int * getIndices() const { return index_; } + + /*! \brief The size of the <code>vectorStarts</code> array + + See #start_. + */ + inline int getSizeVectorStarts() const + { return ((majorDim_ > 0)?(majorDim_+1):(0)) ; } + + /*! \brief The size of the <code>vectorLengths</code> array + + See #length_. + */ + inline int getSizeVectorLengths() const { return majorDim_; } + + /*! \brief The positions where the major-dimension vectors start in + elements and indices. + + See #start_. + */ + inline const CoinBigIndex * getVectorStarts() const { return start_; } + + /*! \brief The lengths of the major-dimension vectors. + + See #length_. + */ + inline const int * getVectorLengths() const { return length_; } + + /** The position of the first element in the i'th major-dimension vector. + */ + CoinBigIndex getVectorFirst(const int i) const { +#ifndef COIN_FAST_CODE + if (i < 0 || i >= majorDim_) + throw CoinError("bad index", "vectorFirst", "CoinPackedMatrix"); +#endif + return start_[i]; + } + /** The position of the last element (well, one entry <em>past</em> the + last) in the i'th major-dimension vector. */ + CoinBigIndex getVectorLast(const int i) const { +#ifndef COIN_FAST_CODE + if (i < 0 || i >= majorDim_) + throw CoinError("bad index", "vectorLast", "CoinPackedMatrix"); +#endif + return start_[i] + length_[i]; + } + /** The length of i'th vector. */ + inline int getVectorSize(const int i) const { +#ifndef COIN_FAST_CODE + if (i < 0 || i >= majorDim_) + throw CoinError("bad index", "vectorSize", "CoinPackedMatrix"); +#endif + return length_[i]; + } +#ifndef CLP_NO_VECTOR + /** Return the i'th vector in matrix. */ + const CoinShallowPackedVector getVector(int i) const { +#ifndef COIN_FAST_CODE + if (i < 0 || i >= majorDim_) + throw CoinError("bad index", "vector", "CoinPackedMatrix"); +#endif + return CoinShallowPackedVector(length_[i], + index_ + start_[i], + element_ + start_[i], + false); + } +#endif + /** Returns an array containing major indices. The array is + getNumElements long and if getVectorStarts() is 0,2,5 then + the array would start 0,0,1,1,1,2... + This method is provided to go back from a packed format + to a triple format. It returns NULL if there are gaps in + matrix so user should use removeGaps() if there are any gaps. + It does this as this array has to match getElements() and + getIndices() and because it makes no sense otherwise. + The returned array is allocated with <code>new int[]</code>, + free it with <code>delete[]</code>. */ + int * getMajorIndices() const; + //@} + + //--------------------------------------------------------------------------- + /**@name Modifying members */ + //@{ + /*! \brief Set the dimensions of the matrix. + + The method name is deceptive; the effect is to append empty columns + and/or rows to the matrix to reach the specified dimensions. + A negative number for either dimension means that that dimension + doesn't change. An exception will be thrown if the specified dimensions + are smaller than the current dimensions. + */ + void setDimensions(int numrows, int numcols); + + /** Set the extra gap to be allocated to the specified value. */ + void setExtraGap(const double newGap); + /** Set the extra major to be allocated to the specified value. */ + void setExtraMajor(const double newMajor); +#ifndef CLP_NO_VECTOR + /*! Append a column to the end of the matrix. + + When compiled with COIN_DEBUG defined this method throws an exception + if the column vector specifies a nonexistent row index. Otherwise the + method assumes that every index fits into the matrix. + */ + void appendCol(const CoinPackedVectorBase& vec); +#endif + /*! Append a column to the end of the matrix. + + When compiled with COIN_DEBUG defined this method throws an exception + if the column vector specifies a nonexistent row index. Otherwise the + method assumes that every index fits into the matrix. + */ + void appendCol(const int vecsize, + const int *vecind, const double *vecelem); +#ifndef CLP_NO_VECTOR + /*! Append a set of columns to the end of the matrix. + + When compiled with COIN_DEBUG defined this method throws an exception + if any of the column vectors specify a nonexistent row index. Otherwise + the method assumes that every index fits into the matrix. + */ + void appendCols(const int numcols, + const CoinPackedVectorBase * const * cols); +#endif + /*! Append a set of columns to the end of the matrix. + + Returns the number of errors (nonexistent or duplicate row index). + No error checking is performed if \p numberRows < 0. + */ + int appendCols(const int numcols, + const CoinBigIndex * columnStarts, const int * row, + const double * element, int numberRows=-1); +#ifndef CLP_NO_VECTOR + /*! Append a row to the end of the matrix. + + When compiled with COIN_DEBUG defined this method throws an exception + if the row vector specifies a nonexistent column index. Otherwise the + method assumes that every index fits into the matrix. + */ + void appendRow(const CoinPackedVectorBase& vec); +#endif + /*! Append a row to the end of the matrix. + + When compiled with COIN_DEBUG defined this method throws an exception + if the row vector specifies a nonexistent column index. Otherwise the + method assumes that every index fits into the matrix. + */ + void appendRow(const int vecsize, + const int *vecind, const double *vecelem); +#ifndef CLP_NO_VECTOR + /*! Append a set of rows to the end of the matrix. + + When compiled with COIN_DEBUG defined this method throws an exception + if any of the row vectors specify a nonexistent column index. Otherwise + the method assumes that every index fits into the matrix. + */ + void appendRows(const int numrows, + const CoinPackedVectorBase * const * rows); +#endif + /*! Append a set of rows to the end of the matrix. + + Returns the number of errors (nonexistent or duplicate column index). + No error checking is performed if \p numberColumns < 0. + */ + int appendRows(const int numrows, + const CoinBigIndex * rowStarts, const int * column, + const double * element, int numberColumns=-1); + + /** Append the argument to the "right" of the current matrix. Imagine this + as adding new columns (don't worry about how the matrices are ordered, + that is taken care of). An exception is thrown if the number of rows + is different in the matrices. */ + void rightAppendPackedMatrix(const CoinPackedMatrix& matrix); + /** Append the argument to the "bottom" of the current matrix. Imagine this + as adding new rows (don't worry about how the matrices are ordered, + that is taken care of). An exception is thrown if the number of columns + is different in the matrices. */ + void bottomAppendPackedMatrix(const CoinPackedMatrix& matrix); + + /** Delete the columns whose indices are listed in <code>indDel</code>. */ + void deleteCols(const int numDel, const int * indDel); + /** Delete the rows whose indices are listed in <code>indDel</code>. */ + void deleteRows(const int numDel, const int * indDel); + + /** Replace the elements of a vector. The indices remain the same. + At most the number specified will be replaced. + The index is between 0 and major dimension of matrix */ + void replaceVector(const int index, + const int numReplace, const double * newElements); + /** 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 */ + void modifyCoefficient(int row, int column, double newElement, + bool keepZero=false); + /** Return one element of packed matrix. + This works for either ordering + If it is not present will return 0.0 */ + double getCoefficient(int row, int column) const; + + /** Eliminate all elements in matrix whose + absolute value is less than threshold. + The column starts are not affected. Returns number of elements + eliminated. Elements eliminated are at end of each vector + */ + int compress(double threshold); + /** Eliminate all duplicate AND small elements in matrix + The column starts are not affected. Returns number of elements + eliminated. + */ + int eliminateDuplicates(double threshold); + /** Sort all columns so indices are increasing.in each column */ + void orderMatrix(); + /** Really clean up matrix. + 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 + */ + int cleanMatrix(double threshold=1.0e-20); + //@} + + //--------------------------------------------------------------------------- + /**@name Methods that reorganize the whole matrix */ + //@{ + /** Remove the gaps from the matrix if there were any + Can also remove small elements fabs() <= removeValue*/ + void removeGaps(double removeValue=-1.0); + + /** Extract a submatrix from matrix. Those major-dimension vectors of + the matrix comprise the submatrix whose indices are given in the + arguments. Does not allow duplicates. */ + void submatrixOf(const CoinPackedMatrix& matrix, + const int numMajor, const int * indMajor); + /** Extract a submatrix from matrix. Those major-dimension vectors of + the matrix comprise the submatrix whose indices are given in the + arguments. Allows duplicates and keeps order. */ + void submatrixOfWithDuplicates(const CoinPackedMatrix& matrix, + const int numMajor, const int * indMajor); +#if 0 + /** Extract a submatrix from matrix. Those major/minor-dimension vectors of + the matrix comprise the submatrix whose indices are given in the + arguments. */ + void submatrixOf(const CoinPackedMatrix& matrix, + const int numMajor, const int * indMajor, + const int numMinor, const int * indMinor); +#endif + + /** Copy method. This method makes an exact replica of the argument, + including the extra space parameters. */ + void copyOf(const CoinPackedMatrix& rhs); + /** Copy the arguments to the matrix. If <code>len</code> is a NULL pointer + then the matrix is assumed to have no gaps in it and <code>len</code> + will be created accordingly. */ + void copyOf(const bool colordered, + const int minor, const int major, const CoinBigIndex numels, + const double * elem, const int * ind, + const CoinBigIndex * start, const int * len, + const double extraMajor=0.0, const double extraGap=0.0); + /** Copy method. This method makes an exact replica of the argument, + including the extra space parameters. + If there is room it will re-use arrays */ + void copyReuseArrays(const CoinPackedMatrix& rhs); + + /*! \brief Make a reverse-ordered copy. + + This method makes an exact replica of the argument with the major + vector orientation changed from row (column) to column (row). + The extra space parameters are also copied and reversed. + (Cf. #reverseOrdering, which does the same thing in place.) + */ + void reverseOrderedCopyOf(const CoinPackedMatrix& rhs); + + /** Assign the arguments to the matrix. If <code>len</code> is a NULL + pointer then the matrix is assumed to have no gaps in it and + <code>len</code> will be created accordingly. <br> + <strong>NOTE 1</strong>: After this method returns the pointers + passed to the method will be NULL pointers! <br> + <strong>NOTE 2</strong>: When the matrix is eventually destructed the + arrays will be deleted by <code>delete[]</code>. Hence one should use + this method ONLY if all array swere allocated by <code>new[]</code>! */ + void assignMatrix(const bool colordered, + const int minor, const int major, + const CoinBigIndex numels, + double *& elem, int *& ind, + CoinBigIndex *& start, int *& len, + const int maxmajor = -1, const CoinBigIndex maxsize = -1); + + + + /** Assignment operator. This copies out the data, but uses the current + matrix's extra space parameters. */ + CoinPackedMatrix & operator=(const CoinPackedMatrix& rhs); + + /*! \brief Reverse the ordering of the packed matrix. + + Change the major vector orientation of the matrix data structures from + row (column) to column (row). (Cf. #reverseOrderedCopyOf, which does + the same thing but produces a new matrix.) + */ + void reverseOrdering(); + + /*! \brief Transpose the matrix. + + \note + If you start with a column-ordered matrix and invoke transpose, you + will have a row-ordered transposed matrix. To change the major vector + orientation (e.g., to transform a column-ordered matrix to a + column-ordered transposed matrix), invoke transpose() followed by + #reverseOrdering(). + */ + void transpose(); + + /*! \brief Swap the content of two packed matrices. */ + void swap(CoinPackedMatrix& matrix); + + //@} + + //--------------------------------------------------------------------------- + /**@name Matrix times vector methods */ + //@{ + /** Return <code>A * x</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numColumns()</code> + @pre <code>y</code> must be of size <code>numRows()</code> */ + void times(const double * x, double * y) const; +#ifndef CLP_NO_VECTOR + /** Return <code>A * x</code> in <code>y</code>. Same as the previous + method, just <code>x</code> is given in the form of a packed vector. */ + void times(const CoinPackedVectorBase& x, double * y) const; +#endif + /** Return <code>x * A</code> in <code>y</code>. + @pre <code>x</code> must be of size <code>numRows()</code> + @pre <code>y</code> must be of size <code>numColumns()</code> */ + void transposeTimes(const double * x, double * y) const; +#ifndef CLP_NO_VECTOR + /** Return <code>x * A</code> in <code>y</code>. Same as the previous + method, just <code>x</code> is given in the form of a packed vector. */ + void transposeTimes(const CoinPackedVectorBase& x, double * y) const; +#endif + //@} + + //--------------------------------------------------------------------------- + /**@name Helper functions used internally, but maybe useful externally. + + These methods do not worry about testing whether the packed matrix is + row or column major ordered; they operate under the assumption that the + correct version is invoked. In fact, a number of other methods simply + just call one of these after testing the ordering of the matrix. */ + //@{ + + //------------------------------------------------------------------------- + /**@name Queries */ + //@{ + /** Count the number of entries in every minor-dimension vector and + return an array containing these lengths. The returned array is + allocated with <code>new int[]</code>, free it with + <code>delete[]</code>. */ + int * countOrthoLength() const; + /** Count the number of entries in every minor-dimension vector and + fill in an array containing these lengths. */ + void countOrthoLength(int * counts) const; + /** Major dimension. For row ordered matrix this would be the number of + rows. */ + inline int getMajorDim() const { return majorDim_; } + /** Set major dimension. For row ordered matrix this would be the number of + rows. Use with great care.*/ + inline void setMajorDim(int value) { majorDim_ = value; } + /** Minor dimension. For row ordered matrix this would be the number of + columns. */ + inline int getMinorDim() const { return minorDim_; } + /** Set minor dimension. For row ordered matrix this would be the number of + columns. Use with great care.*/ + inline void setMinorDim(int value) { minorDim_ = value; } + /** Current maximum for major dimension. For row ordered matrix this many + rows can be added without reallocating the vector related to the + major dimension (<code>start_</code> and <code>length_</code>). */ + inline int getMaxMajorDim() const { return maxMajorDim_; } + + /** Dump the matrix on stdout. When in dire straits this method can + help. */ + void dumpMatrix(const char* fname = NULL) const; + + /// Print a single matrix element. + void printMatrixElement(const int row_val, const int col_val) const; + //@} + + //------------------------------------------------------------------------- + /*! @name Append vectors + + \details + When compiled with COIN_DEBUG defined these methods throw an exception + if the major (minor) vector contains an index that's invalid for the + minor (major) dimension. Otherwise the methods assume that every index + fits into the matrix. + */ + //@{ +#ifndef CLP_NO_VECTOR + /** Append a major-dimension vector to the end of the matrix. */ + void appendMajorVector(const CoinPackedVectorBase& vec); +#endif + /** Append a major-dimension vector to the end of the matrix. */ + void appendMajorVector(const int vecsize, const int *vecind, + const double *vecelem); +#ifndef CLP_NO_VECTOR + /** Append several major-dimensonvectors to the end of the matrix */ + void appendMajorVectors(const int numvecs, + const CoinPackedVectorBase * const * vecs); + + /** Append a minor-dimension vector to the end of the matrix. */ + void appendMinorVector(const CoinPackedVectorBase& vec); +#endif + /** Append a minor-dimension vector to the end of the matrix. */ + void appendMinorVector(const int vecsize, const int *vecind, + const double *vecelem); +#ifndef CLP_NO_VECTOR + /** Append several minor-dimension vectors to the end of the matrix */ + void appendMinorVectors(const int numvecs, + const CoinPackedVectorBase * const * vecs); +#endif + /*! \brief Append a set of rows (columns) to the end of a column (row) + ordered matrix. + + This case is when we know there are no gaps and majorDim_ will not + change. + + \todo + This method really belongs in the group of protected methods with + #appendMinor; there are no safeties here even with COIN_DEBUG. + Apparently this method was needed in ClpPackedMatrix and giving it + proper visibility was too much trouble. Should be moved. + */ + void appendMinorFast(const int number, + const CoinBigIndex * starts, const int * index, + const double * element); + //@} + + //------------------------------------------------------------------------- + /*! \name Append matrices + + \details + We'll document these methods assuming that the current matrix is + column major ordered (Hence in the <code>...SameOrdered()</code> + methods the argument is column ordered, in the + <code>OrthoOrdered()</code> methods the argument is row ordered.) + */ + //@{ + /** Append the columns of the argument to the right end of this matrix. + @pre <code>minorDim_ == matrix.minorDim_</code> <br> + This method throws an exception if the minor dimensions are not the + same. */ + void majorAppendSameOrdered(const CoinPackedMatrix& matrix); + /** Append the columns of the argument to the bottom end of this matrix. + @pre <code>majorDim_ == matrix.majorDim_</code> <br> + This method throws an exception if the major dimensions are not the + same. */ + void minorAppendSameOrdered(const CoinPackedMatrix& matrix); + /** Append the rows of the argument to the right end of this matrix. + @pre <code>minorDim_ == matrix.majorDim_</code> <br> + This method throws an exception if the minor dimension of the + current matrix is not the same as the major dimension of the + argument matrix. */ + void majorAppendOrthoOrdered(const CoinPackedMatrix& matrix); + /** Append the rows of the argument to the bottom end of this matrix. + @pre <code>majorDim_ == matrix.minorDim_</code> <br> + This method throws an exception if the major dimension of the + current matrix is not the same as the minor dimension of the + argument matrix. */ + void minorAppendOrthoOrdered(const CoinPackedMatrix& matrix); + //@} + + //----------------------------------------------------------------------- + /**@name Delete vectors */ + //@{ + /** Delete the major-dimension vectors whose indices are listed in + <code>indDel</code>. */ + void deleteMajorVectors(const int numDel, const int * indDel); + /** Delete the minor-dimension vectors whose indices are listed in + <code>indDel</code>. */ + void deleteMinorVectors(const int numDel, const int * indDel); + //@} + + //----------------------------------------------------------------------- + /**@name Various dot products. */ + //@{ + /** Return <code>A * x</code> (multiplied from the "right" direction) in + <code>y</code>. + @pre <code>x</code> must be of size <code>majorDim()</code> + @pre <code>y</code> must be of size <code>minorDim()</code> */ + void timesMajor(const double * x, double * y) const; +#ifndef CLP_NO_VECTOR + /** Return <code>A * x</code> (multiplied from the "right" direction) in + <code>y</code>. Same as the previous method, just <code>x</code> is + given in the form of a packed vector. */ + void timesMajor(const CoinPackedVectorBase& x, double * y) const; +#endif + /** Return <code>A * x</code> (multiplied from the "right" direction) in + <code>y</code>. + @pre <code>x</code> must be of size <code>minorDim()</code> + @pre <code>y</code> must be of size <code>majorDim()</code> */ + void timesMinor(const double * x, double * y) const; +#ifndef CLP_NO_VECTOR + /** Return <code>A * x</code> (multiplied from the "right" direction) in + <code>y</code>. Same as the previous method, just <code>x</code> is + given in the form of a packed vector. */ + void timesMinor(const CoinPackedVectorBase& x, double * y) const; +#endif + //@} + //@} + + //-------------------------------------------------------------------------- + /**@name Logical Operations. */ + //@{ +#ifndef CLP_NO_VECTOR + /*! \brief Test for equivalence. + + Two matrices are equivalent if they are both row- or column-ordered, + they have the same dimensions, and each (major) vector is equivalent. + The operator used to test for equality can be specified using the + \p FloatEqual template parameter. + */ + template <class FloatEqual> bool + isEquivalent(const CoinPackedMatrix& rhs, const FloatEqual& eq) const + { + // Both must be column order or both row ordered and must be of same size + if ((isColOrdered() ^ rhs.isColOrdered()) || + (getNumCols() != rhs.getNumCols()) || + (getNumRows() != rhs.getNumRows()) || + (getNumElements() != rhs.getNumElements())) + return false; + + for (int i=getMajorDim()-1; i >= 0; --i) { + CoinShallowPackedVector pv = getVector(i); + CoinShallowPackedVector rhsPv = rhs.getVector(i); + if ( !pv.isEquivalent(rhsPv,eq) ) + return false; + } + return true; + } + + /*! \brief Test for equivalence and report differences + + Equivalence is defined as for #isEquivalent. In addition, this method will + print differences to std::cerr. Intended for use in unit tests and + for debugging. + */ + bool isEquivalent2(const CoinPackedMatrix& rhs) const; +#else + /*! \brief Test for equivalence. + + Two matrices are equivalent if they are both row- or column-ordered, + they have the same dimensions, and each (major) vector is equivalent. + This method is optimised for speed. CoinPackedVector#isEquivalent is + replaced with more efficient code for repeated comparison of + equal-length vectors. The CoinRelFltEq operator is used. + */ + bool isEquivalent(const CoinPackedMatrix& rhs, const CoinRelFltEq & eq) const; +#endif + /*! \brief Test for equivalence. + + The test for element equality is the default CoinRelFltEq operator. + */ + bool isEquivalent(const CoinPackedMatrix& rhs) const; + //@} + + //-------------------------------------------------------------------------- + /*! \name Non-const methods + + These are to be used with great care when doing column generation, etc. + */ + //@{ + /** 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 #start_ and #length_. */ + inline double * getMutableElements() const { return element_; } + /** 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 #start_ and + #length_. */ + inline int * getMutableIndices() const { return index_; } + + /** The positions where the major-dimension vectors start in #element_ and + #index_. */ + inline CoinBigIndex * getMutableVectorStarts() const { return start_; } + /** The lengths of the major-dimension vectors. */ + inline int * getMutableVectorLengths() const { return length_; } + /// Change the size of the bulk store after modifying - be careful + inline void setNumElements(CoinBigIndex value) + { size_ = value;} + /*! NULLify element array + + Used when space is very tight. Does not free the space! + */ + inline void nullElementArray() {element_=NULL;} + + /*! NULLify start array + + Used when space is very tight. Does not free the space! + */ + inline void nullStartArray() {start_=NULL;} + + /*! NULLify length array + + Used when space is very tight. Does not free the space! + */ + inline void nullLengthArray() {length_=NULL;} + + /*! NULLify index array + + Used when space is very tight. Does not free the space! + */ + inline void nullIndexArray() {index_=NULL;} + //@} + + //-------------------------------------------------------------------------- + /*! \name Constructors and destructors */ + //@{ + /// Default Constructor creates an empty column ordered packed matrix + CoinPackedMatrix(); + + /// A constructor where the ordering and the gaps are specified + CoinPackedMatrix(const bool colordered, + const double extraMajor, const double extraGap); + + CoinPackedMatrix(const bool colordered, + const int minor, const int major, const CoinBigIndex numels, + const double * elem, const int * ind, + const CoinBigIndex * start, const int * len, + const double extraMajor, const double extraGap); + + CoinPackedMatrix(const bool colordered, + const int minor, const int major, const CoinBigIndex numels, + const double * elem, const int * ind, + const CoinBigIndex * start, const int * len); + + /** Create packed matrix from triples. + If colordered is true then the created matrix will be column ordered. + Duplicate matrix elements are allowed. The created matrix will have + the sum of the duplicates. <br> + For example if: <br> + rowIndices[0]=2; colIndices[0]=5; elements[0]=2.0 <br> + rowIndices[1]=2; colIndices[1]=5; elements[1]=0.5 <br> + then the created matrix will contain a value of 2.5 in row 2 and column 5.<br> + The matrix is created without gaps. + */ + CoinPackedMatrix(const bool colordered, + const int * rowIndices, + const int * colIndices, + const double * elements, + CoinBigIndex numels ); + + /// Copy constructor + CoinPackedMatrix(const CoinPackedMatrix& m); + + /*! \brief Copy constructor with fine tuning + + This constructor allows for the specification of an exact amount of extra + space and/or reverse ordering. + + \p extraForMajor is the exact number of spare major vector slots after + any possible reverse ordering. If \p extraForMajor < 0, all gaps and small + elements will be removed from the copy, otherwise gaps and small elements + are preserved. + + \p extraElements is the exact number of spare element entries. + + The usual multipliers, #extraMajor_ and #extraGap_, are set to zero. + */ + CoinPackedMatrix(const CoinPackedMatrix &m, + int extraForMajor, int extraElements, + bool reverseOrdering = false) ; + + /** Subset constructor (without gaps). Duplicates are allowed + and order is as given */ + CoinPackedMatrix (const CoinPackedMatrix & wholeModel, + int numberRows, const int * whichRows, + int numberColumns, const int * whichColumns); + + /// Destructor + virtual ~CoinPackedMatrix(); + //@} + + /*! \name Debug Utilities */ + //@{ + /*! \brief Scan the matrix for anomalies. + + Returns the number of anomalies. Scans the structure for gaps, + obviously bogus indices and coefficients, and inconsistencies. Gaps + are not an error unless #hasGaps() says the matrix should be + gap-free. Zeroes are not an error unless \p zeroesAreError is set to + true. + + Values for verbosity are: + - 0: No messages, just the return value + - 1: Messages about errors + - 2: If there are no errors, a message indicating the matrix was + checked is printed (positive confirmation). + - 3: Adds a bit more information about the matrix. + - 4: Prints warnings about zeroes even if they're not considered + errors. + + Obviously bogus coefficients are coefficients that are NaN or have + absolute value greater than 1e50. Zeros have absolute value less + than 1e-50. + */ + int verifyMtx(int verbosity = 1, bool zeroesAreError = false) const ; + //@} + + //-------------------------------------------------------------------------- +protected: + void gutsOfDestructor(); + void gutsOfCopyOf(const bool colordered, + const int minor, const int major, const CoinBigIndex numels, + const double * elem, const int * ind, + const CoinBigIndex * start, const int * len, + const double extraMajor=0.0, const double extraGap=0.0); + /// When no gaps we can do faster + void gutsOfCopyOfNoGaps(const bool colordered, + const int minor, const int major, + const double * elem, const int * ind, + const CoinBigIndex * start); + void gutsOfOpEqual(const bool colordered, + const int minor, const int major, const CoinBigIndex numels, + const double * elem, const int * ind, + const CoinBigIndex * start, const int * len); + void resizeForAddingMajorVectors(const int numVec, const int * lengthVec); + void resizeForAddingMinorVectors(const int * addedEntries); + + /*! \brief Append a set of rows (columns) to the end of a row (colum) + ordered matrix. + + If \p numberOther > 0 the method will check if any of the new rows + (columns) contain duplicate indices or invalid indices and return the + number of errors. A valid minor index must satisfy + \code 0 <= k < numberOther \endcode + If \p numberOther < 0 no checking is performed. + */ + int appendMajor(const int number, + const CoinBigIndex * starts, const int * index, + const double * element, int numberOther=-1); + /*! \brief Append a set of rows (columns) to the end of a column (row) + ordered matrix. + + If \p numberOther > 0 the method will check if any of the new rows + (columns) contain duplicate indices or indices outside the current + range for the major dimension and return the number of violations. + If \p numberOther <= 0 the major dimension will be expanded as + necessary and there are no checks for duplicate indices. + */ + int appendMinor(const int number, + const CoinBigIndex * starts, const int * index, + const double * element, int numberOther=-1); + +private: + inline CoinBigIndex getLastStart() const { + return majorDim_ == 0 ? 0 : start_[majorDim_]; + } + + //-------------------------------------------------------------------------- +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /** A flag indicating whether the matrix is column or row major ordered. */ + bool colOrdered_; + /** This much times more space should be allocated for each major-dimension + vector (with respect to the number of entries in the vector) when the + matrix is resized. The purpose of these gaps is to allow fast insertion + of new minor-dimension vectors. */ + double extraGap_; + /** his much times more space should be allocated for major-dimension + vectors when the matrix is resized. The purpose of these gaps is to + allow fast addition of new major-dimension vectors. */ + double extraMajor_; + + /** List of nonzero element values. The entries in the gaps between + major-dimension vectors are undefined. */ + double *element_; + /** List of nonzero element minor-dimension indices. The entries in the gaps + between major-dimension vectors are undefined. */ + int *index_; + /** Starting positions of major-dimension vectors. */ + CoinBigIndex *start_; + /** Lengths of major-dimension vectors. */ + int *length_; + + /// number of vectors in matrix + int majorDim_; + /// size of other dimension + int minorDim_; + /// the number of nonzero entries + CoinBigIndex size_; + + /// max space allocated for major-dimension + int maxMajorDim_; + /// max space allocated for entries + CoinBigIndex maxSize_; + //@} +}; + +//############################################################################# +/*! \brief Test the methods in the CoinPackedMatrix 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 +CoinPackedMatrixUnitTest(); + +#endif diff --git a/thirdparty/windows/include/coin/CoinPackedVector.hpp b/thirdparty/windows/include/coin/CoinPackedVector.hpp new file mode 100644 index 0000000..9ea1feb --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPackedVector.hpp @@ -0,0 +1,657 @@ +/* $Id: CoinPackedVector.hpp 1509 2011-12-05 13:50:48Z 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 CoinPackedVector_H +#define CoinPackedVector_H + +#include <map> + +#include "CoinPragma.hpp" +#include "CoinPackedVectorBase.hpp" +#include "CoinSort.hpp" + +#ifdef COIN_FAST_CODE +#ifndef COIN_NOTEST_DUPLICATE +#define COIN_NOTEST_DUPLICATE +#endif +#endif + +#ifndef COIN_NOTEST_DUPLICATE +#define COIN_DEFAULT_VALUE_FOR_DUPLICATE true +#else +#define COIN_DEFAULT_VALUE_FOR_DUPLICATE false +#endif +/** Sparse Vector + +Stores vector of indices and associated element values. +Supports sorting of vector while maintaining the original indices. + +Here is a sample usage: +@verbatim + const int ne = 4; + int inx[ne] = { 1, 4, 0, 2 } + double el[ne] = { 10., 40., 1., 50. } + + // Create vector and set its value + CoinPackedVector r(ne,inx,el); + + // access each index and element + assert( r.indices ()[0]== 1 ); + assert( r.elements()[0]==10. ); + assert( r.indices ()[1]== 4 ); + assert( r.elements()[1]==40. ); + assert( r.indices ()[2]== 0 ); + assert( r.elements()[2]== 1. ); + assert( r.indices ()[3]== 2 ); + assert( r.elements()[3]==50. ); + + // access original position of index + assert( r.originalPosition()[0]==0 ); + assert( r.originalPosition()[1]==1 ); + assert( r.originalPosition()[2]==2 ); + assert( r.originalPosition()[3]==3 ); + + // access as a full storage vector + assert( r[ 0]==1. ); + assert( r[ 1]==10.); + assert( r[ 2]==50.); + assert( r[ 3]==0. ); + assert( r[ 4]==40.); + + // sort Elements in increasing order + r.sortIncrElement(); + + // access each index and element + assert( r.indices ()[0]== 0 ); + assert( r.elements()[0]== 1. ); + assert( r.indices ()[1]== 1 ); + assert( r.elements()[1]==10. ); + assert( r.indices ()[2]== 4 ); + assert( r.elements()[2]==40. ); + assert( r.indices ()[3]== 2 ); + assert( r.elements()[3]==50. ); + + // access original position of index + assert( r.originalPosition()[0]==2 ); + assert( r.originalPosition()[1]==0 ); + assert( r.originalPosition()[2]==1 ); + assert( r.originalPosition()[3]==3 ); + + // access as a full storage vector + assert( r[ 0]==1. ); + assert( r[ 1]==10.); + assert( r[ 2]==50.); + assert( r[ 3]==0. ); + assert( r[ 4]==40.); + + // Restore orignal sort order + r.sortOriginalOrder(); + + assert( r.indices ()[0]== 1 ); + assert( r.elements()[0]==10. ); + assert( r.indices ()[1]== 4 ); + assert( r.elements()[1]==40. ); + assert( r.indices ()[2]== 0 ); + assert( r.elements()[2]== 1. ); + assert( r.indices ()[3]== 2 ); + assert( r.elements()[3]==50. ); + + // Tests for equality and equivalence + CoinPackedVector r1; + r1=r; + assert( r==r1 ); + assert( r.equivalent(r1) ); + r.sortIncrElement(); + assert( r!=r1 ); + assert( r.equivalent(r1) ); + + // Add packed vectors. + // Similarly for subtraction, multiplication, + // and division. + CoinPackedVector add = r + r1; + assert( add[0] == 1.+ 1. ); + assert( add[1] == 10.+10. ); + assert( add[2] == 50.+50. ); + assert( add[3] == 0.+ 0. ); + assert( add[4] == 40.+40. ); + + assert( r.sum() == 10.+40.+1.+50. ); +@endverbatim +*/ +class CoinPackedVector : public CoinPackedVectorBase { + friend void CoinPackedVectorUnitTest(); + +public: + /**@name Get methods. */ + //@{ + /// Get the size + virtual int getNumElements() const { return nElements_; } + /// Get indices of elements + virtual const int * getIndices() const { return indices_; } + /// Get element values + virtual const double * getElements() const { return elements_; } + /// Get indices of elements + int * getIndices() { return indices_; } + /// Get the size + inline int getVectorNumElements() const { return nElements_; } + /// Get indices of elements + inline const int * getVectorIndices() const { return indices_; } + /// Get element values + inline const double * getVectorElements() const { return elements_; } + /// Get element values + double * getElements() { return elements_; } + /** Get pointer to int * vector of original postions. + If the packed vector has not been sorted then this + function returns the vector: 0, 1, 2, ..., size()-1. */ + const int * getOriginalPosition() const { return origIndices_; } + //@} + + //------------------------------------------------------------------- + // Set indices and elements + //------------------------------------------------------------------- + /**@name Set methods */ + //@{ + /// Reset the vector (as if were just created an empty vector) + void clear(); + /** Assignment operator. <br> + <strong>NOTE</strong>: This operator keeps the current + <code>testForDuplicateIndex</code> setting, and affter copying the data + it acts accordingly. */ + CoinPackedVector & operator=(const CoinPackedVector &); + /** Assignment operator from a CoinPackedVectorBase. <br> + <strong>NOTE</strong>: This operator keeps the current + <code>testForDuplicateIndex</code> setting, and affter copying the data + it acts accordingly. */ + CoinPackedVector & operator=(const CoinPackedVectorBase & rhs); + + /** Assign the ownership of the arguments to this vector. + Size is the length of both the indices and elements vectors. + The indices and elements vectors are copied into this class instance's + member data. The last argument indicates whether this vector will have + to be tested for duplicate indices. + */ + void assignVector(int size, int*& inds, double*& elems, + bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE); + + /** Set vector size, indices, and elements. + Size is the length of both the indices and elements vectors. + The indices and elements vectors are copied into this class instance's + member data. The last argument specifies whether this vector will have + to be checked for duplicate indices whenever that can happen. */ + void setVector(int size, const int * inds, const double * elems, + bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE); + + /** Elements set to have the same scalar value */ + void setConstant(int size, const int * inds, double elems, + bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE); + + /** Indices are not specified and are taken to be 0,1,...,size-1 */ + void setFull(int size, const double * elems, + bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE); + + /** Indices are not specified and are taken to be 0,1,...,size-1, + but only where non zero*/ + void setFullNonZero(int size, const double * elems, + bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE); + + /** Set an existing element in the packed vector + The first argument is the "index" into the elements() array + */ + void setElement(int index, double element); + + /// Insert an element into the vector + void insert(int index, double element); + /// Append a CoinPackedVector to the end + void append(const CoinPackedVectorBase & caboose); + + /// Swap values in positions i and j of indices and elements + void swap(int i, int j); + + /** Resize the packed vector to be the first newSize elements. + Problem with truncate: what happens with origIndices_ ??? */ + void truncate(int newSize); + //@} + + /**@name Arithmetic operators. */ + //@{ + /// add <code>value</code> to every entry + void operator+=(double value); + /// subtract <code>value</code> from every entry + void operator-=(double value); + /// multiply every entry by <code>value</code> + void operator*=(double value); + /// divide every entry by <code>value</code> + void operator/=(double value); + //@} + + /**@name Sorting */ + //@{ + /** Sort the packed storage vector. + Typcical usages: + <pre> + packedVector.sort(CoinIncrIndexOrdered()); //increasing indices + packedVector.sort(CoinIncrElementOrdered()); // increasing elements + </pre> + */ + template <class CoinCompare3> + void sort(const CoinCompare3 & tc) + { CoinSort_3(indices_, indices_ + nElements_, origIndices_, elements_, + tc); } + + void sortIncrIndex() + { CoinSort_3(indices_, indices_ + nElements_, origIndices_, elements_, + CoinFirstLess_3<int, int, double>()); } + + void sortDecrIndex() + { CoinSort_3(indices_, indices_ + nElements_, origIndices_, elements_, + CoinFirstGreater_3<int, int, double>()); } + + void sortIncrElement() + { CoinSort_3(elements_, elements_ + nElements_, origIndices_, indices_, + CoinFirstLess_3<double, int, int>()); } + + void sortDecrElement() + { CoinSort_3(elements_, elements_ + nElements_, origIndices_, indices_, + CoinFirstGreater_3<double, int, int>()); } + + + /** Sort in original order. + If the vector has been sorted, then this method restores + to its orignal sort order. + */ + void sortOriginalOrder(); + //@} + + /**@name Memory usage */ + //@{ + /** Reserve space. + If one knows the eventual size of the packed vector, + then it may be more efficient to reserve the space. + */ + void reserve(int n); + /** capacity returns the size which could be accomodated without + having to reallocate storage. + */ + int capacity() const { return capacity_; } + //@} + /**@name Constructors and destructors */ + //@{ + /** Default constructor */ + CoinPackedVector(bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE); + /** \brief Alternate Constructors - set elements to vector of doubles + + This constructor copies the vectors provided as parameters. + */ + CoinPackedVector(int size, const int * inds, const double * elems, + bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE); + /** \brief Alternate Constructors - set elements to vector of doubles + + This constructor takes ownership of the vectors passed as parameters. + \p inds and \p elems will be NULL on return. + */ + CoinPackedVector(int capacity, int size, int *&inds, double *&elems, + bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE); + /** Alternate Constructors - set elements to same scalar value */ + CoinPackedVector(int size, const int * inds, double element, + bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE); + /** Alternate Constructors - construct full storage with indices 0 through + size-1. */ + CoinPackedVector(int size, const double * elements, + bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE); + /** Copy constructor. */ + CoinPackedVector(const CoinPackedVector &); + /** Copy constructor <em>from a PackedVectorBase</em>. */ + CoinPackedVector(const CoinPackedVectorBase & rhs); + /** Destructor */ + virtual ~CoinPackedVector (); + //@} + +private: + /**@name Private methods */ + //@{ + /// Copy internal date + void gutsOfSetVector(int size, + const int * inds, const double * elems, + bool testForDuplicateIndex, + const char * method); + /// + void gutsOfSetConstant(int size, + const int * inds, double value, + bool testForDuplicateIndex, + const char * method); + //@} + +private: + /**@name Private member data */ + //@{ + /// Vector indices + int * indices_; + ///Vector elements + double * elements_; + /// Size of indices and elements vectors + int nElements_; + /// original unsorted indices + int * origIndices_; + /// Amount of memory allocated for indices_, origIndices_, and elements_. + int capacity_; + //@} +}; + +//############################################################################# + +/**@name Arithmetic operators on packed vectors. + + <strong>NOTE</strong>: These methods operate on those positions where at + least one of the arguments has a value listed. At those positions the + appropriate operation is executed, Otherwise the result of the operation is + considered 0.<br> + <strong>NOTE 2</strong>: There are two kind of operators here. One is used + like "c = binaryOp(a, b)", the other is used like "binaryOp(c, a, b)", but + they are really the same. The first is much more natural to use, but it + involves the creation of a temporary object (the function *must* return an + object), while the second form puts the result directly into the argument + "c". Therefore, depending on the circumstances, the second form can be + significantly faster. + */ +//@{ +template <class BinaryFunction> void +binaryOp(CoinPackedVector& retVal, + const CoinPackedVectorBase& op1, double value, + BinaryFunction bf) +{ + retVal.clear(); + const int s = op1.getNumElements(); + if (s > 0) { + retVal.reserve(s); + const int * inds = op1.getIndices(); + const double * elems = op1.getElements(); + for (int i=0; i<s; ++i ) { + retVal.insert(inds[i], bf(value, elems[i])); + } + } +} + +template <class BinaryFunction> inline void +binaryOp(CoinPackedVector& retVal, + double value, const CoinPackedVectorBase& op2, + BinaryFunction bf) +{ + binaryOp(retVal, op2, value, bf); +} + +template <class BinaryFunction> void +binaryOp(CoinPackedVector& retVal, + const CoinPackedVectorBase& op1, const CoinPackedVectorBase& op2, + BinaryFunction bf) +{ + retVal.clear(); + const int s1 = op1.getNumElements(); + const int s2 = op2.getNumElements(); +/* + Replaced || with &&, in response to complaint from Sven deVries, who + rightly points out || is not appropriate for additive operations. && + should be ok as long as binaryOp is understood not to create something + from nothing. -- lh, 04.06.11 +*/ + if (s1 == 0 && s2 == 0) + return; + + retVal.reserve(s1+s2); + + const int * inds1 = op1.getIndices(); + const double * elems1 = op1.getElements(); + const int * inds2 = op2.getIndices(); + const double * elems2 = op2.getElements(); + + int i; + // loop once for each element in op1 + for ( i=0; i<s1; ++i ) { + const int index = inds1[i]; + const int pos2 = op2.findIndex(index); + const double val = bf(elems1[i], pos2 == -1 ? 0.0 : elems2[pos2]); + // if (val != 0.0) // *THINK* : should we put in only nonzeros? + retVal.insert(index, val); + } + // loop once for each element in operand2 + for ( i=0; i<s2; ++i ) { + const int index = inds2[i]; + // if index exists in op1, then element was processed in prior loop + if ( op1.isExistingIndex(index) ) + continue; + // Index does not exist in op1, so the element value must be zero + const double val = bf(0.0, elems2[i]); + // if (val != 0.0) // *THINK* : should we put in only nonzeros? + retVal.insert(index, val); + } +} + +//----------------------------------------------------------------------------- + +template <class BinaryFunction> CoinPackedVector +binaryOp(const CoinPackedVectorBase& op1, double value, + BinaryFunction bf) +{ + CoinPackedVector retVal; + retVal.setTestForDuplicateIndex(true); + binaryOp(retVal, op1, value, bf); + return retVal; +} + +template <class BinaryFunction> CoinPackedVector +binaryOp(double value, const CoinPackedVectorBase& op2, + BinaryFunction bf) +{ + CoinPackedVector retVal; + retVal.setTestForDuplicateIndex(true); + binaryOp(retVal, op2, value, bf); + return retVal; +} + +template <class BinaryFunction> CoinPackedVector +binaryOp(const CoinPackedVectorBase& op1, const CoinPackedVectorBase& op2, + BinaryFunction bf) +{ + CoinPackedVector retVal; + retVal.setTestForDuplicateIndex(true); + binaryOp(retVal, op1, op2, bf); + return retVal; +} + +//----------------------------------------------------------------------------- +/// Return the sum of two packed vectors +inline CoinPackedVector operator+(const CoinPackedVectorBase& op1, + const CoinPackedVectorBase& op2) +{ + CoinPackedVector retVal; + retVal.setTestForDuplicateIndex(true); + binaryOp(retVal, op1, op2, std::plus<double>()); + return retVal; +} + +/// Return the difference of two packed vectors +inline CoinPackedVector operator-(const CoinPackedVectorBase& op1, + const CoinPackedVectorBase& op2) +{ + CoinPackedVector retVal; + retVal.setTestForDuplicateIndex(true); + binaryOp(retVal, op1, op2, std::minus<double>()); + return retVal; +} + +/// Return the element-wise product of two packed vectors +inline CoinPackedVector operator*(const CoinPackedVectorBase& op1, + const CoinPackedVectorBase& op2) +{ + CoinPackedVector retVal; + retVal.setTestForDuplicateIndex(true); + binaryOp(retVal, op1, op2, std::multiplies<double>()); + return retVal; +} + +/// Return the element-wise ratio of two packed vectors +inline CoinPackedVector operator/(const CoinPackedVectorBase& op1, + const CoinPackedVectorBase& op2) +{ + CoinPackedVector retVal; + retVal.setTestForDuplicateIndex(true); + binaryOp(retVal, op1, op2, std::divides<double>()); + return retVal; +} +//@} + +/// Returns the dot product of two CoinPackedVector objects whose elements are +/// doubles. Use this version if the vectors are *not* guaranteed to be sorted. +inline double sparseDotProduct(const CoinPackedVectorBase& op1, + const CoinPackedVectorBase& op2){ + int len, i; + double acc = 0.0; + CoinPackedVector retVal; + + CoinPackedVector retval = op1*op2; + len = retval.getNumElements(); + double * CParray = retval.getElements(); + + for(i = 0; i < len; i++){ + acc += CParray[i]; + } +return acc; +} + + +/// Returns the dot product of two sorted CoinPackedVector objects. +/// The vectors should be sorted in ascending order of indices. +inline double sortedSparseDotProduct(const CoinPackedVectorBase& op1, + const CoinPackedVectorBase& op2){ + int i, j, len1, len2; + double acc = 0.0; + + const double* v1val = op1.getElements(); + const double* v2val = op2.getElements(); + const int* v1ind = op1.getIndices(); + const int* v2ind = op2.getIndices(); + + len1 = op1.getNumElements(); + len2 = op2.getNumElements(); + + i = 0; + j = 0; + + while(i < len1 && j < len2){ + if(v1ind[i] == v2ind[j]){ + acc += v1val[i] * v2val[j]; + i++; + j++; + } + else if(v2ind[j] < v1ind[i]){ + j++; + } + else{ + i++; + } // end if-else-elseif + } // end while + return acc; + } + + +//----------------------------------------------------------------------------- + +/**@name Arithmetic operators on packed vector and a constant. <br> + These functions create a packed vector as a result. That packed vector will + have the same indices as <code>op1</code> and the specified operation is + done entry-wise with the given value. */ +//@{ +/// Return the sum of a packed vector and a constant +inline CoinPackedVector +operator+(const CoinPackedVectorBase& op1, double value) +{ + CoinPackedVector retVal(op1); + retVal += value; + return retVal; +} + +/// Return the difference of a packed vector and a constant +inline CoinPackedVector +operator-(const CoinPackedVectorBase& op1, double value) +{ + CoinPackedVector retVal(op1); + retVal -= value; + return retVal; +} + +/// Return the element-wise product of a packed vector and a constant +inline CoinPackedVector +operator*(const CoinPackedVectorBase& op1, double value) +{ + CoinPackedVector retVal(op1); + retVal *= value; + return retVal; +} + +/// Return the element-wise ratio of a packed vector and a constant +inline CoinPackedVector +operator/(const CoinPackedVectorBase& op1, double value) +{ + CoinPackedVector retVal(op1); + retVal /= value; + return retVal; +} + +//----------------------------------------------------------------------------- + +/// Return the sum of a constant and a packed vector +inline CoinPackedVector +operator+(double value, const CoinPackedVectorBase& op1) +{ + CoinPackedVector retVal(op1); + retVal += value; + return retVal; +} + +/// Return the difference of a constant and a packed vector +inline CoinPackedVector +operator-(double value, const CoinPackedVectorBase& op1) +{ + CoinPackedVector retVal(op1); + const int size = retVal.getNumElements(); + double* elems = retVal.getElements(); + for (int i = 0; i < size; ++i) { + elems[i] = value - elems[i]; + } + return retVal; +} + +/// Return the element-wise product of a constant and a packed vector +inline CoinPackedVector +operator*(double value, const CoinPackedVectorBase& op1) +{ + CoinPackedVector retVal(op1); + retVal *= value; + return retVal; +} + +/// Return the element-wise ratio of a a constant and packed vector +inline CoinPackedVector +operator/(double value, const CoinPackedVectorBase& op1) +{ + CoinPackedVector retVal(op1); + const int size = retVal.getNumElements(); + double* elems = retVal.getElements(); + for (int i = 0; i < size; ++i) { + elems[i] = value / elems[i]; + } + return retVal; +} +//@} + +//############################################################################# +/** A function that tests the methods in the CoinPackedVector 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 +CoinPackedVectorUnitTest(); + +#endif diff --git a/thirdparty/windows/include/coin/CoinPackedVectorBase.hpp b/thirdparty/windows/include/coin/CoinPackedVectorBase.hpp new file mode 100644 index 0000000..dccc1cd --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPackedVectorBase.hpp @@ -0,0 +1,269 @@ +/* $Id: CoinPackedVectorBase.hpp 1416 2011-04-17 09:57:29Z 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 CoinPackedVectorBase_H +#define CoinPackedVectorBase_H + +#include <set> +#include <map> +#include "CoinPragma.hpp" +#include "CoinError.hpp" + +class CoinPackedVector; + +/** Abstract base class for various sparse vectors. + + Since this class is abstract, no object of this type can be created. The + sole purpose of this class is to provide access to a <em>constant</em> + packed vector. All members of this class are const methods, they can't + change the object. */ + +class CoinPackedVectorBase { + +public: + /**@name Virtual methods that the derived classes must provide */ + //@{ + /// Get length of indices and elements vectors + virtual int getNumElements() const = 0; + /// Get indices of elements + virtual const int * getIndices() const = 0; + /// Get element values + virtual const double * getElements() const = 0; + //@} + + /**@name Methods related to whether duplicate-index checking is performed. + + If the checking for duplicate indices is turned off, then + some CoinPackedVector methods may not work correctly if there + are duplicate indices. + Turning off the checking for duplicate indices may result in + better run time performance. + */ + //@{ + /** \brief Set to the argument value whether to test for duplicate indices + in the vector whenever they can occur. + + Calling this method with \p test set to true will trigger an immediate + check for duplicate indices. + */ + void setTestForDuplicateIndex(bool test) const; + /** \brief Set to the argument value whether to test for duplicate indices + in the vector whenever they can occur BUT we know that right + now the vector has no duplicate indices. + + Calling this method with \p test set to true will <em>not</em> trigger + an immediate check for duplicate indices; instead, it's assumed that + the result of the test will be true. + */ + void setTestForDuplicateIndexWhenTrue(bool test) const; + /** Returns true if the vector should be tested for duplicate indices when + they can occur. */ + bool testForDuplicateIndex() const { return testForDuplicateIndex_; } + /// Just sets test stuff false without a try etc + inline void setTestsOff() const + { testForDuplicateIndex_=false; testedDuplicateIndex_=false;} + //@} + + /**@name Methods for getting info on the packed vector as a full vector */ + //@{ + /** Get the vector as a dense vector. The argument specifies how long this + dense vector is. <br> + <strong>NOTE</strong>: The user needs to <code>delete[]</code> this + pointer after it's not needed anymore. + */ + double * denseVector(int denseSize) const; + /** Access the i'th element of the full storage vector. + If the i'th is not stored, then zero is returned. The initial use of + this method has some computational and storage overhead associated with + it.<br> + <strong>NOTE</strong>: This is <em>very</em> expensive. It is probably + much better to use <code>denseVector()</code>. + */ + double operator[](int i) const; + //@} + + /**@name Index methods */ + //@{ + /// Get value of maximum index + int getMaxIndex() const; + /// Get value of minimum index + int getMinIndex() const; + + /// Throw an exception if there are duplicate indices + void duplicateIndex(const char* methodName = NULL, + const char * className = NULL) const; + + /** Return true if the i'th element of the full storage vector exists in + the packed storage vector.*/ + bool isExistingIndex(int i) const; + + /** Return the position of the i'th element of the full storage vector. + If index does not exist then -1 is returned */ + int findIndex(int i) const; + + //@} + + /**@name Comparison operators on two packed vectors */ + //@{ + /** Equal. Returns true if vectors have same length and corresponding + element of each vector is equal. */ + bool operator==(const CoinPackedVectorBase & rhs) const; + /// Not equal + bool operator!=(const CoinPackedVectorBase & rhs) const; + +#if 0 + // LL: This should be implemented eventually. It is useful to have. + /** Lexicographic comparisons of two packed vectors. Returns + negative/0/positive depending on whether \c this is + smaller/equal.greater than \c rhs */ + int lexCompare(const CoinPackedVectorBase& rhs); +#endif + + /** This method establishes an ordering on packed vectors. It is complete + ordering, but not the same as lexicographic ordering. However, it is + quick and dirty to compute and thus it is useful to keep packed vectors + in a heap when all we care is to quickly check whether a particular + vector is already in the heap or not. Returns negative/0/positive + depending on whether \c this is smaller/equal.greater than \c rhs. */ + int compare(const CoinPackedVectorBase& rhs) const; + + /** equivalent - If shallow packed vector A & B are equivalent, then they + are still equivalent no matter how they are sorted. + In this method the FloatEqual function operator can be specified. The + default equivalence test is that the entries are relatively equal.<br> + <strong>NOTE</strong>: This is a relatively expensive method as it + sorts the two shallow packed vectors. + */ + template <class FloatEqual> bool + isEquivalent(const CoinPackedVectorBase& rhs, const FloatEqual& eq) const + { + if (getNumElements() != rhs.getNumElements()) + return false; + + duplicateIndex("equivalent", "CoinPackedVector"); + rhs.duplicateIndex("equivalent", "CoinPackedVector"); + + std::map<int,double> mv; + const int * inds = getIndices(); + const double * elems = getElements(); + int i; + for ( i = getNumElements() - 1; i >= 0; --i) { + mv.insert(std::make_pair(inds[i], elems[i])); + } + + std::map<int,double> mvRhs; + inds = rhs.getIndices(); + elems = rhs.getElements(); + for ( i = getNumElements() - 1; i >= 0; --i) { + mvRhs.insert(std::make_pair(inds[i], elems[i])); + } + + std::map<int,double>::const_iterator mvI = mv.begin(); + std::map<int,double>::const_iterator mvIlast = mv.end(); + std::map<int,double>::const_iterator mvIrhs = mvRhs.begin(); + while (mvI != mvIlast) { + if (mvI->first != mvIrhs->first || ! eq(mvI->second, mvIrhs->second)) + return false; + ++mvI; + ++mvIrhs; + } + return true; + } + + bool isEquivalent(const CoinPackedVectorBase& rhs) const; + //@} + + + /**@name Arithmetic operators. */ + //@{ + /// Create the dot product with a full vector + double dotProduct(const double* dense) const; + + /// Return the 1-norm of the vector + double oneNorm() const; + + /// Return the square of the 2-norm of the vector + double normSquare() const; + + /// Return the 2-norm of the vector + double twoNorm() const; + + /// Return the infinity-norm of the vector + double infNorm() const; + + /// Sum elements of vector. + double sum() const; + //@} + +protected: + + /**@name Constructors, destructor + <strong>NOTE</strong>: All constructors are protected. There's no need + to expose them, after all, this is an abstract class. */ + //@{ + /** Default constructor. */ + CoinPackedVectorBase(); + +public: + /** Destructor */ + virtual ~CoinPackedVectorBase(); + //@} + +private: + /**@name Disabled methods */ + //@{ + /** The copy constructor. <br> + This must be at least protected, but we make it private. The reason is + that when, say, a shallow packed vector is created, first the + underlying class, it this one is constructed. However, at that point we + don't know how much of the data members of this class we need to copy + over. Therefore the copy constructor is not used. */ + CoinPackedVectorBase(const CoinPackedVectorBase&); + /** This class provides <em>const</em> access to packed vectors, so there's + no need to provide an assignment operator. */ + CoinPackedVectorBase& operator=(const CoinPackedVectorBase&); + //@} + +protected: + + /**@name Protected methods */ + //@{ + /// Find Maximum and Minimum Indices + void findMaxMinIndices() const; + + /// Return indexSetPtr_ (create it if necessary). + std::set<int> * indexSet(const char* methodName = NULL, + const char * className = NULL) const; + + /// Delete the indexSet + void clearIndexSet() const; + void clearBase() const; + void copyMaxMinIndex(const CoinPackedVectorBase & x) const { + maxIndex_ = x.maxIndex_; + minIndex_ = x.minIndex_; + } + //@} + +private: + /**@name Protected member data */ + //@{ + /// Contains max index value or -infinity + mutable int maxIndex_; + /// Contains minimum index value or infinity + mutable int minIndex_; + /** Store the indices in a set. This set is only created if it is needed. + Its primary use is testing for duplicate indices. + */ + mutable std::set<int> * indexSetPtr_; + /** True if the vector should be tested for duplicate indices when they can + occur. */ + mutable bool testForDuplicateIndex_; + /** True if the vector has already been tested for duplicate indices. Most + of the operations in CoinPackedVector preserves this flag. */ + mutable bool testedDuplicateIndex_; + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/CoinParam.hpp b/thirdparty/windows/include/coin/CoinParam.hpp new file mode 100644 index 0000000..30cccc2 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinParam.hpp @@ -0,0 +1,644 @@ +/* $Id: CoinParam.hpp 1493 2011-11-01 16:56:07Z tkr $ */ +#ifndef CoinParam_H +#define CoinParam_H + +/* + 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). +*/ + +/*! \file CoinParam.hpp + \brief Declaration of a class for command line parameters. +*/ + +#include <vector> +#include <string> +#include <cstdio> + +/*! \class CoinParam + \brief A base class for `keyword value' command line parameters. + + The underlying paradigm is that a parameter specifies an action to be + performed on a target object. The base class provides two function + pointers, a `push' function and a `pull' function. By convention, a push + function will set some value in the target object or perform some action + using the target object. A `pull' function will retrieve some value from + the target object. This is only a convention, however; CoinParam and + associated utilities make no use of these functions and have no hardcoded + notion of how they should be used. + + The action to be performed, and the target object, will be specific to a + particular application. It is expected that users will derive + application-specific parameter classes from this base class. A derived + class will typically add fields and methods to set/get a code for the + action to be performed (often, an enum class) and the target object (often, + a pointer or reference). + + Facilities provided by the base class and associated utility routines + include: + <ul> + <li> Support for common parameter types with numeric, string, or + keyword values. + <li> Support for short and long help messages. + <li> Pointers to `push' and `pull' functions as described above. + <li> Command line parsing and keyword matching. + </ul> + All utility routines are declared in the #CoinParamUtils namespace. + + The base class recognises five types of parameters: actions (which require + no value); numeric parameters with integer or real (double) values; keyword + parameters, where the value is one of a defined set of value-keywords; + and string parameters (where the value is a string). + The base class supports the definition of a valid range, a default value, + and short and long help messages for a parameter. + + As defined by the #CoinParamFunc typedef, push and pull functions + should take a single parameter, a pointer to a CoinParam. Typically this + object will actually be a derived class as described above, and the + implementation function will have access to all capabilities of CoinParam and + of the derived class. + + When specified as command line parameters, the expected syntax is `-keyword + value' or `-keyword=value'. You can also use the Gnu double-dash style, + `--keyword'. Spaces around the `=' will \e not work. + + The keyword (name) for a parameter can be defined with an `!' to mark the + minimal match point. For example, allow!ableGap will be considered matched + by the strings `allow', `allowa', `allowab', \e etc. Similarly, the + value-keyword strings for keyword parameters can be defined with `!' to + mark the minimal match point. Matching of keywords and value-keywords is + \e not case sensitive. +*/ + +class CoinParam +{ + +public: + +/*! \name Subtypes */ +//@{ + + /*! \brief Enumeration for the types of parameters supported by CoinParam + + CoinParam provides support for several types of parameters: + <ul> + <li> Action parameters, which require no value. + <li> Integer and double numeric parameters, with upper and lower bounds. + <li> String parameters that take an arbitrary string value. + <li> Keyword parameters that take a defined set of string (value-keyword) + values. Value-keywords are associated with integers in the order in + which they are added, starting from zero. + </ul> + */ + typedef enum { coinParamInvalid = 0, + coinParamAct, coinParamInt, coinParamDbl, + coinParamStr, coinParamKwd } CoinParamType ; + + /*! \brief Type declaration for push and pull functions. + + By convention, a return code of 0 indicates execution without error, >0 + indicates nonfatal error, and <0 indicates fatal error. This is only + convention, however; the base class makes no use of the push and pull + functions and has no hardcoded interpretation of the return code. + */ + typedef int (*CoinParamFunc)(CoinParam *param) ; + +//@} + +/*! \name Constructors and Destructors + + Be careful how you specify parameters for the constructors! Some compilers + are entirely too willing to convert almost anything to bool. +*/ +//@{ + + /*! \brief Default constructor */ + + CoinParam() ; + + /*! \brief Constructor for a parameter with a double value + + The default value is 0.0. Be careful to clearly indicate that \p lower and + \p upper are real (double) values to distinguish this constructor from the + constructor for an integer parameter. + */ + CoinParam(std::string name, std::string help, + double lower, double upper, double dflt = 0.0, + bool display = true) ; + + /*! \brief Constructor for a parameter with an integer value + + The default value is 0. + */ + CoinParam(std::string name, std::string help, + int lower, int upper, int dflt = 0, + bool display = true) ; + + /*! \brief Constructor for a parameter with keyword values + + The string supplied as \p firstValue becomes the first value-keyword. + Additional value-keywords can be added using appendKwd(). It's necessary + to specify both the first value-keyword (\p firstValue) and the default + value-keyword index (\p dflt) in order to distinguish this constructor + from the constructors for string and action parameters. + + Value-keywords are associated with an integer, starting with zero and + increasing as each keyword is added. The value-keyword given as \p + firstValue will be associated with the integer zero. The integer supplied + for \p dflt can be any value, as long as it will be valid once all + value-keywords have been added. + */ + CoinParam(std::string name, std::string help, + std::string firstValue, int dflt, bool display = true) ; + + /*! \brief Constructor for a string parameter + + For some compilers, the default value (\p dflt) must be specified + explicitly with type std::string to distinguish the constructor for a + string parameter from the constructor for an action parameter. For + example, use std::string("default") instead of simply "default", or use a + variable of type std::string. + */ + CoinParam(std::string name, std::string help, + std::string dflt, bool display = true) ; + + /*! \brief Constructor for an action parameter */ + + CoinParam(std::string name, std::string help, + bool display = true) ; + + /*! \brief Copy constructor */ + + CoinParam(const CoinParam &orig) ; + + /*! \brief Clone */ + + virtual CoinParam *clone() ; + + /*! \brief Assignment */ + + CoinParam &operator=(const CoinParam &rhs) ; + + /*! \brief Destructor */ + + virtual ~CoinParam() ; + +//@} + +/*! \name Methods to query and manipulate the value(s) of a parameter */ +//@{ + + /*! \brief Add an additional value-keyword to a keyword parameter */ + + void appendKwd(std::string kwd) ; + + /*! \brief Return the integer associated with the specified value-keyword + + Returns -1 if no value-keywords match the specified string. + */ + int kwdIndex(std::string kwd) const ; + + /*! \brief Return the value-keyword that is the current value of the + keyword parameter + */ + std::string kwdVal() const ; + + /*! \brief Set the value of the keyword parameter using the integer + associated with a value-keyword. + + If \p printIt is true, the corresponding value-keyword string will be + echoed to std::cout. + */ + void setKwdVal(int value, bool printIt = false) ; + + /*! \brief Set the value of the keyword parameter using a value-keyword + string. + + The given string will be tested against the set of value-keywords for + the parameter using the shortest match rules. + */ + void setKwdVal(const std::string value ) ; + + /*! \brief Prints the set of value-keywords defined for this keyword + parameter + */ + void printKwds() const ; + + + /*! \brief Set the value of a string parameter */ + + void setStrVal(std::string value) ; + + /*! \brief Get the value of a string parameter */ + + std::string strVal() const ; + + + /*! \brief Set the value of a double parameter */ + + void setDblVal(double value) ; + + /*! \brief Get the value of a double parameter */ + + double dblVal() const ; + + + /*! \brief Set the value of a integer parameter */ + + void setIntVal(int value) ; + + /*! \brief Get the value of a integer parameter */ + + int intVal() const ; + + + /*! \brief Add a short help string to a parameter */ + + inline void setShortHelp(const std::string help) { shortHelp_ = help ; } + + /*! \brief Retrieve the short help string */ + + inline std::string shortHelp() const { return (shortHelp_) ; } + + /*! \brief Add a long help message to a parameter + + See printLongHelp() for a description of how messages are broken into + lines. + */ + inline void setLongHelp(const std::string help) { longHelp_ = help ; } + + /*! \brief Retrieve the long help message */ + + inline std::string longHelp() const { return (longHelp_) ; } + + /*! \brief Print long help + + Prints the long help string, plus the valid range and/or keywords if + appropriate. The routine makes a best effort to break the message into + lines appropriate for an 80-character line. Explicit line breaks in the + message will be observed. The short help string will be used if + long help is not available. + */ + void printLongHelp() const ; + +//@} + +/*! \name Methods to query and manipulate a parameter object */ +//@{ + + /*! \brief Return the type of the parameter */ + + inline CoinParamType type() const { return (type_) ; } + + /*! \brief Set the type of the parameter */ + + inline void setType(CoinParamType type) { type_ = type ; } + + /*! \brief Return the parameter keyword (name) string */ + + inline std::string name() const { return (name_) ; } + + /*! \brief Set the parameter keyword (name) string */ + + inline void setName(std::string name) { name_ = name ; processName() ; } + + /*! \brief Check if the specified string matches the parameter keyword (name) + string + + Returns 1 if the string matches and meets the minimum match length, + 2 if the string matches but doesn't meet the minimum match length, + and 0 if the string doesn't match. Matches are \e not case-sensitive. + */ + int matches (std::string input) const ; + + /*! \brief Return the parameter keyword (name) string formatted to show + the minimum match length + + For example, if the parameter name was defined as allow!ableGap, the + string returned by matchName would be allow(ableGap). + */ + std::string matchName() const ; + + /*! \brief Set visibility of parameter + + Intended to control whether the parameter is shown when a list of + parameters is processed. Used by CoinParamUtils::printHelp when printing + help messages for a list of parameters. + */ + inline void setDisplay(bool display) { display_ = display ; } + + /*! \brief Get visibility of parameter */ + + inline bool display() const { return (display_) ; } + + /*! \brief Get push function */ + + inline CoinParamFunc pushFunc() { return (pushFunc_) ; } + + /*! \brief Set push function */ + + inline void setPushFunc(CoinParamFunc func) { pushFunc_ = func ; } + + /*! \brief Get pull function */ + + inline CoinParamFunc pullFunc() { return (pullFunc_) ; } + + /*! \brief Set pull function */ + + inline void setPullFunc(CoinParamFunc func) { pullFunc_ = func ; } + +//@} + +private: + +/*! \name Private methods */ +//@{ + + /*! Process a name for efficient matching */ + void processName() ; + +//@} + +/*! \name Private parameter data */ +//@{ + /// Parameter type (see #CoinParamType) + CoinParamType type_ ; + + /// Parameter name + std::string name_ ; + + /// Length of parameter name + size_t lengthName_ ; + + /*! \brief Minimum length required to declare a match for the parameter + name. + */ + size_t lengthMatch_ ; + + /// Lower bound on value for a double parameter + double lowerDblValue_ ; + + /// Upper bound on value for a double parameter + double upperDblValue_ ; + + /// Double parameter - current value + double dblValue_ ; + + /// Lower bound on value for an integer parameter + int lowerIntValue_ ; + + /// Upper bound on value for an integer parameter + int upperIntValue_ ; + + /// Integer parameter - current value + int intValue_ ; + + /// String parameter - current value + std::string strValue_ ; + + /// Set of valid value-keywords for a keyword parameter + std::vector<std::string> definedKwds_ ; + + /*! \brief Current value for a keyword parameter (index into #definedKwds_) + */ + int currentKwd_ ; + + /// Push function + CoinParamFunc pushFunc_ ; + + /// Pull function + CoinParamFunc pullFunc_ ; + + /// Short help + std::string shortHelp_ ; + + /// Long help + std::string longHelp_ ; + + /// Display when processing lists of parameters? + bool display_ ; +//@} + +} ; + +/*! \relatesalso CoinParam + \brief A type for a parameter vector. +*/ +typedef std::vector<CoinParam*> CoinParamVec ; + +/*! \relatesalso CoinParam + \brief A stream output function for a CoinParam object. +*/ +std::ostream &operator<< (std::ostream &s, const CoinParam ¶m) ; + +/* + Bring in the utility functions for parameter handling (CbcParamUtils). +*/ + +/*! \brief Utility functions for processing CoinParam parameters. + + The functions in CoinParamUtils support command line or interactive + parameter processing and a help facility. Consult the `Related Functions' + section of the CoinParam class documentation for individual function + documentation. +*/ +namespace CoinParamUtils { + /*! \relatesalso CoinParam + \brief Take command input from the file specified by src. + + Use stdin for \p src to specify interactive prompting for commands. + */ + void setInputSrc(FILE *src) ; + + /*! \relatesalso CoinParam + \brief Returns true if command line parameters are being processed. + */ + bool isCommandLine() ; + + /*! \relatesalso CoinParam + \brief Returns true if parameters are being obtained from stdin. + */ + bool isInteractive() ; + + /*! \relatesalso CoinParam + \brief Attempt to read a string from the input. + + \p argc and \p argv are used only if isCommandLine() would return true. + If \p valid is supplied, it will be set to 0 if a string is parsed + without error, 2 if no field is present. + */ + std::string getStringField(int argc, const char *argv[], int *valid) ; + + /*! \relatesalso CoinParam + \brief Attempt to read an integer from the input. + + \p argc and \p argv are used only if isCommandLine() would return true. + If \p valid is supplied, it will be set to 0 if an integer is parsed + without error, 1 if there's a parse error, and 2 if no field is present. + */ + int getIntField(int argc, const char *argv[], int *valid) ; + + /*! \relatesalso CoinParam + \brief Attempt to read a real (double) from the input. + + \p argc and \p argv are used only if isCommandLine() would return true. + If \p valid is supplied, it will be set to 0 if a real number is parsed + without error, 1 if there's a parse error, and 2 if no field is present. + */ + double getDoubleField(int argc, const char *argv[], int *valid) ; + + /*! \relatesalso CoinParam + \brief Scan a parameter vector for parameters whose keyword (name) string + matches \p name using minimal match rules. + + \p matchNdx is set to the index of the last parameter that meets the + minimal match criteria (but note there should be at most one matching + parameter if the parameter vector is properly configured). \p shortCnt + is set to the number of short matches (should be zero for a properly + configured parameter vector if a minimal match is found). The return + value is the number of matches satisfying the minimal match requirement + (should be 0 or 1 in a properly configured vector). + */ + int matchParam(const CoinParamVec ¶mVec, std::string name, + int &matchNdx, int &shortCnt) ; + + /*! \relatesalso CoinParam + \brief Get the next command keyword (name) + + To be precise, return the next field from the current command input + source, after a bit of processing. In command line mode (isCommandLine() + returns true) the next field will normally be of the form `-keyword' or + `--keyword' (\e i.e., a parameter keyword), and the string returned would + be `keyword'. In interactive mode (isInteractive() returns true), the + user will be prompted if necessary. It is assumed that the user knows + not to use the `-' or `--' prefixes unless specifying parameters on the + command line. + + There are a number of special cases if we're in command line mode. The + order of processing of the raw string goes like this: + <ul> + <li> A stand-alone `-' is forced to `stdin'. + <li> A stand-alone '--' is returned as a word; interpretation is up to + the client. + <li> A prefix of '-' or '--' is stripped from the string. + </ul> + If the result is the string `stdin', command processing shifts to + interactive mode and the user is immediately prompted for a new command. + + Whatever results from the above sequence is returned to the user as the + return value of the function. An empty string indicates end of input. + + \p prompt will be used only if it's necessary to prompt the user in + interactive mode. + */ + + std::string getCommand(int argc, const char *argv[], + const std::string prompt, std::string *pfx = 0) ; + + /*! \relatesalso CoinParam + \brief Look up the command keyword (name) in the parameter vector. + Print help if requested. + + In the most straightforward use, \p name is a string without `?', and the + value returned is the index in \p paramVec of the single parameter that + matched \p name. One or more '?' characters at the end of \p name is a + query for information. The routine prints short (one '?') or long (more + than one '?') help messages for a query. Help is also printed in the case + where the name is ambiguous (some of the matches did not meet the minimal + match length requirement). + + Note that multiple matches meeting the minimal match requirement is a + configuration error. The mimimal match length for the parameters + involved is too short. + + If provided as parameters, on return + <ul> + <li> \p matchCnt will be set to the number of matches meeting the + minimal match requirement + <li> \p shortCnt will be set to the number of matches that did not + meet the miminal match requirement + <li> \p queryCnt will be set to the number of '?' characters at the + end of the name + </ul> + + The return values are: + <ul> + <li> >0: index in \p paramVec of the single unique match for \p name + <li> -1: a query was detected (one or more '?' characters at the end + of \p name + <li> -2: one or more short matches, not a query + <li> -3: no matches, not a query + <li> -4: multiple matches meeting the minimal match requirement + (configuration error) + </ul> + */ + int lookupParam(std::string name, CoinParamVec ¶mVec, + int *matchCnt = 0, int *shortCnt = 0, int *queryCnt = 0) ; + + /*! \relatesalso CoinParam + \brief Utility to print a long message as filled lines of text + + The routine makes a best effort to break lines without exceeding the + standard 80 character line length. Explicit newlines in \p msg will + be obeyed. + */ + void printIt(const char *msg) ; + + /*! \relatesalso CoinParam + \brief Utility routine to print help given a short match or explicit + request for help. + + The two really are related, in that a query (a string that ends with + one or more `?' characters) will often result in a short match. The + routine expects that \p name matches a single parameter, and does not + look for multiple matches. + + If called with \p matchNdx < 0, the routine will look up \p name in \p + paramVec and print the full name from the parameter. If called with \p + matchNdx > 0, it just prints the name from the specified parameter. If + the name is a query, short (one '?') or long (more than one '?') help + is printed. + + */ void shortOrHelpOne(CoinParamVec ¶mVec,int matchNdx, std::string + name, int numQuery) ; + + /*! \relatesalso CoinParam + \brief Utility routine to print help given multiple matches. + + If the name is not a query, or asks for short help (\e i.e., contains + zero or one '?' characters), the list of matching names is printed. If + the name asks for long help (contains two or more '?' characters), + short help is printed for each matching name. + */ + void shortOrHelpMany(CoinParamVec ¶mVec, + std::string name, int numQuery) ; + + /*! \relatesalso CoinParam + \brief Print a generic `how to use the command interface' help message. + + The message is hard coded to match the behaviour of the parsing utilities. + */ + void printGenericHelp() ; + + /*! \relatesalso CoinParam + \brief Utility routine to print help messages for one or more + parameters. + + Intended as a utility to implement explicit `help' commands. Help will be + printed for all parameters in \p paramVec from \p firstParam to \p + lastParam, inclusive. If \p shortHelp is true, short help messages will + be printed. If \p longHelp is true, long help messages are printed. \p + shortHelp overrules \p longHelp. If neither is true, only command + keywords are printed. \p prefix is printed before each line; it's an + imperfect attempt at indentation. + */ + void printHelp(CoinParamVec ¶mVec, int firstParam, int lastParam, + std::string prefix, + bool shortHelp, bool longHelp, bool hidden) ; +} + + +#endif /* CoinParam_H */ + diff --git a/thirdparty/windows/include/coin/CoinPragma.hpp b/thirdparty/windows/include/coin/CoinPragma.hpp new file mode 100644 index 0000000..b9f8cd2 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPragma.hpp @@ -0,0 +1,26 @@ +/* $Id: CoinPragma.hpp 1372 2011-01-03 23:31:00Z lou $ */ +// 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 CoinPragma_H +#define CoinPragma_H + +//------------------------------------------------------------------- +// +// This is a file which can contain Pragma's that are +// generally applicable to any source file. +// +//------------------------------------------------------------------- + +#if defined(_MSC_VER) +// Turn off compiler warning about long names +# pragma warning(disable:4786) +// Turn off compiler warning: +// "empty controlled statement found; is this the intent?" +# pragma warning(disable:4390) +// Turn off compiler warning about deprecated functions +# pragma warning(disable:4996) +#endif + +#endif diff --git a/thirdparty/windows/include/coin/CoinPresolveDoubleton.hpp b/thirdparty/windows/include/coin/CoinPresolveDoubleton.hpp new file mode 100644 index 0000000..3ad8cd2 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveDoubleton.hpp @@ -0,0 +1,73 @@ +/* $Id: CoinPresolveDoubleton.hpp 1498 2011-11-02 15:25:35Z mjs $ */ +// 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 CoinPresolveDoubleton_H +#define CoinPresolveDoubleton_H + +#define DOUBLETON 5 + +/*! \class doubleton_action + \brief Solve ax+by=c for y and substitute y out of the problem. + + This moves the bounds information for y onto x, making y free and allowing + us to substitute it away. + \verbatim + a x + b y = c + l1 <= x <= u1 + l2 <= y <= u2 ==> + + l2 <= (c - a x) / b <= u2 + b/-a > 0 ==> (b l2 - c) / -a <= x <= (b u2 - c) / -a + b/-a < 0 ==> (b u2 - c) / -a <= x <= (b l2 - c) / -a + \endverbatim +*/ +class doubleton_action : public CoinPresolveAction { + public: + struct action { + + double clox; + double cupx; + double costx; + + double costy; + + double rlo; + + double coeffx; + double coeffy; + + double *colel; + + int icolx; + int icoly; + int row; + int ncolx; + int ncoly; + }; + + const int nactions_; + const action *const actions_; + + private: + doubleton_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), actions_(actions) +{} + + public: + const char *name() const { return ("doubleton_action"); } + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~doubleton_action(); +}; +#endif + + diff --git a/thirdparty/windows/include/coin/CoinPresolveDual.hpp b/thirdparty/windows/include/coin/CoinPresolveDual.hpp new file mode 100644 index 0000000..b021ce0 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveDual.hpp @@ -0,0 +1,85 @@ +/* $Id: CoinPresolveDual.hpp 1510 2011-12-08 23:56:01Z 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 CoinPresolveDual_H +#define CoinPresolveDual_H + +/*! \class remove_dual_action + \brief Attempt to fix variables by bounding reduced costs + + The reduced cost of x_j is d_j = c_j - y*a_j (1). Assume minimization, + so that at optimality d_j >= 0 for x_j nonbasic at lower bound, and + d_j <= 0 for x_j nonbasic at upper bound. + + For a slack variable s_i, c_(n+i) = 0 and a_(n+i) is a unit vector, hence + d_(n+i) = -y_i. If s_i has a finite lower bound and no upper bound, we + must have y_i <= 0 at optimality. Similarly, if s_i has no lower bound and a + finite upper bound, we must have y_i >= 0. + + For a singleton variable x_j, d_j = c_j - y_i*a_ij. Given x_j with a + single finite bound, we can bound d_j greater or less than 0 at + optimality, and that allows us to calculate an upper or lower bound on y_i + (depending on the bound on d_j and the sign of a_ij). + + Now we have bounds on some subset of the y_i, and we can use these to + calculate upper and lower bounds on the d_j, using bound propagation on + (1). If we can manage to bound some d_j as strictly positive or strictly + negative, then at optimality the corresponding variable must be nonbasic + at its lower or upper bound, respectively. If the required bound is lacking, + the problem is unbounded. +*/ + +class remove_dual_action : public CoinPresolveAction { + + public: + + /// Destructor + ~remove_dual_action () ; + + /// Name + inline const char *name () const { return ("remove_dual_action") ; } + + /*! \brief Attempt to fix variables by bounding reduced costs + + Always scans all variables. Propagates bounds on reduced costs until there's + no change or until some set of variables can be fixed. + */ + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + const CoinPresolveAction *next) ; + + /*! \brief Postsolve + + In addition to fixing variables (handled by make_fixed_action), we may + need use our own postsolve to restore constraint bounds. + */ + void postsolve (CoinPostsolveMatrix *prob) const ; + + private: + + /// Postsolve (bound restore) instruction + struct action { + double rlo_ ; ///< restored row lower bound + double rup_ ; ///< restored row upper bound + int ndx_ ; ///< row index + } ; + + /// Constructor with postsolve actions. + remove_dual_action(int nactions, const action *actions, + const CoinPresolveAction *next) + : CoinPresolveAction(next), + nactions_(nactions), + actions_(actions) + {} + + /// Count of bound restore entries + const int nactions_ ; + /// Bound restore entries + const action *actions_ ; + +} ; +#endif + + diff --git a/thirdparty/windows/include/coin/CoinPresolveDupcol.hpp b/thirdparty/windows/include/coin/CoinPresolveDupcol.hpp new file mode 100644 index 0000000..8610adb --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveDupcol.hpp @@ -0,0 +1,230 @@ +/* $Id: CoinPresolveDupcol.hpp 1854 2015-12-18 14:18: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 CoinPresolveDupcol_H +#define CoinPresolveDupcol_H + +#include "CoinPresolveMatrix.hpp" + +/*! + \file +*/ + +#define DUPCOL 10 + +/*! \class dupcol_action + \brief Detect and remove duplicate columns + + The general technique is to sum the coefficients a_(*,j) of each column. + Columns with identical sums are duplicates. The obvious problem is that, + <i>e.g.</i>, [1 0 1 0] and [0 1 0 1] both add to 2. To minimize the + chances of false positives, the coefficients of each row are multipled by + a random number r_i, so that we sum r_i*a_ij. + + Candidate columns are checked to confirm they are identical. Where the + columns have the same objective coefficient, the two are combined. If the + columns have different objective coefficients, complications ensue. In order + to remove the duplicate, it must be possible to fix the variable at a bound. +*/ + +class dupcol_action : public CoinPresolveAction { + dupcol_action(); + dupcol_action(const dupcol_action& rhs); + dupcol_action& operator=(const dupcol_action& rhs); + + struct action { + double thislo; + double thisup; + double lastlo; + double lastup; + int ithis; + int ilast; + + double *colels; + int nincol; + }; + + const int nactions_; + // actions_ is owned by the class and must be deleted at destruction + const action *const actions_; + + dupcol_action(int nactions, const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), + actions_(actions) {} + + public: + const char *name() const; + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~dupcol_action(); + +}; + + +/*! \class duprow_action + \brief Detect and remove duplicate rows + + The algorithm to detect duplicate rows is as outlined for dupcol_action. + + If the feasible interval for one constraint is strictly contained in the + other, the tighter (contained) constraint is kept. If the feasible + intervals are disjoint, the problem is infeasible. If the feasible + intervals overlap, both constraints are kept. + + duprow_action is definitely a work in progress; #postsolve is + unimplemented. + This doesn't matter as it uses useless_constraint. +*/ + +class duprow_action : public CoinPresolveAction { + struct action { + int row; + double lbound; + double ubound; + }; + + const int nactions_; + const action *const actions_; + + duprow_action():CoinPresolveAction(NULL),nactions_(0),actions_(NULL) {} + duprow_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), actions_(actions) {} + + public: + const char *name() const; + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + //~duprow_action() { delete[]actions_; } +}; + +class duprow3_action : public CoinPresolveAction { + struct action { + int row; + double lbound; + double ubound; + }; + + const int nactions_; + const action *const actions_; + + duprow3_action():CoinPresolveAction(NULL),nactions_(0),actions_(NULL) {} + duprow3_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), actions_(actions) {} + + public: + const char *name() const; + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + //~duprow_action() { delete[]actions_; } +}; + +/*! \class gubrow_action + \brief Detect and remove entries whose sum is known + + If we have an equality row where all entries same then + For other rows where all entries for that equality row are same + then we can delete entries and modify rhs + gubrow_action is definitely a work in progress; #postsolve is + unimplemented. +*/ + +class gubrow_action : public CoinPresolveAction { + struct action { + double rhs; + // last is row itself + int * deletedRow; + double * rowels; + int * indices; // indices in gub row + int nDrop; + int ninrow; + }; + + const int nactions_; + const action *const actions_; + + //gubrow_action():CoinPresolveAction(NULL),nactions_(0),actions_(NULL) {} + gubrow_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), actions_(actions) {} + + public: + const char *name() const; + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~gubrow_action(); +}; + +/*! \class twoxtwo_action + \brief Detect interesting 2 by 2 blocks + + If a variable has two entries and for each row there are only + two entries with same other variable then we can get rid of + one constraint and modify costs. + + This is a work in progress - I need more examples +*/ + +class twoxtwo_action : public CoinPresolveAction { + struct action { + double lbound_row; + double ubound_row; + double lbound_col; + double ubound_col; + double cost_col; + double cost_othercol; + int row; + int col; + int othercol; + }; + + const int nactions_; + const action *const actions_; + + twoxtwo_action():CoinPresolveAction(NULL),nactions_(0),actions_(NULL) {} + twoxtwo_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), actions_(actions) {} + + public: + const char *name() const; + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + ~twoxtwo_action() { delete [] actions_; } +}; + +#endif + diff --git a/thirdparty/windows/include/coin/CoinPresolveEmpty.hpp b/thirdparty/windows/include/coin/CoinPresolveEmpty.hpp new file mode 100644 index 0000000..336f1fd --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveEmpty.hpp @@ -0,0 +1,116 @@ +/* $Id: CoinPresolveEmpty.hpp 1561 2012-11-24 00:32:16Z 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 CoinPresolveEmpty_H +#define CoinPresolveEmpty_H + +/*! \file + + Drop/reinsert empty rows/columns. +*/ + +const int DROP_ROW = 3; +const int DROP_COL = 4; + +/*! \class drop_empty_cols_action + \brief Physically removes empty columns in presolve, and reinserts + empty columns in postsolve. + + Physical removal of rows and columns should be the last activities + performed during presolve. Do them exactly once. The row-major matrix + is <b>not</b> maintained by this transform. + + To physically drop the columns, CoinPrePostsolveMatrix::mcstrt_ and + CoinPrePostsolveMatrix::hincol_ are compressed, along with column bounds, + objective, and (if present) the column portions of the solution. This + renumbers the columns. drop_empty_cols_action::presolve will reconstruct + CoinPresolveMatrix::clink_. + + \todo Confirm correct behaviour with solution in presolve. +*/ + +class drop_empty_cols_action : public CoinPresolveAction { +private: + const int nactions_; + + struct action { + double clo; + double cup; + double cost; + double sol; + int jcol; + }; + const action *const actions_; + + drop_empty_cols_action(int nactions, + const action *const actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), + actions_(actions) + {} + + public: + const char *name() const { return ("drop_empty_cols_action"); } + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *, + const int *ecols, + int necols, + const CoinPresolveAction*); + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~drop_empty_cols_action() { deleteAction(actions_,action*); } +}; + + +/*! \class drop_empty_rows_action + \brief Physically removes empty rows in presolve, and reinserts + empty rows in postsolve. + + Physical removal of rows and columns should be the last activities + performed during presolve. Do them exactly once. The row-major matrix + is <b>not</b> maintained by this transform. + + To physically drop the rows, the rows are renumbered, excluding empty + rows. This involves rewriting CoinPrePostsolveMatrix::hrow_ and compressing + the row bounds and (if present) the row portions of the solution. + + \todo Confirm behaviour when a solution is present in presolve. +*/ +class drop_empty_rows_action : public CoinPresolveAction { +private: + struct action { + double rlo; + double rup; + int row; + int fill_row; // which row was moved into position row to fill it + }; + + const int nactions_; + const action *const actions_; + + drop_empty_rows_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), actions_(actions) +{} + + public: + const char *name() const { return ("drop_empty_rows_action"); } + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~drop_empty_rows_action() { deleteAction(actions_,action*); } +}; +#endif + diff --git a/thirdparty/windows/include/coin/CoinPresolveFixed.hpp b/thirdparty/windows/include/coin/CoinPresolveFixed.hpp new file mode 100644 index 0000000..dc59207 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveFixed.hpp @@ -0,0 +1,181 @@ +/* $Id: CoinPresolveFixed.hpp 1510 2011-12-08 23:56:01Z 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 CoinPresolveFixed_H +#define CoinPresolveFixed_H +#define FIXED_VARIABLE 1 + +/*! \class remove_fixed_action + \brief Excise fixed variables from the model. + + Implements the action of virtually removing one or more fixed variables + x_j from the model by substituting the value sol_j in each constraint. + Specifically, for each constraint i where a_ij != 0, rlo_i and rup_i + are adjusted by -a_ij*sol_j and a_ij is set to 0. + + There is an implicit assumption that the variable already has the correct + value. If this isn't true, corrections to row activity may be incorrect. + If you want to guard against this possibility, consider make_fixed_action. + + Actual removal of the empty column from the matrix is handled by + drop_empty_cols_action. Correction of the objective function is done there. +*/ +class remove_fixed_action : public CoinPresolveAction { + public: + /*! \brief Structure to hold information necessary to reintroduce a + column into the problem representation. + */ + struct action { + int col; ///< column index of variable + int start; ///< start of coefficients in #colels_ and #colrows_ + double sol; ///< value of variable + }; + /// Array of row indices for coefficients of excised columns + int *colrows_; + /// Array of coefficients of excised columns + double *colels_; + /// Number of entries in #actions_ + int nactions_; + /// Vector specifying variable(s) affected by this object + action *actions_; + + private: + /*! \brief Constructor */ + remove_fixed_action(int nactions, + action *actions, + double * colels, + int * colrows, + const CoinPresolveAction *next); + + public: + /// Returns string "remove_fixed_action". + const char *name() const; + + /*! \brief Excise the specified columns. + + Remove the specified columns (\p nfcols, \p fcols) from the problem + representation (\p prob), leaving the appropriate postsolve object + linked as the head of the list of postsolve objects (currently headed + by \p next). + */ + static const remove_fixed_action *presolve(CoinPresolveMatrix *prob, + int *fcols, + int nfcols, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + /// Destructor + virtual ~remove_fixed_action(); +}; + + +/*! \relates remove_fixed_action + \brief Scan the problem for fixed columns and remove them. + + A front end to collect a list of columns with equal bounds and hand them to + remove_fixed_action::presolve() for processing. +*/ + +const CoinPresolveAction *remove_fixed(CoinPresolveMatrix *prob, + const CoinPresolveAction *next); + + +/*! \class make_fixed_action + \brief Fix a variable at a specified bound. + + Implements the action of fixing a variable by forcing both bounds to the same + value and forcing the value of the variable to match. + + If the bounds are already equal, and the value of the variable is already + correct, consider remove_fixed_action. +*/ +class make_fixed_action : public CoinPresolveAction { + + /// Structure to preserve the bound overwritten when fixing a variable + struct action { + double bound; ///< Value of bound overwritten to fix variable. + int col ; ///< column index of variable + }; + + /// Number of preserved bounds + int nactions_; + /// Vector of preserved bounds, one for each variable fixed in this object + const action *actions_; + + /*! \brief True to fix at lower bound, false to fix at upper bound. + + Note that this applies to all variables fixed in this object. + */ + const bool fix_to_lower_; + + /*! \brief The postsolve object with the information required to repopulate + the fixed columns. + */ + const remove_fixed_action *faction_; + + /*! \brief Constructor */ + make_fixed_action(int nactions, const action *actions, bool fix_to_lower, + const remove_fixed_action *faction, + const CoinPresolveAction *next) + : CoinPresolveAction(next), + nactions_(nactions), actions_(actions), + fix_to_lower_(fix_to_lower), + faction_(faction) + {} + + public: + /// Returns string "make_fixed_action". + const char *name() const; + + /*! \brief Perform actions to fix variables and return postsolve object + + For each specified variable (\p nfcols, \p fcols), fix the variable to + the specified bound (\p fix_to_lower) by setting the variable's bounds + to be equal in \p prob. Create a postsolve object, link it at the head of + the list of postsolve objects (\p next), and return the object. + */ + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + int *fcols, + int nfcols, + bool fix_to_lower, + const CoinPresolveAction *next); + + /*! \brief Postsolve (unfix variables) + + Back out the variables fixed by the presolve side of this object. + */ + void postsolve(CoinPostsolveMatrix *prob) const; + + /// Destructor + virtual ~make_fixed_action() { + deleteAction(actions_,action*); + delete faction_; + } +}; + +/*! \relates make_fixed_action + \brief Scan variables and fix any with equal bounds + + A front end to collect a list of columns with equal bounds and hand them to + make_fixed_action::presolve() for processing. +*/ + +const CoinPresolveAction *make_fixed(CoinPresolveMatrix *prob, + const CoinPresolveAction *next) ; + +/*! \brief Transfer costs from singleton variables + \relates make_fixed_action + + Transfers costs from singleton variables in equalities onto the other + variables. Will also transfer costs from one integer variable to other + integer variables with zero cost if there's a net gain in integer variables + with non-zero cost. + + The relation to make_fixed_action is tenuous, but this transform should be + attempted before the initial round of variable fixing. +*/ +void transferCosts(CoinPresolveMatrix * prob); +#endif diff --git a/thirdparty/windows/include/coin/CoinPresolveForcing.hpp b/thirdparty/windows/include/coin/CoinPresolveForcing.hpp new file mode 100644 index 0000000..ee5a641 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveForcing.hpp @@ -0,0 +1,61 @@ +/* $Id: CoinPresolveForcing.hpp 1498 2011-11-02 15:25:35Z mjs $ */ +// 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 CoinPresolveForcing_H +#define CoinPresolveForcing_H + +#include "CoinPresolveMatrix.hpp" + +/*! + \file +*/ + +#define IMPLIED_BOUND 7 + +/*! \class forcing_constraint_action + \brief Detect and process forcing constraints and useless constraints + + A constraint is useless if the bounds on the variables prevent the constraint + from ever being violated. + + A constraint is a forcing constraint if the bounds on the constraint force + the value of an involved variable to one of its bounds. A constraint can + force more than one variable. +*/ +class forcing_constraint_action : public CoinPresolveAction { + forcing_constraint_action(); + forcing_constraint_action(const forcing_constraint_action& rhs); + forcing_constraint_action& operator=(const forcing_constraint_action& rhs); +public: + struct action { + const int *rowcols; + const double *bounds; + int row; + int nlo; + int nup; + }; +private: + const int nactions_; + // actions_ is owned by the class and must be deleted at destruction + const action *const actions_; + +public: + forcing_constraint_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), actions_(actions) {} + + const char *name() const; + + static const CoinPresolveAction *presolve(CoinPresolveMatrix * prob, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~forcing_constraint_action(); +}; + +#endif diff --git a/thirdparty/windows/include/coin/CoinPresolveImpliedFree.hpp b/thirdparty/windows/include/coin/CoinPresolveImpliedFree.hpp new file mode 100644 index 0000000..8215b98 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveImpliedFree.hpp @@ -0,0 +1,60 @@ +/* $Id: CoinPresolveImpliedFree.hpp 1694 2014-04-29 02:08:35Z tkr $ */ +// 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 CoinPresolveImpliedFree_H +#define CoinPresolveImpliedFree_H + +/*! + \file +*/ + +#define IMPLIED_FREE 9 + +/*! \class implied_free_action + \brief Detect and process implied free variables + + Consider a singleton variable x (<i>i.e.</i>, a variable involved in only + one constraint). Suppose that the bounds on that constraint, combined with + the bounds on the other variables involved in the constraint, are such that + even the worst case values of the other variables still imply bounds for x + which are tighter than the variable's original bounds. Since x can never + reach its upper or lower bounds, it is an implied free variable. Both x and + the constraint can be deleted from the problem. + + A similar transform for the case where the variable is not a natural column + singleton is handled by #subst_constraint_action. +*/ +class implied_free_action : public CoinPresolveAction { + struct action { + int row, col; + double clo, cup; + double rlo, rup; + const double *rowels; + const double *costs; + int ninrow; + }; + + const int nactions_; + const action *const actions_; + + implied_free_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), actions_(actions) {} + + public: + const char *name() const; + + static const CoinPresolveAction *presolve(CoinPresolveMatrix * prob, + const CoinPresolveAction *next, + int & fillLevel); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~implied_free_action(); +}; + +#endif diff --git a/thirdparty/windows/include/coin/CoinPresolveIsolated.hpp b/thirdparty/windows/include/coin/CoinPresolveIsolated.hpp new file mode 100644 index 0000000..38c700f --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveIsolated.hpp @@ -0,0 +1,51 @@ +/* $Id: CoinPresolveIsolated.hpp 1498 2011-11-02 15:25:35Z mjs $ */ +// 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 CoinPresolveIsolated_H +#define CoinPresolveIsolated_H + +#include "CoinPresolveMatrix.hpp" + +class isolated_constraint_action : public CoinPresolveAction { + isolated_constraint_action(); + isolated_constraint_action(const isolated_constraint_action& rhs); + isolated_constraint_action& operator=(const isolated_constraint_action& rhs); + + double rlo_; + double rup_; + int row_; + int ninrow_; + // the arrays are owned by the class and must be deleted at destruction + const int *rowcols_; + const double *rowels_; + const double *costs_; + + isolated_constraint_action(double rlo, + double rup, + int row, + int ninrow, + const int *rowcols, + const double *rowels, + const double *costs, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + rlo_(rlo), rup_(rup), row_(row), ninrow_(ninrow), + rowcols_(rowcols), rowels_(rowels), costs_(costs) {} + + public: + const char *name() const; + + static const CoinPresolveAction *presolve(CoinPresolveMatrix * prob, + int row, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~isolated_constraint_action(); +}; + + + +#endif diff --git a/thirdparty/windows/include/coin/CoinPresolveMatrix.hpp b/thirdparty/windows/include/coin/CoinPresolveMatrix.hpp new file mode 100644 index 0000000..e608738 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveMatrix.hpp @@ -0,0 +1,1842 @@ +/* $Id: CoinPresolveMatrix.hpp 1761 2014-12-10 09:43:07Z 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 CoinPresolveMatrix_H +#define CoinPresolveMatrix_H + +#include "CoinPragma.hpp" +#include "CoinPackedMatrix.hpp" +#include "CoinMessage.hpp" +#include "CoinTime.hpp" + +#include <cmath> +#include <cassert> +#include <cfloat> +#include <cassert> +#include <cstdlib> + +#if PRESOLVE_DEBUG > 0 +#include "CoinFinite.hpp" +#endif + +/*! \file + + Declarations for CoinPresolveMatrix and CoinPostsolveMatrix and their + common base class CoinPrePostsolveMatrix. Also declarations for + CoinPresolveAction and a number of non-member utility functions. +*/ + + +#if defined(_MSC_VER) +// Avoid MS Compiler problem in recognizing type to delete +// by casting to type. +// Is this still necessary? -- lh, 111202 -- +#define deleteAction(array,type) delete [] ((type) array) +#else +#define deleteAction(array,type) delete [] array +#endif + +/* + Define PRESOLVE_DEBUG and PRESOLVE_CONSISTENCY on the configure command + line or in a Makefile! See comments in CoinPresolvePsdebug.hpp. +*/ +#if PRESOLVE_DEBUG > 0 || PRESOLVE_CONSISTENCY > 0 + +#define PRESOLVE_STMT(s) s + +#define PRESOLVEASSERT(x) \ + ((x) ? 1 : ((std::cerr << "FAILED ASSERTION at line " \ + << __LINE__ << ": " #x "\n"), abort(), 0)) + +inline void DIE(const char *s) { std::cout << s ; abort() ; } + +/*! \brief Indicate column or row present at start of postsolve + + This code is used during postsolve in [cr]done to indicate columns and rows + that are present in the presolved system (i.e., present at the start of + postsolve processing). + + \todo + There are a bunch of these code definitions, scattered through presolve + files. They should be collected in one place. +*/ +#define PRESENT_IN_REDUCED '\377' + +#else + +#define PRESOLVEASSERT(x) {} +#define PRESOLVE_STMT(s) {} + +inline void DIE(const char *) {} + +#endif + +/* + Unclear why these are separate from standard debug. +*/ +#ifndef PRESOLVE_DETAIL +#define PRESOLVE_DETAIL_PRINT(s) {} +#else +#define PRESOLVE_DETAIL_PRINT(s) s +#endif + +/*! \brief Zero tolerance + + OSL had a fixed zero tolerance; we still use that here. +*/ +const double ZTOLDP = 1e-12 ; +/*! \brief Alternate zero tolerance + + Use a different one if we are doing doubletons, etc. +*/ +const double ZTOLDP2 = 1e-10 ; + +/// The usual finite infinity +#define PRESOLVE_INF COIN_DBL_MAX +/// And a small infinity +#define PRESOLVE_SMALL_INF 1.0e20 +/// Check for infinity using finite infinity +#define PRESOLVEFINITE(n) (-PRESOLVE_INF < (n) && (n) < PRESOLVE_INF) + + +class CoinPostsolveMatrix ; + +/*! \class CoinPresolveAction + \brief Abstract base class of all presolve routines. + + The details will make more sense after a quick overview of the grand plan: + A presolve object is handed a problem object, which it is expected to + modify in some useful way. Assuming that it succeeds, the presolve object + should create a postsolve object, <i>i.e.</i>, an object that contains + instructions for backing out the presolve transform to recover the original + problem. These postsolve objects are accumulated in a linked list, with each + successive presolve action adding its postsolve action to the head of the + list. The end result of all this is a presolved problem object, and a list + of postsolve objects. The presolved problem object is then handed to a + solver for optimization, and the problem object augmented with the + results. The list of postsolve objects is then traversed. Each of them + (un)modifies the problem object, with the end result being the original + problem, augmented with solution information. + + The problem object representation is CoinPrePostsolveMatrix and subclasses. + Check there for details. The \c CoinPresolveAction class and subclasses + represent the presolve and postsolve objects. + + In spite of the name, the only information held in a \c CoinPresolveAction + object is the information needed to postsolve (<i>i.e.</i>, the information + needed to back out the presolve transformation). This information is not + expected to change, so the fields are all \c const. + + A subclass of \c CoinPresolveAction, implementing a specific pre/postsolve + action, is expected to declare a static function that attempts to perform a + presolve transformation. This function will be handed a CoinPresolveMatrix + to transform, and a pointer to the head of the list of postsolve objects. + If the transform is successful, the function will create a new + \c CoinPresolveAction object, link it at the head of the list of postsolve + objects, and return a pointer to the postsolve object it has just created. + Otherwise, it should return 0. It is expected that these static functions + will be the only things that can create new \c CoinPresolveAction objects; + this is expressed by making each subclass' constructor(s) private. + + Every subclass must also define a \c postsolve method. + This function will be handed a CoinPostsolveMatrix to transform. + + It is the client's responsibility to implement presolve and postsolve driver + routines. See OsiPresolve for examples. + + \note Since the only fields in a \c CoinPresolveAction are \c const, anything + one can do with a variable declared \c CoinPresolveAction* can also be + done with a variable declared \c const \c CoinPresolveAction* It is + expected that all derived subclasses of \c CoinPresolveAction also have + this property. +*/ +class CoinPresolveAction +{ + public: + /*! \brief Stub routine to throw exceptions. + + Exceptions are inefficient, particularly with g++. Even with xlC, the + use of exceptions adds a long prologue to a routine. Therefore, rather + than use throw directly in the routine, I use it in a stub routine. + */ + static void throwCoinError(const char *error, const char *ps_routine) + { throw CoinError(error, ps_routine, "CoinPresolve"); } + + /*! \brief The next presolve transformation + + Set at object construction. + */ + const CoinPresolveAction *next; + + /*! \brief Construct a postsolve object and add it to the transformation list. + + This is an `add to head' operation. This object will point to the + one passed as the parameter. + */ + CoinPresolveAction(const CoinPresolveAction *next) : next(next) {} + /// modify next (when building rather than passing) + inline void setNext(const CoinPresolveAction *nextAction) + { next = nextAction;} + + /*! \brief A name for debug printing. + + It is expected that the name is not stored in the transform itself. + */ + virtual const char *name() const = 0; + + /*! \brief Apply the postsolve transformation for this particular + presolve action. + */ + virtual void postsolve(CoinPostsolveMatrix *prob) const = 0; + + /*! \brief Virtual destructor. */ + virtual ~CoinPresolveAction() {} +}; + +/* + These are needed for OSI-aware constructors associated with + CoinPrePostsolveMatrix, CoinPresolveMatrix, and CoinPostsolveMatrix. +*/ +class ClpSimplex; +class OsiSolverInterface; + +/* + CoinWarmStartBasis is required for methods in CoinPrePostsolveMatrix + that accept/return a CoinWarmStartBasis object. +*/ +class CoinWarmStartBasis ; + +/*! \class CoinPrePostsolveMatrix + \brief Collects all the information about the problem that is needed + in both presolve and postsolve. + + In a bit more detail, a column-major representation of the constraint + matrix and upper and lower bounds on variables and constraints, plus row + and column solutions, reduced costs, and status. There's also a set of + arrays holding the original row and column numbers. + + As presolve and postsolve transform the matrix, it will occasionally be + necessary to expand the number of entries in a column. There are two + aspects: + <ul> + <li> During postsolve, the constraint system is expected to grow as + the smaller presolved system is transformed back to the original + system. + <li> During both pre- and postsolve, transforms can increase the number + of coefficients in a row or column. (See the + variable substitution, doubleton, and tripleton transforms.) + </ul> + + The first is addressed by the members #ncols0_, #nrows0_, and #nelems0_. + These should be set (via constructor parameters) to values large enough + for the largest size taken on by the constraint system. Typically, this + will be the size of the original constraint system. + + The second is addressed by a generous allocation of extra (empty) space + for the arrays used to hold coefficients and row indices. When columns + must be expanded, they are moved into the empty space. When it is used up, + the arrays are compacted. When compaction fails to produce sufficient + space, presolve/postsolve will fail. + + CoinPrePostsolveMatrix isn't really intended to be used `bare' --- the + expectation is that it'll be used through CoinPresolveMatrix or + CoinPostsolveMatrix. Some of the functions needed to load a problem are + defined in the derived classes. + + When CoinPresolve is applied when reoptimising, we need to be prepared to + accept a basis and modify it in step with the presolve actions (otherwise + we throw away all the advantages of warm start for reoptimization). But + other solution components (#acts_, #rowduals_, #sol_, and #rcosts_) are + needed only for postsolve, where they're used in places to determine the + proper action(s) when restoring rows or columns. If presolve is provided + with a solution, it will modify it in step with the presolve actions. + Moving the solution components from CoinPrePostsolveMatrix to + CoinPostsolveMatrix would break a lot of code. It's not clear that it's + worth it, and it would preclude upgrades to the presolve side that might + make use of any of these. -- lh, 080501 -- + + The constructors that take an OSI or ClpSimplex as a parameter really should + not be here, but for historical reasons they will likely remain for the + forseeable future. -- lh, 111202 -- +*/ + +class CoinPrePostsolveMatrix +{ + public: + + /*! \name Constructors & Destructors */ + + //@{ + /*! \brief `Native' constructor + + This constructor creates an empty object which must then be loaded. On + the other hand, it doesn't assume that the client is an + OsiSolverInterface. + */ + CoinPrePostsolveMatrix(int ncols_alloc, int nrows_alloc, + CoinBigIndex nelems_alloc) ; + + /*! \brief Generic OSI constructor + + See OSI code for the definition. + */ + CoinPrePostsolveMatrix(const OsiSolverInterface * si, + int ncols_, + int nrows_, + CoinBigIndex nelems_); + + /*! ClpOsi constructor + + See Clp code for the definition. + */ + CoinPrePostsolveMatrix(const ClpSimplex * si, + int ncols_, + int nrows_, + CoinBigIndex nelems_, + double bulkRatio); + + /// Destructor + ~CoinPrePostsolveMatrix(); + //@} + + /*! \brief Enum for status of various sorts + + Matches CoinWarmStartBasis::Status and adds superBasic. Most code that + converts between CoinPrePostsolveMatrix::Status and + CoinWarmStartBasis::Status will break if this correspondence is broken. + + superBasic is an unresolved problem: there's no analogue in + CoinWarmStartBasis::Status. + */ + enum Status { + isFree = 0x00, + basic = 0x01, + atUpperBound = 0x02, + atLowerBound = 0x03, + superBasic = 0x04 + }; + + /*! \name Functions to work with variable status + + Functions to work with the CoinPrePostsolveMatrix::Status enum and + related vectors. + + \todo + Why are we futzing around with three bit status? A holdover from the + packed arrays of CoinWarmStartBasis? Big swaths of the presolve code + manipulates colstat_ and rowstat_ as unsigned char arrays using simple + assignment to set values. + */ + //@{ + + /// Set row status (<i>i.e.</i>, status of artificial for this row) + inline void setRowStatus(int sequence, Status status) + { + unsigned char & st_byte = rowstat_[sequence]; + st_byte = static_cast<unsigned char>(st_byte & (~7)) ; + st_byte = static_cast<unsigned char>(st_byte | status) ; + } + /// Get row status + inline Status getRowStatus(int sequence) const + {return static_cast<Status> (rowstat_[sequence]&7);} + /// Check if artificial for this row is basic + inline bool rowIsBasic(int sequence) const + {return (static_cast<Status> (rowstat_[sequence]&7)==basic);} + /// Set column status (<i>i.e.</i>, status of primal variable) + inline void setColumnStatus(int sequence, Status status) + { + unsigned char & st_byte = colstat_[sequence]; + st_byte = static_cast<unsigned char>(st_byte & (~7)) ; + st_byte = static_cast<unsigned char>(st_byte | status) ; + +# ifdef PRESOLVE_DEBUG + switch (status) + { case isFree: + { if (clo_[sequence] > -PRESOLVE_INF || cup_[sequence] < PRESOLVE_INF) + { std::cout << "Bad status: Var " << sequence + << " isFree, lb = " << clo_[sequence] + << ", ub = " << cup_[sequence] << std::endl ; } + break ; } + case basic: + { break ; } + case atUpperBound: + { if (cup_[sequence] >= PRESOLVE_INF) + { std::cout << "Bad status: Var " << sequence + << " atUpperBound, lb = " << clo_[sequence] + << ", ub = " << cup_[sequence] << std::endl ; } + break ; } + case atLowerBound: + { if (clo_[sequence] <= -PRESOLVE_INF) + { std::cout << "Bad status: Var " << sequence + << " atLowerBound, lb = " << clo_[sequence] + << ", ub = " << cup_[sequence] << std::endl ; } + break ; } + case superBasic: + { if (clo_[sequence] <= -PRESOLVE_INF && cup_[sequence] >= PRESOLVE_INF) + { std::cout << "Bad status: Var " << sequence + << " superBasic, lb = " << clo_[sequence] + << ", ub = " << cup_[sequence] << std::endl ; } + break ; } + default: + { assert(false) ; + break ; } } +# endif + } + /// Get column (structural variable) status + inline Status getColumnStatus(int sequence) const + {return static_cast<Status> (colstat_[sequence]&7);} + /// Check if column (structural variable) is basic + inline bool columnIsBasic(int sequence) const + {return (static_cast<Status> (colstat_[sequence]&7)==basic);} + /*! \brief Set status of row (artificial variable) to the correct nonbasic + status given bounds and current value + */ + void setRowStatusUsingValue(int iRow); + /*! \brief Set status of column (structural variable) to the correct + nonbasic status given bounds and current value + */ + void setColumnStatusUsingValue(int iColumn); + /*! \brief Set column (structural variable) status vector */ + void setStructuralStatus(const char *strucStatus, int lenParam) ; + /*! \brief Set row (artificial variable) status vector */ + void setArtificialStatus(const char *artifStatus, int lenParam) ; + /*! \brief Set the status of all variables from a basis */ + void setStatus(const CoinWarmStartBasis *basis) ; + /*! \brief Get status in the form of a CoinWarmStartBasis */ + CoinWarmStartBasis *getStatus() ; + /*! \brief Return a print string for status of a column (structural + variable) + */ + const char *columnStatusString(int j) const ; + /*! \brief Return a print string for status of a row (artificial + variable) + */ + const char *rowStatusString(int i) const ; + //@} + + /*! \name Functions to load problem and solution information + + These functions can be used to load portions of the problem definition + and solution. See also the CoinPresolveMatrix and CoinPostsolveMatrix + classes. + */ + //@{ + /// Set the objective function offset for the original system. + void setObjOffset(double offset) ; + /*! \brief Set the objective sense (max/min) + + Coded as 1.0 for min, -1.0 for max. + Yes, there's a method, and a matching attribute. No, you really + don't want to set this to maximise. + */ + void setObjSense(double objSense) ; + /// Set the primal feasibility tolerance + void setPrimalTolerance(double primTol) ; + /// Set the dual feasibility tolerance + void setDualTolerance(double dualTol) ; + /// Set column lower bounds + void setColLower(const double *colLower, int lenParam) ; + /// Set column upper bounds + void setColUpper(const double *colUpper, int lenParam) ; + /// Set column solution + void setColSolution(const double *colSol, int lenParam) ; + /// Set objective coefficients + void setCost(const double *cost, int lenParam) ; + /// Set reduced costs + void setReducedCost(const double *redCost, int lenParam) ; + /// Set row lower bounds + void setRowLower(const double *rowLower, int lenParam) ; + /// Set row upper bounds + void setRowUpper(const double *rowUpper, int lenParam) ; + /// Set row solution + void setRowPrice(const double *rowSol, int lenParam) ; + /// Set row activity + void setRowActivity(const double *rowAct, int lenParam) ; + //@} + + /*! \name Functions to retrieve problem and solution information */ + //@{ + /// Get current number of columns + inline int getNumCols() const + { return (ncols_) ; } + /// Get current number of rows + inline int getNumRows() const + { return (nrows_) ; } + /// Get current number of non-zero coefficients + inline int getNumElems() const + { return (nelems_) ; } + /// Get column start vector for column-major packed matrix + inline const CoinBigIndex *getColStarts() const + { return (mcstrt_) ; } + /// Get column length vector for column-major packed matrix + inline const int *getColLengths() const + { return (hincol_) ; } + /// Get vector of row indices for column-major packed matrix + inline const int *getRowIndicesByCol() const + { return (hrow_) ; } + /// Get vector of elements for column-major packed matrix + inline const double *getElementsByCol() const + { return (colels_) ; } + /// Get column lower bounds + inline const double *getColLower() const + { return (clo_) ; } + /// Get column upper bounds + inline const double *getColUpper() const + { return (cup_) ; } + /// Get objective coefficients + inline const double *getCost() const + { return (cost_) ; } + /// Get row lower bounds + inline const double *getRowLower() const + { return (rlo_) ; } + /// Get row upper bounds + inline const double *getRowUpper() const + { return (rup_) ; } + /// Get column solution (primal variable values) + inline const double *getColSolution() const + { return (sol_) ; } + /// Get row activity (constraint lhs values) + inline const double *getRowActivity() const + { return (acts_) ; } + /// Get row solution (dual variables) + inline const double *getRowPrice() const + { return (rowduals_) ; } + /// Get reduced costs + inline const double *getReducedCost() const + { return (rcosts_) ; } + /// Count empty columns + inline int countEmptyCols() + { int empty = 0 ; + for (int i = 0 ; i < ncols_ ; i++) if (hincol_[i] == 0) empty++ ; + return (empty) ; } + //@} + + + /*! \name Message handling */ + //@{ + /// Return message handler + inline CoinMessageHandler *messageHandler() const + { return handler_; } + /*! \brief Set message handler + + The client retains responsibility for the handler --- it will not be + destroyed with the \c CoinPrePostsolveMatrix object. + */ + inline void setMessageHandler(CoinMessageHandler *handler) + { if (defaultHandler_ == true) + { delete handler_ ; + defaultHandler_ = false ; } + handler_ = handler ; } + /// Return messages + inline CoinMessages messages() const + { return messages_; } + //@} + + /*! \name Current and Allocated Size + + During pre- and postsolve, the matrix will change in size. During presolve + it will shrink; during postsolve it will grow. Hence there are two sets of + size variables, one for the current size and one for the allocated size. + (See the general comments for the CoinPrePostsolveMatrix class for more + information.) + */ + //@{ + + /// current number of columns + int ncols_; + /// current number of rows + int nrows_; + /// current number of coefficients + CoinBigIndex nelems_; + + /// Allocated number of columns + int ncols0_; + /// Allocated number of rows + int nrows0_ ; + /// Allocated number of coefficients + CoinBigIndex nelems0_ ; + /*! \brief Allocated size of bulk storage for row indices and coefficients + + This is the space allocated for hrow_ and colels_. This must be large + enough to allow columns to be copied into empty space when they need to + be expanded. For efficiency (to minimize the number of times the + representation must be compressed) it's recommended that this be at least + 2*nelems0_. + */ + CoinBigIndex bulk0_ ; + /// Ratio of bulk0_ to nelems0_; default is 2. + double bulkRatio_; + //@} + + /*! \name Problem representation + + The matrix is the common column-major format: A pair of vectors with + positional correspondence to hold coefficients and row indices, and a + second pair of vectors giving the starting position and length of each + column in the first pair. + */ + //@{ + /// Vector of column start positions in #hrow_, #colels_ + CoinBigIndex *mcstrt_; + /// Vector of column lengths + int *hincol_; + /// Row indices (positional correspondence with #colels_) + int *hrow_; + /// Coefficients (positional correspondence with #hrow_) + double *colels_; + + /// Objective coefficients + double *cost_; + /// Original objective offset + double originalOffset_; + + /// Column (primal variable) lower bounds + double *clo_; + /// Column (primal variable) upper bounds + double *cup_; + + /// Row (constraint) lower bounds + double *rlo_; + /// Row (constraint) upper bounds + double *rup_; + + /*! \brief Original column numbers + + Over the current range of column numbers in the presolved problem, + the entry for column j will contain the index of the corresponding + column in the original problem. + */ + int * originalColumn_; + /*! \brief Original row numbers + + Over the current range of row numbers in the presolved problem, the + entry for row i will contain the index of the corresponding row in + the original problem. + */ + int * originalRow_; + + /// Primal feasibility tolerance + double ztolzb_; + /// Dual feasibility tolerance + double ztoldj_; + + /*! \brief Maximization/minimization + + Yes, there's a variable here. No, you really don't want to set this to + maximise. See the main notes for CoinPresolveMatrix. + */ + double maxmin_; + //@} + + /*! \name Problem solution information + + The presolve phase will work without any solution information + (appropriate for initial optimisation) or with solution information + (appropriate for reoptimisation). When solution information is supplied, + presolve will maintain it to the best of its ability. #colstat_ is + checked to determine the presence/absence of status information. #sol_ is + checked for primal solution information, and #rowduals_ for dual solution + information. + + The postsolve phase requires the complete solution information from the + presolved problem (status, primal and dual solutions). It will be + transformed into a correct solution for the original problem. + */ + //@{ + /*! \brief Vector of primal variable values + + If #sol_ exists, it is assumed that primal solution information should be + updated and that #acts_ also exists. + */ + double *sol_; + /*! \brief Vector of dual variable values + + If #rowduals_ exists, it is assumed that dual solution information should + be updated and that #rcosts_ also exists. + */ + double *rowduals_; + /*! \brief Vector of constraint left-hand-side values (row activity) + + Produced by evaluating constraints according to #sol_. Updated iff + #sol_ exists. + */ + double *acts_; + /*! \brief Vector of reduced costs + + Produced by evaluating dual constraints according to #rowduals_. Updated + iff #rowduals_ exists. + */ + double *rcosts_; + + /*! \brief Status of primal variables + + Coded with CoinPrePostSolveMatrix::Status, one code per char. colstat_ and + #rowstat_ <b>MUST</b> be allocated as a single vector. This is to maintain + compatibility with ClpPresolve and OsiPresolve, which do it this way. + */ + unsigned char *colstat_; + + /*! \brief Status of constraints + + More accurately, the status of the logical variable associated with the + constraint. Coded with CoinPrePostSolveMatrix::Status, one code per char. + Note that this must be allocated as a single vector with #colstat_. + */ + unsigned char *rowstat_; + //@} + + /*! \name Message handling + + Uses the standard COIN approach: a default handler is installed, and the + CoinPrePostsolveMatrix object takes responsibility for it. If the client + replaces the handler with one of their own, it becomes their + responsibility. + */ + //@{ + /// Message handler + CoinMessageHandler *handler_; + /// Indicates if the current #handler_ is default (true) or not (false). + bool defaultHandler_; + /// Standard COIN messages + CoinMessage messages_; + //@} + +}; + +/*! \relates CoinPrePostsolveMatrix + \brief Generate a print string for a status code. +*/ +const char *statusName (CoinPrePostsolveMatrix::Status status) ; + + +/*! \class presolvehlink + \brief Links to aid in packed matrix modification + + Currently, the matrices held by the CoinPrePostsolveMatrix and + CoinPresolveMatrix objects are represented in the same way as a + CoinPackedMatrix. In the course of presolve and postsolve transforms, it + will happen that a major-dimension vector needs to increase in size. In + order to check whether there is enough room to add another coefficient in + place, it helps to know the next vector (in memory order) in the bulk + storage area. To do that, a linked list of major-dimension vectors is + maintained; the "pre" and "suc" fields give the previous and next vector, + in memory order (that is, the vector whose mcstrt_ or mrstrt_ entry is + next smaller or larger). + + Consider a column-major matrix with ncols columns. By definition, + presolvehlink[ncols].pre points to the column in the last occupied + position of the bulk storage arrays. There is no easy way to find the + column which occupies the first position (there is no presolvehlink[-1] to + consult). If the column that initially occupies the first position is + moved for expansion, there is no way to reclaim the space until the bulk + storage is compacted. The same holds for the last and first rows of a + row-major matrix, of course. +*/ + +class presolvehlink +{ public: + int pre, suc; +} ; + +#define NO_LINK -66666666 + +/*! \relates presolvehlink + \brief unlink vector i + + Remove vector i from the ordering. +*/ +inline void PRESOLVE_REMOVE_LINK(presolvehlink *link, int i) +{ + int ipre = link[i].pre; + int isuc = link[i].suc; + if (ipre >= 0) { + link[ipre].suc = isuc; + } + if (isuc >= 0) { + link[isuc].pre = ipre; + } + link[i].pre = NO_LINK, link[i].suc = NO_LINK; +} + +/*! \relates presolvehlink + \brief insert vector i after vector j + + Insert vector i between j and j.suc. +*/ +inline void PRESOLVE_INSERT_LINK(presolvehlink *link, int i, int j) +{ + int isuc = link[j].suc; + link[j].suc = i; + link[i].pre = j; + if (isuc >= 0) { + link[isuc].pre = i; + } + link[i].suc = isuc; +} + +/*! \relates presolvehlink + \brief relink vector j in place of vector i + + Replace vector i in the ordering with vector j. This is equivalent to + <pre> + int pre = link[i].pre; + PRESOLVE_REMOVE_LINK(link,i); + PRESOLVE_INSERT_LINK(link,j,pre); + </pre> + But, this routine will work even if i happens to be first in the order. +*/ +inline void PRESOLVE_MOVE_LINK(presolvehlink *link, int i, int j) +{ + int ipre = link[i].pre; + int isuc = link[i].suc; + if (ipre >= 0) { + link[ipre].suc = j; + } + if (isuc >= 0) { + link[isuc].pre = j; + } + link[i].pre = NO_LINK, link[i].suc = NO_LINK; +} + + +/*! \class CoinPresolveMatrix + \brief Augments CoinPrePostsolveMatrix with information about the problem + that is only needed during presolve. + + For problem manipulation, this class adds a row-major matrix + representation, linked lists that allow for easy manipulation of the matrix + when applying presolve transforms, and vectors to track row and column + processing status (changed, needs further processing, change prohibited) + + For problem representation, this class adds information about variable type + (integer or continuous), an objective offset, and a feasibility tolerance. + + <b>NOTE</b> that the #anyInteger_ and #anyProhibited_ flags are independent + of the vectors used to track this information for individual variables + (#integerType_ and #rowChanged_ and #colChanged_, respectively). + + <b>NOTE</b> also that at the end of presolve the column-major and row-major + matrix representations are loosely packed (<i>i.e.</i>, there may be gaps + between columns in the bulk storage arrays). + + <b>NOTE</b> that while you might think that CoinPresolve is prepared to + handle minimisation or maximisation, it's unlikely that this still works. + This is a good thing: better to convert objective coefficients and duals + once, before starting presolve, rather than doing it over and over in + each transform that considers dual variables. + + The constructors that take an OSI or ClpSimplex as a parameter really should + not be here, but for historical reasons they will likely remain for the + forseeable future. -- lh, 111202 -- +*/ + +class CoinPresolveMatrix : public CoinPrePostsolveMatrix +{ + public: + + /*! \brief `Native' constructor + + This constructor creates an empty object which must then be loaded. + On the other hand, it doesn't assume that the client is an + OsiSolverInterface. + */ + CoinPresolveMatrix(int ncols_alloc, int nrows_alloc, + CoinBigIndex nelems_alloc) ; + + /*! \brief Clp OSI constructor + + See Clp code for the definition. + */ + CoinPresolveMatrix(int ncols0, + double maxmin, + // end prepost members + + ClpSimplex * si, + + // rowrep + int nrows, + CoinBigIndex nelems, + bool doStatus, + double nonLinearVariable, + double bulkRatio); + + /*! \brief Update the model held by a Clp OSI */ + void update_model(ClpSimplex * si, + int nrows0, + int ncols0, + CoinBigIndex nelems0); + /*! \brief Generic OSI constructor + + See OSI code for the definition. + */ + CoinPresolveMatrix(int ncols0, + double maxmin, + // end prepost members + OsiSolverInterface * si, + // rowrep + int nrows, + CoinBigIndex nelems, + bool doStatus, + double nonLinearVariable, + const char * prohibited, + const char * rowProhibited=NULL); + + /*! \brief Update the model held by a generic OSI */ + void update_model(OsiSolverInterface * si, + int nrows0, + int ncols0, + CoinBigIndex nelems0); + + /// Destructor + ~CoinPresolveMatrix(); + + /*! \brief Initialize a CoinPostsolveMatrix object, destroying the + CoinPresolveMatrix object. + + See CoinPostsolveMatrix::assignPresolveToPostsolve. + */ + friend void assignPresolveToPostsolve (CoinPresolveMatrix *&preObj) ; + + /*! \name Functions to load the problem representation + */ + //@{ + /*! \brief Load the cofficient matrix. + + Load the coefficient matrix before loading the other vectors (bounds, + objective, variable type) required to define the problem. + */ + void setMatrix(const CoinPackedMatrix *mtx) ; + + /// Count number of empty rows + inline int countEmptyRows() + { int empty = 0 ; + for (int i = 0 ; i < nrows_ ; i++) if (hinrow_[i] == 0) empty++ ; + return (empty) ; } + + /*! \brief Set variable type information for a single variable + + Set \p variableType to 0 for continous, 1 for integer. + Does not manipulate the #anyInteger_ flag. + */ + inline void setVariableType(int i, int variableType) + { if (integerType_ == 0) integerType_ = new unsigned char [ncols0_] ; + integerType_[i] = static_cast<unsigned char>(variableType) ; } + + /*! \brief Set variable type information for all variables + + Set \p variableType[i] to 0 for continuous, 1 for integer. + Does not manipulate the #anyInteger_ flag. + */ + void setVariableType(const unsigned char *variableType, int lenParam) ; + + /*! \brief Set the type of all variables + + allIntegers should be true to set the type to integer, false to set the + type to continuous. + */ + void setVariableType (bool allIntegers, int lenParam) ; + + /// Set a flag for presence (true) or absence (false) of integer variables + inline void setAnyInteger (bool anyInteger = true) + { anyInteger_ = anyInteger ; } + //@} + + /*! \name Functions to retrieve problem information + */ + //@{ + + /// Get row start vector for row-major packed matrix + inline const CoinBigIndex *getRowStarts() const + { return (mrstrt_) ; } + /// Get vector of column indices for row-major packed matrix + inline const int *getColIndicesByRow() const + { return (hcol_) ; } + /// Get vector of elements for row-major packed matrix + inline const double *getElementsByRow() const + { return (rowels_) ; } + + /*! \brief Check for integrality of the specified variable. + + Consults the #integerType_ vector if present; fallback is the + #anyInteger_ flag. + */ + inline bool isInteger (int i) const + { if (integerType_ == 0) + { return (anyInteger_) ; } + else + if (integerType_[i] == 1) + { return (true) ; } + else + { return (false) ; } } + + /*! \brief Check if there are any integer variables + + Consults the #anyInteger_ flag + */ + inline bool anyInteger () const + { return (anyInteger_) ; } + /// Picks up any special options + inline int presolveOptions() const + { return presolveOptions_;} + /// Sets any special options (see #presolveOptions_) + inline void setPresolveOptions(int value) + { presolveOptions_=value;} + //@} + + /*! \name Matrix storage management links + + Linked lists, modelled after the linked lists used in OSL + factorization. They are used for management of the bulk coefficient + and minor index storage areas. + */ + //@{ + /// Linked list for the column-major representation. + presolvehlink *clink_; + /// Linked list for the row-major representation. + presolvehlink *rlink_; + //@} + + /// Objective function offset introduced during presolve + double dobias_ ; + + /// Adjust objective function constant offset + inline void change_bias(double change_amount) + { + dobias_ += change_amount ; + # if PRESOLVE_DEBUG > 2 + assert(fabs(change_amount)<1.0e50) ; + if (change_amount) + PRESOLVE_STMT(printf("changing bias by %g to %g\n", + change_amount, dobias_)) ; + # endif + } + + /*! \name Row-major representation + + Common row-major format: A pair of vectors with positional + correspondence to hold coefficients and column indices, and a second pair + of vectors giving the starting position and length of each row in + the first pair. + */ + //@{ + /// Vector of row start positions in #hcol, #rowels_ + CoinBigIndex *mrstrt_; + /// Vector of row lengths + int *hinrow_; + /// Coefficients (positional correspondence with #hcol_) + double *rowels_; + /// Column indices (positional correspondence with #rowels_) + int *hcol_; + //@} + + /// Tracks integrality of columns (1 for integer, 0 for continuous) + unsigned char *integerType_; + /*! \brief Flag to say if any variables are integer + + Note that this flag is <i>not</i> manipulated by the various + \c setVariableType routines. + */ + bool anyInteger_ ; + /// Print statistics for tuning + bool tuning_; + /// Say we want statistics - also set time + void statistics(); + /// Start time of presolve + double startTime_; + + /// Bounds can be moved by this to retain feasibility + double feasibilityTolerance_; + /// Return feasibility tolerance + inline double feasibilityTolerance() + { return (feasibilityTolerance_) ; } + /// Set feasibility tolerance + inline void setFeasibilityTolerance (double val) + { feasibilityTolerance_ = val ; } + + /*! \brief Output status: 0 = feasible, 1 = infeasible, 2 = unbounded + + Actually implemented as single bit flags: 1^0 = infeasible, 1^1 = + unbounded. + */ + int status_; + /// Returns problem status (0 = feasible, 1 = infeasible, 2 = unbounded) + inline int status() + { return (status_) ; } + /// Set problem status + inline void setStatus(int status) + { status_ = (status&0x3) ; } + + /*! \brief Presolve pass number + + Should be incremented externally by the method controlling application of + presolve transforms. + Used to control the execution of testRedundant (evoked by the + implied_free transform). + */ + int pass_; + /// Set pass number + inline void setPass (int pass = 0) + { pass_ = pass ; } + + /*! \brief Maximum substitution level + + Used to control the execution of subst from implied_free + */ + int maxSubstLevel_; + /// Set Maximum substitution level (normally 3) + inline void setMaximumSubstitutionLevel (int level) + { maxSubstLevel_ = level ; } + + + /*! \name Row and column processing status + + Information used to determine if rows or columns can be changed and + if they require further processing due to changes. + + There are four major lists: the [row,col]ToDo list, and the + [row,col]NextToDo list. In general, a transform processes entries from + the ToDo list and adds entries to the NextToDo list. + + There are two vectors, [row,col]Changed, which track the status of + individual rows and columns. + */ + //@{ + /*! \brief Column change status information + + Coded using the following bits: + <ul> + <li> 0x01: Column has changed + <li> 0x02: preprocessing prohibited + <li> 0x04: Column has been used + <li> 0x08: Column originally had infinite ub + </ul> + */ + unsigned char * colChanged_; + /// Input list of columns to process + int * colsToDo_; + /// Length of #colsToDo_ + int numberColsToDo_; + /// Output list of columns to process next + int * nextColsToDo_; + /// Length of #nextColsToDo_ + int numberNextColsToDo_; + + /*! \brief Row change status information + + Coded using the following bits: + <ul> + <li> 0x01: Row has changed + <li> 0x02: preprocessing prohibited + <li> 0x04: Row has been used + </ul> + */ + unsigned char * rowChanged_; + /// Input list of rows to process + int * rowsToDo_; + /// Length of #rowsToDo_ + int numberRowsToDo_; + /// Output list of rows to process next + int * nextRowsToDo_; + /// Length of #nextRowsToDo_ + int numberNextRowsToDo_; + /*! \brief Fine control over presolve actions + + Set/clear the following bits to allow or suppress actions: + - 0x01 allow duplicate column tests for integer variables + - 0x02 not used + - 0x04 set to inhibit x+y+z=1 mods + - 0x08 not used + - 0x10 set to allow stuff which won't unroll easily (overlapping + duplicate rows; opportunistic fixing of variables from bound + propagation). + - 0x04000 allow presolve transforms to arbitrarily ignore infeasibility + and set arbitrary feasible bounds. + - 0x10000 instructs implied_free_action to be `more lightweight'; will + return without doing anything after 15 presolve passes. + - 0x(2,4,6)0000 instructs implied_free_action to remove small created elements + - 0x80000000 set by presolve to say dupcol_action compressed columns + */ + int presolveOptions_; + /*! Flag to say if any rows or columns are marked as prohibited + + Note that this flag is <i>not</i> manipulated by any of the + various \c set*Prohibited routines. + */ + bool anyProhibited_; + //@} + + /*! \name Scratch work arrays + + Preallocated work arrays are useful to avoid having to allocate and free + work arrays in individual presolve methods. + + All are allocated from #setMatrix by #initializeStuff, freed from + #~CoinPresolveMatrix. You can use #deleteStuff followed by + #initializeStuff to remove and recreate them. + */ + //@{ + /// Preallocated scratch work array, 3*nrows_ + int *usefulRowInt_ ; + /// Preallocated scratch work array, 2*nrows_ + double *usefulRowDouble_ ; + /// Preallocated scratch work array, 2*ncols_ + int *usefulColumnInt_ ; + /// Preallocated scratch work array, ncols_ + double *usefulColumnDouble_ ; + /// Array of random numbers (max row,column) + double *randomNumber_ ; + + /// Work array for count of infinite contributions to row lhs upper bound + int *infiniteUp_ ; + /// Work array for sum of finite contributions to row lhs upper bound + double *sumUp_ ; + /// Work array for count of infinite contributions to row lhs lower bound + int *infiniteDown_ ; + /// Work array for sum of finite contributions to row lhs lower bound + double *sumDown_ ; + //@} + + /*! \brief Recompute row lhs bounds + + Calculate finite contributions to row lhs upper and lower bounds + and count infinite contributions. Returns the number of rows found + to be infeasible. + + If \p whichRow < 0, bounds are recomputed for all rows. + + As of 110611, this seems to be a work in progress in the sense that it's + barely used by the existing presolve code. + */ + int recomputeSums(int whichRow) ; + + /// Allocate scratch arrays + void initializeStuff() ; + /// Free scratch arrays + void deleteStuff() ; + + /*! \name Functions to manipulate row and column processing status */ + //@{ + + /*! \brief Initialise the column ToDo lists + + Places all columns in the #colsToDo_ list except for columns marked + as prohibited (<i>viz.</i> #colChanged_). + */ + void initColsToDo () ; + + /*! \brief Step column ToDo lists + + Moves columns on the #nextColsToDo_ list to the #colsToDo_ list, emptying + #nextColsToDo_. Returns the number of columns transferred. + */ + int stepColsToDo () ; + + /// Return the number of columns on the #colsToDo_ list + inline int numberColsToDo() + { return (numberColsToDo_) ; } + + /// Has column been changed? + inline bool colChanged(int i) const { + return (colChanged_[i]&1)!=0; + } + /// Mark column as not changed + inline void unsetColChanged(int i) { + colChanged_[i] = static_cast<unsigned char>(colChanged_[i] & (~1)) ; + } + /// Mark column as changed. + inline void setColChanged(int i) { + colChanged_[i] = static_cast<unsigned char>(colChanged_[i] | (1)) ; + } + /// Mark column as changed and add to list of columns to process next + inline void addCol(int i) { + if ((colChanged_[i]&1)==0) { + colChanged_[i] = static_cast<unsigned char>(colChanged_[i] | (1)) ; + nextColsToDo_[numberNextColsToDo_++] = i; + } + } + /// Test if column is eligible for preprocessing + inline bool colProhibited(int i) const { + return (colChanged_[i]&2)!=0; + } + /*! \brief Test if column is eligible for preprocessing + + The difference between this method and #colProhibited() is that this + method first tests #anyProhibited_ before examining the specific entry + for the specified column. + */ + inline bool colProhibited2(int i) const { + if (!anyProhibited_) + return false; + else + return (colChanged_[i]&2)!=0; + } + /// Mark column as ineligible for preprocessing + inline void setColProhibited(int i) { + colChanged_[i] = static_cast<unsigned char>(colChanged_[i] | (2)) ; + } + /*! \brief Test if column is marked as used + + This is for doing faster lookups to see where two columns have entries + in common. + */ + inline bool colUsed(int i) const { + return (colChanged_[i]&4)!=0; + } + /// Mark column as used + inline void setColUsed(int i) { + colChanged_[i] = static_cast<unsigned char>(colChanged_[i] | (4)) ; + } + /// Mark column as unused + inline void unsetColUsed(int i) { + colChanged_[i] = static_cast<unsigned char>(colChanged_[i] & (~4)) ; + } + /// Has column infinite ub (originally) + inline bool colInfinite(int i) const { + return (colChanged_[i]&8)!=0; + } + /// Mark column as not infinite ub (originally) + inline void unsetColInfinite(int i) { + colChanged_[i] = static_cast<unsigned char>(colChanged_[i] & (~8)) ; + } + /// Mark column as infinite ub (originally) + inline void setColInfinite(int i) { + colChanged_[i] = static_cast<unsigned char>(colChanged_[i] | (8)) ; + } + + /*! \brief Initialise the row ToDo lists + + Places all rows in the #rowsToDo_ list except for rows marked + as prohibited (<i>viz.</i> #rowChanged_). + */ + void initRowsToDo () ; + + /*! \brief Step row ToDo lists + + Moves rows on the #nextRowsToDo_ list to the #rowsToDo_ list, emptying + #nextRowsToDo_. Returns the number of rows transferred. + */ + int stepRowsToDo () ; + + /// Return the number of rows on the #rowsToDo_ list + inline int numberRowsToDo() + { return (numberRowsToDo_) ; } + + /// Has row been changed? + inline bool rowChanged(int i) const { + return (rowChanged_[i]&1)!=0; + } + /// Mark row as not changed + inline void unsetRowChanged(int i) { + rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] & (~1)) ; + } + /// Mark row as changed + inline void setRowChanged(int i) { + rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] | (1)) ; + } + /// Mark row as changed and add to list of rows to process next + inline void addRow(int i) { + if ((rowChanged_[i]&1)==0) { + rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] | (1)) ; + nextRowsToDo_[numberNextRowsToDo_++] = i; + } + } + /// Test if row is eligible for preprocessing + inline bool rowProhibited(int i) const { + return (rowChanged_[i]&2)!=0; + } + /*! \brief Test if row is eligible for preprocessing + + The difference between this method and #rowProhibited() is that this + method first tests #anyProhibited_ before examining the specific entry + for the specified row. + */ + inline bool rowProhibited2(int i) const { + if (!anyProhibited_) + return false; + else + return (rowChanged_[i]&2)!=0; + } + /// Mark row as ineligible for preprocessing + inline void setRowProhibited(int i) { + rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] | (2)) ; + } + /*! \brief Test if row is marked as used + + This is for doing faster lookups to see where two rows have entries + in common. It can be used anywhere as long as it ends up zeroed out. + */ + inline bool rowUsed(int i) const { + return (rowChanged_[i]&4)!=0; + } + /// Mark row as used + inline void setRowUsed(int i) { + rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] | (4)) ; + } + /// Mark row as unused + inline void unsetRowUsed(int i) { + rowChanged_[i] = static_cast<unsigned char>(rowChanged_[i] & (~4)) ; + } + + + /// Check if there are any prohibited rows or columns + inline bool anyProhibited() const + { return anyProhibited_;} + /// Set a flag for presence of prohibited rows or columns + inline void setAnyProhibited(bool val = true) + { anyProhibited_ = val ; } + //@} + +}; + +/*! \class CoinPostsolveMatrix + \brief Augments CoinPrePostsolveMatrix with information about the problem + that is only needed during postsolve. + + The notable point is that the matrix representation is threaded. The + representation is column-major and starts with the standard two pairs of + arrays: one pair to hold the row indices and coefficients, the second pair + to hold the column starting positions and lengths. But the row indices and + coefficients for a column do not necessarily occupy a contiguous block in + their respective arrays. Instead, a link array gives the position of the + next (row index,coefficient) pair. If the row index and value of a + coefficient a<p,j> occupy position kp in their arrays, then the position of + the next coefficient a<q,j> is found as kq = link[kp]. + + This threaded representation allows for efficient expansion of columns as + rows are reintroduced during postsolve transformations. The basic packed + structures are allocated to the expected size of the postsolved matrix, + and as new coefficients are added, their location is simply added to the + thread for the column. + + There is no provision to convert the threaded representation to a packed + representation. In the context of postsolve, it's not required. (You did + keep a copy of the original matrix, eh?) + + The constructors that take an OSI or ClpSimplex as a parameter really should + not be here, but for historical reasons they will likely remain for the + forseeable future. -- lh, 111202 -- +*/ +class CoinPostsolveMatrix : public CoinPrePostsolveMatrix +{ + public: + + /*! \brief `Native' constructor + + This constructor creates an empty object which must then be loaded. + On the other hand, it doesn't assume that the client is an + OsiSolverInterface. + */ + CoinPostsolveMatrix(int ncols_alloc, int nrows_alloc, + CoinBigIndex nelems_alloc) ; + + + /*! \brief Clp OSI constructor + + See Clp code for the definition. + */ + CoinPostsolveMatrix(ClpSimplex * si, + + int ncols0, + int nrows0, + CoinBigIndex nelems0, + + double maxmin_, + // end prepost members + + double *sol, + double *acts, + + unsigned char *colstat, + unsigned char *rowstat); + + /*! \brief Generic OSI constructor + + See OSI code for the definition. + */ + CoinPostsolveMatrix(OsiSolverInterface * si, + + int ncols0, + int nrows0, + CoinBigIndex nelems0, + + double maxmin_, + // end prepost members + + double *sol, + double *acts, + + unsigned char *colstat, + unsigned char *rowstat); + + /*! \brief Load an empty CoinPostsolveMatrix from a CoinPresolveMatrix + + This routine transfers the contents of the CoinPrePostsolveMatrix + object from the CoinPresolveMatrix object to the CoinPostsolveMatrix + object and completes initialisation of the CoinPostsolveMatrix object. + The empty shell of the CoinPresolveMatrix object is destroyed. + + The routine expects an empty CoinPostsolveMatrix object. If handed a loaded + object, a lot of memory will leak. + */ + void assignPresolveToPostsolve (CoinPresolveMatrix *&preObj) ; + + /// Destructor + ~CoinPostsolveMatrix(); + + /*! \name Column thread structures + + As mentioned in the class documentation, the entries for a given column + do not necessarily occupy a contiguous block of space. The #link_ array + is used to maintain the threading. There is one thread for each column, + and a single thread for all free entries in #hrow_ and #colels_. + + The allocated size of #link_ must be at least as large as the allocated + size of #hrow_ and #colels_. + */ + //@{ + + /*! \brief First entry in free entries thread */ + CoinBigIndex free_list_; + /// Allocated size of #link_ + int maxlink_; + /*! \brief Thread array + + Within a thread, link_[k] points to the next entry in the thread. + */ + CoinBigIndex *link_; + + //@} + + /*! \name Debugging aids + + These arrays are allocated only when CoinPresolve is compiled with + PRESOLVE_DEBUG defined. They hold codes which track the reason that + a column or row is added to the problem during postsolve. + */ + //@{ + char *cdone_; + char *rdone_; + //@} + + /// debug + void check_nbasic(); + +}; + + +/*! \defgroup MtxManip Presolve Matrix Manipulation Functions + + Functions to work with the loosely packed and threaded packed matrix + structures used during presolve and postsolve. +*/ +//@{ + +/*! \relates CoinPrePostsolveMatrix + \brief Initialise linked list for major vector order in bulk storage +*/ + +void presolve_make_memlists(/*CoinBigIndex *starts,*/ int *lengths, + presolvehlink *link, int n); + +/*! \relates CoinPrePostsolveMatrix + \brief Make sure a major-dimension vector k has room for one more + coefficient. + + You can use this directly, or use the inline wrappers presolve_expand_col + and presolve_expand_row +*/ +bool presolve_expand_major(CoinBigIndex *majstrts, double *majels, + int *minndxs, int *majlens, + presolvehlink *majlinks, int nmaj, int k) ; + +/*! \relates CoinPrePostsolveMatrix + \brief Make sure a column (colx) in a column-major matrix has room for + one more coefficient +*/ + +inline bool presolve_expand_col(CoinBigIndex *mcstrt, double *colels, + int *hrow, int *hincol, + presolvehlink *clink, int ncols, int colx) +{ return presolve_expand_major(mcstrt,colels, + hrow,hincol,clink,ncols,colx) ; } + +/*! \relates CoinPrePostsolveMatrix + \brief Make sure a row (rowx) in a row-major matrix has room for one + more coefficient +*/ + +inline bool presolve_expand_row(CoinBigIndex *mrstrt, double *rowels, + int *hcol, int *hinrow, + presolvehlink *rlink, int nrows, int rowx) +{ return presolve_expand_major(mrstrt,rowels, + hcol,hinrow,rlink,nrows,rowx) ; } + + +/*! \relates CoinPrePostsolveMatrix + \brief Find position of a minor index in a major vector. + + The routine returns the position \c k in \p minndxs for the specified + minor index \p tgt. It will abort if the entry does not exist. Can be + used directly or via the inline wrappers presolve_find_row and + presolve_find_col. +*/ +inline CoinBigIndex presolve_find_minor(int tgt, + CoinBigIndex ks, CoinBigIndex ke, + const int *minndxs) +{ CoinBigIndex k ; + for (k = ks ; k < ke ; k++) +#ifndef NDEBUG + { if (minndxs[k] == tgt) + return (k) ; } + DIE("FIND_MINOR") ; + + abort () ; return -1; +#else + { if (minndxs[k] == tgt) + break ; } + return (k) ; +#endif +} + +/*! \relates CoinPrePostsolveMatrix + \brief Find position of a row in a column in a column-major matrix. + + The routine returns the position \c k in \p hrow for the specified \p row. + It will abort if the entry does not exist. +*/ +inline CoinBigIndex presolve_find_row(int row, CoinBigIndex kcs, + CoinBigIndex kce, const int *hrow) +{ return presolve_find_minor(row,kcs,kce,hrow) ; } + +/*! \relates CoinPostsolveMatrix + \brief Find position of a column in a row in a row-major matrix. + + The routine returns the position \c k in \p hcol for the specified \p col. + It will abort if the entry does not exist. +*/ +inline CoinBigIndex presolve_find_col(int col, CoinBigIndex krs, + CoinBigIndex kre, const int *hcol) +{ return presolve_find_minor(col,krs,kre,hcol) ; } + + +/*! \relates CoinPrePostsolveMatrix + \brief Find position of a minor index in a major vector. + + The routine returns the position \c k in \p minndxs for the specified + minor index \p tgt. A return value of \p ke means the entry does not + exist. Can be used directly or via the inline wrappers + presolve_find_row1 and presolve_find_col1. +*/ +CoinBigIndex presolve_find_minor1(int tgt, CoinBigIndex ks, CoinBigIndex ke, + const int *minndxs); + +/*! \relates CoinPrePostsolveMatrix + \brief Find position of a row in a column in a column-major matrix. + + The routine returns the position \c k in \p hrow for the specified \p row. + A return value of \p kce means the entry does not exist. +*/ +inline CoinBigIndex presolve_find_row1(int row, CoinBigIndex kcs, + CoinBigIndex kce, const int *hrow) +{ return presolve_find_minor1(row,kcs,kce,hrow) ; } + +/*! \relates CoinPrePostsolveMatrix + \brief Find position of a column in a row in a row-major matrix. + + The routine returns the position \c k in \p hcol for the specified \p col. + A return value of \p kre means the entry does not exist. +*/ +inline CoinBigIndex presolve_find_col1(int col, CoinBigIndex krs, + CoinBigIndex kre, const int *hcol) +{ return presolve_find_minor1(col,krs,kre,hcol) ; } + +/*! \relates CoinPostsolveMatrix + \brief Find position of a minor index in a major vector in a threaded + matrix. + + The routine returns the position \c k in \p minndxs for the specified + minor index \p tgt. It will abort if the entry does not exist. Can be + used directly or via the inline wrapper presolve_find_row2. +*/ +CoinBigIndex presolve_find_minor2(int tgt, CoinBigIndex ks, int majlen, + const int *minndxs, + const CoinBigIndex *majlinks) ; + +/*! \relates CoinPostsolveMatrix + \brief Find position of a row in a column in a column-major threaded + matrix. + + The routine returns the position \c k in \p hrow for the specified \p row. + It will abort if the entry does not exist. +*/ +inline CoinBigIndex presolve_find_row2(int row, CoinBigIndex kcs, int collen, + const int *hrow, + const CoinBigIndex *clinks) +{ return presolve_find_minor2(row,kcs,collen,hrow,clinks) ; } + +/*! \relates CoinPostsolveMatrix + \brief Find position of a minor index in a major vector in a threaded + matrix. + + The routine returns the position \c k in \p minndxs for the specified + minor index \p tgt. It will return -1 if the entry does not exist. + Can be used directly or via the inline wrappers presolve_find_row3. +*/ +CoinBigIndex presolve_find_minor3(int tgt, CoinBigIndex ks, int majlen, + const int *minndxs, + const CoinBigIndex *majlinks) ; + +/*! \relates CoinPostsolveMatrix + \brief Find position of a row in a column in a column-major threaded + matrix. + + The routine returns the position \c k in \p hrow for the specified \p row. + It will return -1 if the entry does not exist. +*/ +inline CoinBigIndex presolve_find_row3(int row, CoinBigIndex kcs, int collen, + const int *hrow, + const CoinBigIndex *clinks) +{ return presolve_find_minor3(row,kcs,collen,hrow,clinks) ; } + +/*! \relates CoinPrePostsolveMatrix + \brief Delete the entry for a minor index from a major vector. + + Deletes the entry for \p minndx from the major vector \p majndx. + Specifically, the relevant entries are removed from the minor index + (\p minndxs) and coefficient (\p els) arrays and the vector length (\p + majlens) is decremented. Loose packing is maintained by swapping the last + entry in the row into the position occupied by the deleted entry. +*/ +inline void presolve_delete_from_major(int majndx, int minndx, + const CoinBigIndex *majstrts, + int *majlens, int *minndxs, double *els) +{ + const CoinBigIndex ks = majstrts[majndx] ; + const CoinBigIndex ke = ks+majlens[majndx] ; + + const CoinBigIndex kmi = presolve_find_minor(minndx,ks,ke,minndxs) ; + + minndxs[kmi] = minndxs[ke-1] ; + els[kmi] = els[ke-1] ; + majlens[majndx]-- ; + + return ; +} + +/*! \relates CoinPrePostsolveMatrix + \brief Delete marked entries + + Removes the entries specified in \p marked, compressing the major vector + to maintain loose packing. \p marked is cleared in the process. +*/ +inline void presolve_delete_many_from_major(int majndx, char *marked, + const CoinBigIndex *majstrts, + int *majlens, int *minndxs, double *els) +{ + const CoinBigIndex ks = majstrts[majndx] ; + const CoinBigIndex ke = ks+majlens[majndx] ; + CoinBigIndex put = ks ; + for (CoinBigIndex k = ks ; k < ke ; k++) { + int iMinor = minndxs[k] ; + if (!marked[iMinor]) { + minndxs[put] = iMinor ; + els[put++] = els[k] ; + } else { + marked[iMinor] = 0 ; + } + } + majlens[majndx] = put-ks ; + return ; +} + +/*! \relates CoinPrePostsolveMatrix + \brief Delete the entry for row \p row from column \p col in a + column-major matrix + + Deletes the entry for \p row from the major vector for \p col. + Specifically, the relevant entries are removed from the row index (\p + hrow) and coefficient (\p colels) arrays and the vector length (\p + hincol) is decremented. Loose packing is maintained by swapping the last + entry in the row into the position occupied by the deleted entry. +*/ +inline void presolve_delete_from_col(int row, int col, + const CoinBigIndex *mcstrt, + int *hincol, int *hrow, double *colels) +{ presolve_delete_from_major(col,row,mcstrt,hincol,hrow,colels) ; } + +/*! \relates CoinPrePostsolveMatrix + \brief Delete the entry for column \p col from row \p row in a + row-major matrix + + Deletes the entry for \p col from the major vector for \p row. + Specifically, the relevant entries are removed from the column index (\p + hcol) and coefficient (\p rowels) arrays and the vector length (\p + hinrow) is decremented. Loose packing is maintained by swapping the last + entry in the column into the position occupied by the deleted entry. +*/ +inline void presolve_delete_from_row(int row, int col, + const CoinBigIndex *mrstrt, + int *hinrow, int *hcol, double *rowels) +{ presolve_delete_from_major(row,col,mrstrt,hinrow,hcol,rowels) ; } + +/*! \relates CoinPostsolveMatrix + \brief Delete the entry for a minor index from a major vector in a + threaded matrix. + + Deletes the entry for \p minndx from the major vector \p majndx. + Specifically, the relevant entries are removed from the minor index (\p + minndxs) and coefficient (\p els) arrays and the vector length (\p + majlens) is decremented. The thread for the major vector is relinked + around the deleted entry and the space is returned to the free list. +*/ +void presolve_delete_from_major2 (int majndx, int minndx, + CoinBigIndex *majstrts, int *majlens, + int *minndxs, int *majlinks, + CoinBigIndex *free_listp) ; + +/*! \relates CoinPostsolveMatrix + \brief Delete the entry for row \p row from column \p col in a + column-major threaded matrix + + Deletes the entry for \p row from the major vector for \p col. + Specifically, the relevant entries are removed from the row index (\p + hrow) and coefficient (\p colels) arrays and the vector length (\p + hincol) is decremented. The thread for the major vector is relinked + around the deleted entry and the space is returned to the free list. +*/ +inline void presolve_delete_from_col2(int row, int col, CoinBigIndex *mcstrt, + int *hincol, int *hrow, + int *clinks, CoinBigIndex *free_listp) +{ presolve_delete_from_major2(col,row,mcstrt,hincol,hrow,clinks,free_listp) ; } + +//@} + +/*! \defgroup PresolveUtilities Presolve Utility Functions + + Utilities used by multiple presolve transform objects. +*/ +//@{ + +/*! \brief Duplicate a major-dimension vector; optionally omit the entry + with minor index \p tgt. + + Designed to copy a major-dimension vector from the paired coefficient + (\p elems) and minor index (\p indices) arrays used in the standard + packed matrix representation. Copies \p length entries starting at + \p offset. + + If \p tgt is specified, the entry with minor index == \p tgt is + omitted from the copy. +*/ +double *presolve_dupmajor(const double *elems, const int *indices, + int length, CoinBigIndex offset, int tgt = -1); + +/// Initialize a vector with random numbers +void coin_init_random_vec(double *work, int n); + +//@} + + +#endif diff --git a/thirdparty/windows/include/coin/CoinPresolveMonitor.hpp b/thirdparty/windows/include/coin/CoinPresolveMonitor.hpp new file mode 100644 index 0000000..cef7a41 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveMonitor.hpp @@ -0,0 +1,105 @@ + +#ifndef CoinPresolveMonitor_H +#define CoinPresolveMonitor_H + +/*! + \brief Monitor a row or column for modification + + The purpose of this class is to monitor a row or column for modifications + during presolve and postsolve. Each object can monitor one row or + column. The initial copy of the row or column is loaded by the constructor. + Each subsequent call to checkAndTell() compares the current state of the row + or column with the stored state and reports any modifications. + + Internally the row or column is held as a CoinPackedVector so that it's + possible to follow a row or column through presolve (CoinPresolveMatrix) + and postsolve (CoinPostsolveMatrix). + + Do not underestimate the amount of work required here. Extracting a row from + the CoinPostsolve matrix requires a scan of every element in the matrix. + That's one scan by the constructor and one scan with every call to modify. + But that's precisely why it's virtually impossible to debug presolve without + aids. + + Parameter overloads for CoinPresolveMatrix and CoinPostsolveMatrix are a + little clumsy, but not a problem in use. The alternative is to add methods + to the CoinPresolveMatrix and CoinPostsolveMatrix classes that will only be + used for debugging. That's not too attractive either. +*/ +class CoinPresolveMonitor +{ + public: + + /*! \brief Default constructor + + Creates an empty monitor. + */ + CoinPresolveMonitor() ; + + /*! \brief Initialise from a CoinPresolveMatrix + + Load the initial row or column from a CoinPresolveMatrix. Set \p isRow + true for a row, false for a column. + */ + CoinPresolveMonitor(const CoinPresolveMatrix *mtx, bool isRow, int k) ; + + /*! \brief Initialise from a CoinPostsolveMatrix + + Load the initial row or column from a CoinPostsolveMatrix. Set \p isRow + true for a row, false for a column. + */ + CoinPresolveMonitor(const CoinPostsolveMatrix *mtx, bool isRow, int k) ; + + /*! \brief Compare the present row or column against the stored copy and + report differences. + + Load the current row or column from a CoinPresolveMatrix and compare. + Differences are printed to std::cout. + */ + void checkAndTell(const CoinPresolveMatrix *mtx) ; + + /*! \brief Compare the present row or column against the stored copy and + report differences. + + Load the current row or column from a CoinPostsolveMatrix and compare. + Differences are printed to std::cout. + */ + void checkAndTell(const CoinPostsolveMatrix *mtx) ; + + private: + + /// Extract a row from a CoinPresolveMatrix + CoinPackedVector *extractRow(int i, const CoinPresolveMatrix *mtx) const ; + + /// Extract a column from a CoinPresolveMatrix + CoinPackedVector *extractCol(int j, const CoinPresolveMatrix *mtx) const ; + + /// Extract a row from a CoinPostsolveMatrix + CoinPackedVector *extractRow(int i, const CoinPostsolveMatrix *mtx) const ; + + /// Extract a column from a CoinPostsolveMatrix + CoinPackedVector *extractCol(int j, const CoinPostsolveMatrix *mtx) const ; + + /// Worker method underlying the public checkAndTell methods. + void checkAndTell(CoinPackedVector *curVec, double lb, double ub) ; + + /// True to monitor a row, false to monitor a column + bool isRow_ ; + + /// Row or column index + int ndx_ ; + + /*! The original row or column + + Sorted in increasing order of indices. + */ + CoinPackedVector *origVec_ ; + + /// Original row or column lower bound + double lb_ ; + + /// Original row or column upper bound + double ub_ ; +} ; + +#endif diff --git a/thirdparty/windows/include/coin/CoinPresolvePsdebug.hpp b/thirdparty/windows/include/coin/CoinPresolvePsdebug.hpp new file mode 100644 index 0000000..445278e --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolvePsdebug.hpp @@ -0,0 +1,169 @@ +/* $Id: CoinPresolvePsdebug.hpp 1854 2015-12-18 14:18: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 CoinPresolvePsdebug_H +#define CoinPresolvePsdebug_H + +/* + The current idea of the relation between PRESOLVE_DEBUG and + PRESOLVE_CONSISTENCY is that PRESOLVE_CONSISTENCY triggers the consistency + checks and PRESOLVE_DEBUG triggers consistency checks and output. + This isn't always true in the code, but that's the goal. Really, + the whole compile-time scheme should be replaced with something more + user-friendly (control variables that can be changed during the run). + + Also floating about are PRESOLVE_SUMMARY and COIN_PRESOLVE_TUNING. + -- lh, 111208 -- +*/ +/*! \defgroup PresolveDebugFunctions Presolve Debug Functions + + These functions implement consistency checks on data structures involved + in presolve and postsolve and on the components of the lp solution. + + To use these functions, include CoinPresolvePsdebug.hpp in your file and + define the compile-time constants PRESOLVE_SUMMARY, PRESOLVE_DEBUG, and + PRESOLVE_CONSISTENCY. A value is needed (<i>i.e.</i>, PRESOLVE_DEBUG=1). + In a few places, higher values will get you a bit more output. + + ******** + + Define the symbols PRESOLVE_DEBUG and PRESOLVE_CONSISTENCY on the configure + command line (use ADD_CXXFLAGS), in a Makefile, or similar and do a full + rebuild (including any presolve driver code). If the symbols are not + consistently nonzero across *all* presolve code, you'll get something + between garbage and a core dump! Debugging adds messages to CoinMessage + and allocates and maintains arrays that hold debug information. + + That said, given that you've configured and built with PRESOLVE_DEBUG and + PRESOLVE_CONSISTENCY nonzero everywhere, it's safe to adjust PRESOLVE_DEBUG + to values in the range 1..n in individual files to increase or decrease the + amount of output. + + The suggested approach for PRESOLVE_DEBUG is to define it to 1 in the build + and then increase it in individual presolve code files to get more detail. + + ******** +*/ +//@{ + +/*! \relates CoinPresolveMatrix + \brief Check column-major and/or row-major matrices for duplicate + entries in the major vectors. + + By default, scans both the column- and row-major matrices. Set doCol (doRow) + to false to suppress the column (row) scan. +*/ +void presolve_no_dups(const CoinPresolveMatrix *preObj, + bool doCol = true, bool doRow = true) ; + +/*! \relates CoinPresolveMatrix + \brief Check the links which track storage order for major vectors in + the bulk storage area. + + By default, scans both the column- and row-major matrix. Set doCol = false to + suppress the column-major scan. Set doRow = false to suppres the row-major + scan. +*/ +void presolve_links_ok(const CoinPresolveMatrix *preObj, + bool doCol = true, bool doRow = true) ; + +/*! \relates CoinPresolveMatrix + \brief Check for explicit zeros in the column- and/or row-major matrices. + + By default, scans both the column- and row-major matrices. Set doCol (doRow) + to false to suppress the column (row) scan. +*/ +void presolve_no_zeros(const CoinPresolveMatrix *preObj, + bool doCol = true, bool doRow = true) ; + +/*! \relates CoinPresolveMatrix + \brief Checks for equivalence of the column- and row-major matrices. + + Normally the routine will test for coefficient presence and value. Set + \p chkvals to false to suppress the check for equal value. +*/ +void presolve_consistent(const CoinPresolveMatrix *preObj, + bool chkvals = true) ; + +/*! \relates CoinPostsolveMatrix + \brief Checks that column threads agree with column lengths +*/ +void presolve_check_threads(const CoinPostsolveMatrix *obj) ; + +/*! \relates CoinPostsolveMatrix + \brief Checks the free list + + Scans the thread of free locations in the bulk store and checks that all + entries are reasonable (0 <= index < bulk0_). If chkElemCnt is true, it + also checks that the total number of entries in the matrix plus the + locations on the free list total to the size of the bulk store. Postsolve + routines do not maintain an accurate element count, but this is useful + for checking a newly constructed postsolve matrix. +*/ +void presolve_check_free_list(const CoinPostsolveMatrix *obj, + bool chkElemCnt = false) ; + +/*! \relates CoinPostsolveMatrix + \brief Check stored reduced costs for accuracy and consistency with + variable status. + + The routine will check the value of the reduced costs for architectural + variables (CoinPrePostsolveMatrix::rcosts_). It performs an accuracy check + by recalculating the reduced cost from scratch. It will also check the + value for consistency with the status information in + CoinPrePostsolveMatrix::colstat_. +*/ +void presolve_check_reduced_costs(const CoinPostsolveMatrix *obj) ; + +/*! \relates CoinPostsolveMatrix + \brief Check the dual variables for consistency with row activity. + + The routine checks that the value of the dual variable is consistent + with the state of the constraint (loose, tight at lower bound, or tight at + upper bound). +*/ +void presolve_check_duals(const CoinPostsolveMatrix *postObj) ; + +/*! \relates CoinPresolveMatrix + \brief Check primal solution and architectural variable status. + + The architectural variables can be checked for bogus values, feasibility, + and valid status. The row activity is checked for bogus values, accuracy, + and feasibility. By default, row activity is not checked (presolve is + sloppy about maintaining it). See the definitions in + CoinPresolvePsdebug.cpp for more information. +*/ +void presolve_check_sol(const CoinPresolveMatrix *preObj, + int chkColSol = 2, int chkRowAct = 1, + int chkStatus = 1) ; + +/*! \relates CoinPostsolveMatrix + \brief Check primal solution and architectural variable status. + + The architectural variables can be checked for bogus values, feasibility, + and valid status. The row activity is checked for bogus values, accuracy, + and feasibility. See the definitions in CoinPresolvePsdebug.cpp for more + information. +*/ +void presolve_check_sol(const CoinPostsolveMatrix *postObj, + int chkColSol = 2, int chkRowAct = 2, + int chkStatus = 1) ; + +/*! \relates CoinPresolveMatrix + \brief Check for the proper number of basic variables. +*/ +void presolve_check_nbasic(const CoinPresolveMatrix *preObj) ; + +/*! \relates CoinPostsolveMatrix + \brief Check for the proper number of basic variables. +*/ +void presolve_check_nbasic(const CoinPostsolveMatrix *postObj) ; + +/// get a row copy in postsolve +void postsolve_get_rowcopy(const CoinPostsolveMatrix *postObj, + int * & rowStarts, int * & columns, double * & elements ) ; +//@} + +#endif diff --git a/thirdparty/windows/include/coin/CoinPresolveSingleton.hpp b/thirdparty/windows/include/coin/CoinPresolveSingleton.hpp new file mode 100644 index 0000000..10bc1cc --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveSingleton.hpp @@ -0,0 +1,112 @@ +/* $Id: CoinPresolveSingleton.hpp 1498 2011-11-02 15:25:35Z mjs $ */ +// 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 CoinPresolveSingleton_H +#define CoinPresolveSingleton_H +#define SLACK_DOUBLETON 2 +#define SLACK_SINGLETON 8 + +/*! + \file +*/ + +//const int MAX_SLACK_DOUBLETONS = 1000; + +/*! \class slack_doubleton_action + \brief Convert an explicit bound constraint to a column bound + + This transform looks for explicit bound constraints for a variable and + transfers the bound to the appropriate column bound array. + The constraint is removed from the constraint system. +*/ +class slack_doubleton_action : public CoinPresolveAction { + struct action { + double clo; + double cup; + + double rlo; + double rup; + + double coeff; + + int col; + int row; + }; + + const int nactions_; + const action *const actions_; + + slack_doubleton_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), + actions_(actions) +{} + + public: + const char *name() const { return ("slack_doubleton_action"); } + + /*! \brief Convert explicit bound constraints to column bounds. + + Not now There is a hard limit (#MAX_SLACK_DOUBLETONS) on the number of + constraints processed in a given call. \p notFinished is set to true + if candidates remain. + */ + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + const CoinPresolveAction *next, + bool ¬Finished); + + void postsolve(CoinPostsolveMatrix *prob) const; + + + virtual ~slack_doubleton_action() { deleteAction(actions_,action*); } +}; +/*! \class slack_singleton_action + \brief For variables with one entry + + If we have a variable with one entry and no cost then we can + transform the row from E to G etc. + If there is a row objective region then we may be able to do + this even with a cost. +*/ +class slack_singleton_action : public CoinPresolveAction { + struct action { + double clo; + double cup; + + double rlo; + double rup; + + double coeff; + + int col; + int row; + }; + + const int nactions_; + const action *const actions_; + + slack_singleton_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), + actions_(actions) +{} + + public: + const char *name() const { return ("slack_singleton_action"); } + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + const CoinPresolveAction *next, + double * rowObjective); + + void postsolve(CoinPostsolveMatrix *prob) const; + + + virtual ~slack_singleton_action() { deleteAction(actions_,action*); } +}; +#endif diff --git a/thirdparty/windows/include/coin/CoinPresolveSubst.hpp b/thirdparty/windows/include/coin/CoinPresolveSubst.hpp new file mode 100644 index 0000000..93822a5 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveSubst.hpp @@ -0,0 +1,101 @@ +/* $Id: CoinPresolveSubst.hpp 1562 2012-11-24 00:36:15Z 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 CoinPresolveSubst_H +#define CoinPresolveSubst_H + +/*! + \file +*/ + +#define SUBST_ROW 21 + +#include "CoinPresolveMatrix.hpp" + +/*! \class subst_constraint_action + \brief Detect and process implied free variables + + Consider a variable x. Suppose that we can find an equality such that the + bound on the equality, combined with + the bounds on the other variables involved in the equality, are such that + even the worst case values of the other variables still imply bounds for x + which are tighter than the variable's original bounds. Since x can never + reach its upper or lower bounds, it is an implied free variable. By solving + the equality for x and substituting for x in every other constraint + entangled with x, we can make x into a column singleton. Now x is an implied + free column singleton and both x and the equality can be removed. + + A similar transform for the case where the variable is a natural column + singleton is handled by #implied_free_action. In the current presolve + architecture, #implied_free_action is responsible for detecting implied free + variables that are natural column singletons or can be reduced to column + singletons. #implied_free_action calls subst_constraint_action to process + variables that must be reduced to column singletons. +*/ +class subst_constraint_action : public CoinPresolveAction { +private: + subst_constraint_action(); + subst_constraint_action(const subst_constraint_action& rhs); + subst_constraint_action& operator=(const subst_constraint_action& rhs); + + struct action { + double *rlos; + double *rups; + + double *coeffxs; + int *rows; + + int *ninrowxs; + int *rowcolsxs; + double *rowelsxs; + + const double *costsx; + int col; + int rowy; + + int nincol; + }; + + const int nactions_; + // actions_ is owned by the class and must be deleted at destruction + const action *const actions_; + + subst_constraint_action(int nactions, + action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), actions_(actions) {} + + public: + const char *name() const; + + static const CoinPresolveAction *presolve(CoinPresolveMatrix * prob, + const int *implied_free, + const int * which, + int numberFree, + const CoinPresolveAction *next, + int fill_level); + static const CoinPresolveAction *presolveX(CoinPresolveMatrix * prob, + const CoinPresolveAction *next, + int fillLevel); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~subst_constraint_action(); +}; + + + + + +/*static*/ void implied_bounds(const double *els, + const double *clo, const double *cup, + const int *hcol, + CoinBigIndex krs, CoinBigIndex kre, + double *maxupp, double *maxdownp, + int jcol, + double rlo, double rup, + double *iclb, double *icub); +#endif diff --git a/thirdparty/windows/include/coin/CoinPresolveTighten.hpp b/thirdparty/windows/include/coin/CoinPresolveTighten.hpp new file mode 100644 index 0000000..3a5319b --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveTighten.hpp @@ -0,0 +1,55 @@ +/* $Id: CoinPresolveTighten.hpp 1498 2011-11-02 15:25:35Z mjs $ */ +// 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 CoinPresolveTighten_H +#define CoinPresolveTighten_H + +#include "CoinPresolveMatrix.hpp" + +// This action has no separate class; +// instead, it decides which columns can be made fixed +// and calls make_fixed_action::presolve. +const CoinPresolveAction *tighten_zero_cost(CoinPresolveMatrix *prob, + const CoinPresolveAction *next); + +#define DO_TIGHTEN 30 + +class do_tighten_action : public CoinPresolveAction { + do_tighten_action(); + do_tighten_action(const do_tighten_action& rhs); + do_tighten_action& operator=(const do_tighten_action& rhs); + + struct action { + int *rows; + double *lbound; + double *ubound; + int col; + int nrows; + int direction; // just for assertions + }; + + const int nactions_; + const action *const actions_; + + do_tighten_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), actions_(actions) {} + + public: + const char *name() const; + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~do_tighten_action(); + +}; +#endif + + diff --git a/thirdparty/windows/include/coin/CoinPresolveTripleton.hpp b/thirdparty/windows/include/coin/CoinPresolveTripleton.hpp new file mode 100644 index 0000000..eaa79c5 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveTripleton.hpp @@ -0,0 +1,66 @@ +/* $Id: CoinPresolveTripleton.hpp 1498 2011-11-02 15:25:35Z mjs $ */ +// 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 CoinPresolveTripleton_H +#define CoinPresolveTripleton_H +#define TRIPLETON 11 +/** We are only going to do this if it does not increase number of elements?. + It could be generalized to more than three but it seems unlikely it would + help. + + As it is adapted from doubleton icoly is one dropped. + */ +class tripleton_action : public CoinPresolveAction { + public: + struct action { + int icolx; + int icolz; + int row; + + int icoly; + double cloy; + double cupy; + double costy; + double clox; + double cupx; + double costx; + + double rlo; + double rup; + + double coeffx; + double coeffy; + double coeffz; + + double *colel; + + int ncolx; + int ncoly; + }; + + const int nactions_; + const action *const actions_; + + private: + tripleton_action(int nactions, + const action *actions, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nactions_(nactions), actions_(actions) +{} + + public: + const char *name() const { return ("tripleton_action"); } + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~tripleton_action(); +}; +#endif + + diff --git a/thirdparty/windows/include/coin/CoinPresolveUseless.hpp b/thirdparty/windows/include/coin/CoinPresolveUseless.hpp new file mode 100644 index 0000000..624a373 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveUseless.hpp @@ -0,0 +1,63 @@ +/* $Id: CoinPresolveUseless.hpp 1566 2012-11-29 19:33:56Z 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 CoinPresolveUseless_H +#define CoinPresolveUseless_H +#define USELESS 20 + +class useless_constraint_action : public CoinPresolveAction { + struct action { + double rlo; + double rup; + const int *rowcols; + const double *rowels; + int row; + int ninrow; + }; + + const int nactions_; + const action *const actions_; + + useless_constraint_action(int nactions, + const action *actions, + const CoinPresolveAction *next); + + public: + const char *name() const; + + // These rows are asserted to be useless, + // that is, given a solution the row activity + // must be in range. + static const CoinPresolveAction *presolve(CoinPresolveMatrix * prob, + const int *useless_rows, + int nuseless_rows, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~useless_constraint_action(); + +}; + +/*! \relates useless_constraint_action + \brief Scan constraints looking for useless constraints + + A front end to identify useless constraints and hand them to + useless_constraint_action::presolve() for processing. + + In a bit more detail, the routine implements a greedy algorithm that + identifies a set of necessary constraints. A constraint is necessary if it + implies a tighter bound on a variable than the original column bound. These + tighter column bounds are then used to calculate row activity and identify + constraints that are useless given the presence of the necessary + constraints. +*/ + +const CoinPresolveAction *testRedundant(CoinPresolveMatrix *prob, + const CoinPresolveAction *next) ; + + + +#endif diff --git a/thirdparty/windows/include/coin/CoinPresolveZeros.hpp b/thirdparty/windows/include/coin/CoinPresolveZeros.hpp new file mode 100644 index 0000000..219e613 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinPresolveZeros.hpp @@ -0,0 +1,60 @@ +/* $Id: CoinPresolveZeros.hpp 1498 2011-11-02 15:25:35Z mjs $ */ +// 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 CoinPresolveZeros_H +#define CoinPresolveZeros_H + +/*! \file + + Drop/reintroduce explicit zeros. +*/ + +#define DROP_ZERO 8 + +/*! \brief Tracking information for an explicit zero coefficient + + \todo Why isn't this a nested class in drop_zero_coefficients_action? + That would match the structure of other presolve classes. +*/ + +struct dropped_zero { + int row; + int col; +}; + +/*! \brief Removal of explicit zeros + + The presolve action for this class removes explicit zeros from the constraint + matrix. The postsolve action puts them back. +*/ +class drop_zero_coefficients_action : public CoinPresolveAction { + + const int nzeros_; + const dropped_zero *const zeros_; + + drop_zero_coefficients_action(int nzeros, + const dropped_zero *zeros, + const CoinPresolveAction *next) : + CoinPresolveAction(next), + nzeros_(nzeros), zeros_(zeros) +{} + + public: + const char *name() const { return ("drop_zero_coefficients_action"); } + + static const CoinPresolveAction *presolve(CoinPresolveMatrix *prob, + int *checkcols, + int ncheckcols, + const CoinPresolveAction *next); + + void postsolve(CoinPostsolveMatrix *prob) const; + + virtual ~drop_zero_coefficients_action() { deleteAction(zeros_,dropped_zero*); } +}; + +const CoinPresolveAction *drop_zero_coefficients(CoinPresolveMatrix *prob, + const CoinPresolveAction *next); + +#endif diff --git a/thirdparty/windows/include/coin/CoinRational.hpp b/thirdparty/windows/include/coin/CoinRational.hpp new file mode 100644 index 0000000..bfbfa5f --- /dev/null +++ b/thirdparty/windows/include/coin/CoinRational.hpp @@ -0,0 +1,44 @@ +// Authors: Matthew Saltzman and Ted Ralphs +// Copyright 2015, Matthew Saltzman and Ted Ralphs +// Licensed under the Eclipse Public License 1.0 + +#ifndef CoinRational_H +#define CoinRational_H + +#include <cmath> + +//Small class for rational numbers +class CoinRational +{ + +public : + long getDenominator() { return denominator_; } + long getNumerator() { return numerator_; } + + CoinRational(): + numerator_(0), + denominator_(1) + {}; + + CoinRational(long n, long d): + numerator_(n), + denominator_(d) + {}; + + CoinRational(double val, double maxdelta, long maxdnom) + { + if (!nearestRational_(val, maxdelta, maxdnom)){ + numerator_ = 0; + denominator_ = 1; + } + }; + +private : + + long numerator_; + long denominator_; + + bool nearestRational_(double val, double maxdelta, long maxdnom); +}; + +#endif diff --git a/thirdparty/windows/include/coin/CoinSearchTree.hpp b/thirdparty/windows/include/coin/CoinSearchTree.hpp new file mode 100644 index 0000000..f7c101d --- /dev/null +++ b/thirdparty/windows/include/coin/CoinSearchTree.hpp @@ -0,0 +1,465 @@ +/* $Id: CoinSearchTree.hpp 1824 2015-04-04 16:27:28Z tkr $ */ +// Copyright (C) 2006, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef CoinSearchTree_H +#define CoinSearchTree_H + +#include <vector> +#include <algorithm> +#include <cmath> +#include <string> + +#include "CoinFinite.hpp" +#include "CoinHelperFunctions.hpp" + +// #define DEBUG_PRINT + +//############################################################################# + +class BitVector128 { + friend bool operator<(const BitVector128& b0, const BitVector128& b1); +private: + unsigned int bits_[4]; +public: + BitVector128(); + BitVector128(unsigned int bits[4]); + ~BitVector128() {} + void set(unsigned int bits[4]); + void setBit(int i); + void clearBit(int i); + std::string str() const; +}; + +bool operator<(const BitVector128& b0, const BitVector128& b1); + +//############################################################################# + +/** A class from which the real tree nodes should be derived from. Some of the + data that undoubtedly exist in the real tree node is replicated here for + fast access. This class is used in the various comparison functions. */ +class CoinTreeNode { +protected: + CoinTreeNode() : + depth_(-1), + fractionality_(-1), + quality_(-COIN_DBL_MAX), + true_lower_bound_(-COIN_DBL_MAX), + preferred_() {} + CoinTreeNode(int d, + int f = -1, + double q = -COIN_DBL_MAX, + double tlb = -COIN_DBL_MAX, + BitVector128 p = BitVector128()) : + depth_(d), + fractionality_(f), + quality_(q), + true_lower_bound_(tlb), + preferred_(p) {} + CoinTreeNode(const CoinTreeNode& x) : + depth_(x.depth_), + fractionality_(x.fractionality_), + quality_(x.quality_), + true_lower_bound_(x.true_lower_bound_), + preferred_(x.preferred_) {} + CoinTreeNode& operator=(const CoinTreeNode& x) { + if (this != &x) { + depth_ = x.depth_; + fractionality_ = x.fractionality_; + quality_ = x.quality_; + true_lower_bound_ = x.true_lower_bound_; + preferred_ = x.preferred_; + } + return *this; + } +private: + /// The depth of the node in the tree + int depth_; + /** A measure of fractionality, e.g., the number of unsatisfied + integrality requirements */ + int fractionality_; + /** Some quality for the node. For normal branch-and-cut problems the LP + relaxation value will do just fine. It is probably an OK approximation + even if column generation is done. */ + double quality_; + /** A true lower bound on the node. May be -infinity. For normal + branch-and-cut problems the LP relaxation value is OK. It is different + when column generation is done. */ + double true_lower_bound_; + /** */ + BitVector128 preferred_; +public: + virtual ~CoinTreeNode() {} + + inline int getDepth() const { return depth_; } + inline int getFractionality() const { return fractionality_; } + inline double getQuality() const { return quality_; } + inline double getTrueLB() const { return true_lower_bound_; } + inline BitVector128 getPreferred() const { return preferred_; } + + inline void setDepth(int d) { depth_ = d; } + inline void setFractionality(int f) { fractionality_ = f; } + inline void setQuality(double q) { quality_ = q; } + inline void setTrueLB(double tlb) { true_lower_bound_ = tlb; } + inline void setPreferred(BitVector128 p) { preferred_ = p; } +}; + +//============================================================================== + +class CoinTreeSiblings { +private: + CoinTreeSiblings(); + CoinTreeSiblings& operator=(const CoinTreeSiblings&); +private: + int current_; + int numSiblings_; + CoinTreeNode** siblings_; +public: + CoinTreeSiblings(const int n, CoinTreeNode** nodes) : + current_(0), numSiblings_(n), siblings_(new CoinTreeNode*[n]) + { + CoinDisjointCopyN(nodes, n, siblings_); + } + CoinTreeSiblings(const CoinTreeSiblings& s) : + current_(s.current_), + numSiblings_(s.numSiblings_), + siblings_(new CoinTreeNode*[s.numSiblings_]) + { + CoinDisjointCopyN(s.siblings_, s.numSiblings_, siblings_); + } + ~CoinTreeSiblings() { delete[] siblings_; } + inline CoinTreeNode* currentNode() const { return siblings_[current_]; } + /** returns false if cannot be advanced */ + inline bool advanceNode() { return ++current_ != numSiblings_; } + inline int toProcess() const { return numSiblings_ - current_; } + inline int size() const { return numSiblings_; } + inline void printPref() const { + for (int i = 0; i < numSiblings_; ++i) { + std::string pref = siblings_[i]->getPreferred().str(); + printf("prefs of sibligs: sibling[%i]: %s\n", i, pref.c_str()); + } + } +}; + +//############################################################################# + +/** Function objects to compare search tree nodes. The comparison function + must return true if the first argument is "better" than the second one, + i.e., it should be processed first. */ +/*@{*/ +/** Depth First Search. */ +struct CoinSearchTreeComparePreferred { + static inline const char* name() { return "CoinSearchTreeComparePreferred"; } + inline bool operator()(const CoinTreeSiblings* x, + const CoinTreeSiblings* y) const { + register const CoinTreeNode* xNode = x->currentNode(); + register const CoinTreeNode* yNode = y->currentNode(); + const BitVector128 xPref = xNode->getPreferred(); + const BitVector128 yPref = yNode->getPreferred(); + bool retval = true; + if (xPref < yPref) { + retval = true; + } else if (yPref < xPref) { + retval = false; + } else { + retval = xNode->getQuality() < yNode->getQuality(); + } +#ifdef DEBUG_PRINT + printf("Comparing xpref (%s) and ypref (%s) : %s\n", + xpref.str().c_str(), ypref.str().c_str(), retval ? "T" : "F"); +#endif + return retval; + } +}; + +//----------------------------------------------------------------------------- +/** Depth First Search. */ +struct CoinSearchTreeCompareDepth { + static inline const char* name() { return "CoinSearchTreeCompareDepth"; } + inline bool operator()(const CoinTreeSiblings* x, + const CoinTreeSiblings* y) const { +#if 1 + return x->currentNode()->getDepth() >= y->currentNode()->getDepth(); +#else + if(x->currentNode()->getDepth() > y->currentNode()->getDepth()) + return 1; + if(x->currentNode()->getDepth() == y->currentNode()->getDepth() && + x->currentNode()->getQuality() <= y->currentNode()->getQuality()) + return 1; + return 0; +#endif + } +}; + +//----------------------------------------------------------------------------- +/* Breadth First Search */ +struct CoinSearchTreeCompareBreadth { + static inline const char* name() { return "CoinSearchTreeCompareBreadth"; } + inline bool operator()(const CoinTreeSiblings* x, + const CoinTreeSiblings* y) const { + return x->currentNode()->getDepth() < y->currentNode()->getDepth(); + } +}; + +//----------------------------------------------------------------------------- +/** Best first search */ +struct CoinSearchTreeCompareBest { + static inline const char* name() { return "CoinSearchTreeCompareBest"; } + inline bool operator()(const CoinTreeSiblings* x, + const CoinTreeSiblings* y) const { + return x->currentNode()->getQuality() < y->currentNode()->getQuality(); + } +}; + +//############################################################################# + +class CoinSearchTreeBase +{ +private: + CoinSearchTreeBase(const CoinSearchTreeBase&); + CoinSearchTreeBase& operator=(const CoinSearchTreeBase&); + +protected: + std::vector<CoinTreeSiblings*> candidateList_; + int numInserted_; + int size_; + +protected: + CoinSearchTreeBase() : candidateList_(), numInserted_(0), size_(0) {} + + virtual void realpop() = 0; + virtual void realpush(CoinTreeSiblings* s) = 0; + virtual void fixTop() = 0; + +public: + virtual ~CoinSearchTreeBase() {} + virtual const char* compName() const = 0; + + inline const std::vector<CoinTreeSiblings*>& getCandidates() const { + return candidateList_; + } + inline bool empty() const { return candidateList_.empty(); } + inline int size() const { return size_; } + inline int numInserted() const { return numInserted_; } + inline CoinTreeNode* top() const { + if (size_ == 0 || candidateList_.size() == 0) + return NULL; +#ifdef DEBUG_PRINT + char output[44]; + output[43] = 0; + candidateList_.front()->currentNode()->getPreferred().print(output); + printf("top's pref: %s\n", output); +#endif + return candidateList_.front()->currentNode(); + } + /** pop will advance the \c next pointer among the siblings on the top and + then moves the top to its correct position. #realpop is the method + that actually removes the element from the heap */ + inline void pop() { + CoinTreeSiblings* s = candidateList_.front(); + if (!s->advanceNode()) { + realpop(); + delete s; + } else { + fixTop(); + } + --size_; + } + inline void push(int numNodes, CoinTreeNode** nodes, + const bool incrInserted = true) { + CoinTreeSiblings* s = new CoinTreeSiblings(numNodes, nodes); + realpush(s); + if (incrInserted) { + numInserted_ += numNodes; + } + size_ += numNodes; + } + inline void push(const CoinTreeSiblings& sib, + const bool incrInserted = true) { + CoinTreeSiblings* s = new CoinTreeSiblings(sib); +#ifdef DEBUG_PRINT + s->printPref(); +#endif + realpush(s); + if (incrInserted) { + numInserted_ += sib.toProcess(); + } + size_ += sib.toProcess(); + } +}; + +//############################################################################# + +// #define CAN_TRUST_STL_HEAP +#ifdef CAN_TRUST_STL_HEAP + +template <class Comp> +class CoinSearchTree : public CoinSearchTreeBase +{ +private: + Comp comp_; +protected: + virtual void realpop() { + candidateList_.pop_back(); + } + virtual void fixTop() { + CoinTreeSiblings* s = top(); + realpop(); + push(s, false); + } + virtual void realpush(CoinTreeSiblings* s) { + nodes_.push_back(s); + std::push_heap(candidateList_.begin(), candidateList_.end(), comp_); + } +public: + CoinSearchTree() : CoinSearchTreeBase(), comp_() {} + CoinSearchTree(const CoinSearchTreeBase& t) : + CoinSearchTreeBase(), comp_() { + candidateList_ = t.getCandidates(); + std::make_heap(candidateList_.begin(), candidateList_.end(), comp_); + numInserted_ = t.numInserted_; + size_ = t.size_; + } + ~CoinSearchTree() {} + const char* compName() const { return Comp::name(); } +}; + +#else + +template <class Comp> +class CoinSearchTree : public CoinSearchTreeBase +{ +private: + Comp comp_; + +protected: + virtual void realpop() { + candidateList_[0] = candidateList_.back(); + candidateList_.pop_back(); + fixTop(); + } + /** After changing data in the top node, fix the heap */ + virtual void fixTop() { + const size_t size = candidateList_.size(); + if (size > 1) { + CoinTreeSiblings** candidates = &candidateList_[0]; + CoinTreeSiblings* s = candidates[0]; + --candidates; + size_t pos = 1; + size_t ch; + for (ch = 2; ch < size; pos = ch, ch *= 2) { + if (comp_(candidates[ch+1], candidates[ch])) + ++ch; + if (comp_(s, candidates[ch])) + break; + candidates[pos] = candidates[ch]; + } + if (ch == size) { + if (comp_(candidates[ch], s)) { + candidates[pos] = candidates[ch]; + pos = ch; + } + } + candidates[pos] = s; + } + } + virtual void realpush(CoinTreeSiblings* s) { + candidateList_.push_back(s); + CoinTreeSiblings** candidates = &candidateList_[0]; + --candidates; + size_t pos = candidateList_.size(); + size_t ch; + for (ch = pos/2; ch != 0; pos = ch, ch /= 2) { + if (comp_(candidates[ch], s)) + break; + candidates[pos] = candidates[ch]; + } + candidates[pos] = s; + } + +public: + CoinSearchTree() : CoinSearchTreeBase(), comp_() {} + CoinSearchTree(const CoinSearchTreeBase& t) : + CoinSearchTreeBase(), comp_() { + candidateList_ = t.getCandidates(); + std::sort(candidateList_.begin(), candidateList_.end(), comp_); + numInserted_ = t.numInserted(); + size_ = t.size(); + } + virtual ~CoinSearchTree() {} + const char* compName() const { return Comp::name(); } +}; + +#endif + +//############################################################################# + +enum CoinNodeAction { + CoinAddNodeToCandidates, + CoinTestNodeForDiving, + CoinDiveIntoNode +}; + +class CoinSearchTreeManager +{ +private: + CoinSearchTreeManager(const CoinSearchTreeManager&); + CoinSearchTreeManager& operator=(const CoinSearchTreeManager&); +private: + CoinSearchTreeBase* candidates_; + int numSolution; + /** Whether there is an upper bound or not. The upper bound may have come + as input, not necessarily from a solution */ + bool hasUB_; + + /** variable used to test whether we need to reevaluate search strategy */ + bool recentlyReevaluatedSearchStrategy_; + +public: + CoinSearchTreeManager() : + candidates_(NULL), + numSolution(0), + recentlyReevaluatedSearchStrategy_(true) + {} + virtual ~CoinSearchTreeManager() { + delete candidates_; + } + + inline void setTree(CoinSearchTreeBase* t) { + delete candidates_; + candidates_ = t; + } + inline CoinSearchTreeBase* getTree() const { + return candidates_; + } + + inline bool empty() const { return candidates_->empty(); } + inline size_t size() const { return candidates_->size(); } + inline size_t numInserted() const { return candidates_->numInserted(); } + inline CoinTreeNode* top() const { return candidates_->top(); } + inline void pop() { candidates_->pop(); } + inline void push(CoinTreeNode* node, const bool incrInserted = true) { + candidates_->push(1, &node, incrInserted); + } + inline void push(const CoinTreeSiblings& s, const bool incrInserted=true) { + candidates_->push(s, incrInserted); + } + inline void push(const int n, CoinTreeNode** nodes, + const bool incrInserted = true) { + candidates_->push(n, nodes, incrInserted); + } + + inline CoinTreeNode* bestQualityCandidate() const { + return candidates_->top(); + } + inline double bestQuality() const { + return candidates_->top()->getQuality(); + } + void newSolution(double solValue); + void reevaluateSearchStrategy(); +}; + +//############################################################################# + +#endif diff --git a/thirdparty/windows/include/coin/CoinShallowPackedVector.hpp b/thirdparty/windows/include/coin/CoinShallowPackedVector.hpp new file mode 100644 index 0000000..07c1870 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinShallowPackedVector.hpp @@ -0,0 +1,148 @@ +/* $Id: CoinShallowPackedVector.hpp 1498 2011-11-02 15:25:35Z mjs $ */ +// 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 CoinShallowPackedVector_H +#define CoinShallowPackedVector_H + +#if defined(_MSC_VER) +// Turn off compiler warning about long names +# pragma warning(disable:4786) +#endif + +#include "CoinError.hpp" +#include "CoinPackedVectorBase.hpp" + +/** Shallow Sparse Vector + +This class is for sparse vectors where the indices and +elements are stored elsewhere. This class only maintains +pointers to the indices and elements. Since this class +does not own the index and element data it provides +read only access to to the data. An CoinSparsePackedVector +must be used when the sparse vector's data will be altered. + +This class stores pointers to the vectors. +It does not actually contain the vectors. + +Here is a sample usage: +@verbatim + const int ne = 4; + int inx[ne] = { 1, 4, 0, 2 }; + double el[ne] = { 10., 40., 1., 50. }; + + // Create vector and set its value + CoinShallowPackedVector r(ne,inx,el); + + // access each index and element + assert( r.indices ()[0]== 1 ); + assert( r.elements()[0]==10. ); + assert( r.indices ()[1]== 4 ); + assert( r.elements()[1]==40. ); + assert( r.indices ()[2]== 0 ); + assert( r.elements()[2]== 1. ); + assert( r.indices ()[3]== 2 ); + assert( r.elements()[3]==50. ); + + // access as a full storage vector + assert( r[ 0]==1. ); + assert( r[ 1]==10.); + assert( r[ 2]==50.); + assert( r[ 3]==0. ); + assert( r[ 4]==40.); + + // Tests for equality and equivalence + CoinShallowPackedVector r1; + r1=r; + assert( r==r1 ); + r.sort(CoinIncrElementOrdered()); + assert( r!=r1 ); + + // Add packed vectors. + // Similarly for subtraction, multiplication, + // and division. + CoinPackedVector add = r + r1; + assert( add[0] == 1.+ 1. ); + assert( add[1] == 10.+10. ); + assert( add[2] == 50.+50. ); + assert( add[3] == 0.+ 0. ); + assert( add[4] == 40.+40. ); + assert( r.sum() == 10.+40.+1.+50. ); +@endverbatim +*/ +class CoinShallowPackedVector : public CoinPackedVectorBase { + friend void CoinShallowPackedVectorUnitTest(); + +public: + + /**@name Get methods */ + //@{ + /// Get length of indices and elements vectors + virtual int getNumElements() const { return nElements_; } + /// Get indices of elements + virtual const int * getIndices() const { return indices_; } + /// Get element values + virtual const double * getElements() const { return elements_; } + //@} + + /**@name Set methods */ + //@{ + /// Reset the vector (as if were just created an empty vector) + void clear(); + /** Assignment operator. */ + CoinShallowPackedVector& operator=(const CoinShallowPackedVector & x); + /** Assignment operator from a CoinPackedVectorBase. */ + CoinShallowPackedVector& operator=(const CoinPackedVectorBase & x); + /** just like the explicit constructor */ + void setVector(int size, const int * indices, const double * elements, + bool testForDuplicateIndex = true); + //@} + + /**@name Methods to create, set and destroy */ + //@{ + /** Default constructor. */ + CoinShallowPackedVector(bool testForDuplicateIndex = true); + /** Explicit Constructor. + Set vector size, indices, and elements. Size is the length of both the + indices and elements vectors. The indices and elements vectors are not + copied into this class instance. The ShallowPackedVector only maintains + the pointers to the indices and elements vectors. <br> + The last argument specifies whether the creator of the object knows in + advance that there are no duplicate indices. + */ + CoinShallowPackedVector(int size, + const int * indices, const double * elements, + bool testForDuplicateIndex = true); + /** Copy constructor from the base class. */ + CoinShallowPackedVector(const CoinPackedVectorBase &); + /** Copy constructor. */ + CoinShallowPackedVector(const CoinShallowPackedVector &); + /** Destructor. */ + virtual ~CoinShallowPackedVector() {} + /// Print vector information. + void print(); + //@} + +private: + /**@name Private member data */ + //@{ + /// Vector indices + const int * indices_; + ///Vector elements + const double * elements_; + /// Size of indices and elements vectors + int nElements_; + //@} +}; + +//############################################################################# +/** A function that tests the methods in the CoinShallowPackedVector 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 +CoinShallowPackedVectorUnitTest(); + +#endif diff --git a/thirdparty/windows/include/coin/CoinSignal.hpp b/thirdparty/windows/include/coin/CoinSignal.hpp new file mode 100644 index 0000000..2bbf0d0 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinSignal.hpp @@ -0,0 +1,117 @@ +/* $Id: CoinSignal.hpp 1810 2015-03-13 20:16:34Z tkr $ */ +// 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 _CoinSignal_hpp +#define _CoinSignal_hpp + +// This file is fully docified. +// There's nothing to docify... + +//############################################################################# + +#include <csignal> + +//############################################################################# + +#if defined(_MSC_VER) + typedef void (__cdecl *CoinSighandler_t) (int); +# define CoinSighandler_t_defined +#endif + +//----------------------------------------------------------------------------- + +#if (defined(__GNUC__) && defined(__linux__)) + typedef sighandler_t CoinSighandler_t; +# define CoinSighandler_t_defined +#endif + +//----------------------------------------------------------------------------- + +#if defined(__CYGWIN__) && defined(__GNUC__) + typedef __decltype(SIG_DFL) CoinSighandler_t; +# define CoinSighandler_t_defined +#endif + +//----------------------------------------------------------------------------- + +#if defined(__MINGW32__) && defined(__GNUC__) + typedef __decltype(SIG_DFL) CoinSighandler_t; +# define CoinSighandler_t_defined +#endif + +//----------------------------------------------------------------------------- + +#if defined(__FreeBSD__) && defined(__GNUC__) + typedef __decltype(SIG_DFL) CoinSighandler_t; +# define CoinSighandler_t_defined +#endif + +//----------------------------------------------------------------------------- + +#if defined(__NetBSD__) && defined(__GNUC__) + typedef __decltype(SIG_DFL) CoinSighandler_t; +# define CoinSighandler_t_defined +#endif + +//----------------------------------------------------------------------------- + +#if defined(_AIX) +# if defined(__GNUC__) + typedef __decltype(SIG_DFL) CoinSighandler_t; +# define CoinSighandler_t_defined +# endif +#endif + +//----------------------------------------------------------------------------- + +#if defined (__hpux) +# define CoinSighandler_t_defined +# if defined(__GNUC__) + typedef __decltype(SIG_DFL) CoinSighandler_t; +# else + extern "C" { + typedef void (*CoinSighandler_t) (int); + } +# endif +#endif + +//----------------------------------------------------------------------------- + +#if defined(__sun) +# if defined(__SUNPRO_CC) +# include <signal.h> + extern "C" { + typedef void (*CoinSighandler_t) (int); + } +# define CoinSighandler_t_defined +# endif +# if defined(__GNUC__) + typedef __decltype(SIG_DFL) CoinSighandler_t; +# define CoinSighandler_t_defined +# endif +#endif + +//----------------------------------------------------------------------------- + +#if defined(__MACH__) && defined(__GNUC__) +typedef __decltype(SIG_DFL) CoinSighandler_t; +# define CoinSighandler_t_defined +#endif + +//############################################################################# + +#ifndef CoinSighandler_t_defined +# warning("OS and/or compiler is not recognized. Defaulting to:"); +# warning("extern 'C' {") +# warning(" typedef void (*CoinSighandler_t) (int);") +# warning("}") + extern "C" { + typedef void (*CoinSighandler_t) (int); + } +#endif + +//############################################################################# + +#endif diff --git a/thirdparty/windows/include/coin/CoinSimpFactorization.hpp b/thirdparty/windows/include/coin/CoinSimpFactorization.hpp new file mode 100644 index 0000000..242b6cd --- /dev/null +++ b/thirdparty/windows/include/coin/CoinSimpFactorization.hpp @@ -0,0 +1,431 @@ +/* $Id: CoinSimpFactorization.hpp 1416 2011-04-17 09:57:29Z 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). + +/* + This is a simple factorization of the LP Basis + */ +#ifndef CoinSimpFactorization_H +#define CoinSimpFactorization_H + +#include <iostream> +#include <string> +#include <cassert> +#include "CoinTypes.hpp" +#include "CoinIndexedVector.hpp" +#include "CoinDenseFactorization.hpp" +class CoinPackedMatrix; + + +/// pointers used during factorization +class FactorPointers{ +public: + double *rowMax; + int *firstRowKnonzeros; + int *prevRow; + int *nextRow; + int *firstColKnonzeros; + int *prevColumn; + int *nextColumn; + int *newCols; + //constructor + FactorPointers( int numRows, int numCols, int *UrowLengths_, int *UcolLengths_ ); + // destructor + ~ FactorPointers(); +}; + +class CoinSimpFactorization : public CoinOtherFactorization { + friend void CoinSimpFactorizationUnitTest( const std::string & mpsDir ); + +public: + + /**@name Constructors and destructor and copy */ + //@{ + /// Default constructor + CoinSimpFactorization ( ); + /// Copy constructor + CoinSimpFactorization ( const CoinSimpFactorization &other); + + /// Destructor + virtual ~CoinSimpFactorization ( ); + /// = copy + CoinSimpFactorization & operator = ( const CoinSimpFactorization & other ); + /// Clone + virtual CoinOtherFactorization * clone() const ; + //@} + + /**@name Do factorization - public */ + //@{ + /// Gets space for a factorization + virtual void getAreas ( int numberRows, + int numberColumns, + CoinBigIndex maximumL, + CoinBigIndex maximumU ); + + /// PreProcesses column ordered copy of basis + virtual void preProcess ( ); + /** Does most of factorization returning status + 0 - OK + -99 - needs more memory + -1 - singular - use numberGoodColumns and redo + */ + virtual int factor ( ); + /// Does post processing on valid factorization - putting variables on correct rows + virtual void postProcess(const int * sequence, int * pivotVariable); + /// Makes a non-singular basis by replacing variables + virtual void makeNonSingular(int * sequence, int numberColumns); + //@} + + /**@name general stuff such as status */ + //@{ + /// Total number of elements in factorization + virtual inline int numberElements ( ) const { + return numberRows_*(numberColumns_+numberPivots_); + } + /// Returns maximum absolute value in factorization + double maximumCoefficient() const; + //@} + + /**@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 */ + virtual int replaceColumn ( CoinIndexedVector * regionSparse, + 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 regionSparse2 + Tries to do FT update + number returned is negative if no room + regionSparse starts as zero and is zero at end. + Note - if regionSparse2 packed on input - will be packed on output + */ + + virtual int updateColumnFT ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2, + bool noPermute=false); + + /** This version has same effect as above with FTUpdate==false + so number returned is always >=0 */ + virtual int updateColumn ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2, + bool noPermute=false) const; + /// does FTRAN on two columns + virtual int updateTwoColumnsFT(CoinIndexedVector * regionSparse1, + CoinIndexedVector * regionSparse2, + CoinIndexedVector * regionSparse3, + bool noPermute=false); + /// does updatecolumn if save==true keeps column for replace column + int upColumn ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2, + bool noPermute=false, bool save=false) const; + /** Updates one column (BTRAN) from regionSparse2 + regionSparse starts as zero and is zero at end + Note - if regionSparse2 packed on input - will be packed on output + */ + virtual int updateColumnTranspose ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2) const; + /// does updateColumnTranspose, the other is a wrapper + int upColumnTranspose ( CoinIndexedVector * regionSparse, + CoinIndexedVector * regionSparse2) const; + //@} + /// *** Below this user may not want to know about + + /**@name various uses of factorization + which user may not want to know about (left over from my LP code) */ + //@{ + /// Get rid of all memory + inline void clearArrays() + { gutsOfDestructor();} + /// Returns array to put basis indices in + inline int * indices() const + { return reinterpret_cast<int *> (elements_+numberRows_*numberRows_);} + /// Returns permute in + virtual inline int * permute() const + { return pivotRow_;} + //@} + + /// The real work of destructor + void gutsOfDestructor(); + /// The real work of constructor + void gutsOfInitialize(); + /// The real work of copy + void gutsOfCopy(const CoinSimpFactorization &other); + + + /// calls factorization + void factorize(int numberOfRows, + int numberOfColumns, + const int colStarts[], + const int indicesRow[], + const double elements[]); + /// main loop of factorization + int mainLoopFactor (FactorPointers &pointers ); + /// copies L by rows + void copyLbyRows(); + /// copies U by columns + void copyUbyColumns(); + /// finds a pivot element using Markowitz count + int findPivot(FactorPointers &pointers, int &r, int &s, bool &ifSlack); + /// finds a pivot in a shortest column + int findPivotShCol(FactorPointers &pointers, int &r, int &s); + /// finds a pivot in the first column available + int findPivotSimp(FactorPointers &pointers, int &r, int &s); + /// does Gauss elimination + void GaussEliminate(FactorPointers &pointers, int &r, int &s); + /// finds short row that intersects a given column + int findShortRow(const int column, const int length, int &minRow, + int &minRowLength, FactorPointers &pointers); + /// finds short column that intersects a given row + int findShortColumn(const int row, const int length, int &minCol, + int &minColLength, FactorPointers &pointers); + /// finds maximum absolute value in a row + double findMaxInRrow(const int row, FactorPointers &pointers); + /// does pivoting + void pivoting(const int pivotRow, const int pivotColumn, + const double invPivot, FactorPointers &pointers); + /// part of pivoting + void updateCurrentRow(const int pivotRow, const int row, + const double multiplier, FactorPointers &pointers, + int &newNonZeros); + /// allocates more space for L + void increaseLsize(); + /// allocates more space for a row of U + void increaseRowSize(const int row, const int newSize); + /// allocates more space for a column of U + void increaseColSize(const int column, const int newSize, const bool b); + /// allocates more space for rows of U + void enlargeUrow(const int numNewElements); + /// allocates more space for columns of U + void enlargeUcol(const int numNewElements, const bool b); + /// finds a given row in a column + int findInRow(const int row, const int column); + /// finds a given column in a row + int findInColumn(const int column, const int row); + /// declares a row inactive + void removeRowFromActSet(const int row, FactorPointers &pointers); + /// declares a column inactive + void removeColumnFromActSet(const int column, FactorPointers &pointers); + /// allocates space for U + void allocateSpaceForU(); + /// allocates several working arrays + void allocateSomeArrays(); + /// initializes some numbers + void initialSomeNumbers(); + /// solves L x = b + void Lxeqb(double *b) const; + /// same as above but with two rhs + void Lxeqb2(double *b1, double *b2) const; + /// solves U x = b + void Uxeqb(double *b, double *sol) const; + /// same as above but with two rhs + void Uxeqb2(double *b1, double *sol1, double *sol2, double *b2) const; + /// solves x L = b + void xLeqb(double *b) const; + /// solves x U = b + void xUeqb(double *b, double *sol) const; + /// updates factorization after a Simplex iteration + int LUupdate(int newBasicCol); + /// creates a new eta vector + void newEta(int row, int numNewElements); + /// makes a copy of row permutations + void copyRowPermutations(); + /// solves H x = b, where H is a product of eta matrices + void Hxeqb(double *b) const; + /// same as above but with two rhs + void Hxeqb2(double *b1, double *b2) const; + /// solves x H = b + void xHeqb(double *b) const; + /// does FTRAN + void ftran(double *b, double *sol, bool save) const; + /// same as above but with two columns + void ftran2(double *b1, double *sol1, double *b2, double *sol2) const; + /// does BTRAN + void btran(double *b, double *sol) const; + ///--------------------------------------- + + + + //@} +protected: + /** Returns accuracy status of replaceColumn + returns 0=OK, 1=Probably OK, 2=singular */ + int checkPivot(double saveFromU, double oldPivot) const; +////////////////// data ////////////////// +protected: + + /**@name data */ + //@{ + /// work array (should be initialized to zero) + double *denseVector_; + /// work array + double *workArea2_; + /// work array + double *workArea3_; + /// array of labels (should be initialized to zero) + int *vecLabels_; + /// array of indices + int *indVector_; + + /// auxiliary vector + double *auxVector_; + /// auxiliary vector + int *auxInd_; + + /// vector to keep for LUupdate + double *vecKeep_; + /// indices of this vector + int *indKeep_; + /// number of nonzeros + mutable int keepSize_; + + + + /// Starts of the rows of L + int *LrowStarts_; + /// Lengths of the rows of L + int *LrowLengths_; + /// L by rows + double *Lrows_; + /// indices in the rows of L + int *LrowInd_; + /// Size of Lrows_; + int LrowSize_; + /// Capacity of Lrows_ + int LrowCap_; + + /// Starts of the columns of L + int *LcolStarts_; + /// Lengths of the columns of L + int *LcolLengths_; + /// L by columns + double *Lcolumns_; + /// indices in the columns of L + int *LcolInd_; + /// numbers of elements in L + int LcolSize_; + /// maximum capacity of L + int LcolCap_; + + + /// Starts of the rows of U + int *UrowStarts_; + /// Lengths of the rows of U + int *UrowLengths_; +#ifdef COIN_SIMP_CAPACITY + /// Capacities of the rows of U + int *UrowCapacities_; +#endif + /// U by rows + double *Urows_; + /// Indices in the rows of U + int *UrowInd_; + /// maximum capacity of Urows + int UrowMaxCap_; + /// number of used places in Urows + int UrowEnd_; + /// first row in U + int firstRowInU_; + /// last row in U + int lastRowInU_; + /// previous row in U + int *prevRowInU_; + /// next row in U + int *nextRowInU_; + + /// Starts of the columns of U + int *UcolStarts_; + /// Lengths of the columns of U + int *UcolLengths_; +#ifdef COIN_SIMP_CAPACITY + /// Capacities of the columns of U + int *UcolCapacities_; +#endif + /// U by columns + double *Ucolumns_; + /// Indices in the columns of U + int *UcolInd_; + /// previous column in U + int *prevColInU_; + /// next column in U + int *nextColInU_; + /// first column in U + int firstColInU_; + /// last column in U + int lastColInU_; + /// maximum capacity of Ucolumns_ + int UcolMaxCap_; + /// last used position in Ucolumns_ + int UcolEnd_; + /// indicator of slack variables + int *colSlack_; + + /// inverse values of the elements of diagonal of U + double *invOfPivots_; + + /// permutation of columns + int *colOfU_; + /// position of column after permutation + int *colPosition_; + /// permutations of rows + int *rowOfU_; + /// position of row after permutation + int *rowPosition_; + /// permutations of rows during LUupdate + int *secRowOfU_; + /// position of row after permutation during LUupdate + int *secRowPosition_; + + /// position of Eta vector + int *EtaPosition_; + /// Starts of eta vectors + int *EtaStarts_; + /// Lengths of eta vectors + int *EtaLengths_; + /// columns of eta vectors + int *EtaInd_; + /// elements of eta vectors + double *Eta_; + /// number of elements in Eta_ + int EtaSize_; + /// last eta row + int lastEtaRow_; + /// maximum number of eta vectors + int maxEtaRows_; + /// Capacity of Eta_ + int EtaMaxCap_; + + /// minimum storage increase + int minIncrease_; + /// maximum size for the diagonal of U after update + double updateTol_; + /// do Shul heuristic + bool doSuhlHeuristic_; + /// maximum of U + double maxU_; + /// bound on the growth rate + double maxGrowth_; + /// maximum of A + double maxA_; + /// maximum number of candidates for pivot + int pivotCandLimit_; + /// number of slacks in basis + int numberSlacks_; + /// number of slacks in irst basis + int firstNumberSlacks_; + //@} +}; +#endif diff --git a/thirdparty/windows/include/coin/CoinSmartPtr.hpp b/thirdparty/windows/include/coin/CoinSmartPtr.hpp new file mode 100644 index 0000000..93366a2 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinSmartPtr.hpp @@ -0,0 +1,528 @@ +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Eclipse Public License. +// +// $Id: CoinSmartPtr.hpp 1520 2012-01-29 00:43:31Z tkr $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 +// Removed lots of debugging stuff and reformatted: Laszlo Ladanyi, IBM +#ifndef CoinSmartPtr_hpp +#define CoinSmartPtr_hpp + +#include <list> +#include <cassert> +#include <cstddef> +#include <cstring> + +namespace Coin { + + //######################################################################### + + /** ReferencedObject class. + * This is part of the implementation of an intrusive smart pointer + * design. This class stores the reference count of all the smart + * pointers that currently reference it. See the documentation for + * the SmartPtr class for more details. + * + * A SmartPtr behaves much like a raw pointer, but manages the lifetime + * of an object, deleting the object automatically. This class implements + * a reference-counting, intrusive smart pointer design, where all + * objects pointed to must inherit off of ReferencedObject, which + * stores the reference count. Although this is intrusive (native types + * and externally authored classes require wrappers to be referenced + * by smart pointers), it is a safer design. A more detailed discussion of + * these issues follows after the usage information. + * + * Usage Example: + * Note: to use the SmartPtr, all objects to which you point MUST + * inherit off of ReferencedObject. + * + * \verbatim + * + * In MyClass.hpp... + * + * #include "CoinSmartPtr.hpp" + + * + * class MyClass : public Coin::ReferencedObject // must derive from ReferencedObject + * { + * ... + * } + * + * In my_usage.cpp... + * + * #include "CoinSmartPtr.hpp" + * #include "MyClass.hpp" + * + * void func(AnyObject& obj) + * { + * Coin::SmartPtr<MyClass> ptr_to_myclass = new MyClass(...); + * // ptr_to_myclass now points to a new MyClass, + * // and the reference count is 1 + * + * ... + * + * obj.SetMyClass(ptr_to_myclass); + * // Here, let's assume that AnyObject uses a + * // SmartPtr<MyClass> internally here. + * // Now, both ptr_to_myclass and the internal + * // SmartPtr in obj point to the same MyClass object + * // and its reference count is 2. + * + * ... + * + * // No need to delete ptr_to_myclass, this + * // will be done automatically when the + * // reference count drops to zero. + * + * } + * + * \endverbatim + * + * Other Notes: + * The SmartPtr implements both dereference operators -> & *. + * The SmartPtr does NOT implement a conversion operator to + * the raw pointer. Use the GetRawPtr() method when this + * is necessary. Make sure that the raw pointer is NOT + * deleted. + * The SmartPtr implements the comparison operators == & != + * for a variety of types. Use these instead of + * \verbatim + * if (GetRawPtr(smrt_ptr) == ptr) // Don't use this + * \endverbatim + * SmartPtr's, as currently implemented, do NOT handle circular references. + * For example: consider a higher level object using SmartPtrs to point + * to A and B, but A and B also point to each other (i.e. A has a + * SmartPtr to B and B has a SmartPtr to A). In this scenario, when the + * higher level object is finished with A and B, their reference counts + * will never drop to zero (since they reference each other) and they + * will not be deleted. This can be detected by memory leak tools like + * valgrind. If the circular reference is necessary, the problem can be + * overcome by a number of techniques: + * + * 1) A and B can have a method that "releases" each other, that is + * they set their internal SmartPtrs to NULL. + * \verbatim + * void AClass::ReleaseCircularReferences() + * { + * smart_ptr_to_B = NULL; + * } + * \endverbatim + * Then, the higher level class can call these methods before + * it is done using A & B. + * + * 2) Raw pointers can be used in A and B to reference each other. + * Here, an implicit assumption is made that the lifetime is + * controlled by the higher level object and that A and B will + * both exist in a controlled manner. Although this seems + * dangerous, in many situations, this type of referencing + * is very controlled and this is reasonably safe. + * + * 3) This SmartPtr class could be redesigned with the Weak/Strong + * design concept. Here, the SmartPtr is identified as being + * Strong (controls lifetime of the object) or Weak (merely + * referencing the object). The Strong SmartPtr increments + * (and decrements) the reference count in ReferencedObject + * but the Weak SmartPtr does not. In the example above, + * the higher level object would have Strong SmartPtrs to + * A and B, but A and B would have Weak SmartPtrs to each + * other. Then, when the higher level object was done with + * A and B, they would be deleted. The Weak SmartPtrs in A + * and B would not decrement the reference count and would, + * of course, not delete the object. This idea is very similar + * to item (2), where it is implied that the sequence of events + * is controlled such that A and B will not call anything using + * their pointers following the higher level delete (i.e. in + * their destructors!). This is somehow safer, however, because + * code can be written (however expensive) to perform run-time + * detection of this situation. For example, the ReferencedObject + * could store pointers to all Weak SmartPtrs that are referencing + * it and, in its destructor, tell these pointers that it is + * dying. They could then set themselves to NULL, or set an + * internal flag to detect usage past this point. + * + * Comments on Non-Intrusive Design: + * In a non-intrusive design, the reference count is stored somewhere other + * than the object being referenced. This means, unless the reference + * counting pointer is the first referencer, it must get a pointer to the + * referenced object from another smart pointer (so it has access to the + * reference count location). In this non-intrusive design, if we are + * pointing to an object with a smart pointer (or a number of smart + * pointers), and we then give another smart pointer the address through + * a RAW pointer, we will have two independent, AND INCORRECT, reference + * counts. To avoid this pitfall, we use an intrusive reference counting + * technique where the reference count is stored in the object being + * referenced. + */ + class ReferencedObject { + public: + ReferencedObject() : reference_count_(0) {} + virtual ~ReferencedObject() { assert(reference_count_ == 0); } + inline int ReferenceCount() const { return reference_count_; } + inline void AddRef() const { ++reference_count_; } + inline void ReleaseRef() const { --reference_count_; } + + private: + mutable int reference_count_; + }; + + //######################################################################### + + +//#define IP_DEBUG_SMARTPTR +#if COIN_IPOPT_CHECKLEVEL > 2 +# define IP_DEBUG_SMARTPTR +#endif +#ifdef IP_DEBUG_SMARTPTR +# include "IpDebug.hpp" +#endif + + /** Template class for Smart Pointers. + * A SmartPtr behaves much like a raw pointer, but manages the lifetime + * of an object, deleting the object automatically. This class implements + * a reference-counting, intrusive smart pointer design, where all + * objects pointed to must inherit off of ReferencedObject, which + * stores the reference count. Although this is intrusive (native types + * and externally authored classes require wrappers to be referenced + * by smart pointers), it is a safer design. A more detailed discussion of + * these issues follows after the usage information. + * + * Usage Example: + * Note: to use the SmartPtr, all objects to which you point MUST + * inherit off of ReferencedObject. + * + * \verbatim + * + * In MyClass.hpp... + * + * #include "CoinSmartPtr.hpp" + * + * class MyClass : public Coin::ReferencedObject // must derive from ReferencedObject + * { + * ... + * } + * + * In my_usage.cpp... + * + * #include "CoinSmartPtr.hpp" + * #include "MyClass.hpp" + * + * void func(AnyObject& obj) + * { + * SmartPtr<MyClass> ptr_to_myclass = new MyClass(...); + * // ptr_to_myclass now points to a new MyClass, + * // and the reference count is 1 + * + * ... + * + * obj.SetMyClass(ptr_to_myclass); + * // Here, let's assume that AnyObject uses a + * // SmartPtr<MyClass> internally here. + * // Now, both ptr_to_myclass and the internal + * // SmartPtr in obj point to the same MyClass object + * // and its reference count is 2. + * + * ... + * + * // No need to delete ptr_to_myclass, this + * // will be done automatically when the + * // reference count drops to zero. + * + * } + * + * \endverbatim + * + * It is not necessary to use SmartPtr's in all cases where an + * object is used that has been allocated "into" a SmartPtr. It is + * possible to just pass objects by reference or regular pointers, + * even if lower down in the stack a SmartPtr is to be held on to. + * Everything should work fine as long as a pointer created by "new" + * is immediately passed into a SmartPtr, and if SmartPtr's are used + * to hold on to objects. + * + * Other Notes: + * The SmartPtr implements both dereference operators -> & *. + * The SmartPtr does NOT implement a conversion operator to + * the raw pointer. Use the GetRawPtr() method when this + * is necessary. Make sure that the raw pointer is NOT + * deleted. + * The SmartPtr implements the comparison operators == & != + * for a variety of types. Use these instead of + * \verbatim + * if (GetRawPtr(smrt_ptr) == ptr) // Don't use this + * \endverbatim + * SmartPtr's, as currently implemented, do NOT handle circular references. + * For example: consider a higher level object using SmartPtrs to point to + * A and B, but A and B also point to each other (i.e. A has a SmartPtr + * to B and B has a SmartPtr to A). In this scenario, when the higher + * level object is finished with A and B, their reference counts will + * never drop to zero (since they reference each other) and they + * will not be deleted. This can be detected by memory leak tools like + * valgrind. If the circular reference is necessary, the problem can be + * overcome by a number of techniques: + * + * 1) A and B can have a method that "releases" each other, that is + * they set their internal SmartPtrs to NULL. + * \verbatim + * void AClass::ReleaseCircularReferences() + * { + * smart_ptr_to_B = NULL; + * } + * \endverbatim + * Then, the higher level class can call these methods before + * it is done using A & B. + * + * 2) Raw pointers can be used in A and B to reference each other. + * Here, an implicit assumption is made that the lifetime is + * controlled by the higher level object and that A and B will + * both exist in a controlled manner. Although this seems + * dangerous, in many situations, this type of referencing + * is very controlled and this is reasonably safe. + * + * 3) This SmartPtr class could be redesigned with the Weak/Strong + * design concept. Here, the SmartPtr is identified as being + * Strong (controls lifetime of the object) or Weak (merely + * referencing the object). The Strong SmartPtr increments + * (and decrements) the reference count in ReferencedObject + * but the Weak SmartPtr does not. In the example above, + * the higher level object would have Strong SmartPtrs to + * A and B, but A and B would have Weak SmartPtrs to each + * other. Then, when the higher level object was done with + * A and B, they would be deleted. The Weak SmartPtrs in A + * and B would not decrement the reference count and would, + * of course, not delete the object. This idea is very similar + * to item (2), where it is implied that the sequence of events + * is controlled such that A and B will not call anything using + * their pointers following the higher level delete (i.e. in + * their destructors!). This is somehow safer, however, because + * code can be written (however expensive) to perform run-time + * detection of this situation. For example, the ReferencedObject + * could store pointers to all Weak SmartPtrs that are referencing + * it and, in its destructor, tell these pointers that it is + * dying. They could then set themselves to NULL, or set an + * internal flag to detect usage past this point. + * + * Comments on Non-Intrusive Design: + * In a non-intrusive design, the reference count is stored somewhere other + * than the object being referenced. This means, unless the reference + * counting pointer is the first referencer, it must get a pointer to the + * referenced object from another smart pointer (so it has access to the + * reference count location). In this non-intrusive design, if we are + * pointing to an object with a smart pointer (or a number of smart + * pointers), and we then give another smart pointer the address through + * a RAW pointer, we will have two independent, AND INCORRECT, reference + * counts. To avoid this pitfall, we use an intrusive reference counting + * technique where the reference count is stored in the object being + * referenced. + */ + template <class T> + class SmartPtr { + public: + /** Returns the raw pointer contained. Use to get the value of the + * raw ptr (i.e. to pass to other methods/functions, etc.) Note: This + * method does NOT copy, therefore, modifications using this value + * modify the underlying object contained by the SmartPtr, NEVER + * delete this returned value. + */ + T* GetRawPtr() const { return ptr_; } + + /** Returns true if the SmartPtr is NOT NULL. + * Use this to check if the SmartPtr is not null + * This is preferred to if(GetRawPtr(sp) != NULL) + */ + bool IsValid() const { return ptr_ != NULL; } + + /** Returns true if the SmartPtr is NULL. + * Use this to check if the SmartPtr IsNull. + * This is preferred to if(GetRawPtr(sp) == NULL) + */ + bool IsNull() const { return ptr_ == NULL; } + + private: + /**@name Private Data/Methods */ + //@{ + /** Actual raw pointer to the object. */ + T* ptr_; + + /** Release the currently referenced object. */ + void ReleasePointer_() { + if (ptr_) { + ptr_->ReleaseRef(); + if (ptr_->ReferenceCount() == 0) { + delete ptr_; + } + ptr_ = NULL; + } + } + + /** Set the value of the internal raw pointer from another raw + * pointer, releasing the previously referenced object if necessary. */ + SmartPtr<T>& SetFromRawPtr_(T* rhs){ + ReleasePointer_(); // Release any old pointer + if (rhs != NULL) { + rhs->AddRef(); + ptr_ = rhs; + } + return *this; + } + + /** Set the value of the internal raw pointer from a SmartPtr, + * releasing the previously referenced object if necessary. */ + inline SmartPtr<T>& SetFromSmartPtr_(const SmartPtr<T>& rhs) { + SetFromRawPtr_(rhs.GetRawPtr()); + return (*this); + } + + //@} + + public: +#define dbg_smartptr_verbosity 0 + + /**@name Constructors/Destructors */ + //@{ + /** Default constructor, initialized to NULL */ + SmartPtr() : ptr_(NULL) {} + + /** Copy constructor, initialized from copy */ + SmartPtr(const SmartPtr<T>& copy) : ptr_(NULL) { + (void) SetFromSmartPtr_(copy); + } + + /** Constructor, initialized from T* ptr */ + SmartPtr(T* ptr) : ptr_(NULL) { + (void) SetFromRawPtr_(ptr); + } + + /** Destructor, automatically decrements the reference count, deletes + * the object if necessary.*/ + ~SmartPtr() { + ReleasePointer_(); + } + //@} + + /**@name Overloaded operators. */ + //@{ + /** Overloaded arrow operator, allows the user to call + * methods using the contained pointer. */ + T* operator->() const { +#if COIN_COINUTILS_CHECKLEVEL > 0 + assert(ptr_); +#endif + return ptr_; + } + + /** Overloaded dereference operator, allows the user + * to dereference the contained pointer. */ + T& operator*() const { +#if COIN_IPOPT_CHECKLEVEL > 0 + assert(ptr_); +#endif + return *ptr_; + } + + /** Overloaded equals operator, allows the user to + * set the value of the SmartPtr from a raw pointer */ + SmartPtr<T>& operator=(T* rhs) { + return SetFromRawPtr_(rhs); + } + + /** Overloaded equals operator, allows the user to + * set the value of the SmartPtr from another + * SmartPtr */ + SmartPtr<T>& operator=(const SmartPtr<T>& rhs) { + return SetFromSmartPtr_(rhs); + } + + /** Overloaded equality comparison operator, allows the + * user to compare the value of two SmartPtrs */ + template <class U1, class U2> + friend + bool operator==(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs); + + /** Overloaded equality comparison operator, allows the + * user to compare the value of a SmartPtr with a raw pointer. */ + template <class U1, class U2> + friend + bool operator==(const SmartPtr<U1>& lhs, U2* raw_rhs); + + /** Overloaded equality comparison operator, allows the + * user to compare the value of a raw pointer with a SmartPtr. */ + template <class U1, class U2> + friend + bool operator==(U1* lhs, const SmartPtr<U2>& raw_rhs); + + /** Overloaded in-equality comparison operator, allows the + * user to compare the value of two SmartPtrs */ + template <class U1, class U2> + friend + bool operator!=(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs); + + /** Overloaded in-equality comparison operator, allows the + * user to compare the value of a SmartPtr with a raw pointer. */ + template <class U1, class U2> + friend + bool operator!=(const SmartPtr<U1>& lhs, U2* raw_rhs); + + /** Overloaded in-equality comparison operator, allows the + * user to compare the value of a SmartPtr with a raw pointer. */ + template <class U1, class U2> + friend + bool operator!=(U1* lhs, const SmartPtr<U2>& raw_rhs); + //@} + + }; + + template <class U1, class U2> + bool ComparePointers(const U1* lhs, const U2* rhs) { + if (lhs == rhs) { + return true; + } + // If lhs and rhs point to the same object with different interfaces + // U1 and U2, we cannot guarantee that the value of the pointers will + // be equivalent. We can guarantee this if we convert to void*. + return static_cast<const void*>(lhs) == static_cast<const void*>(rhs); + } + +} // namespace Coin + +//############################################################################# + +/**@name SmartPtr friends that are overloaded operators, so they are not in + the Coin namespace. */ +//@{ +template <class U1, class U2> +bool operator==(const Coin::SmartPtr<U1>& lhs, const Coin::SmartPtr<U2>& rhs) { + return Coin::ComparePointers(lhs.GetRawPtr(), rhs.GetRawPtr()); +} + +template <class U1, class U2> +bool operator==(const Coin::SmartPtr<U1>& lhs, U2* raw_rhs) { + return Coin::ComparePointers(lhs.GetRawPtr(), raw_rhs); +} + +template <class U1, class U2> +bool operator==(U1* raw_lhs, const Coin::SmartPtr<U2>& rhs) { + return Coin::ComparePointers(raw_lhs, rhs.GetRawPtr()); +} + +template <class U1, class U2> +bool operator!=(const Coin::SmartPtr<U1>& lhs, const Coin::SmartPtr<U2>& rhs) { + return ! operator==(lhs, rhs); +} + +template <class U1, class U2> +bool operator!=(const Coin::SmartPtr<U1>& lhs, U2* raw_rhs) { + return ! operator==(lhs, raw_rhs); +} + +template <class U1, class U2> +bool operator!=(U1* raw_lhs, const Coin::SmartPtr<U2>& rhs) { + return ! operator==(raw_lhs, rhs); +} +//@} + +#define CoinReferencedObject Coin::ReferencedObject +#define CoinSmartPtr Coin::SmartPtr +#define CoinComparePointers Coin::ComparePointers + +#endif diff --git a/thirdparty/windows/include/coin/CoinSnapshot.hpp b/thirdparty/windows/include/coin/CoinSnapshot.hpp new file mode 100644 index 0000000..e928026 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinSnapshot.hpp @@ -0,0 +1,476 @@ +/* $Id: CoinSnapshot.hpp 1416 2011-04-17 09:57:29Z stefan $ */ +// Copyright (C) 2006, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef CoinSnapshot_H +#define CoinSnapshot_H + +class CoinPackedMatrix; +#include "CoinTypes.hpp" + +//############################################################################# + +/** NON Abstract Base Class for interfacing with cut generators or branching code or .. + It is designed to be snapshot of a problem at a node in tree + + The class may or may not own the arrays - see owned_ + + + Querying a problem that has no data associated with it will result in + zeros for the number of rows and columns, and NULL pointers from + the methods that return arrays. +*/ + +class CoinSnapshot { + +public: + + //--------------------------------------------------------------------------- + /**@name Problem query methods + + The Matrix pointers may be NULL + */ + //@{ + /// Get number of columns + inline int getNumCols() const + { return numCols_;} + + /// Get number of rows + inline int getNumRows() const + { return numRows_;} + + /// Get number of nonzero elements + inline int getNumElements() const + { return numElements_;} + + /// Get number of integer variables + inline int getNumIntegers() const + { return numIntegers_;} + + /// Get pointer to array[getNumCols()] of column lower bounds + inline const double * getColLower() const + { return colLower_;} + + /// Get pointer to array[getNumCols()] of column upper bounds + inline const double * getColUpper() const + { return colUpper_;} + + /// Get pointer to array[getNumRows()] of row lower bounds + inline const double * getRowLower() const + { return rowLower_;} + + /// Get pointer to array[getNumRows()] of row upper bounds + inline const double * getRowUpper() const + { return rowUpper_;} + + /** Get pointer to array[getNumRows()] of row right-hand sides + This gives same results as OsiSolverInterface for useful cases + If getRowUpper()[i] != infinity then + getRightHandSide()[i] == getRowUpper()[i] + else + getRightHandSide()[i] == getRowLower()[i] + */ + inline const double * getRightHandSide() const + { return rightHandSide_;} + + /// Get pointer to array[getNumCols()] of objective function coefficients + inline const double * getObjCoefficients() const + { return objCoefficients_;} + + /// Get objective function sense (1 for min (default), -1 for max) + inline double getObjSense() const + { return objSense_;} + + /// Return true if variable is continuous + inline bool isContinuous(int colIndex) const + { return colType_[colIndex]=='C';} + + /// Return true if variable is binary + inline bool isBinary(int colIndex) const + { return colType_[colIndex]=='B';} + + /// Return true if column is integer. + inline bool isInteger(int colIndex) const + { return colType_[colIndex]=='B'||colType_[colIndex]=='I';} + + /// Return true if variable is general integer + inline bool isIntegerNonBinary(int colIndex) const + { return colType_[colIndex]=='I';} + + /// Return true if variable is binary and not fixed at either bound + inline bool isFreeBinary(int colIndex) const + { return colType_[colIndex]=='B'&&colUpper_[colIndex]>colLower_[colIndex];} + + /// Get colType array ('B', 'I', or 'C' for Binary, Integer and Continuous) + inline const char * getColType() const + { return colType_;} + + /// Get pointer to row-wise copy of current matrix + inline const CoinPackedMatrix * getMatrixByRow() const + { return matrixByRow_;} + + /// Get pointer to column-wise copy of current matrix + inline const CoinPackedMatrix * getMatrixByCol() const + { return matrixByCol_;} + + /// Get pointer to row-wise copy of "original" matrix + inline const CoinPackedMatrix * getOriginalMatrixByRow() const + { return originalMatrixByRow_;} + + /// Get pointer to column-wise copy of "original" matrix + inline const CoinPackedMatrix * getOriginalMatrixByCol() const + { return originalMatrixByCol_;} + //@} + + /**@name Solution query methods */ + //@{ + /// Get pointer to array[getNumCols()] of primal variable values + inline const double * getColSolution() const + { return colSolution_;} + + /// Get pointer to array[getNumRows()] of dual variable values + inline const double * getRowPrice() const + { return rowPrice_;} + + /// Get a pointer to array[getNumCols()] of reduced costs + inline const double * getReducedCost() const + { return reducedCost_;} + + /// Get pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vector). + inline const double * getRowActivity() const + { return rowActivity_;} + + /// Get pointer to array[getNumCols()] of primal variable values which should not be separated (for debug) + inline const double * getDoNotSeparateThis() const + { return doNotSeparateThis_;} + //@} + + /**@name Other scalar get methods */ + //@{ + /// Get solver's value for infinity + inline double getInfinity() const + { return infinity_;} + + /** Get objective function value - includinbg any offset i.e. + sum c sub j * x subj - objValue = objOffset */ + inline double getObjValue() const + { return objValue_;} + + /// Get objective offset i.e. sum c sub j * x subj -objValue = objOffset + inline double getObjOffset() const + { return objOffset_;} + + /// Get dual tolerance + inline double getDualTolerance() const + { return dualTolerance_;} + + /// Get primal tolerance + inline double getPrimalTolerance() const + { return primalTolerance_;} + + /// Get integer tolerance + inline double getIntegerTolerance() const + { return integerTolerance_;} + + /// Get integer upper bound i.e. best solution * getObjSense + inline double getIntegerUpperBound() const + { return integerUpperBound_;} + + /// Get integer lower bound i.e. best possible solution * getObjSense + inline double getIntegerLowerBound() const + { return integerLowerBound_;} + //@} + + //--------------------------------------------------------------------------- + + /**@name Method to input a problem */ + //@{ + /** Load in an problem by copying the arguments (the constraints on the + rows are given by lower and upper bounds). If a pointer is NULL then the + following values are the default: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>rowub</code>: all rows have upper bound infinity + <li> <code>rowlb</code>: all rows have lower bound -infinity + <li> <code>obj</code>: all variables have 0 objective coefficient + </ul> + All solution type arrays will be deleted + */ + void loadProblem(const CoinPackedMatrix& matrix, + const double* collb, const double* colub, + const double* obj, + const double* rowlb, const double* rowub, + bool makeRowCopy=false); + + //@} + + //--------------------------------------------------------------------------- + + /**@name Methods to set data */ + //@{ + /// Set number of columns + inline void setNumCols(int value) + { numCols_ = value;} + + /// Set number of rows + inline void setNumRows(int value) + { numRows_ = value;} + + /// Set number of nonzero elements + inline void setNumElements(int value) + { numElements_ = value;} + + /// Set number of integer variables + inline void setNumIntegers(int value) + { numIntegers_ = value;} + + /// Set pointer to array[getNumCols()] of column lower bounds + void setColLower(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumCols()] of column upper bounds + void setColUpper(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumRows()] of row lower bounds + void setRowLower(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumRows()] of row upper bounds + void setRowUpper(const double * array, bool copyIn=true); + + /** Set pointer to array[getNumRows()] of row right-hand sides + This gives same results as OsiSolverInterface for useful cases + If getRowUpper()[i] != infinity then + getRightHandSide()[i] == getRowUpper()[i] + else + getRightHandSide()[i] == getRowLower()[i] + */ + void setRightHandSide(const double * array, bool copyIn=true); + + /** Create array[getNumRows()] of row right-hand sides + using existing information + This gives same results as OsiSolverInterface for useful cases + If getRowUpper()[i] != infinity then + getRightHandSide()[i] == getRowUpper()[i] + else + getRightHandSide()[i] == getRowLower()[i] + */ + void createRightHandSide(); + + /// Set pointer to array[getNumCols()] of objective function coefficients + void setObjCoefficients(const double * array, bool copyIn=true); + + /// Set objective function sense (1 for min (default), -1 for max) + inline void setObjSense(double value) + { objSense_ = value;} + + /// Set colType array ('B', 'I', or 'C' for Binary, Integer and Continuous) + void setColType(const char *array, bool copyIn=true); + + /// Set pointer to row-wise copy of current matrix + void setMatrixByRow(const CoinPackedMatrix * matrix, bool copyIn=true); + + /// Create row-wise copy from MatrixByCol + void createMatrixByRow(); + + /// Set pointer to column-wise copy of current matrix + void setMatrixByCol(const CoinPackedMatrix * matrix, bool copyIn=true); + + /// Set pointer to row-wise copy of "original" matrix + void setOriginalMatrixByRow(const CoinPackedMatrix * matrix, bool copyIn=true); + + /// Set pointer to column-wise copy of "original" matrix + void setOriginalMatrixByCol(const CoinPackedMatrix * matrix, bool copyIn=true); + + /// Set pointer to array[getNumCols()] of primal variable values + void setColSolution(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumRows()] of dual variable values + void setRowPrice(const double * array, bool copyIn=true); + + /// Set a pointer to array[getNumCols()] of reduced costs + void setReducedCost(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vector). + void setRowActivity(const double * array, bool copyIn=true); + + /// Set pointer to array[getNumCols()] of primal variable values which should not be separated (for debug) + void setDoNotSeparateThis(const double * array, bool copyIn=true); + + /// Set solver's value for infinity + inline void setInfinity(double value) + { infinity_ = value;} + + /// Set objective function value (including any rhs offset) + inline void setObjValue(double value) + { objValue_ = value;} + + /// Set objective offset i.e. sum c sub j * x subj -objValue = objOffset + inline void setObjOffset(double value) + { objOffset_ = value;} + + /// Set dual tolerance + inline void setDualTolerance(double value) + { dualTolerance_ = value;} + + /// Set primal tolerance + inline void setPrimalTolerance(double value) + { primalTolerance_ = value;} + + /// Set integer tolerance + inline void setIntegerTolerance(double value) + { integerTolerance_ = value;} + + /// Set integer upper bound i.e. best solution * getObjSense + inline void setIntegerUpperBound(double value) + { integerUpperBound_ = value;} + + /// Set integer lower bound i.e. best possible solution * getObjSense + inline void setIntegerLowerBound(double value) + { integerLowerBound_ = value;} + //@} + + //--------------------------------------------------------------------------- + + ///@name Constructors and destructors + //@{ + /// Default Constructor + CoinSnapshot(); + + /// Copy constructor + CoinSnapshot(const CoinSnapshot &); + + /// Assignment operator + CoinSnapshot & operator=(const CoinSnapshot& rhs); + + /// Destructor + virtual ~CoinSnapshot (); + + //@} + +private: + ///@name private functions + //@{ + /** Does main work of destructor - type (or'ed) + 1 - NULLify pointers + 2 - delete pointers + 4 - initialize scalars (tolerances etc) + 8 - initialize scalars (objValue etc0 + */ + void gutsOfDestructor(int type); + /// Does main work of copy + void gutsOfCopy(const CoinSnapshot & rhs); + //@} + + ///@name Private member data + + /// objective function sense (1 for min (default), -1 for max) + double objSense_; + + /// solver's value for infinity + double infinity_; + + /// objective function value (including any rhs offset) + double objValue_; + + /// objective offset i.e. sum c sub j * x subj -objValue = objOffset + double objOffset_; + + /// dual tolerance + double dualTolerance_; + + /// primal tolerance + double primalTolerance_; + + /// integer tolerance + double integerTolerance_; + + /// integer upper bound i.e. best solution * getObjSense + double integerUpperBound_; + + /// integer lower bound i.e. best possible solution * getObjSense + double integerLowerBound_; + + /// pointer to array[getNumCols()] of column lower bounds + const double * colLower_; + + /// pointer to array[getNumCols()] of column upper bounds + const double * colUpper_; + + /// pointer to array[getNumRows()] of row lower bounds + const double * rowLower_; + + /// pointer to array[getNumRows()] of row upper bounds + const double * rowUpper_; + + /// pointer to array[getNumRows()] of rhs side values + const double * rightHandSide_; + + /// pointer to array[getNumCols()] of objective function coefficients + const double * objCoefficients_; + + /// colType array ('B', 'I', or 'C' for Binary, Integer and Continuous) + const char * colType_; + + /// pointer to row-wise copy of current matrix + const CoinPackedMatrix * matrixByRow_; + + /// pointer to column-wise copy of current matrix + const CoinPackedMatrix * matrixByCol_; + + /// pointer to row-wise copy of "original" matrix + const CoinPackedMatrix * originalMatrixByRow_; + + /// pointer to column-wise copy of "original" matrix + const CoinPackedMatrix * originalMatrixByCol_; + + /// pointer to array[getNumCols()] of primal variable values + const double * colSolution_; + + /// pointer to array[getNumRows()] of dual variable values + const double * rowPrice_; + + /// a pointer to array[getNumCols()] of reduced costs + const double * reducedCost_; + + /// pointer to array[getNumRows()] of row activity levels (constraint matrix times the solution vector). + const double * rowActivity_; + + /// pointer to array[getNumCols()] of primal variable values which should not be separated (for debug) + const double * doNotSeparateThis_; + + /// number of columns + int numCols_; + + /// number of rows + int numRows_; + + /// number of nonzero elements + int numElements_; + + /// number of integer variables + int numIntegers_; + + /// To say whether arrays etc are owned by CoinSnapshot + typedef struct { + unsigned int colLower:1; + unsigned int colUpper:1; + unsigned int rowLower:1; + unsigned int rowUpper:1; + unsigned int rightHandSide:1; + unsigned int objCoefficients:1; + unsigned int colType:1; + unsigned int matrixByRow:1; + unsigned int matrixByCol:1; + unsigned int originalMatrixByRow:1; + unsigned int originalMatrixByCol:1; + unsigned int colSolution:1; + unsigned int rowPrice:1; + unsigned int reducedCost:1; + unsigned int rowActivity:1; + unsigned int doNotSeparateThis:1; + } coinOwned; + coinOwned owned_; + //@} +}; +#endif diff --git a/thirdparty/windows/include/coin/CoinSort.hpp b/thirdparty/windows/include/coin/CoinSort.hpp new file mode 100644 index 0000000..259fb35 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinSort.hpp @@ -0,0 +1,678 @@ +/* $Id: CoinSort.hpp 1594 2013-04-19 14:33:00Z 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 CoinSort_H +#define CoinSort_H + +#include <functional> +#include <new> +#include <algorithm> +#include "CoinDistance.hpp" + +// Uncomment the next three lines to get thorough initialisation of memory. +// #ifndef ZEROFAULT +// #define ZEROFAULT +// #endif + +#ifdef COIN_FAST_CODE +#ifndef COIN_USE_EKK_SORT +#define COIN_USE_EKK_SORT +#endif +#endif + +//############################################################################# + +/** An ordered pair. It's the same as std::pair, just this way it'll have the + same look as the triple sorting. */ +template <class S, class T> +struct CoinPair { +public: + /// First member of pair + S first; + /// Second member of pair + T second; +public: + /// Construct from ordered pair + CoinPair(const S& s, const T& t) : first(s), second(t) {} +}; + +//############################################################################# + +/**@name Comparisons on first element of two ordered pairs */ +//@{ +/** Function operator. + Returns true if t1.first < t2.first (i.e., increasing). */ +template < class S, class T> +class CoinFirstLess_2 { +public: + /// Compare function + inline bool operator()(const CoinPair<S,T>& t1, + const CoinPair<S,T>& t2) const + { return t1.first < t2.first; } +}; +//----------------------------------------------------------------------------- +/** Function operator. + Returns true if t1.first > t2.first (i.e, decreasing). */ +template < class S, class T> +class CoinFirstGreater_2 { +public: + /// Compare function + inline bool operator()(const CoinPair<S,T>& t1, + const CoinPair<S,T>& t2) const + { return t1.first > t2.first; } +}; +//----------------------------------------------------------------------------- +/** Function operator. + Returns true if abs(t1.first) < abs(t2.first) (i.e., increasing). */ +template < class S, class T> +class CoinFirstAbsLess_2 { +public: + /// Compare function + inline bool operator()(const CoinPair<S,T>& t1, + const CoinPair<S,T>& t2) const + { + const T t1Abs = t1.first < static_cast<T>(0) ? -t1.first : t1.first; + const T t2Abs = t2.first < static_cast<T>(0) ? -t2.first : t2.first; + return t1Abs < t2Abs; + } +}; +//----------------------------------------------------------------------------- +/** Function operator. + Returns true if abs(t1.first) > abs(t2.first) (i.e., decreasing). */ +template < class S, class T> +class CoinFirstAbsGreater_2 { +public: + /// Compare function + inline bool operator()(CoinPair<S,T> t1, CoinPair<S,T> t2) const + { + const T t1Abs = t1.first < static_cast<T>(0) ? -t1.first : t1.first; + const T t2Abs = t2.first < static_cast<T>(0) ? -t2.first : t2.first; + return t1Abs > t2Abs; + } +}; +//----------------------------------------------------------------------------- +/** Function operator. + Compare based on the entries of an external vector, i.e., returns true if + vec[t1.first < vec[t2.first] (i.e., increasing wrt. vec). Note that to + use this comparison operator .first must be a data type automatically + convertible to int. */ +template < class S, class T, class V> +class CoinExternalVectorFirstLess_2 { +private: + CoinExternalVectorFirstLess_2(); +private: + const V* vec_; +public: + inline bool operator()(const CoinPair<S,T>& t1, + const CoinPair<S,T>& t2) const + { return vec_[t1.first] < vec_[t2.first]; } + CoinExternalVectorFirstLess_2(const V* v) : vec_(v) {} +}; +//----------------------------------------------------------------------------- +/** Function operator. + Compare based on the entries of an external vector, i.e., returns true if + vec[t1.first > vec[t2.first] (i.e., decreasing wrt. vec). Note that to + use this comparison operator .first must be a data type automatically + convertible to int. */ +template < class S, class T, class V> +class CoinExternalVectorFirstGreater_2 { +private: + CoinExternalVectorFirstGreater_2(); +private: + const V* vec_; +public: + inline bool operator()(const CoinPair<S,T>& t1, + const CoinPair<S,T>& t2) const + { return vec_[t1.first] > vec_[t2.first]; } + CoinExternalVectorFirstGreater_2(const V* v) : vec_(v) {} +}; +//@} + +//############################################################################# + +/** Sort a pair of containers.<br> + + Iter_S - iterator for first container<br> + Iter_T - iterator for 2nd container<br> + CoinCompare2 - class comparing CoinPairs<br> +*/ + +#ifdef COIN_SORT_ARBITRARY_CONTAINERS +template <class Iter_S, class Iter_T, class CoinCompare2> void +CoinSort_2(Iter_S sfirst, Iter_S slast, Iter_T tfirst, const CoinCompare2& pc) +{ + typedef typename std::iterator_traits<Iter_S>::value_type S; + typedef typename std::iterator_traits<Iter_T>::value_type T; + const size_t len = coinDistance(sfirst, slast); + if (len <= 1) + return; + + typedef CoinPair<S,T> ST_pair; + ST_pair* x = static_cast<ST_pair*>(::operator new(len * sizeof(ST_pair))); +# ifdef ZEROFAULT + memset(x,0,(len*sizeof(ST_pair))) ; +# endif + + int i = 0; + Iter_S scurrent = sfirst; + Iter_T tcurrent = tfirst; + while (scurrent != slast) { + new (x+i++) ST_pair(*scurrent++, *tcurrent++); + } + + std::sort(x.begin(), x.end(), pc); + + scurrent = sfirst; + tcurrent = tfirst; + for (i = 0; i < len; ++i) { + *scurrent++ = x[i].first; + *tcurrent++ = x[i].second; + } + + ::operator delete(x); +} +//----------------------------------------------------------------------------- +template <class Iter_S, class Iter_T> void +CoinSort_2(Iter_S sfirst, Iter_S slast, Iter_T tfirst) +{ + typedef typename std::iterator_traits<Iter_S>::value_type S; + typedef typename std::iterator_traits<Iter_T>::value_type T; + CoinSort_2(sfirst, slast, tfirst, CoinFirstLess_2<S,T>()); +} + +#else //======================================================================= + +template <class S, class T, class CoinCompare2> void +CoinSort_2(S* sfirst, S* slast, T* tfirst, const CoinCompare2& pc) +{ + const size_t len = coinDistance(sfirst, slast); + if (len <= 1) + return; + + typedef CoinPair<S,T> ST_pair; + ST_pair* x = static_cast<ST_pair*>(::operator new(len * sizeof(ST_pair))); +# ifdef ZEROFAULT + // Can show RUI errors on some systems due to copy of ST_pair with gaps. + // E.g., <int, double> has 4 byte alignment gap on Solaris/SUNWspro. + memset(x,0,(len*sizeof(ST_pair))) ; +# endif + + size_t i = 0; + S* scurrent = sfirst; + T* tcurrent = tfirst; + while (scurrent != slast) { + new (x+i++) ST_pair(*scurrent++, *tcurrent++); + } + + std::sort(x, x + len, pc); + + scurrent = sfirst; + tcurrent = tfirst; + for (i = 0; i < len; ++i) { + *scurrent++ = x[i].first; + *tcurrent++ = x[i].second; + } + + ::operator delete(x); +} +template <class S, class T> void +// This Always uses std::sort +CoinSort_2Std(S* sfirst, S* slast, T* tfirst) +{ + CoinSort_2(sfirst, slast, tfirst, CoinFirstLess_2<S,T>()); +} +#ifndef COIN_USE_EKK_SORT +//----------------------------------------------------------------------------- +template <class S, class T> void +CoinSort_2(S* sfirst, S* slast, T* tfirst) +{ + CoinSort_2(sfirst, slast, tfirst, CoinFirstLess_2<S,T>()); +} +#else +//----------------------------------------------------------------------------- +extern int boundary_sort; +extern int boundary_sort2; +extern int boundary_sort3; +/// Sort without new and delete +template <class S, class T> void +CoinSort_2(S* key, S* lastKey, T* array2) +{ + const size_t number = coinDistance(key, lastKey); + if (number <= 1) { + return; + } else if (number>10000) { + CoinSort_2Std(key, lastKey, array2); + return; + } +#if 0 + if (number==boundary_sort3) { + printf("before sort %d entries\n",number); + for (int j=0;j<number;j++) { + std::cout<<" ( "<<key[j]<<","<<array2[j]<<")"; + } + std::cout<<std::endl; + } +#endif + int minsize=10; + int n = static_cast<int>(number); + int sp; + S *v = key; + S *m, t; + S * ls[32] , * rs[32]; + S *l , *r , c; + T it; + int j; + /*check already sorted */ + S last=key[0]; + for (j=1;j<n;j++) { + if (key[j]>=last) { + last=key[j]; + } else { + break; + } /* endif */ + } /* endfor */ + if (j==n) { + return; + } /* endif */ + sp = 0 ; ls[sp] = v ; rs[sp] = v + (n-1) ; + while( sp >= 0 ) + { + if ( rs[sp] - ls[sp] > minsize ) + { + l = ls[sp] ; r = rs[sp] ; m = l + (r-l)/2 ; + if ( *l > *m ) + { + t = *l ; *l = *m ; *m = t ; + it = array2[l-v] ; array2[l-v] = array2[m-v] ; array2[m-v] = it ; + } + if ( *m > *r ) + { + t = *m ; *m = *r ; *r = t ; + it = array2[m-v] ; array2[m-v] = array2[r-v] ; array2[r-v] = it ; + if ( *l > *m ) + { + t = *l ; *l = *m ; *m = t ; + it = array2[l-v] ; array2[l-v] = array2[m-v] ; array2[m-v] = it ; + } + } + c = *m ; + while ( r - l > 1 ) + { + while ( *(++l) < c ) ; + while ( *(--r) > c ) ; + t = *l ; *l = *r ; *r = t ; + it = array2[l-v] ; array2[l-v] = array2[r-v] ; array2[r-v] = it ; + } + l = r - 1 ; + if ( l < m ) + { ls[sp+1] = ls[sp] ; + rs[sp+1] = l ; + ls[sp ] = r ; + } + else + { ls[sp+1] = r ; + rs[sp+1] = rs[sp] ; + rs[sp ] = l ; + } + sp++ ; + } + else sp-- ; + } + for ( l = v , m = v + (n-1) ; l < m ; l++ ) + { if ( *l > *(l+1) ) + { + c = *(l+1) ; + it = array2[(l-v)+1] ; + for ( r = l ; r >= v && *r > c ; r-- ) + { + *(r+1) = *r ; + array2[(r-v)+1] = array2[(r-v)] ; + } + *(r+1) = c ; + array2[(r-v)+1] = it ; + } + } +#if 0 + if (number==boundary_sort3) { + printf("after sort %d entries\n",number); + for (int j=0;j<number;j++) { + std::cout<<" ( "<<key[j]<<","<<array2[j]<<")"; + } + std::cout<<std::endl; + CoinSort_2Many(key, lastKey, array2); + printf("after2 sort %d entries\n",number); + for (int j=0;j<number;j++) { + std::cout<<" ( "<<key[j]<<","<<array2[j]<<")"; + } + std::cout<<std::endl; + } +#endif +} +#endif +#endif +/// Sort without new and delete +template <class S, class T> void +CoinShortSort_2(S* key, S* lastKey, T* array2) +{ + const size_t number = coinDistance(key, lastKey); + if (number <= 2) { + if (number == 2 && key[0] > key[1]) { + S tempS = key[0]; + T tempT = array2[0]; + key[0] = key[1]; + array2[0] = array2[1]; + key[1] = tempS; + array2[1] = tempT; + } + return; + } else if (number>10000) { + CoinSort_2Std(key, lastKey, array2); + return; + } + int minsize=10; + size_t n = number; + int sp; + S *v = key; + S *m, t; + S * ls[32] , * rs[32]; + S *l , *r , c; + T it; + size_t j; + /*check already sorted */ + S last=key[0]; + for (j=1;j<n;j++) { + if (key[j]>=last) { + last=key[j]; + } else { + break; + } /* endif */ + } /* endfor */ + if (j==n) { + return; + } /* endif */ + sp = 0 ; ls[sp] = v ; rs[sp] = v + (n-1) ; + while( sp >= 0 ) + { + if ( rs[sp] - ls[sp] > minsize ) + { + l = ls[sp] ; r = rs[sp] ; m = l + (r-l)/2 ; + if ( *l > *m ) + { + t = *l ; *l = *m ; *m = t ; + it = array2[l-v] ; array2[l-v] = array2[m-v] ; array2[m-v] = it ; + } + if ( *m > *r ) + { + t = *m ; *m = *r ; *r = t ; + it = array2[m-v] ; array2[m-v] = array2[r-v] ; array2[r-v] = it ; + if ( *l > *m ) + { + t = *l ; *l = *m ; *m = t ; + it = array2[l-v] ; array2[l-v] = array2[m-v] ; array2[m-v] = it ; + } + } + c = *m ; + while ( r - l > 1 ) + { + while ( *(++l) < c ) ; + while ( *(--r) > c ) ; + t = *l ; *l = *r ; *r = t ; + it = array2[l-v] ; array2[l-v] = array2[r-v] ; array2[r-v] = it ; + } + l = r - 1 ; + if ( l < m ) + { ls[sp+1] = ls[sp] ; + rs[sp+1] = l ; + ls[sp ] = r ; + } + else + { ls[sp+1] = r ; + rs[sp+1] = rs[sp] ; + rs[sp ] = l ; + } + sp++ ; + } + else sp-- ; + } + for ( l = v , m = v + (n-1) ; l < m ; l++ ) + { if ( *l > *(l+1) ) + { + c = *(l+1) ; + it = array2[(l-v)+1] ; + for ( r = l ; r >= v && *r > c ; r-- ) + { + *(r+1) = *r ; + array2[(r-v)+1] = array2[(r-v)] ; + } + *(r+1) = c ; + array2[(r-v)+1] = it ; + } + } +} +//############################################################################# +//############################################################################# + +/**@name Ordered Triple Struct */ +template <class S, class T, class U> +class CoinTriple { +public: + /// First member of triple + S first; + /// Second member of triple + T second; + /// Third member of triple + U third; +public: + /// Construct from ordered triple + CoinTriple(const S& s, const T& t, const U& u):first(s),second(t),third(u) {} +}; + +//############################################################################# +/**@name Comparisons on first element of two ordered triples */ +//@{ +/** Function operator. + Returns true if t1.first < t2.first (i.e., increasing). */ +template < class S, class T, class U > +class CoinFirstLess_3 { +public: + /// Compare function + inline bool operator()(const CoinTriple<S,T,U>& t1, + const CoinTriple<S,T,U>& t2) const + { return t1.first < t2.first; } +}; +//----------------------------------------------------------------------------- +/** Function operator. + Returns true if t1.first > t2.first (i.e, decreasing). */ +template < class S, class T, class U > +class CoinFirstGreater_3 { +public: + /// Compare function + inline bool operator()(const CoinTriple<S,T,U>& t1, + const CoinTriple<S,T,U>& t2) const + { return t1.first>t2.first; } +}; +//----------------------------------------------------------------------------- +/** Function operator. + Returns true if abs(t1.first) < abs(t2.first) (i.e., increasing). */ +template < class S, class T, class U > +class CoinFirstAbsLess_3 { +public: + /// Compare function + inline bool operator()(const CoinTriple<S,T,U>& t1, + const CoinTriple<S,T,U>& t2) const + { + const T t1Abs = t1.first < static_cast<T>(0) ? -t1.first : t1.first; + const T t2Abs = t2.first < static_cast<T>(0) ? -t2.first : t2.first; + return t1Abs < t2Abs; + } +}; +//----------------------------------------------------------------------------- +/** Function operator. + Returns true if abs(t1.first) > abs(t2.first) (i.e., decreasing). */ +template < class S, class T, class U > +class CoinFirstAbsGreater_3 { +public: + /// Compare function + inline bool operator()(const CoinTriple<S,T,U>& t1, + const CoinTriple<S,T,U>& t2) const + { + const T t1Abs = t1.first < static_cast<T>(0) ? -t1.first : t1.first; + const T t2Abs = t2.first < static_cast<T>(0) ? -t2.first : t2.first; + return t1Abs > t2Abs; + } +}; +//----------------------------------------------------------------------------- +/** Function operator. + Compare based on the entries of an external vector, i.e., returns true if + vec[t1.first < vec[t2.first] (i.e., increasing wrt. vec). Note that to + use this comparison operator .first must be a data type automatically + convertible to int. */ +template < class S, class T, class U, class V> +class CoinExternalVectorFirstLess_3 { +private: + CoinExternalVectorFirstLess_3(); +private: + const V* vec_; +public: + inline bool operator()(const CoinTriple<S,T,U>& t1, + const CoinTriple<S,T,U>& t2) const + { return vec_[t1.first] < vec_[t2.first]; } + CoinExternalVectorFirstLess_3(const V* v) : vec_(v) {} +}; +//----------------------------------------------------------------------------- +/** Function operator. + Compare based on the entries of an external vector, i.e., returns true if + vec[t1.first > vec[t2.first] (i.e., decreasing wrt. vec). Note that to + use this comparison operator .first must be a data type automatically + convertible to int. */ +template < class S, class T, class U, class V> +class CoinExternalVectorFirstGreater_3 { +private: + CoinExternalVectorFirstGreater_3(); +private: + const V* vec_; +public: + inline bool operator()(const CoinTriple<S,T,U>& t1, + const CoinTriple<S,T,U>& t2) const + { return vec_[t1.first] > vec_[t2.first]; } + CoinExternalVectorFirstGreater_3(const V* v) : vec_(v) {} +}; +//@} + +//############################################################################# + +/**@name Typedefs for sorting the entries of a packed vector based on an + external vector. */ +//@{ +/// Sort packed vector in increasing order of the external vector +typedef CoinExternalVectorFirstLess_3<int, int, double, double> +CoinIncrSolutionOrdered; +/// Sort packed vector in decreasing order of the external vector +typedef CoinExternalVectorFirstGreater_3<int, int, double, double> +CoinDecrSolutionOrdered; +//@} + +//############################################################################# + +/** Sort a triple of containers.<br> + + Iter_S - iterator for first container<br> + Iter_T - iterator for 2nd container<br> + Iter_U - iterator for 3rd container<br> + CoinCompare3 - class comparing CoinTriples<br> +*/ +#ifdef COIN_SORT_ARBITRARY_CONTAINERS +template <class Iter_S, class Iter_T, class Iter_U, class CoinCompare3> void +CoinSort_3(Iter_S sfirst, Iter_S slast, Iter_T tfirst, Iter_U, ufirst, + const CoinCompare3& tc) +{ + typedef typename std::iterator_traits<Iter_S>::value_type S; + typedef typename std::iterator_traits<Iter_T>::value_type T; + typedef typename std::iterator_traits<Iter_U>::value_type U; + const size_t len = coinDistance(sfirst, slast); + if (len <= 1) + return; + + typedef CoinTriple<S,T,U> STU_triple; + STU_triple* x = + static_cast<STU_triple*>(::operator new(len * sizeof(STU_triple))); + + int i = 0; + Iter_S scurrent = sfirst; + Iter_T tcurrent = tfirst; + Iter_U ucurrent = ufirst; + while (scurrent != slast) { + new (x+i++) STU_triple(*scurrent++, *tcurrent++, *ucurrent++); + } + + std::sort(x, x+len, tc); + + scurrent = sfirst; + tcurrent = tfirst; + ucurrent = ufirst; + for (i = 0; i < len; ++i) { + *scurrent++ = x[i].first; + *tcurrent++ = x[i].second; + *ucurrent++ = x[i].third; + } + + ::operator delete(x); +} +//----------------------------------------------------------------------------- +template <class Iter_S, class Iter_T, class Iter_U> void +CoinSort_3(Iter_S sfirst, Iter_S slast, Iter_T tfirst, Iter_U, ufirst) +{ + typedef typename std::iterator_traits<Iter_S>::value_type S; + typedef typename std::iterator_traits<Iter_T>::value_type T; + typedef typename std::iterator_traits<Iter_U>::value_type U; + CoinSort_3(sfirts, slast, tfirst, ufirst, CoinFirstLess_3<S,T,U>()); +} + +#else //======================================================================= + +template <class S, class T, class U, class CoinCompare3> void +CoinSort_3(S* sfirst, S* slast, T* tfirst, U* ufirst, const CoinCompare3& tc) +{ + const size_t len = coinDistance(sfirst,slast); + if (len <= 1) + return; + + typedef CoinTriple<S,T,U> STU_triple; + STU_triple* x = + static_cast<STU_triple*>(::operator new(len * sizeof(STU_triple))); + + size_t i = 0; + S* scurrent = sfirst; + T* tcurrent = tfirst; + U* ucurrent = ufirst; + while (scurrent != slast) { + new (x+i++) STU_triple(*scurrent++, *tcurrent++, *ucurrent++); + } + + std::sort(x, x+len, tc); + + scurrent = sfirst; + tcurrent = tfirst; + ucurrent = ufirst; + for (i = 0; i < len; ++i) { + *scurrent++ = x[i].first; + *tcurrent++ = x[i].second; + *ucurrent++ = x[i].third; + } + + ::operator delete(x); +} +//----------------------------------------------------------------------------- +template <class S, class T, class U> void +CoinSort_3(S* sfirst, S* slast, T* tfirst, U* ufirst) +{ + CoinSort_3(sfirst, slast, tfirst, ufirst, CoinFirstLess_3<S,T,U>()); +} + +#endif + +//############################################################################# + +#endif diff --git a/thirdparty/windows/include/coin/CoinStructuredModel.hpp b/thirdparty/windows/include/coin/CoinStructuredModel.hpp new file mode 100644 index 0000000..19659b8 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinStructuredModel.hpp @@ -0,0 +1,247 @@ +/* $Id: CoinStructuredModel.hpp 1691 2014-03-19 12:43:56Z forrest $ */ +// 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 CoinStructuredModel_H +#define CoinStructuredModel_H + +#include "CoinModel.hpp" +#include <vector> + +/** + This is a model which is made up of Coin(Structured)Model blocks. +*/ + typedef struct CoinModelInfo2 { + int rowBlock; // Which row block + int columnBlock; // Which column block + char matrix; // nonzero if matrix exists + char rhs; // nonzero if non default rhs exists + char rowName; // nonzero if row names exists + char integer; // nonzero if integer information exists + char bounds; // nonzero if non default bounds/objective exists + char columnName; // nonzero if column names exists + CoinModelInfo2() : + rowBlock(0), + columnBlock(0), + matrix(0), + rhs(0), + rowName(0), + integer(0), + bounds(0), + columnName(0) + {} +} CoinModelBlockInfo; + +class CoinStructuredModel : public CoinBaseModel { + +public: + /**@name Useful methods for building model */ + //@{ + /** add a block from a CoinModel using names given as parameters + returns number of errors (e.g. both have objectives but not same) + */ + int addBlock(const std::string & rowBlock, + const std::string & columnBlock, + const CoinBaseModel & block); + /** add a block from a CoinModel with names in model + returns number of errors (e.g. both have objectives but not same) + */ + int addBlock(const CoinBaseModel & block); + /** add a block from a CoinModel using names given as parameters + returns number of errors (e.g. both have objectives but not same) + This passes in block - structured model takes ownership + */ + int addBlock(const std::string & rowBlock, + const std::string & columnBlock, + CoinBaseModel * block); + /** add a block using names + */ + int addBlock(const std::string & rowBlock, + const std::string & columnBlock, + const CoinPackedMatrix & matrix, + const double * rowLower, const double * rowUpper, + const double * columnLower, const double * columnUpper, + const double * objective); + + /** Write the problem in MPS format to a file with the given filename. + + \param compression can be set to three values to indicate what kind + of file should be written + <ul> + <li> 0: plain text (default) + <li> 1: gzip compressed (.gz is appended to \c filename) + <li> 2: bzip2 compressed (.bz2 is appended to \c filename) (TODO) + </ul> + If the library was not compiled with the requested compression then + writeMps falls back to writing a plain text file. + + \param formatType specifies the precision to used for values in the + MPS file + <ul> + <li> 0: normal precision (default) + <li> 1: extra accuracy + <li> 2: IEEE hex + </ul> + + \param numberAcross specifies whether 1 or 2 (default) values should be + specified on every data line in the MPS file. + + not const as may change model e.g. fill in default bounds + */ + int writeMps(const char *filename, int compression = 0, + int formatType = 0, int numberAcross = 2, bool keepStrings=false) ; + /// Read SMPS model + int readSmps(const char *filename, + bool keepNames = false, + bool ignoreErrors = false); + + /** Decompose a CoinModel + 1 - try D-W + 2 - try Benders + 3 - try Staircase + Returns number of blocks or zero if no structure + */ + int decompose(const CoinModel &model,int type, + int maxBlocks=50, const char ** starts=NULL); + /** Decompose a model specified as arrays + CoinPackedMatrix + 1 - try D-W + 2 - try Benders + 3 - try Staircase + Returns number of blocks or zero if no structure + */ + int decompose(const CoinPackedMatrix & matrix, + const double * rowLower, const double * rowUpper, + const double * columnLower, const double * columnUpper, + const double * objective, int type,int maxBlocks=50, + int * starts=NULL, + double objectiveOffset=0.0); + + //@} + + + /**@name For getting information */ + //@{ + /// Return number of row blocks + inline int numberRowBlocks() const + { return numberRowBlocks_;} + /// Return number of column blocks + inline int numberColumnBlocks() const + { return numberColumnBlocks_;} + /// Return number of elementBlocks + inline CoinBigIndex numberElementBlocks() const + { return numberElementBlocks_;} + /// Return number of elements + CoinBigIndex numberElements() const; + /// Return the i'th row block name + inline const std::string & getRowBlock(int i) const + { return rowBlockNames_[i];} + /// Set i'th row block name + inline void setRowBlock(int i,const std::string &name) + { rowBlockNames_[i] = name;} + /// Add or check a row block name and number of rows + int addRowBlock(int numberRows,const std::string &name) ; + /// Return a row block index given a row block name + int rowBlock(const std::string &name) const; + /// Return i'th the column block name + inline const std::string & getColumnBlock(int i) const + { return columnBlockNames_[i];} + /// Set i'th column block name + inline void setColumnBlock(int i,const std::string &name) + { columnBlockNames_[i] = name;} + /// Add or check a column block name and number of columns + int addColumnBlock(int numberColumns,const std::string &name) ; + /// Return a column block index given a column block name + int columnBlock(const std::string &name) const; + /// Return i'th block type + inline const CoinModelBlockInfo & blockType(int i) const + { return blockType_[i];} + /// Return i'th block + inline CoinBaseModel * block(int i) const + { return blocks_[i];} + /// Return block corresponding to row and column + const CoinBaseModel * block(int row,int column) const; + /// Return i'th block as CoinModel (or NULL) + CoinModel * coinBlock(int i) const; + /// Return block corresponding to row and column as CoinModel + const CoinBaseModel * coinBlock(int row,int column) const; + /// Return block number corresponding to row and column + int blockIndex(int row,int column) const; + /** Return model as a CoinModel block + and fill in info structure and update counts + */ + CoinModel * coinModelBlock(CoinModelBlockInfo & info) ; + /// Sets given block into coinModelBlocks_ + void setCoinModel(CoinModel * block, int iBlock); + /// Refresh info in blockType_ + void refresh(int iBlock); + /** Fill pointers corresponding to row and column */ + + CoinModelBlockInfo block(int row,int column, + const double * & rowLower, const double * & rowUpper, + const double * & columnLower, const double * & columnUpper, + const double * & objective) const; + /// Direction of optimization (1 - minimize, -1 - maximize, 0 - ignore + inline double optimizationDirection() const { + return optimizationDirection_; + } + /// Set direction of optimization (1 - minimize, -1 - maximize, 0 - ignore + inline void setOptimizationDirection(double value) + { optimizationDirection_=value;} + //@} + + /**@name Constructors, destructor */ + //@{ + /** Default constructor. */ + CoinStructuredModel(); + /** Read a problem in MPS format from the given filename. + May try and decompose + */ + CoinStructuredModel(const char *fileName,int decompose=0, + int maxBlocks=50); + /** Destructor */ + virtual ~CoinStructuredModel(); + //@} + + /**@name Copy method */ + //@{ + /** The copy constructor. */ + CoinStructuredModel(const CoinStructuredModel&); + /// = + CoinStructuredModel& operator=(const CoinStructuredModel&); + /// Clone + virtual CoinBaseModel * clone() const; + //@} + +private: + + /** Fill in info structure and update counts + Returns number of inconsistencies on border + */ + int fillInfo(CoinModelBlockInfo & info,const CoinModel * block); + /** Fill in info structure and update counts + */ + void fillInfo(CoinModelBlockInfo & info,const CoinStructuredModel * block); + /**@name Data members */ + //@{ + /// Current number of row blocks + int numberRowBlocks_; + /// Current number of column blocks + int numberColumnBlocks_; + /// Current number of element blocks + int numberElementBlocks_; + /// Maximum number of element blocks + int maximumElementBlocks_; + /// Rowblock name + std::vector<std::string> rowBlockNames_; + /// Columnblock name + std::vector<std::string> columnBlockNames_; + /// Blocks + CoinBaseModel ** blocks_; + /// CoinModel copies of blocks or NULL if original CoinModel + CoinModel ** coinModelBlocks_; + /// Which parts of model are set in block + CoinModelBlockInfo * blockType_; + //@} +}; +#endif diff --git a/thirdparty/windows/include/coin/CoinTime.hpp b/thirdparty/windows/include/coin/CoinTime.hpp new file mode 100644 index 0000000..49e8507 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinTime.hpp @@ -0,0 +1,310 @@ +/* $Id: CoinTime.hpp 1372 2011-01-03 23:31:00Z 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 _CoinTime_hpp +#define _CoinTime_hpp + +// Uncomment the next three lines for thorough memory initialisation. +// #ifndef ZEROFAULT +// # define ZEROFAULT +// #endif + +//############################################################################# + +#include <ctime> +#if defined(_MSC_VER) +// Turn off compiler warning about long names +# pragma warning(disable:4786) +#else +// MacOS-X and FreeBSD needs sys/time.h +#if defined(__MACH__) || defined (__FreeBSD__) +#include <sys/time.h> +#endif +#if !defined(__MSVCRT__) +#include <sys/resource.h> +#endif +#endif + +//############################################################################# + +#if defined(_MSC_VER) + +#if 0 // change this to 1 if want to use the win32 API +#include <windows.h> +#ifdef small +/* for some unfathomable reason (to me) rpcndr.h (pulled in by windows.h) does a + '#define small char' */ +#undef small +#endif +#define TWO_TO_THE_THIRTYTWO 4294967296.0 +#define DELTA_EPOCH_IN_SECS 11644473600.0 +inline double CoinGetTimeOfDay() +{ + FILETIME ft; + + GetSystemTimeAsFileTime(&ft); + double t = ft.dwHighDateTime * TWO_TO_THE_THIRTYTWO + ft.dwLowDateTime; + t = t/10000000.0 - DELTA_EPOCH_IN_SECS; + return t; +} +#else +#include <sys/types.h> +#include <sys/timeb.h> +inline double CoinGetTimeOfDay() +{ + struct _timeb timebuffer; +#pragma warning(disable:4996) + _ftime( &timebuffer ); // C4996 +#pragma warning(default:4996) + return timebuffer.time + timebuffer.millitm/1000.0; +} +#endif + +#else + +#include <sys/time.h> + +inline double CoinGetTimeOfDay() +{ + struct timeval tv; + gettimeofday(&tv, NULL); + return static_cast<double>(tv.tv_sec) + static_cast<int>(tv.tv_usec)/1000000.0; +} + +#endif // _MSC_VER + +/** + Query the elapsed wallclock time since the first call to this function. If + a positive argument is passed to the function then the time of the first + call is set to that value (this kind of argument is allowed only at the + first call!). If a negative argument is passed to the function then it + returns the time when it was set. +*/ + +inline double CoinWallclockTime(double callType = 0) +{ + double callTime = CoinGetTimeOfDay(); + static const double firstCall = callType > 0 ? callType : callTime; + return callType < 0 ? firstCall : callTime - firstCall; +} + +//############################################################################# + +//#define HAVE_SDK // if SDK under Win32 is installed, for CPU instead of elapsed time under Win +#ifdef HAVE_SDK +#include <windows.h> +#ifdef small +/* for some unfathomable reason (to me) rpcndr.h (pulled in by windows.h) does a + '#define small char' */ +#undef small +#endif +#define TWO_TO_THE_THIRTYTWO 4294967296.0 +#endif + +static inline double CoinCpuTime() +{ + double cpu_temp; +#if defined(_MSC_VER) || defined(__MSVCRT__) +#ifdef HAVE_SDK + FILETIME creation; + FILETIME exit; + FILETIME kernel; + FILETIME user; + GetProcessTimes(GetCurrentProcess(), &creation, &exit, &kernel, &user); + double t = user.dwHighDateTime * TWO_TO_THE_THIRTYTWO + user.dwLowDateTime; + return t/10000000.0; +#else + unsigned int ticksnow; /* clock_t is same as int */ + ticksnow = (unsigned int)clock(); + cpu_temp = (double)((double)ticksnow/CLOCKS_PER_SEC); +#endif + +#else + struct rusage usage; +# ifdef ZEROFAULT + usage.ru_utime.tv_sec = 0 ; + usage.ru_utime.tv_usec = 0 ; +# endif + getrusage(RUSAGE_SELF,&usage); + cpu_temp = static_cast<double>(usage.ru_utime.tv_sec); + cpu_temp += 1.0e-6*(static_cast<double> (usage.ru_utime.tv_usec)); +#endif + return cpu_temp; +} + +//############################################################################# + + + +static inline double CoinSysTime() +{ + double sys_temp; +#if defined(_MSC_VER) || defined(__MSVCRT__) + sys_temp = 0.0; +#else + struct rusage usage; +# ifdef ZEROFAULT + usage.ru_utime.tv_sec = 0 ; + usage.ru_utime.tv_usec = 0 ; +# endif + getrusage(RUSAGE_SELF,&usage); + sys_temp = static_cast<double>(usage.ru_stime.tv_sec); + sys_temp += 1.0e-6*(static_cast<double> (usage.ru_stime.tv_usec)); +#endif + return sys_temp; +} + +//############################################################################# +// On most systems SELF seems to include children threads, This is for when it doesn't +static inline double CoinCpuTimeJustChildren() +{ + double cpu_temp; +#if defined(_MSC_VER) || defined(__MSVCRT__) + cpu_temp = 0.0; +#else + struct rusage usage; +# ifdef ZEROFAULT + usage.ru_utime.tv_sec = 0 ; + usage.ru_utime.tv_usec = 0 ; +# endif + getrusage(RUSAGE_CHILDREN,&usage); + cpu_temp = static_cast<double>(usage.ru_utime.tv_sec); + cpu_temp += 1.0e-6*(static_cast<double> (usage.ru_utime.tv_usec)); +#endif + return cpu_temp; +} +//############################################################################# + +#include <fstream> + +/** + This class implements a timer that also implements a tracing functionality. + + The timer stores the start time of the timer, for how much time it was set to + and when does it expire (start + limit = end). Queries can be made that tell + whether the timer is expired, is past an absolute time, is past a percentage + of the length of the timer. All times are given in seconds, but as double + numbers, so there can be fractional values. + + The timer can also be initialized with a stream and a specification whether + to write to or read from the stream. In the former case the result of every + query is written into the stream, in the latter case timing is not tested at + all, rather the supposed result is read out from the stream. This makes it + possible to exactly retrace time sensitive program execution. +*/ +class CoinTimer +{ +private: + /// When the timer was initialized/reset/restarted + double start; + /// + double limit; + double end; +#ifdef COIN_COMPILE_WITH_TRACING + std::fstream* stream; + bool write_stream; +#endif + +private: +#ifdef COIN_COMPILE_WITH_TRACING + inline bool evaluate(bool b_tmp) const { + int i_tmp = b_tmp; + if (stream) { + if (write_stream) + (*stream) << i_tmp << "\n"; + else + (*stream) >> i_tmp; + } + return i_tmp; + } + inline double evaluate(double d_tmp) const { + if (stream) { + if (write_stream) + (*stream) << d_tmp << "\n"; + else + (*stream) >> d_tmp; + } + return d_tmp; + } +#else + inline bool evaluate(const bool b_tmp) const { + return b_tmp; + } + inline double evaluate(const double d_tmp) const { + return d_tmp; + } +#endif + +public: + /// Default constructor creates a timer with no time limit and no tracing + CoinTimer() : + start(0), limit(1e100), end(1e100) +#ifdef COIN_COMPILE_WITH_TRACING + , stream(0), write_stream(true) +#endif + {} + + /// Create a timer with the given time limit and with no tracing + CoinTimer(double lim) : + start(CoinCpuTime()), limit(lim), end(start+lim) +#ifdef COIN_COMPILE_WITH_TRACING + , stream(0), write_stream(true) +#endif + {} + +#ifdef COIN_COMPILE_WITH_TRACING + /** Create a timer with no time limit and with writing/reading the trace + to/from the given stream, depending on the argument \c write. */ + CoinTimer(std::fstream* s, bool write) : + start(0), limit(1e100), end(1e100), + stream(s), write_stream(write) {} + + /** Create a timer with the given time limit and with writing/reading the + trace to/from the given stream, depending on the argument \c write. */ + CoinTimer(double lim, std::fstream* s, bool w) : + start(CoinCpuTime()), limit(lim), end(start+lim), + stream(s), write_stream(w) {} +#endif + + /// Restart the timer (keeping the same time limit) + inline void restart() { start=CoinCpuTime(); end=start+limit; } + /// An alternate name for \c restart() + inline void reset() { restart(); } + /// Reset (and restart) the timer and change its time limit + inline void reset(double lim) { limit=lim; restart(); } + + /** Return whether the given percentage of the time limit has elapsed since + the timer was started */ + inline bool isPastPercent(double pct) const { + return evaluate(start + limit * pct < CoinCpuTime()); + } + /** Return whether the given amount of time has elapsed since the timer was + started */ + inline bool isPast(double lim) const { + return evaluate(start + lim < CoinCpuTime()); + } + /** Return whether the originally specified time limit has passed since the + timer was started */ + inline bool isExpired() const { + return evaluate(end < CoinCpuTime()); + } + + /** Return how much time is left on the timer */ + inline double timeLeft() const { + return evaluate(end - CoinCpuTime()); + } + + /** Return how much time has elapsed */ + inline double timeElapsed() const { + return evaluate(CoinCpuTime() - start); + } + + inline void setLimit(double l) { + limit = l; + return; + } +}; + +#endif diff --git a/thirdparty/windows/include/coin/CoinTypes.hpp b/thirdparty/windows/include/coin/CoinTypes.hpp new file mode 100644 index 0000000..3adee2e --- /dev/null +++ b/thirdparty/windows/include/coin/CoinTypes.hpp @@ -0,0 +1,64 @@ +/* $Id: CoinTypes.hpp 1762 2014-12-29 20:37:12Z tkr $ */ +// 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 _CoinTypes_hpp +#define _CoinTypes_hpp + +#include "CoinUtilsConfig.h" +/* On some systems, we require stdint.h to have the 64bit integer type defined. */ +#ifdef COINUTILS_HAS_STDINT_H +#include <stdint.h> +#endif +#ifdef COINUTILS_HAS_CSTDINT +#include <cstdint> +#endif + +#define CoinInt64 COIN_INT64_T +#define CoinUInt64 COIN_UINT64_T +#define CoinIntPtr COIN_INTPTR_T + +//============================================================================= +#ifndef COIN_BIG_INDEX +#define COIN_BIG_INDEX 0 +#endif + +#if COIN_BIG_INDEX==0 +typedef int CoinBigIndex; +#elif COIN_BIG_INDEX==1 +typedef long CoinBigIndex; +#else +typedef long long CoinBigIndex; +#endif + +//============================================================================= +#ifndef COIN_BIG_DOUBLE +#define COIN_BIG_DOUBLE 0 +#endif + +// See if we want the ability to have long double work arrays +#if COIN_BIG_DOUBLE==2 +#undef COIN_BIG_DOUBLE +#define COIN_BIG_DOUBLE 0 +#define COIN_LONG_WORK 1 +typedef long double CoinWorkDouble; +#elif COIN_BIG_DOUBLE==3 +#undef COIN_BIG_DOUBLE +#define COIN_BIG_DOUBLE 1 +#define COIN_LONG_WORK 1 +typedef long double CoinWorkDouble; +#else +#define COIN_LONG_WORK 0 +typedef double CoinWorkDouble; +#endif + +#if COIN_BIG_DOUBLE==0 +typedef double CoinFactorizationDouble; +#elif COIN_BIG_DOUBLE==1 +typedef long double CoinFactorizationDouble; +#else +typedef double CoinFactorizationDouble; +#endif + +#endif diff --git a/thirdparty/windows/include/coin/CoinUtility.hpp b/thirdparty/windows/include/coin/CoinUtility.hpp new file mode 100644 index 0000000..49a30e2 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinUtility.hpp @@ -0,0 +1,19 @@ +/* $Id: CoinUtility.hpp 1372 2011-01-03 23:31:00Z 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 CoinUtility_h_ +#define CoinUtility_h_ + +#include "CoinSort.hpp" + +template <typename S, typename T> +CoinPair<S,T> CoinMakePair(const S& s, const T& t) +{ return CoinPair<S,T>(s, t); } + +template <typename S, typename T, typename U> +CoinTriple<S,T,U> CoinMakeTriple(const S& s, const T& t, const U& u) +{ return CoinTriple<S,T,U>(s, t, u); } + +#endif diff --git a/thirdparty/windows/include/coin/CoinUtilsConfig.h b/thirdparty/windows/include/coin/CoinUtilsConfig.h new file mode 100644 index 0000000..d7e8eaa --- /dev/null +++ b/thirdparty/windows/include/coin/CoinUtilsConfig.h @@ -0,0 +1,34 @@ +/* src/config_coinutils.h. Generated by configure. */ +/* inc/config_coinutils.h.in. */ + +#ifndef __CONFIG_COINUTILS_H__ +#define __CONFIG_COINUTILS_H__ + +/* Define to 1 if stdint.h is available for CoinUtils */ +#define COINUTILS_HAS_STDINT_H 1 + +/* Define to 1 if stdint.h is available for CoinUtils */ +/* #undef COINUTILS_HAS_CSTDINT */ + +/* Version number of project */ +#define COINUTILS_VERSION "2.10.13" + +/* Major Version number of project */ +#define COINUTILS_VERSION_MAJOR 2 + +/* Minor Version number of project */ +#define COINUTILS_VERSION_MINOR 10 + +/* Release Version number of project */ +#define COINUTILS_VERSION_RELEASE 13 + +/* Define to 64bit integer type */ +#define COIN_INT64_T int64_t + +/* Define to integer type capturing pointer */ +#define COIN_INTPTR_T intptr_t + +/* Define to 64bit unsigned integer type */ +#define COIN_UINT64_T int64_t + +#endif diff --git a/thirdparty/windows/include/coin/CoinWarmStart.hpp b/thirdparty/windows/include/coin/CoinWarmStart.hpp new file mode 100644 index 0000000..a7e28c8 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinWarmStart.hpp @@ -0,0 +1,58 @@ +/* $Id: CoinWarmStart.hpp 1372 2011-01-03 23:31:00Z lou $ */ +// 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 CoinWarmStart_H +#define CoinWarmStart_H + +//############################################################################# + +class CoinWarmStartDiff; + +/** Abstract base class for warm start information. + + Really nothing can be generalized for warm start information --- all we + know is that it exists. Hence the abstract base class contains only a + virtual destructor and a virtual clone function (a virtual constructor), + so that derived classes can provide these functions. +*/ + +class CoinWarmStart { +public: + + /// Abstract destructor + virtual ~CoinWarmStart() {} + + /// `Virtual constructor' + virtual CoinWarmStart *clone() const = 0 ; + + virtual CoinWarmStartDiff* + generateDiff (const CoinWarmStart *const ) const { return 0; } + + + virtual void + applyDiff (const CoinWarmStartDiff *const ) {} + +}; + + +/*! \class CoinWarmStartDiff + \brief Abstract base class for warm start `diff' objects + + For those types of warm start objects where the notion of a `diff' makes + sense, this virtual base class is provided. As with CoinWarmStart, its sole + reason for existence is to make it possible to write solver-independent code. +*/ + +class CoinWarmStartDiff { +public: + + /// Abstract destructor + virtual ~CoinWarmStartDiff() {} + + /// `Virtual constructor' + virtual CoinWarmStartDiff *clone() const = 0 ; +}; + +#endif diff --git a/thirdparty/windows/include/coin/CoinWarmStartBasis.hpp b/thirdparty/windows/include/coin/CoinWarmStartBasis.hpp new file mode 100644 index 0000000..272d393 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinWarmStartBasis.hpp @@ -0,0 +1,456 @@ +/* $Id: CoinWarmStartBasis.hpp 1515 2011-12-10 23:38:04Z lou $ */ +/*! \legal + Copyright (C) 2000 -- 2003, International Business Machines Corporation + and others. All Rights Reserved. + This code is licensed under the terms of the Eclipse Public License (EPL). +*/ + +/*! \file CoinWarmStart.hpp + \brief Declaration of the generic simplex (basis-oriented) warm start + class. Also contains a basis diff class. +*/ + +#ifndef CoinWarmStartBasis_H +#define CoinWarmStartBasis_H + +#include <vector> + +#include "CoinSort.hpp" +#include "CoinHelperFunctions.hpp" +#include "CoinWarmStart.hpp" + +//############################################################################# + +/*! \class CoinWarmStartBasis + \brief The default COIN simplex (basis-oriented) warm start class + + CoinWarmStartBasis provides for a warm start object which contains the + status of each variable (structural and artificial). + + \todo Modify this class so that the number of status entries per byte + and bytes per status vector allocation unit are not hardcoded. + At the least, collect this into a couple of macros. + + \todo Consider separate fields for allocated capacity and actual basis + size. We could avoid some reallocation, at the price of retaining + more space than we need. Perhaps more important, we could do much + better sanity checks. +*/ + +class CoinWarmStartBasis : public virtual CoinWarmStart { +public: + + /*! \brief Enum for status of variables + + Matches CoinPrePostsolveMatrix::Status, without superBasic. Most code that + converts between CoinPrePostsolveMatrix::Status and + CoinWarmStartBasis::Status will break if this correspondence is broken. + + The status vectors are currently packed using two bits per status code, + four codes per byte. The location of the status information for + variable \c i is in byte <code>i>>2</code> and occupies bits 0:1 + if <code>i\%4 == 0</code>, bits 2:3 if <code>i\%4 == 1</code>, etc. + The non-member functions getStatus(const char*,int) and + setStatus(char*,int,CoinWarmStartBasis::Status) are provided to hide + details of the packing. + */ + enum Status { + isFree = 0x00, ///< Nonbasic free variable + basic = 0x01, ///< Basic variable + atUpperBound = 0x02, ///< Nonbasic at upper bound + atLowerBound = 0x03 ///< Nonbasic at lower bound + }; + + /** \brief Transfer vector entry for + mergeBasis(const CoinWarmStartBasis*,const XferVec*,const XferVec*) + */ + typedef CoinTriple<int,int,int> XferEntry ; + + /** \brief Transfer vector for + mergeBasis(const CoinWarmStartBasis*,const XferVec*,const XferVec*) + */ + typedef std::vector<XferEntry> XferVec ; + +public: + +/*! \name Methods to get and set basis information. + + The status of variables is kept in a pair of arrays, one for structural + variables, and one for artificials (aka logicals and slacks). The status + is coded using the values of the Status enum. + + \sa CoinWarmStartBasis::Status for a description of the packing used in + the status arrays. +*/ +//@{ + /// Return the number of structural variables + inline int getNumStructural() const { return numStructural_; } + + /// Return the number of artificial variables + inline int getNumArtificial() const { return numArtificial_; } + + /** Return the number of basic structurals + + A fast test for an all-slack basis. + */ + int numberBasicStructurals() const ; + + /// Return the status of the specified structural variable. + inline Status getStructStatus(int i) const { + const int st = (structuralStatus_[i>>2] >> ((i&3)<<1)) & 3; + return static_cast<CoinWarmStartBasis::Status>(st); + } + + /// Set the status of the specified structural variable. + inline void setStructStatus(int i, Status st) { + char& st_byte = structuralStatus_[i>>2]; + st_byte = static_cast<char>(st_byte & ~(3 << ((i&3)<<1))) ; + st_byte = static_cast<char>(st_byte | (st << ((i&3)<<1))) ; + } + + /** Return the status array for the structural variables + + The status information is stored using the codes defined in the + Status enum, 2 bits per variable, packed 4 variables per byte. + */ + inline char * getStructuralStatus() { return structuralStatus_; } + + /** \c const overload for + \link CoinWarmStartBasis::getStructuralStatus() + getStructuralStatus() + \endlink + */ + inline const char * getStructuralStatus() const { return structuralStatus_; } + + /** As for \link getStructuralStatus() getStructuralStatus \endlink, + but returns the status array for the artificial variables. + */ + inline char * getArtificialStatus() { return artificialStatus_; } + + /// Return the status of the specified artificial variable. + inline Status getArtifStatus(int i) const { + const int st = (artificialStatus_[i>>2] >> ((i&3)<<1)) & 3; + return static_cast<CoinWarmStartBasis::Status>(st); + } + + /// Set the status of the specified artificial variable. + inline void setArtifStatus(int i, Status st) { + char& st_byte = artificialStatus_[i>>2]; + st_byte = static_cast<char>(st_byte & ~(3 << ((i&3)<<1))) ; + st_byte = static_cast<char>(st_byte | (st << ((i&3)<<1))) ; + } + + /** \c const overload for + \link CoinWarmStartBasis::getArtificialStatus() + getArtificialStatus() + \endlink + */ + inline const char * getArtificialStatus() const { return artificialStatus_; } + +//@} + +/*! \name Basis `diff' methods */ +//@{ + + /*! \brief Generate a `diff' that can convert the warm start basis passed as + a parameter to the warm start basis specified by \c this. + + The capabilities are limited: the basis passed as a parameter can be no + larger than the basis pointed to by \c this. + */ + + virtual CoinWarmStartDiff* + generateDiff (const CoinWarmStart *const oldCWS) const ; + + /*! \brief Apply \p diff to this basis + + Update this basis by applying \p diff. It's assumed that the allocated + capacity of the basis is sufficiently large. + */ + + virtual void + applyDiff (const CoinWarmStartDiff *const cwsdDiff) ; + +//@} + + +/*! \name Methods to modify the warm start object */ +//@{ + + /*! \brief Set basis capacity; existing basis is discarded. + + After execution of this routine, the warm start object does not describe + a valid basis: all structural and artificial variables have status isFree. + */ + virtual void setSize(int ns, int na) ; + + /*! \brief Set basis capacity; existing basis is maintained. + + After execution of this routine, the warm start object describes a valid + basis: the status of new structural variables (added columns) is set to + nonbasic at lower bound, and the status of new artificial variables + (added rows) is set to basic. (The basis can be invalid if new structural + variables do not have a finite lower bound.) + */ + virtual void resize (int newNumberRows, int newNumberColumns); + + /** \brief Delete a set of rows from the basis + + \warning + This routine assumes that the set of indices to be deleted is sorted in + ascending order and contains no duplicates. Use deleteRows() if this is + not the case. + + \warning + The resulting basis is guaranteed valid only if all deleted + constraints are slack (hence the associated logicals are basic). + + Removal of a tight constraint with a nonbasic logical implies that + some basic variable must be made nonbasic. This correction is left to + the client. + */ + + virtual void compressRows (int tgtCnt, const int *tgts) ; + + /** \brief Delete a set of rows from the basis + + \warning + The resulting basis is guaranteed valid only if all deleted + constraints are slack (hence the associated logicals are basic). + + Removal of a tight constraint with a nonbasic logical implies that + some basic variable must be made nonbasic. This correction is left to + the client. + */ + + virtual void deleteRows(int rawTgtCnt, const int *rawTgts) ; + + /** \brief Delete a set of columns from the basis + + \warning + The resulting basis is guaranteed valid only if all deleted variables + are nonbasic. + + Removal of a basic variable implies that some nonbasic variable must be + made basic. This correction is left to the client. + */ + + virtual void deleteColumns(int number, const int * which); + + /** \brief Merge entries from a source basis into this basis. + + \warning + It's the client's responsibility to ensure validity of the merged basis, + if that's important to the application. + + The vector xferCols (xferRows) specifies runs of entries to be taken from + the source basis and placed in this basis. Each entry is a CoinTriple, + with first specifying the starting source index of a run, second + specifying the starting destination index, and third specifying the run + length. + */ + virtual void mergeBasis(const CoinWarmStartBasis *src, + const XferVec *xferRows, + const XferVec *xferCols) ; + +//@} + +/*! \name Constructors, destructors, and related functions */ + +//@{ + + /** Default constructor + + Creates a warm start object representing an empty basis + (0 rows, 0 columns). + */ + CoinWarmStartBasis(); + + /** Constructs a warm start object with the specified status vectors. + + The parameters are copied. + Consider assignBasisStatus(int,int,char*&,char*&) if the object should + assume ownership. + + \sa CoinWarmStartBasis::Status for a description of the packing used in + the status arrays. + */ + CoinWarmStartBasis(int ns, int na, const char* sStat, const char* aStat) ; + + /** Copy constructor */ + CoinWarmStartBasis(const CoinWarmStartBasis& ws) ; + + /** `Virtual constructor' */ + virtual CoinWarmStart *clone() const + { + return new CoinWarmStartBasis(*this); + } + + /** Destructor */ + virtual ~CoinWarmStartBasis(); + + /** Assignment */ + + virtual CoinWarmStartBasis& operator=(const CoinWarmStartBasis& rhs) ; + + /** Assign the status vectors to be the warm start information. + + In this method the CoinWarmStartBasis object assumes ownership of the + pointers and upon return the argument pointers will be NULL. + If copying is desirable, use the + \link CoinWarmStartBasis(int,int,const char*,const char*) + array constructor \endlink + or the + \link operator=(const CoinWarmStartBasis&) + assignment operator \endlink. + + \note + The pointers passed to this method will be + freed using delete[], so they must be created using new[]. + */ + virtual void assignBasisStatus(int ns, int na, char*& sStat, char*& aStat) ; +//@} + +/*! \name Miscellaneous methods */ +//@{ + + /// Prints in readable format (for debug) + virtual void print() const; + /// Returns true if full basis (for debug) + bool fullBasis() const; + /// Returns true if full basis and fixes up (for debug) + bool fixFullBasis(); + +//@} + +protected: + /** \name Protected data members + + \sa CoinWarmStartBasis::Status for a description of the packing used in + the status arrays. + */ + //@{ + /// The number of structural variables + int numStructural_; + /// The number of artificial variables + int numArtificial_; + /// The maximum sise (in ints - actually 4*char) (so resize does not need to do new) + int maxSize_; + /** The status of the structural variables. */ + char * structuralStatus_; + /** The status of the artificial variables. */ + char * artificialStatus_; + //@} +}; + + +/*! \relates CoinWarmStartBasis + \brief Get the status of the specified variable in the given status array. +*/ + +inline CoinWarmStartBasis::Status getStatus(const char *array, int i) { + const int st = (array[i>>2] >> ((i&3)<<1)) & 3; + return static_cast<CoinWarmStartBasis::Status>(st); +} + +/*! \relates CoinWarmStartBasis + \brief Set the status of the specified variable in the given status array. +*/ + +inline void setStatus(char * array, int i, CoinWarmStartBasis::Status st) { + char& st_byte = array[i>>2]; + st_byte = static_cast<char>(st_byte & ~(3 << ((i&3)<<1))) ; + st_byte = static_cast<char>(st_byte | (st << ((i&3)<<1))) ; +} + +/*! \relates CoinWarmStartBasis + \brief Generate a print string for a status code +*/ +const char *statusName(CoinWarmStartBasis::Status status) ; + + +/*! \class CoinWarmStartBasisDiff + \brief A `diff' between two CoinWarmStartBasis objects + + This class exists in order to hide from the world the details of + calculating and representing a `diff' between two CoinWarmStartBasis + objects. For convenience, assignment, cloning, and deletion are visible to + the world, and default and copy constructors are made available to derived + classes. Knowledge of the rest of this structure, and of generating and + applying diffs, is restricted to the friend functions + CoinWarmStartBasis::generateDiff() and CoinWarmStartBasis::applyDiff(). + + The actual data structure is an unsigned int vector, #difference_ which + starts with indices of changed and then has values starting after #sze_ + + \todo This is a pretty generic structure, and vector diff is a pretty generic + activity. We should be able to convert this to a template. + + \todo Using unsigned int as the data type for the diff vectors might help + to contain the damage when this code is inevitably compiled for 64 bit + architectures. But the notion of int as 4 bytes is hardwired into + CoinWarmStartBasis, so changes are definitely required. +*/ + +class CoinWarmStartBasisDiff : public virtual CoinWarmStartDiff +{ public: + + /*! \brief `Virtual constructor' */ + virtual CoinWarmStartDiff *clone() const + { CoinWarmStartBasisDiff *cwsbd = new CoinWarmStartBasisDiff(*this) ; + return (dynamic_cast<CoinWarmStartDiff *>(cwsbd)) ; } + + /*! \brief Assignment */ + virtual + CoinWarmStartBasisDiff &operator= (const CoinWarmStartBasisDiff &rhs) ; + + /*! \brief Destructor */ + virtual ~CoinWarmStartBasisDiff(); + + protected: + + /*! \brief Default constructor + + This is protected (rather than private) so that derived classes can + see it when they make <i>their</i> default constructor protected or + private. + */ + CoinWarmStartBasisDiff () : sze_(0), difference_(0) { } + + /*! \brief Copy constructor + + For convenience when copying objects containing CoinWarmStartBasisDiff + objects. But consider whether you should be using #clone() to retain + polymorphism. + + This is protected (rather than private) so that derived classes can + see it when they make <i>their</i> copy constructor protected or + private. + */ + CoinWarmStartBasisDiff (const CoinWarmStartBasisDiff &cwsbd) ; + + /*! \brief Standard constructor */ + CoinWarmStartBasisDiff (int sze, const unsigned int *const diffNdxs, + const unsigned int *const diffVals) ; + + /*! \brief Constructor when full is smaller than diff!*/ + CoinWarmStartBasisDiff (const CoinWarmStartBasis * rhs); + + private: + + friend CoinWarmStartDiff* + CoinWarmStartBasis::generateDiff(const CoinWarmStart *const oldCWS) const ; + friend void + CoinWarmStartBasis::applyDiff(const CoinWarmStartDiff *const diff) ; + + /*! \brief Number of entries (and allocated capacity), in units of \c int. */ + int sze_ ; + + /*! \brief Array of diff indices and diff values */ + + unsigned int *difference_ ; + +} ; + + +#endif diff --git a/thirdparty/windows/include/coin/CoinWarmStartDual.hpp b/thirdparty/windows/include/coin/CoinWarmStartDual.hpp new file mode 100644 index 0000000..3e60d11 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinWarmStartDual.hpp @@ -0,0 +1,166 @@ +/* $Id: CoinWarmStartDual.hpp 1372 2011-01-03 23:31:00Z lou $ */ +// 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 CoinWarmStartDual_H +#define CoinWarmStartDual_H + +#include "CoinHelperFunctions.hpp" +#include "CoinWarmStart.hpp" +#include "CoinWarmStartVector.hpp" + + +//############################################################################# + +/** WarmStart information that is only a dual vector */ + +class CoinWarmStartDual : public virtual CoinWarmStart { +public: + /// return the size of the dual vector + inline int size() const { return dual_.size(); } + /// return a pointer to the array of duals + inline const double * dual() const { return dual_.values(); } + + /** Assign the dual vector to be the warmstart information. In this method + the object assumes ownership of the pointer and upon return "dual" will + be a NULL pointer. If copying is desirable use the constructor. */ + inline void assignDual(int size, double *& dual) + { dual_.assignVector(size, dual); } + + CoinWarmStartDual() {} + + CoinWarmStartDual(int size, const double * dual) : dual_(size, dual) {} + + CoinWarmStartDual(const CoinWarmStartDual& rhs) : dual_(rhs.dual_) {} + + CoinWarmStartDual& operator=(const CoinWarmStartDual& rhs) { + if (this != &rhs) { + dual_ = rhs.dual_; + } + return *this; + } + + /** `Virtual constructor' */ + virtual CoinWarmStart *clone() const { + return new CoinWarmStartDual(*this); + } + + virtual ~CoinWarmStartDual() {} + +/*! \name Dual warm start `diff' methods */ +//@{ + + /*! \brief Generate a `diff' that can convert the warm start passed as a + parameter to the warm start specified by \c this. + + The capabilities are limited: the basis passed as a parameter can be no + larger than the basis pointed to by \c this. + */ + + virtual CoinWarmStartDiff* + generateDiff (const CoinWarmStart *const oldCWS) const ; + + /*! \brief Apply \p diff to this warm start. + + Update this warm start by applying \p diff. It's assumed that the + allocated capacity of the warm start is sufficiently large. + */ + + virtual void applyDiff (const CoinWarmStartDiff *const cwsdDiff) ; + +#if 0 +protected: + inline const CoinWarmStartVector<double>& warmStartVector() const { return dual_; } +#endif + +//@} + +private: + ///@name Private data members + CoinWarmStartVector<double> dual_; +}; + +//############################################################################# + +/*! \class CoinWarmStartDualDiff + \brief A `diff' between two CoinWarmStartDual objects + + This class exists in order to hide from the world the details of + calculating and representing a `diff' between two CoinWarmStartDual + objects. For convenience, assignment, cloning, and deletion are visible to + the world, and default and copy constructors are made available to derived + classes. Knowledge of the rest of this structure, and of generating and + applying diffs, is restricted to the friend functions + CoinWarmStartDual::generateDiff() and CoinWarmStartDual::applyDiff(). + + The actual data structure is a pair of vectors, #diffNdxs_ and #diffVals_. + +*/ + +class CoinWarmStartDualDiff : public virtual CoinWarmStartDiff +{ public: + + /*! \brief `Virtual constructor' */ + virtual CoinWarmStartDiff *clone() const + { + return new CoinWarmStartDualDiff(*this) ; + } + + /*! \brief Assignment */ + virtual CoinWarmStartDualDiff &operator= (const CoinWarmStartDualDiff &rhs) + { + if (this != &rhs) { + diff_ = rhs.diff_; + } + return *this; + } + + /*! \brief Destructor */ + virtual ~CoinWarmStartDualDiff() {} + + protected: + + /*! \brief Default constructor + + This is protected (rather than private) so that derived classes can + see it when they make <i>their</i> default constructor protected or + private. + */ + CoinWarmStartDualDiff () : diff_() {} + + /*! \brief Copy constructor + + For convenience when copying objects containing CoinWarmStartDualDiff + objects. But consider whether you should be using #clone() to retain + polymorphism. + + This is protected (rather than private) so that derived classes can + see it when the make <i>their</i> copy constructor protected or + private. + */ + CoinWarmStartDualDiff (const CoinWarmStartDualDiff &rhs) : + diff_(rhs.diff_) {} + + private: + + friend CoinWarmStartDiff* + CoinWarmStartDual::generateDiff(const CoinWarmStart *const oldCWS) const ; + friend void + CoinWarmStartDual::applyDiff(const CoinWarmStartDiff *const diff) ; + + /*! \brief Standard constructor */ + CoinWarmStartDualDiff (int sze, const unsigned int *const diffNdxs, + const double *const diffVals) : + diff_(sze, diffNdxs, diffVals) {} + + /*! + \brief The difference in the dual vector is simply the difference in a + vector. + */ + CoinWarmStartVectorDiff<double> diff_; +}; + + +#endif + diff --git a/thirdparty/windows/include/coin/CoinWarmStartPrimalDual.hpp b/thirdparty/windows/include/coin/CoinWarmStartPrimalDual.hpp new file mode 100644 index 0000000..c98d423 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinWarmStartPrimalDual.hpp @@ -0,0 +1,211 @@ +/* $Id: CoinWarmStartPrimalDual.hpp 1372 2011-01-03 23:31:00Z lou $ */ +// 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 CoinWarmStartPrimalDual_H +#define CoinWarmStartPrimalDual_H + +#include "CoinHelperFunctions.hpp" +#include "CoinWarmStart.hpp" +#include "CoinWarmStartVector.hpp" + + +//############################################################################# + +/** WarmStart information that is only a dual vector */ + +class CoinWarmStartPrimalDual : public virtual CoinWarmStart { +public: + /// return the size of the dual vector + inline int dualSize() const { return dual_.size(); } + /// return a pointer to the array of duals + inline const double * dual() const { return dual_.values(); } + + /// return the size of the primal vector + inline int primalSize() const { return primal_.size(); } + /// return a pointer to the array of primals + inline const double * primal() const { return primal_.values(); } + + /** Assign the primal/dual vectors to be the warmstart information. In this + method the object assumes ownership of the pointers and upon return \c + primal and \c dual will be a NULL pointers. If copying is desirable use + the constructor. + + NOTE: \c primal and \c dual must have been allocated by new double[], + because they will be freed by delete[] upon the desructtion of this + object... + */ + void assign(int primalSize, int dualSize, double*& primal, double *& dual) { + primal_.assignVector(primalSize, primal); + dual_.assignVector(dualSize, dual); + } + + CoinWarmStartPrimalDual() : primal_(), dual_() {} + + CoinWarmStartPrimalDual(int primalSize, int dualSize, + const double* primal, const double * dual) : + primal_(primalSize, primal), dual_(dualSize, dual) {} + + CoinWarmStartPrimalDual(const CoinWarmStartPrimalDual& rhs) : + primal_(rhs.primal_), dual_(rhs.dual_) {} + + CoinWarmStartPrimalDual& operator=(const CoinWarmStartPrimalDual& rhs) { + if (this != &rhs) { + primal_ = rhs.primal_; + dual_ = rhs.dual_; + } + return *this; + } + + /*! \brief Clear the data + + Make it appear as if the warmstart was just created using the default + constructor. + */ + inline void clear() { + primal_.clear(); + dual_.clear(); + } + + inline void swap(CoinWarmStartPrimalDual& rhs) { + if (this != &rhs) { + primal_.swap(rhs.primal_); + dual_.swap(rhs.dual_); + } + } + + /** `Virtual constructor' */ + virtual CoinWarmStart *clone() const { + return new CoinWarmStartPrimalDual(*this); + } + + virtual ~CoinWarmStartPrimalDual() {} + + /*! \name PrimalDual warm start `diff' methods */ + //@{ + + /*! \brief Generate a `diff' that can convert the warm start passed as a + parameter to the warm start specified by \c this. + + The capabilities are limited: the basis passed as a parameter can be no + larger than the basis pointed to by \c this. + */ + + virtual CoinWarmStartDiff* + generateDiff (const CoinWarmStart *const oldCWS) const ; + + /*! \brief Apply \p diff to this warm start. + + Update this warm start by applying \p diff. It's assumed that the + allocated capacity of the warm start is sufficiently large. + */ + + virtual void applyDiff (const CoinWarmStartDiff *const cwsdDiff) ; + + //@} + +#if 0 +protected: + inline const CoinWarmStartVector<double>& primalWarmStartVector() const + { return primal_; } + inline const CoinWarmStartVector<double>& dualWarmStartVector() const + { return dual_; } +#endif + +private: + ///@name Private data members + //@{ + CoinWarmStartVector<double> primal_; + CoinWarmStartVector<double> dual_; + //@} +}; + +//############################################################################# + +/*! \class CoinWarmStartPrimalDualDiff + \brief A `diff' between two CoinWarmStartPrimalDual objects + + This class exists in order to hide from the world the details of calculating + and representing a `diff' between two CoinWarmStartPrimalDual objects. For + convenience, assignment, cloning, and deletion are visible to the world, and + default and copy constructors are made available to derived classes. + Knowledge of the rest of this structure, and of generating and applying + diffs, is restricted to the friend functions + CoinWarmStartPrimalDual::generateDiff() and + CoinWarmStartPrimalDual::applyDiff(). + + The actual data structure is a pair of vectors, #diffNdxs_ and #diffVals_. + +*/ + +class CoinWarmStartPrimalDualDiff : public virtual CoinWarmStartDiff +{ + friend CoinWarmStartDiff* + CoinWarmStartPrimalDual::generateDiff(const CoinWarmStart *const oldCWS) const; + friend void + CoinWarmStartPrimalDual::applyDiff(const CoinWarmStartDiff *const diff) ; + +public: + + /*! \brief `Virtual constructor'. To be used when retaining polymorphism is + important */ + virtual CoinWarmStartDiff *clone() const + { + return new CoinWarmStartPrimalDualDiff(*this); + } + + /*! \brief Destructor */ + virtual ~CoinWarmStartPrimalDualDiff() {} + +protected: + + /*! \brief Default constructor + + This is protected (rather than private) so that derived classes can + see it when they make <i>their</i> default constructor protected or + private. + */ + CoinWarmStartPrimalDualDiff () : primalDiff_(), dualDiff_() {} + + /*! \brief Copy constructor + + For convenience when copying objects containing + CoinWarmStartPrimalDualDiff objects. But consider whether you should be + using #clone() to retain polymorphism. + + This is protected (rather than private) so that derived classes can + see it when the make <i>their</i> copy constructor protected or + private. + */ + CoinWarmStartPrimalDualDiff (const CoinWarmStartPrimalDualDiff &rhs) : + primalDiff_(rhs.primalDiff_), dualDiff_(rhs.dualDiff_) {} + + /*! \brief Clear the data + + Make it appear as if the diff was just created using the default + constructor. + */ + inline void clear() { + primalDiff_.clear(); + dualDiff_.clear(); + } + + inline void swap(CoinWarmStartPrimalDualDiff& rhs) { + if (this != &rhs) { + primalDiff_.swap(rhs.primalDiff_); + dualDiff_.swap(rhs.dualDiff_); + } + } + +private: + + /*! + \brief These two differences describe the differences in the primal and + in the dual vector. + */ + CoinWarmStartVectorDiff<double> primalDiff_; + CoinWarmStartVectorDiff<double> dualDiff_; +} ; + +#endif diff --git a/thirdparty/windows/include/coin/CoinWarmStartVector.hpp b/thirdparty/windows/include/coin/CoinWarmStartVector.hpp new file mode 100644 index 0000000..e43ea10 --- /dev/null +++ b/thirdparty/windows/include/coin/CoinWarmStartVector.hpp @@ -0,0 +1,488 @@ +/* $Id: CoinWarmStartVector.hpp 1498 2011-11-02 15:25:35Z mjs $ */ +// 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 CoinWarmStartVector_H +#define CoinWarmStartVector_H + +#if defined(_MSC_VER) +// Turn off compiler warning about long names +# pragma warning(disable:4786) +#endif + +#include <cassert> +#include <cmath> + +#include "CoinHelperFunctions.hpp" +#include "CoinWarmStart.hpp" + + +//############################################################################# + +/** WarmStart information that is only a vector */ + +template <typename T> +class CoinWarmStartVector : public virtual CoinWarmStart +{ +protected: + inline void gutsOfDestructor() { + delete[] values_; + } + inline void gutsOfCopy(const CoinWarmStartVector<T>& rhs) { + size_ = rhs.size_; + values_ = new T[size_]; + CoinDisjointCopyN(rhs.values_, size_, values_); + } + +public: + /// return the size of the vector + int size() const { return size_; } + /// return a pointer to the array of vectors + const T* values() const { return values_; } + + /** Assign the vector to be the warmstart information. In this method + the object assumes ownership of the pointer and upon return #vector will + be a NULL pointer. If copying is desirable use the constructor. */ + void assignVector(int size, T*& vec) { + size_ = size; + delete[] values_; + values_ = vec; + vec = NULL; + } + + CoinWarmStartVector() : size_(0), values_(NULL) {} + + CoinWarmStartVector(int size, const T* vec) : + size_(size), values_(new T[size]) { + CoinDisjointCopyN(vec, size, values_); + } + + CoinWarmStartVector(const CoinWarmStartVector& rhs) { + gutsOfCopy(rhs); + } + + CoinWarmStartVector& operator=(const CoinWarmStartVector& rhs) { + if (this != &rhs) { + gutsOfDestructor(); + gutsOfCopy(rhs); + } + return *this; + } + + inline void swap(CoinWarmStartVector& rhs) { + if (this != &rhs) { + std::swap(size_, rhs.size_); + std::swap(values_, rhs.values_); + } + } + + /** `Virtual constructor' */ + virtual CoinWarmStart *clone() const { + return new CoinWarmStartVector(*this); + } + + virtual ~CoinWarmStartVector() { + gutsOfDestructor(); + } + + /*! \brief Clear the data + + Make it appear as if the warmstart was just created using the default + constructor. + */ + inline void clear() { + size_ = 0; + delete[] values_; + values_ = NULL; + } + + /*! \name Vector warm start `diff' methods */ + //@{ + + /*! \brief Generate a `diff' that can convert the warm start passed as a + parameter to the warm start specified by \c this. + + The capabilities are limited: the basis passed as a parameter can be no + larger than the basis pointed to by \c this. + */ + + virtual CoinWarmStartDiff* + generateDiff (const CoinWarmStart *const oldCWS) const ; + + /*! \brief Apply \p diff to this warm start. + + Update this warm start by applying \p diff. It's assumed that the + allocated capacity of the warm start is sufficiently large. + */ + + virtual void applyDiff (const CoinWarmStartDiff *const cwsdDiff) ; + + //@} + +private: + ///@name Private data members + //@{ + /// the size of the vector + int size_; + /// the vector itself + T* values_; + //@} +}; + +//============================================================================= + +/*! \class CoinWarmStartVectorDiff + \brief A `diff' between two CoinWarmStartVector objects + + This class exists in order to hide from the world the details of calculating + and representing a `diff' between two CoinWarmStartVector objects. For + convenience, assignment, cloning, and deletion are visible to the world, and + default and copy constructors are made available to derived classes. + Knowledge of the rest of this structure, and of generating and applying + diffs, is restricted to the friend functions + CoinWarmStartVector::generateDiff() and CoinWarmStartVector::applyDiff(). + + The actual data structure is a pair of vectors, #diffNdxs_ and #diffVals_. + +*/ + +template <typename T> +class CoinWarmStartVectorDiff : public virtual CoinWarmStartDiff +{ + friend CoinWarmStartDiff* + CoinWarmStartVector<T>::generateDiff(const CoinWarmStart *const oldCWS) const; + friend void + CoinWarmStartVector<T>::applyDiff(const CoinWarmStartDiff *const diff) ; + +public: + + /*! \brief `Virtual constructor' */ + virtual CoinWarmStartDiff * clone() const { + return new CoinWarmStartVectorDiff(*this) ; + } + + /*! \brief Assignment */ + virtual CoinWarmStartVectorDiff & + operator= (const CoinWarmStartVectorDiff<T>& rhs) ; + + /*! \brief Destructor */ + virtual ~CoinWarmStartVectorDiff() { + delete[] diffNdxs_ ; + delete[] diffVals_ ; + } + + inline void swap(CoinWarmStartVectorDiff& rhs) { + if (this != &rhs) { + std::swap(sze_, rhs.sze_); + std::swap(diffNdxs_, rhs.diffNdxs_); + std::swap(diffVals_, rhs.diffVals_); + } + } + + /*! \brief Default constructor + */ + CoinWarmStartVectorDiff () : sze_(0), diffNdxs_(0), diffVals_(NULL) {} + + /*! \brief Copy constructor + + For convenience when copying objects containing CoinWarmStartVectorDiff + objects. But consider whether you should be using #clone() to retain + polymorphism. + */ + CoinWarmStartVectorDiff(const CoinWarmStartVectorDiff<T>& rhs) ; + + /*! \brief Standard constructor */ + CoinWarmStartVectorDiff(int sze, const unsigned int* const diffNdxs, + const T* const diffVals) ; + + /*! \brief Clear the data + + Make it appear as if the diff was just created using the default + constructor. + */ + inline void clear() { + sze_ = 0; + delete[] diffNdxs_; diffNdxs_ = NULL; + delete[] diffVals_; diffVals_ = NULL; + } + +private: + + /*! + \brief Number of entries (and allocated capacity), in units of \c T. + */ + int sze_ ; + + /*! \brief Array of diff indices */ + + unsigned int* diffNdxs_ ; + + /*! \brief Array of diff values */ + + T* diffVals_ ; +}; + +//############################################################################## + +template <typename T, typename U> +class CoinWarmStartVectorPair : public virtual CoinWarmStart +{ +private: + CoinWarmStartVector<T> t_; + CoinWarmStartVector<U> u_; + +public: + inline int size0() const { return t_.size(); } + inline int size1() const { return u_.size(); } + inline const T* values0() const { return t_.values(); } + inline const U* values1() const { return u_.values(); } + + inline void assignVector0(int size, T*& vec) { t_.assignVector(size, vec); } + inline void assignVector1(int size, U*& vec) { u_.assignVector(size, vec); } + + CoinWarmStartVectorPair() {} + CoinWarmStartVectorPair(int s0, const T* v0, int s1, const U* v1) : + t_(s0, v0), u_(s1, v1) {} + + CoinWarmStartVectorPair(const CoinWarmStartVectorPair<T,U>& rhs) : + t_(rhs.t_), u_(rhs.u_) {} + CoinWarmStartVectorPair& operator=(const CoinWarmStartVectorPair<T,U>& rhs) { + if (this != &rhs) { + t_ = rhs.t_; + u_ = rhs.u_; + } + return *this; + } + + inline void swap(CoinWarmStartVectorPair<T,U>& rhs) { + t_.swap(rhs.t_); + u_.swap(rhs.u_); + } + + virtual CoinWarmStart *clone() const { + return new CoinWarmStartVectorPair(*this); + } + + virtual ~CoinWarmStartVectorPair() {} + + inline void clear() { + t_.clear(); + u_.clear(); + } + + virtual CoinWarmStartDiff* + generateDiff (const CoinWarmStart *const oldCWS) const ; + + virtual void applyDiff (const CoinWarmStartDiff *const cwsdDiff) ; +}; + +//============================================================================= + +template <typename T, typename U> +class CoinWarmStartVectorPairDiff : public virtual CoinWarmStartDiff +{ + friend CoinWarmStartDiff* + CoinWarmStartVectorPair<T,U>::generateDiff(const CoinWarmStart *const oldCWS) const; + friend void + CoinWarmStartVectorPair<T,U>::applyDiff(const CoinWarmStartDiff *const diff) ; + +private: + CoinWarmStartVectorDiff<T> tdiff_; + CoinWarmStartVectorDiff<U> udiff_; + +public: + CoinWarmStartVectorPairDiff() {} + CoinWarmStartVectorPairDiff(const CoinWarmStartVectorPairDiff<T,U>& rhs) : + tdiff_(rhs.tdiff_), udiff_(rhs.udiff_) {} + virtual ~CoinWarmStartVectorPairDiff() {} + + virtual CoinWarmStartVectorPairDiff& + operator=(const CoinWarmStartVectorPairDiff<T,U>& rhs) { + if (this != &rhs) { + tdiff_ = rhs.tdiff_; + udiff_ = rhs.udiff_; + } + return *this; + } + + virtual CoinWarmStartDiff * clone() const { + return new CoinWarmStartVectorPairDiff(*this) ; + } + + inline void swap(CoinWarmStartVectorPairDiff<T,U>& rhs) { + tdiff_.swap(rhs.tdiff_); + udiff_.swap(rhs.udiff_); + } + + inline void clear() { + tdiff_.clear(); + udiff_.clear(); + } +}; + +//############################################################################## +//############################################################################# + +/* + Generate a `diff' that can convert the warm start passed as a parameter to + the warm start specified by this. + + The capabilities are limited: the basis passed as a parameter can be no + larger than the basis pointed to by this. +*/ + +template <typename T> CoinWarmStartDiff* +CoinWarmStartVector<T>::generateDiff(const CoinWarmStart *const oldCWS) const +{ +/* + Make sure the parameter is CoinWarmStartVector or derived class. +*/ + const CoinWarmStartVector<T>* oldVector = + dynamic_cast<const CoinWarmStartVector<T>*>(oldCWS); + if (!oldVector) + { throw CoinError("Old warm start not derived from CoinWarmStartVector.", + "generateDiff","CoinWarmStartVector") ; } + const CoinWarmStartVector<T>* newVector = this ; + /* + Make sure newVector is equal or bigger than oldVector. Calculate the worst + case number of diffs and allocate vectors to hold them. + */ + const int oldCnt = oldVector->size() ; + const int newCnt = newVector->size() ; + + assert(newCnt >= oldCnt) ; + + unsigned int *diffNdx = new unsigned int [newCnt]; + T* diffVal = new T[newCnt]; + /* + Scan the vector vectors. For the portion of the vectors which overlap, + create diffs. Then add any additional entries from newVector. + */ + const T*oldVal = oldVector->values() ; + const T*newVal = newVector->values() ; + int numberChanged = 0 ; + int i ; + for (i = 0 ; i < oldCnt ; i++) { + if (oldVal[i] != newVal[i]) { + diffNdx[numberChanged] = i ; + diffVal[numberChanged++] = newVal[i] ; + } + } + for ( ; i < newCnt ; i++) { + diffNdx[numberChanged] = i ; + diffVal[numberChanged++] = newVal[i] ; + } + /* + Create the object of our desire. + */ + CoinWarmStartVectorDiff<T> *diff = + new CoinWarmStartVectorDiff<T>(numberChanged,diffNdx,diffVal) ; + /* + Clean up and return. + */ + delete[] diffNdx ; + delete[] diffVal ; + + return diff; + // return (dynamic_cast<CoinWarmStartDiff<T>*>(diff)) ; +} + + +/* + Apply diff to this warm start. + + Update this warm start by applying diff. It's assumed that the + allocated capacity of the warm start is sufficiently large. +*/ + +template <typename T> void +CoinWarmStartVector<T>::applyDiff (const CoinWarmStartDiff *const cwsdDiff) +{ + /* + Make sure we have a CoinWarmStartVectorDiff + */ + const CoinWarmStartVectorDiff<T>* diff = + dynamic_cast<const CoinWarmStartVectorDiff<T>*>(cwsdDiff) ; + if (!diff) { + throw CoinError("Diff not derived from CoinWarmStartVectorDiff.", + "applyDiff","CoinWarmStartVector") ; + } + /* + Application is by straighforward replacement of words in the vector vector. + */ + const int numberChanges = diff->sze_ ; + const unsigned int *diffNdxs = diff->diffNdxs_ ; + const T* diffVals = diff->diffVals_ ; + T* vals = this->values_ ; + + for (int i = 0 ; i < numberChanges ; i++) { + unsigned int diffNdx = diffNdxs[i] ; + T diffVal = diffVals[i] ; + vals[diffNdx] = diffVal ; + } +} + +//############################################################################# + + +// Assignment + +template <typename T> CoinWarmStartVectorDiff<T>& +CoinWarmStartVectorDiff<T>::operator=(const CoinWarmStartVectorDiff<T> &rhs) +{ + if (this != &rhs) { + if (sze_ > 0) { + delete[] diffNdxs_ ; + delete[] diffVals_ ; + } + sze_ = rhs.sze_ ; + if (sze_ > 0) { + diffNdxs_ = new unsigned int[sze_] ; + memcpy(diffNdxs_,rhs.diffNdxs_,sze_*sizeof(unsigned int)) ; + diffVals_ = new T[sze_] ; + memcpy(diffVals_,rhs.diffVals_,sze_*sizeof(T)) ; + } else { + diffNdxs_ = 0 ; + diffVals_ = 0 ; + } + } + + return (*this) ; +} + + +// Copy constructor + +template <typename T> +CoinWarmStartVectorDiff<T>::CoinWarmStartVectorDiff(const CoinWarmStartVectorDiff<T> &rhs) + : sze_(rhs.sze_), + diffNdxs_(0), + diffVals_(0) +{ + if (sze_ > 0) { + diffNdxs_ = new unsigned int[sze_] ; + memcpy(diffNdxs_,rhs.diffNdxs_,sze_*sizeof(unsigned int)) ; + diffVals_ = new T[sze_] ; + memcpy(diffVals_,rhs.diffVals_,sze_*sizeof(T)) ; + } +} + +/// Standard constructor + +template <typename T> +CoinWarmStartVectorDiff<T>::CoinWarmStartVectorDiff +(int sze, const unsigned int *const diffNdxs, const T *const diffVals) + : sze_(sze), + diffNdxs_(0), + diffVals_(0) +{ + if (sze > 0) { + diffNdxs_ = new unsigned int[sze] ; + memcpy(diffNdxs_,diffNdxs,sze*sizeof(unsigned int)) ; + diffVals_ = new T[sze] ; + memcpy(diffVals_,diffVals,sze*sizeof(T)) ; + } +} + +#endif diff --git a/thirdparty/windows/include/coin/Coin_C_defines.h b/thirdparty/windows/include/coin/Coin_C_defines.h new file mode 100644 index 0000000..5c43aaa --- /dev/null +++ b/thirdparty/windows/include/coin/Coin_C_defines.h @@ -0,0 +1,115 @@ +/* $Id: Coin_C_defines.h 1690 2014-03-13 17:45:21Z mlubin $ */ +/* + Copyright (C) 2002, 2003 International Business Machines Corporation + and others. All Rights Reserved. + + This code is licensed under the terms of the Eclipse Public License (EPL). +*/ +#ifndef CoinCDefine_H +#define CoinCDefine_H + +/** This has #defines etc for the "C" interface to Coin. + If COIN_EXTERN_C defined then an extra extern C +*/ + +#if defined (CLP_EXTERN_C) +#define COIN_EXTERN_C +#define COIN_NO_SBB +#define COIN_NO_CBC +#endif +#if defined (SBB_EXTERN_C) +#define COIN_EXTERN_C +#define COIN_NO_CLP +#endif +#if defined (CBC_EXTERN_C) +#define COIN_EXTERN_C +#define COIN_NO_CLP +#endif +/* We need to allow for Microsoft */ +#ifndef COINLIBAPI + +#if defined(CBCCINTERFACEDLL_EXPORTS) || defined(CLPMSDLL) +#if defined (COIN_EXTERN_C) +# define COINLIBAPI __declspec(dllexport) +#else +# define COINLIBAPI __declspec(dllexport) +#endif +# define COINLINKAGE __stdcall +# define COINLINKAGE_CB __cdecl +#else +#if defined (COIN_EXTERN_C) +# define COINLIBAPI extern "C" +#else +# define COINLIBAPI +#endif +# define COINLINKAGE +# define COINLINKAGE_CB +#endif + +#endif +/** User does not need to see structure of model but C++ code does */ +#if defined (CLP_EXTERN_C) +/* Real typedef for structure */ +class CMessageHandler; +typedef struct { + ClpSimplex * model_; + CMessageHandler * handler_; +} Clp_Simplex; +#else +typedef void Clp_Simplex; +#endif + +#ifndef COIN_NO_CLP +/** typedef for user call back. + The cvec are constructed so don't need to be const*/ +typedef void (COINLINKAGE_CB *clp_callback) (Clp_Simplex * model,int msgno, int ndouble, + const double * dvec, int nint, const int * ivec, + int nchar, char ** cvec); +#endif +/** User does not need to see structure of model but C++ code does */ +#if defined (SBB_EXTERN_C) +/* Real typedef for structure */ +class Sbb_MessageHandler; +typedef struct { + OsiClpSolverInterface * solver_; + SbbModel * model_; + Sbb_MessageHandler * handler_; + char * information_; +} Sbb_Model; +#else +typedef void Sbb_Model; +#endif +#if defined (CBC_EXTERN_C) +/* Real typedef for structure */ +class Cbc_MessageHandler; +typedef struct { + OsiClpSolverInterface * solver_; + CbcModel * model_; + Cbc_MessageHandler * handler_; + std::vector<std::string> cmdargs_; +} Cbc_Model; +#else +typedef void Cbc_Model; +#endif +#ifndef COIN_NO_SBB +/** typedef for user call back. + The cvec are constructed so don't need to be const*/ +typedef void (COINLINKAGE_CB *sbb_callback) (Sbb_Model * model,int msgno, int ndouble, + const double * dvec, int nint, const int * ivec, + int nchar, char ** cvec); +typedef void (COINLINKAGE_CB *cbc_callback) (Cbc_Model * model,int msgno, int ndouble, + const double * dvec, int nint, const int * ivec, + int nchar, char ** cvec); +#endif +#if COIN_BIG_INDEX==0 +typedef int CoinBigIndex; +#elif COIN_BIG_INDEX==1 +typedef long CoinBigIndex; +#else +typedef long long CoinBigIndex; +#endif +/* just in case used somewhere */ +#undef COIN_NO_CLP +#undef COIN_NO_SBB +#undef COIN_NO_CBC +#endif diff --git a/thirdparty/windows/include/coin/Idiot.hpp b/thirdparty/windows/include/coin/Idiot.hpp new file mode 100644 index 0000000..b675c4f --- /dev/null +++ b/thirdparty/windows/include/coin/Idiot.hpp @@ -0,0 +1,298 @@ +/* $Id: Idiot.hpp 2143 2015-05-20 15:49:17Z 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). + +// "Idiot" as the name of this algorithm is copylefted. If you want to change +// the name then it should be something equally stupid (but not "Stupid") or +// even better something witty. + +#ifndef Idiot_H +#define Idiot_H +#ifndef OSI_IDIOT +#include "ClpSimplex.hpp" +#define OsiSolverInterface ClpSimplex +#else +#include "OsiSolverInterface.hpp" +typedef int CoinBigIndex; +#endif +class CoinMessageHandler; +class CoinMessages; +/// for use internally +typedef struct { + double infeas; + double objval; + double dropThis; + double weighted; + double sumSquared; + double djAtBeginning; + double djAtEnd; + int iteration; +} IdiotResult; +/** This class implements a very silly algorithm. It has no merit + apart from the fact that it gets an approximate solution to + some classes of problems. Better if vaguely homogeneous. + It works on problems where volume algorithm works and often + gets a better primal solution but it has no dual solution. + + It can also be used as a "crash" to get a problem started. This + is probably its most useful function. + + It is based on the idea that algorithms with terrible convergence + properties may be okay at first. Throw in some random dubious tricks + and the resulting code may be worth keeping as long as you don't + look at it. + +*/ + +class Idiot { + +public: + + /**@name Constructors and destructor + Just a pointer to model is kept + */ + //@{ + /// Default constructor + Idiot ( ); + /// Constructor with model + Idiot ( OsiSolverInterface & model ); + + /// Copy constructor. + Idiot(const Idiot &); + /// Assignment operator. This copies the data + Idiot & operator=(const Idiot & rhs); + /// Destructor + ~Idiot ( ); + //@} + + + /**@name Algorithmic calls + */ + //@{ + /// Get an approximate solution with the idiot code + void solve(); + /// Lightweight "crash" + void crash(int numberPass, CoinMessageHandler * handler, + const CoinMessages * messages, bool doCrossover = true); + /** Use simplex to get an optimal solution + mode is how many steps the simplex crossover should take to + arrive to an extreme point: + 0 - chosen,all ever used, all + 1 - chosen, all + 2 - all + 3 - do not do anything - maybe basis + + 16 do presolves + */ + void crossOver(int mode); + //@} + + + /**@name Gets and sets of most useful data + */ + //@{ + /** Starting weight - small emphasizes feasibility, + default 1.0e-4 */ + inline double getStartingWeight() const { + return mu_; + } + inline void setStartingWeight(double value) { + mu_ = value; + } + /** Weight factor - weight multiplied by this when changes, + default 0.333 */ + inline double getWeightFactor() const { + return muFactor_; + } + inline void setWeightFactor(double value) { + muFactor_ = value; + } + /** Feasibility tolerance - problem essentially feasible if + individual infeasibilities less than this. + default 0.1 */ + inline double getFeasibilityTolerance() const { + return smallInfeas_; + } + inline void setFeasibilityTolerance(double value) { + smallInfeas_ = value; + } + /** Reasonably feasible. Dubious method concentrates more on + objective when sum of infeasibilities less than this. + Very dubious default value of (Number of rows)/20 */ + inline double getReasonablyFeasible() const { + return reasonableInfeas_; + } + inline void setReasonablyFeasible(double value) { + reasonableInfeas_ = value; + } + /** Exit infeasibility - exit if sum of infeasibilities less than this. + Default -1.0 (i.e. switched off) */ + inline double getExitInfeasibility() const { + return exitFeasibility_; + } + inline void setExitInfeasibility(double value) { + exitFeasibility_ = value; + } + /** Major iterations. stop after this number. + Default 30. Use 2-5 for "crash" 50-100 for serious crunching */ + inline int getMajorIterations() const { + return majorIterations_; + } + inline void setMajorIterations(int value) { + majorIterations_ = value; + } + /** Minor iterations. Do this number of tiny steps before + deciding whether to change weights etc. + Default - dubious sqrt(Number of Rows). + Good numbers 105 to 405 say (5 is dubious method of making sure + idiot is not trying to be clever which it may do every 10 minor + iterations) */ + inline int getMinorIterations() const { + return maxIts2_; + } + inline void setMinorIterations(int value) { + maxIts2_ = value; + } + // minor iterations for first time + inline int getMinorIterations0() const { + return maxIts_; + } + inline void setMinorIterations0(int value) { + maxIts_ = value; + } + /** Reduce weight after this many major iterations. It may + get reduced before this but this is a maximum. + Default 3. 3-10 plausible. */ + inline int getReduceIterations() const { + return maxBigIts_; + } + inline void setReduceIterations(int value) { + maxBigIts_ = value; + } + /// Amount of information - default of 1 should be okay + inline int getLogLevel() const { + return logLevel_; + } + inline void setLogLevel(int value) { + logLevel_ = value; + } + /// How lightweight - 0 not, 1 yes, 2 very lightweight + inline int getLightweight() const { + return lightWeight_; + } + inline void setLightweight(int value) { + lightWeight_ = value; + } + /// strategy + inline int getStrategy() const { + return strategy_; + } + inline void setStrategy(int value) { + strategy_ = value; + } + /// Fine tuning - okay if feasibility drop this factor + inline double getDropEnoughFeasibility() const { + return dropEnoughFeasibility_; + } + inline void setDropEnoughFeasibility(double value) { + dropEnoughFeasibility_ = value; + } + /// Fine tuning - okay if weighted obj drop this factor + inline double getDropEnoughWeighted() const { + return dropEnoughWeighted_; + } + inline void setDropEnoughWeighted(double value) { + dropEnoughWeighted_ = value; + } + /// Set model + inline void setModel(OsiSolverInterface * model) { + model_ = model; + }; + //@} + + +/// Stuff for internal use +private: + + /// Does actual work + // allow public! +public: + void solve2(CoinMessageHandler * handler, const CoinMessages *messages); +private: + IdiotResult IdiSolve( + int nrows, int ncols, double * rowsol , double * colsol, + double * pi, double * djs, const double * origcost , + double * rowlower, + double * rowupper, const double * lower, + const double * upper, const double * element, + const int * row, const CoinBigIndex * colcc, + const int * length, double * lambda, + int maxIts, double mu, double drop, + double maxmin, double offset, + int strategy, double djTol, double djExit, double djFlag, + CoinThreadRandom * randomNumberGenerator); + int dropping(IdiotResult result, + double tolerance, + double small, + int *nbad); + IdiotResult objval(int nrows, int ncols, double * rowsol , double * colsol, + double * pi, double * djs, const double * cost , + const double * rowlower, + const double * rowupper, const double * lower, + const double * upper, const double * elemnt, + const int * row, const CoinBigIndex * columnStart, + const int * length, int extraBlock, int * rowExtra, + double * solExtra, double * elemExtra, double * upperExtra, + double * costExtra, double weight); + // Deals with whenUsed and slacks + int cleanIteration(int iteration, int ordinaryStart, int ordinaryEnd, + double * colsol, const double * lower, const double * upper, + const double * rowLower, const double * rowUpper, + const double * cost, const double * element, double fixTolerance, double & objChange, + double & infChange, double & maxInfeasibility); +private: + /// Underlying model + OsiSolverInterface * model_; + + double djTolerance_; + double mu_; /* starting mu */ + double drop_; /* exit if drop over 5 checks less than this */ + double muFactor_; /* reduce mu by this */ + double stopMu_; /* exit if mu gets smaller than this */ + double smallInfeas_; /* feasibility tolerance */ + double reasonableInfeas_; /* use lambdas if feasibility less than this */ + double exitDrop_; /* candidate for stopping after a major iteration */ + double muAtExit_; /* mu on exit */ + double exitFeasibility_; /* exit if infeasibility less than this */ + double dropEnoughFeasibility_; /* okay if feasibility drop this factor */ + double dropEnoughWeighted_; /* okay if weighted obj drop this factor */ + int * whenUsed_; /* array to say what was used */ + int maxBigIts_; /* always reduce mu after this */ + int maxIts_; /* do this many iterations on first go */ + int majorIterations_; + int logLevel_; + int logFreq_; + int checkFrequency_; /* can exit after 5 * this iterations (on drop) */ + int lambdaIterations_; /* do at least this many lambda iterations */ + int maxIts2_; /* do this many iterations on subsequent goes */ + int strategy_; /* 0 - default strategy + 1 - do accelerator step but be cautious + 2 - do not do accelerator step + 4 - drop, exitDrop and djTolerance all relative + 8 - keep accelerator step to theta=10.0 + + 32 - Scale + 512 - crossover + 2048 - keep lambda across mu change + 4096 - return best solution (not last found) + 8192 - always do a presolve in crossover + 16384 - costed slacks found - so whenUsed_ longer + 32768 - experimental 1 + 65536 - experimental 2 + 131072 - experimental 3 + 262144 - just values pass etc + 524288 - don't treat structural slacks as slacks */ + + int lightWeight_; // 0 - normal, 1 lightweight +}; +#endif diff --git a/thirdparty/windows/include/coin/IpAlgTypes.hpp b/thirdparty/windows/include/coin/IpAlgTypes.hpp new file mode 100644 index 0000000..63abf41 --- /dev/null +++ b/thirdparty/windows/include/coin/IpAlgTypes.hpp @@ -0,0 +1,64 @@ +// Copyright (C) 2005, 2009 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpAlgTypes.hpp 1430 2009-04-20 20:58:25Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2005-07-19 + +#ifndef __IPALGTYPES_HPP__ +#define __IPALGTYPES_HPP__ + +#include "IpTypes.hpp" +#include "IpException.hpp" + +namespace Ipopt +{ + + /**@name Enumerations */ + //@{ + /** enum for the return from the optimize algorithm + * (obviously we need to add more) */ + enum SolverReturn { + SUCCESS, + MAXITER_EXCEEDED, + CPUTIME_EXCEEDED, + STOP_AT_TINY_STEP, + STOP_AT_ACCEPTABLE_POINT, + LOCAL_INFEASIBILITY, + USER_REQUESTED_STOP, + FEASIBLE_POINT_FOUND, + DIVERGING_ITERATES, + RESTORATION_FAILURE, + ERROR_IN_STEP_COMPUTATION, + INVALID_NUMBER_DETECTED, + TOO_FEW_DEGREES_OF_FREEDOM, + INVALID_OPTION, + OUT_OF_MEMORY, + INTERNAL_ERROR + }; + //@} + + /** @name Some exceptions used in multiple places */ + //@{ + DECLARE_STD_EXCEPTION(LOCALLY_INFEASIBLE); + DECLARE_STD_EXCEPTION(TOO_FEW_DOF); + DECLARE_STD_EXCEPTION(TINY_STEP_DETECTED); + DECLARE_STD_EXCEPTION(ACCEPTABLE_POINT_REACHED); + DECLARE_STD_EXCEPTION(FEASIBILITY_PROBLEM_SOLVED); + DECLARE_STD_EXCEPTION(INVALID_WARMSTART); + DECLARE_STD_EXCEPTION(INTERNAL_ABORT); + DECLARE_STD_EXCEPTION(NO_FREE_VARIABLES_BUT_FEASIBLE); + DECLARE_STD_EXCEPTION(NO_FREE_VARIABLES_AND_INFEASIBLE); + /** Exception FAILED_INITIALIZATION for problem during + * initialization of a strategy object (or other problems). This + * is thrown by a strategy object, if a problem arises during + * initialization, such as a value out of a feasible range. + */ + DECLARE_STD_EXCEPTION(FAILED_INITIALIZATION); + //@} + + +} + +#endif diff --git a/thirdparty/windows/include/coin/IpCachedResults.hpp b/thirdparty/windows/include/coin/IpCachedResults.hpp new file mode 100644 index 0000000..bcc0d10 --- /dev/null +++ b/thirdparty/windows/include/coin/IpCachedResults.hpp @@ -0,0 +1,781 @@ +// Copyright (C) 2004, 2007 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpCachedResults.hpp 949 2007-03-27 00:41:26Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPCACHEDRESULTS_HPP__ +#define __IPCACHEDRESULTS_HPP__ + +#include "IpTaggedObject.hpp" +#include "IpObserver.hpp" +#include <algorithm> +#include <vector> +#include <list> + +namespace Ipopt + //#define IP_DEBUG_CACHE +#if COIN_IPOPT_CHECKLEVEL > 2 +# define IP_DEBUG_CACHE +#endif +#ifdef IP_DEBUG_CACHE +# include "IpDebug.hpp" +#endif +{ + + // Forward Declarations + + template <class T> + class DependentResult; + + // AW: I'm taking this out, since this is by far the most used + // class. We should keep it as simple as possible. + // /** Cache Priority Enum */ + // enum CachePriority + // { + // CP_Lowest, + // CP_Standard, + // CP_Trial, + // CP_Iterate + // }; + + /** Templated class for Chached Results. This class stores up to a + * given number of "results", entities that are stored here + * together with identifies, that can be used to later retrieve the + * information again. + * + * Typically, T is a SmartPtr for some calculated quantity that + * should be stored (such as a Vector). The identifiers (or + * dependencies) are a (possibly varying) number of Tags from + * TaggedObjects, and a number of Numbers. Results are added to + * the cache using the AddCachedResults methods, and the can be + * retrieved with the GetCachedResults methods. The second set of + * methods checks whether a result has been cached for the given + * identifiers. If a corresponding results is found, a copy of it + * is returned and the method evaluates to true, otherwise it + * evaluates to false. + * + * Note that cached results can become "stale", namely when a + * TaggedObject that is used to identify this CachedResult is + * changed. When this happens, the cached result can never be + * asked for again, so that there is no point in storing it any + * longer. For this purpose, a cached result, which is stored as a + * DependentResult, inherits off an Observer. This Observer + * retrieves notification whenever a TaggedObject dependency has + * changed. Stale results are later removed from the cache. + */ + template <class T> + class CachedResults + { + public: +#ifdef IP_DEBUG_CACHE + /** (Only if compiled in DEBUG mode): debug verbosity level */ + static const Index dbg_verbosity; +#endif + + /** @name Constructors and Destructors. */ + //@{ + /** Constructor, where max_cache_size is the maximal number of + * results that should be cached. If max_cache_size is negative, + * we allow an infinite abount of cache. + */ + CachedResults(Int max_cache_size); + + /** Destructor */ + virtual ~CachedResults(); + //@} + + /** @name Generic methods for adding and retrieving cached results. */ + //@{ + /** Generic method for adding a result to the cache, given a + * std::vector of TaggesObjects and a std::vector of Numbers. + */ + void AddCachedResult(const T& result, + const std::vector<const TaggedObject*>& dependents, + const std::vector<Number>& scalar_dependents); + + /** Generic method for retrieving a cached results, given the + * dependencies as a std::vector of TaggesObjects and a + * std::vector of Numbers. + */ + bool GetCachedResult(T& retResult, + const std::vector<const TaggedObject*>& dependents, + const std::vector<Number>& scalar_dependents) const; + + /** Method for adding a result, providing only a std::vector of + * TaggedObjects. + */ + void AddCachedResult(const T& result, + const std::vector<const TaggedObject*>& dependents); + + /** Method for retrieving a cached result, providing only a + * std::vector of TaggedObjects. + */ + bool GetCachedResult(T& retResult, + const std::vector<const TaggedObject*>& dependents) const; + //@} + + /** @name Pointer-based methods for adding and retrieving cached + * results, providing dependencies explicitly. + */ + //@{ + /** Method for adding a result to the cache, proving one + * dependency as a TaggedObject explicitly. + */ + void AddCachedResult1Dep(const T& result, + const TaggedObject* dependent1); + + /** Method for retrieving a cached result, proving one dependency + * as a TaggedObject explicitly. + */ + bool GetCachedResult1Dep(T& retResult, const TaggedObject* dependent1); + + /** Method for adding a result to the cache, proving two + * dependencies as a TaggedObject explicitly. + */ + void AddCachedResult2Dep(const T& result, + const TaggedObject* dependent1, + const TaggedObject* dependent2); + + /** Method for retrieving a cached result, proving two + * dependencies as a TaggedObject explicitly. + */ + bool GetCachedResult2Dep(T& retResult, + const TaggedObject* dependent1, + const TaggedObject* dependent2); + + /** Method for adding a result to the cache, proving three + * dependencies as a TaggedObject explicitly. + */ + void AddCachedResult3Dep(const T& result, + const TaggedObject* dependent1, + const TaggedObject* dependent2, + const TaggedObject* dependent3); + + /** Method for retrieving a cached result, proving three + * dependencies as a TaggedObject explicitly. + */ + bool GetCachedResult3Dep(T& retResult, + const TaggedObject* dependent1, + const TaggedObject* dependent2, + const TaggedObject* dependent3); + + /** @name Pointer-free version of the Add and Get methods */ + //@{ + bool GetCachedResult1Dep(T& retResult, const TaggedObject& dependent1) + { + return GetCachedResult1Dep(retResult, &dependent1); + } + bool GetCachedResult2Dep(T& retResult, + const TaggedObject& dependent1, + const TaggedObject& dependent2) + { + return GetCachedResult2Dep(retResult, &dependent1, &dependent2); + } + bool GetCachedResult3Dep(T& retResult, + const TaggedObject& dependent1, + const TaggedObject& dependent2, + const TaggedObject& dependent3) + { + return GetCachedResult3Dep(retResult, &dependent1, &dependent2, &dependent3); + } + void AddCachedResult1Dep(const T& result, + const TaggedObject& dependent1) + { + AddCachedResult1Dep(result, &dependent1); + } + void AddCachedResult2Dep(const T& result, + const TaggedObject& dependent1, + const TaggedObject& dependent2) + { + AddCachedResult2Dep(result, &dependent1, &dependent2); + } + void AddCachedResult3Dep(const T& result, + const TaggedObject& dependent1, + const TaggedObject& dependent2, + const TaggedObject& dependent3) + { + AddCachedResult3Dep(result, &dependent1, &dependent2, &dependent3); + } + //@} + + /** Invalidates the result for given dependecies. Sets the stale + * flag for the corresponding cached result to true if it is + * found. Returns true, if the result was found. */ + bool InvalidateResult(const std::vector<const TaggedObject*>& dependents, + const std::vector<Number>& scalar_dependents); + + /** Invalidates all cached results */ + void Clear(); + + /** Invalidate all cached results and changes max_cache_size */ + void Clear(Int max_cache_size); + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + CachedResults(); + + /** Copy Constructor */ + CachedResults(const CachedResults&); + + /** Overloaded Equals Operator */ + void operator=(const CachedResults&); + //@} + + /** maximum number of cached results */ + Int max_cache_size_; + + /** list of currently cached results. */ + mutable std::list<DependentResult<T>*>* cached_results_; + + /** internal method for removing stale DependentResults from the + * list. It is called at the beginning of every + * GetDependentResult method. + */ + void CleanupInvalidatedResults() const; + + /** Print list of currently cached results */ + void DebugPrintCachedResults() const; + }; + + /** Templated class which stores one entry for the CachedResult + * class. It stores the result (of type T), together with its + * dependencies (vector of TaggedObjects and vector of Numbers). + * It also stores a priority. + */ + template <class T> + class DependentResult : public Observer + { + public: + +#ifdef IP_DEBUG_CACHE + + static const Index dbg_verbosity; +#endif + + /** @name Constructor, Destructors */ + //@{ + /** Constructor, given all information about the result. */ + DependentResult(const T& result, const std::vector<const TaggedObject*>& dependents, + const std::vector<Number>& scalar_dependents); + + /** Destructor. */ + ~DependentResult(); + //@} + + /** @name Accessor method. */ + //@{ + /** This returns true, if the DependentResult is no longer valid. */ + bool IsStale() const; + + /** Invalidates the cached result. */ + void Invalidate(); + + /** Returns the cached result. */ + const T& GetResult() const; + //@} + + /** This method returns true if the dependencies provided to this + * function are identical to the ones stored with the + * DependentResult. + */ + bool DependentsIdentical(const std::vector<const TaggedObject*>& dependents, + const std::vector<Number>& scalar_dependents) const; + + /** Print information about this DependentResults. */ + void DebugPrint() const; + + protected: + /** This method is overloading the pure virtual method from the + * Observer base class. This method is called when a Subject + * registered for this Observer sends a notification. In this + * particular case, if this method is called with + * notify_type==NT_Changed or NT_BeingDeleted, then this results + * is marked as stale. + */ + virtual void RecieveNotification(NotifyType notify_type, const Subject* subject); + + private: + + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + DependentResult(); + + /** Copy Constructor */ + DependentResult(const DependentResult&); + + /** Overloaded Equals Operator */ + void operator=(const DependentResult&); + //@} + + /** Flag indicating, if the cached result is still valid. A + result becomes invalid, if the RecieveNotification method is + called with NT_Changed */ + bool stale_; + /** The value of the dependent results */ + const T result_; + /** Dependencies in form of TaggedObjects */ + std::vector<TaggedObject::Tag> dependent_tags_; + /** Dependencies in form a Numbers */ + std::vector<Number> scalar_dependents_; + }; + +#ifdef IP_DEBUG_CACHE + + template <class T> + const Index CachedResults<T>::dbg_verbosity = 0; + + template <class T> + const Index DependentResult<T>::dbg_verbosity = 0; +#endif + + template <class T> + DependentResult<T>::DependentResult( + const T& result, + const std::vector<const TaggedObject*>& dependents, + const std::vector<Number>& scalar_dependents) + : + stale_(false), + result_(result), + dependent_tags_(dependents.size()), + scalar_dependents_(scalar_dependents) + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("DependentResult<T>::DependentResult()", dbg_verbosity); +#endif + + for (Index i=0; i<(Index)dependents.size(); i++) { + if (dependents[i]) { + // Call the RequestAttach method of the Observer base class. + // This will add this dependent result in the Observer list + // for the Subject dependents[i]. As a consequence, the + // RecieveNotification method of this DependentResult will be + // called with notify_type=NT_Changed, whenever the + // TaggedResult dependents[i] is changed (i.e. its HasChanged + // method is called). + RequestAttach(NT_Changed, dependents[i]); + dependent_tags_[i] = dependents[i]->GetTag(); + } + else { + dependent_tags_[i] = 0; + } + } + } + + template <class T> + DependentResult<T>::~DependentResult() + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("DependentResult<T>::~DependentResult()", dbg_verbosity); + //DBG_ASSERT(stale_ == true); +#endif + // Nothing to be done here, destructor + // of T should sufficiently remove + // any memory, etc. + } + + template <class T> + bool DependentResult<T>::IsStale() const + { + return stale_; + } + + template <class T> + void DependentResult<T>::Invalidate() + { + stale_ = true; + } + + template <class T> + void DependentResult<T>::RecieveNotification(NotifyType notify_type, const Subject* subject) + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("DependentResult<T>::RecieveNotification", dbg_verbosity); +#endif + + if (notify_type == NT_Changed || notify_type==NT_BeingDestroyed) { + stale_ = true; + // technically, I could unregister the notifications here, but they + // aren't really hurting anything + } + } + + template <class T> + bool DependentResult<T>::DependentsIdentical(const std::vector<const TaggedObject*>& dependents, + const std::vector<Number>& scalar_dependents) const + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("DependentResult<T>::DependentsIdentical", dbg_verbosity); + DBG_ASSERT(stale_ == false); + DBG_ASSERT(dependents.size() == dependent_tags_.size()); +#endif + + bool retVal = true; + + if (dependents.size() != dependent_tags_.size() + || scalar_dependents.size() != scalar_dependents_.size()) { + retVal = false; + } + else { + for (Index i=0; i<(Index)dependents.size(); i++) { + if ( (dependents[i] && dependents[i]->GetTag() != dependent_tags_[i]) + || (!dependents[i] && dependent_tags_[i] != 0) ) { + retVal = false; + break; + } + } + if (retVal) { + for (Index i=0; i<(Index)scalar_dependents.size(); i++) { + if (scalar_dependents[i] != scalar_dependents_[i]) { + retVal = false; + break; + } + } + } + } + + return retVal; + } + + template <class T> + const T& DependentResult<T>::GetResult() const + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("DependentResult<T>::GetResult()", dbg_verbosity); + DBG_ASSERT(stale_ == false); +#endif + + return result_; + } + + template <class T> + void DependentResult<T>::DebugPrint() const + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("DependentResult<T>::DebugPrint", dbg_verbosity); +#endif + + } + + template <class T> + CachedResults<T>::CachedResults(Int max_cache_size) + : + max_cache_size_(max_cache_size), + cached_results_(NULL) + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::CachedResults", dbg_verbosity); +#endif + + } + + template <class T> + CachedResults<T>::~CachedResults() + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::!CachedResults()", dbg_verbosity); +#endif + + if (cached_results_) { + for (typename std::list< DependentResult<T>* >::iterator iter = cached_results_-> + begin(); + iter != cached_results_->end(); + iter++) { + delete *iter; + } + delete cached_results_; + } + /* + while (!cached_results_.empty()) { + DependentResult<T>* result = cached_results_.back(); + cached_results_.pop_back(); + delete result; + } + */ + } + + template <class T> + void CachedResults<T>::AddCachedResult(const T& result, + const std::vector<const TaggedObject*>& dependents, + const std::vector<Number>& scalar_dependents) + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::AddCachedResult", dbg_verbosity); +#endif + + CleanupInvalidatedResults(); + + // insert the new one here + DependentResult<T>* newResult = new DependentResult<T>(result, dependents, scalar_dependents); + if (!cached_results_) { + cached_results_ = new std::list<DependentResult<T>*>; + } + cached_results_->push_front(newResult); + + // keep the list small enough + if (max_cache_size_ >= 0) { // if negative, allow infinite cache + // non-negative - limit size of list to max_cache_size + DBG_ASSERT((Int)cached_results_->size()<=max_cache_size_+1); + if ((Int)cached_results_->size() > max_cache_size_) { + delete cached_results_->back(); + cached_results_->pop_back(); + } + } + +#ifdef IP_DEBUG_CACHE + DBG_EXEC(2, DebugPrintCachedResults()); +#endif + + } + + template <class T> + void CachedResults<T>::AddCachedResult(const T& result, + const std::vector<const TaggedObject*>& dependents) + { + std::vector<Number> scalar_dependents; + AddCachedResult(result, dependents, scalar_dependents); + } + + template <class T> + bool CachedResults<T>::GetCachedResult(T& retResult, const std::vector<const TaggedObject*>& dependents, + const std::vector<Number>& scalar_dependents) const + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::GetCachedResult", dbg_verbosity); +#endif + + if (!cached_results_) + return false; + + CleanupInvalidatedResults(); + + bool retValue = false; + typename std::list< DependentResult<T>* >::const_iterator iter; + for (iter = cached_results_->begin(); iter != cached_results_->end(); iter++) { + if ((*iter)->DependentsIdentical(dependents, scalar_dependents)) { + retResult = (*iter)->GetResult(); + retValue = true; + break; + } + } + +#ifdef IP_DEBUG_CACHE + DBG_EXEC(2, DebugPrintCachedResults()); +#endif + + return retValue; + } + + template <class T> + bool CachedResults<T>::GetCachedResult( + T& retResult, const std::vector<const TaggedObject*>& dependents) const + { + std::vector<Number> scalar_dependents; + return GetCachedResult(retResult, dependents, scalar_dependents); + } + + template <class T> + void CachedResults<T>::AddCachedResult1Dep(const T& result, + const TaggedObject* dependent1) + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::AddCachedResult1Dep", dbg_verbosity); +#endif + + std::vector<const TaggedObject*> dependents(1); + dependents[0] = dependent1; + + AddCachedResult(result, dependents); + } + + template <class T> + bool CachedResults<T>::GetCachedResult1Dep(T& retResult, const TaggedObject* dependent1) + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::GetCachedResult1Dep", dbg_verbosity); +#endif + + std::vector<const TaggedObject*> dependents(1); + dependents[0] = dependent1; + + return GetCachedResult(retResult, dependents); + } + + template <class T> + void CachedResults<T>::AddCachedResult2Dep(const T& result, const TaggedObject* dependent1, + const TaggedObject* dependent2) + + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::AddCachedResult2dDep", dbg_verbosity); +#endif + + std::vector<const TaggedObject*> dependents(2); + dependents[0] = dependent1; + dependents[1] = dependent2; + + AddCachedResult(result, dependents); + } + + template <class T> + bool CachedResults<T>::GetCachedResult2Dep(T& retResult, const TaggedObject* dependent1, const TaggedObject* dependent2) + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::GetCachedResult2Dep", dbg_verbosity); +#endif + + std::vector<const TaggedObject*> dependents(2); + dependents[0] = dependent1; + dependents[1] = dependent2; + + return GetCachedResult(retResult, dependents); + } + + template <class T> + void CachedResults<T>::AddCachedResult3Dep(const T& result, const TaggedObject* dependent1, + const TaggedObject* dependent2, + const TaggedObject* dependent3) + + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::AddCachedResult2dDep", dbg_verbosity); +#endif + + std::vector<const TaggedObject*> dependents(3); + dependents[0] = dependent1; + dependents[1] = dependent2; + dependents[2] = dependent3; + + AddCachedResult(result, dependents); + } + + template <class T> + bool CachedResults<T>::GetCachedResult3Dep(T& retResult, const TaggedObject* dependent1, + const TaggedObject* dependent2, + const TaggedObject* dependent3) + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::GetCachedResult2Dep", dbg_verbosity); +#endif + + std::vector<const TaggedObject*> dependents(3); + dependents[0] = dependent1; + dependents[1] = dependent2; + dependents[2] = dependent3; + + return GetCachedResult(retResult, dependents); + } + + template <class T> + bool CachedResults<T>::InvalidateResult(const std::vector<const TaggedObject*>& dependents, + const std::vector<Number>& scalar_dependents) + { + if (!cached_results_) + return false; + + CleanupInvalidatedResults(); + + bool retValue = false; + typename std::list< DependentResult<T>* >::const_iterator iter; + for (iter = cached_results_->begin(); iter != cached_results_->end(); + iter++) { + if ((*iter)->DependentsIdentical(dependents, scalar_dependents)) { + (*iter)->Invalidate(); + retValue = true; + break; + } + } + + return retValue; + } + + template <class T> + void CachedResults<T>::Clear() + { + if (!cached_results_) + return; + + typename std::list< DependentResult<T>* >::const_iterator iter; + for (iter = cached_results_->begin(); iter != cached_results_->end(); + iter++) { + (*iter)->Invalidate(); + } + + CleanupInvalidatedResults(); + } + + template <class T> + void CachedResults<T>::Clear(Int max_cache_size) + { + Clear(); + max_cache_size_ = max_cache_size; + } + + template <class T> + void CachedResults<T>::CleanupInvalidatedResults() const + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::CleanupInvalidatedResults", dbg_verbosity); +#endif + + if (!cached_results_) + return; + + typename std::list< DependentResult<T>* >::iterator iter; + iter = cached_results_->begin(); + while (iter != cached_results_->end()) { + if ((*iter)->IsStale()) { + typename std::list< DependentResult<T>* >::iterator + iter_to_remove = iter; + iter++; + DependentResult<T>* result_to_delete = (*iter_to_remove); + cached_results_->erase(iter_to_remove); + delete result_to_delete; + } + else { + iter++; + } + } + } + + template <class T> + void CachedResults<T>::DebugPrintCachedResults() const + { +#ifdef IP_DEBUG_CACHE + DBG_START_METH("CachedResults<T>::DebugPrintCachedResults", dbg_verbosity); + if (DBG_VERBOSITY()>=2 ) { + if (!chached_results_) { + DBG_PRINT((2," DependentResult:0x%x\n", (*iter))); + } + else { + typename std::list< DependentResult<T>* >::const_iterator iter; + DBG_PRINT((2,"Current set of cached results:\n")); + for (iter = cached_results_->begin(); iter != cached_results_->end(); iter++) { + DBG_PRINT((2," DependentResult:0x%x\n", (*iter))); + } + } + } +#endif + + } + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpDebug.hpp b/thirdparty/windows/include/coin/IpDebug.hpp new file mode 100644 index 0000000..9716f5d --- /dev/null +++ b/thirdparty/windows/include/coin/IpDebug.hpp @@ -0,0 +1,142 @@ +// Copyright (C) 2004, 2007 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpDebug.hpp 1000 2007-06-16 06:52:34Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPDEBUG_HPP__ +#define __IPDEBUG_HPP__ + +#include "IpoptConfig.h" +#include "IpTypes.hpp" + +#ifdef HAVE_CASSERT +# include <cassert> +#else +# ifdef HAVE_ASSERT_H +# include <assert.h> +# else +# error "don't have header file for assert" +# endif +#endif + +#if COIN_IPOPT_CHECKLEVEL > 0 +# ifdef NDEBUG +# undef NDEBUG +# endif +# define DBG_ASSERT(test) assert(test) +# define DBG_ASSERT_EXCEPTION(__condition, __except_type, __msg) \ + ASSERT_EXCEPTION( (__condition), __except_type, __msg); +# define DBG_DO(__cmd) __cmd +#else +# define DBG_ASSERT(test) +# define DBG_ASSERT_EXCEPTION(__condition, __except_type, __msg) +# define DBG_DO(__cmd) +#endif + +#if COIN_IPOPT_VERBOSITY < 1 +# define DBG_START_FUN(__func_name, __verbose_level) +# define DBG_START_METH(__func_name, __verbose_level) +# define DBG_PRINT(__printf_args) +# define DBG_PRINT_VECTOR(__verbose_level, __vec_name, __vec) +# define DBG_PRINT_MATRIX(__verbose_level, __mat_name, __mat) +# define DBG_EXEC(__verbosity, __cmd) +# define DBG_VERBOSITY() 0 +#else +#include <string> + +namespace Ipopt +{ + // forward definition + class Journalist; + + /** Class that lives throughout the execution of a method or + * function for which debug output is to be generated. The output + * is sent to the unique debug journalist that is set with + * SetJournalist at the beginning of program execution. */ + class DebugJournalistWrapper + { + public: + /** @name Constructors/Destructors. */ + //@{ + DebugJournalistWrapper(std::string func_name, Index verbose_level); + DebugJournalistWrapper(std::string func_name, Index verbose_level, + const void* const method_owner); + ~DebugJournalistWrapper(); + //@} + + /** @name accessor methods */ + //@{ + Index Verbosity() + { + return verbose_level_; + } + const Journalist* Jnlst() + { + return jrnl_; + } + Index IndentationLevel() + { + return indentation_level_; + } + //@} + + /** Printing */ + void DebugPrintf(Index verbosity, const char* pformat, ...); + + /* Method for initialization of the static GLOBAL journalist, + * through with all debug printout is to be written. This needs + * to be set before any debug printout can be done. */ + static void SetJournalist(Journalist* jrnl); + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** default constructor */ + DebugJournalistWrapper(); + + /** copy contructor */ + DebugJournalistWrapper(const DebugJournalistWrapper&); + + /** Overloaded Equals Operator */ + DebugJournalistWrapper& operator=(const DebugJournalistWrapper&); + //@} + + static Index indentation_level_; + std::string func_name_; + Index verbose_level_; + const void* method_owner_; + + static Journalist* jrnl_; + }; +} + +# define DBG_START_FUN(__func_name, __verbose_level) \ + DebugJournalistWrapper dbg_jrnl((__func_name), (__verbose_level)); \ + +# define DBG_START_METH(__func_name, __verbose_level) \ + DebugJournalistWrapper dbg_jrnl((__func_name), (__verbose_level), this); + +# define DBG_PRINT(__args) \ + dbg_jrnl.DebugPrintf __args; + +# define DBG_EXEC(__verbose_level, __cmd) \ + if (dbg_jrnl.Verbosity() >= (__verbose_level)) { \ + (__cmd); \ + } + +# define DBG_VERBOSITY() \ + dbg_jrnl.Verbosity() + +#endif + + +#endif diff --git a/thirdparty/windows/include/coin/IpException.hpp b/thirdparty/windows/include/coin/IpException.hpp new file mode 100644 index 0000000..d5fd944 --- /dev/null +++ b/thirdparty/windows/include/coin/IpException.hpp @@ -0,0 +1,147 @@ +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpException.hpp 1019 2007-06-24 03:52:34Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPEXCEPTION_HPP__ +#define __IPEXCEPTION_HPP__ + +#include "IpUtils.hpp" +#include "IpJournalist.hpp" + +/* This file contains a base class for all exceptions + * and a set of macros to help with exceptions + */ + +namespace Ipopt +{ + + /** This is the base class for all exceptions. The easiest way to + * use this class is by means of the following macros: + * + * \verbatim + + DECLARE_STD_EXCEPTION(ExceptionType); + \endverbatim + * + * This macro defines a new class with the name ExceptionType, + * inherited from the base class IpoptException. After this, + * exceptions of this type can be thrown using + * + * \verbatim + + THROW_EXCEPTION(ExceptionType, Message); + \endverbatim + * + * where Message is a std::string with a message that gives an + * indication of what caused the exception. Exceptions can also be + * thrown using the macro + * + * \verbatim + + ASSERT_EXCEPTION(Condition, ExceptionType, Message); + \endverbatim + * + * where Conditions is an expression. If Condition evaluates to + * false, then the exception of the type ExceptionType is thrown + * with Message. + * + * When an exception is caught, the method ReportException can be + * used to write the information about the exception to the + * Journalist, using the level J_ERROR and the category J_MAIN. + * + */ + class IpoptException + { + public: + /**@name Constructors/Destructors */ + //@{ + /** Constructor */ + IpoptException(std::string msg, std::string file_name, Index line_number, std::string type="IpoptException") + : + msg_(msg), + file_name_(file_name), + line_number_(line_number), + type_(type) + {} + + /** Copy Constructor */ + IpoptException(const IpoptException& copy) + : + msg_(copy.msg_), + file_name_(copy.file_name_), + line_number_(copy.line_number_), + type_(copy.type_) + {} + + /** Default destructor */ + virtual ~IpoptException() + {} + //@} + + /** Method to report the exception to a journalist */ + void ReportException(const Journalist& jnlst, + EJournalLevel level = J_ERROR) const + { + jnlst.Printf(level, J_MAIN, + "Exception of type: %s in file \"%s\" at line %d:\n Exception message: %s\n", + type_.c_str(), file_name_.c_str(), line_number_, msg_.c_str()); + } + + const std::string& Message() const + { + return msg_; + } + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + IpoptException(); + + /** Overloaded Equals Operator */ + void operator=(const IpoptException&); + //@} + + std::string msg_; + std::string file_name_; + Index line_number_; + std::string type_; + }; + +#define THROW_EXCEPTION(__except_type, __msg) \ + throw __except_type( (__msg), (__FILE__), (__LINE__) ); + +#define ASSERT_EXCEPTION(__condition, __except_type, __msg) \ + if (! (__condition) ) { \ + std::string newmsg = #__condition; \ + newmsg += " evaluated false: "; \ + newmsg += __msg; \ + throw __except_type( (newmsg), (__FILE__), (__LINE__) ); \ + } + +#define DECLARE_STD_EXCEPTION(__except_type) \ + class __except_type : public IpoptException \ + { \ + public: \ + __except_type(std::string msg, std::string fname, Index line) \ + : IpoptException(msg,fname,line, #__except_type) {} \ + __except_type(const __except_type& copy) \ + : IpoptException(copy) {} \ + private: \ + __except_type(); \ + void operator=(const __except_type&); \ + } + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpIpoptApplication.hpp b/thirdparty/windows/include/coin/IpIpoptApplication.hpp new file mode 100644 index 0000000..d2bcf27 --- /dev/null +++ b/thirdparty/windows/include/coin/IpIpoptApplication.hpp @@ -0,0 +1,240 @@ +// Copyright (C) 2004, 2009 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpIpoptApplication.hpp 1587 2009-10-27 16:09:21Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPIPOPTAPPLICATION_HPP__ +#define __IPIPOPTAPPLICATION_HPP__ + +#ifndef IPOPT_EXPORT +#ifdef _MSC_VER +#ifdef IPOPT_DLL +#define IPOPT_EXPORT(type) __declspec(dllexport) type __cdecl +#else +#define IPOPT_EXPORT(type) type __cdecl +#endif +#else +#define IPOPT_EXPORT(type) type +#endif +#endif + +#include <iostream> + +#include "IpJournalist.hpp" +#include "IpTNLP.hpp" +#include "IpNLP.hpp" +/* Return codes for the Optimize call for an application */ +#include "IpReturnCodes.hpp" + +namespace Ipopt +{ + DECLARE_STD_EXCEPTION(IPOPT_APPLICATION_ERROR); + + /* forward declarations */ + class IpoptAlgorithm; + class IpoptNLP; + class IpoptData; + class IpoptCalculatedQuantities; + class AlgorithmBuilder; + class RegisteredOptions; + class OptionsList; + class SolveStatistics; + + /** This is the main application class for making calls to Ipopt. */ + class IpoptApplication : public ReferencedObject + { + public: + IpoptApplication(bool create_console_out = true, + bool create_empty = false); + + /** Another constructor that assumes that the code in the + * (default) constructor has already been executed */ + IpoptApplication(SmartPtr<RegisteredOptions> reg_options, + SmartPtr<OptionsList> options, + SmartPtr<Journalist> jnlst); + + virtual ~IpoptApplication(); + + /** Method for creating a new IpoptApplication that uses the same + * journalist and registered options, and a copy of the options + list. */ + virtual SmartPtr<IpoptApplication> clone(); + + /** Initialize method. This method reads the params file and + * initializes the journalists. You should call this method at + * some point before the first optimize call. Note: you can skip + * the processing of a params file by setting params_file to "". + * It returns something other than Solve_Succeeded if there was a + * problem in the initialization (such as an invalid option). + */ + virtual ApplicationReturnStatus Initialize(std::string params_file = "ipopt.opt"); + virtual ApplicationReturnStatus Initialize(std::istream& is); + + /**@name Solve methods */ + //@{ + /** Solve a problem that inherits from TNLP */ + virtual ApplicationReturnStatus OptimizeTNLP(const SmartPtr<TNLP>& tnlp); + + /** Solve a problem that inherits from NLP */ + virtual ApplicationReturnStatus OptimizeNLP(const SmartPtr<NLP>& nlp); + + /** Solve a problem that inherits from NLP */ + virtual ApplicationReturnStatus OptimizeNLP(const SmartPtr<NLP>& nlp, SmartPtr<AlgorithmBuilder>& alg_builder); + + /** Solve a problem (that inherits from TNLP) for a repeated time. + * The OptimizeTNLP method must have been called before. The + * TNLP must be the same object, and the structure (number of + * variables and constraints and position of nonzeros in Jacobian + * and Hessian must be the same). */ + virtual ApplicationReturnStatus ReOptimizeTNLP(const SmartPtr<TNLP>& tnlp); + + /** Solve a problem (that inherits from NLP) for a repeated time. + * The OptimizeNLP method must have been called before. The + * NLP must be the same object, and the structure (number of + * variables and constraints and position of nonzeros in Jacobian + * and Hessian must be the same). */ + virtual ApplicationReturnStatus ReOptimizeNLP(const SmartPtr<NLP>& nlp); + //@} + + /** Method for opening an output file with given print_level. + * Returns false if there was a problem. */ + virtual bool OpenOutputFile(std::string file_name, EJournalLevel print_level); + + /**@name Accessor methods */ + //@{ + /** Get the Journalist for printing output */ + virtual SmartPtr<Journalist> Jnlst() + { + return jnlst_; + } + + /** Get a pointer to RegisteredOptions object to + * add new options */ + virtual SmartPtr<RegisteredOptions> RegOptions() + { + return reg_options_; + } + + /** Get the options list for setting options */ + virtual SmartPtr<OptionsList> Options() + { + return options_; + } + + /** Get the options list for setting options (const version) */ + virtual SmartPtr<const OptionsList> Options() const + { + return ConstPtr(options_); + } + + /** Get the object with the statistics about the most recent + * optimization run. */ + virtual SmartPtr<SolveStatistics> Statistics(); + + /** Get the IpoptNLP Object */ + virtual SmartPtr<IpoptNLP> IpoptNLPObject(); + + /** Get the IpoptData Object */ + SmartPtr<IpoptData> IpoptDataObject(); + + /** Get the IpoptCQ Object */ + virtual SmartPtr<IpoptCalculatedQuantities> IpoptCQObject(); + + /** Get the Algorithm Object */ + SmartPtr<IpoptAlgorithm> AlgorithmObject(); + //@} + + /** @name Methods for IpoptTypeInfo */ + //@{ + static void RegisterOptions(SmartPtr<RegisteredOptions> roptions); + //@} + + /** Method to registering all Ipopt options. */ + static void + RegisterAllIpoptOptions(const SmartPtr<RegisteredOptions>& roptions); + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + // IpoptApplication(); + + /** Copy Constructor */ + IpoptApplication(const IpoptApplication&); + + /** Overloaded Equals Operator */ + void operator=(const IpoptApplication&); + //@} + + /** Method for the actual optimize call of the Ipopt algorithm. + * This is used both for Optimize and ReOptimize */ + ApplicationReturnStatus call_optimize(); + + /**@name Variables that customize the application behavior */ + //@{ + /** Decide whether or not the ipopt.opt file should be read */ + bool read_params_dat_; + //@} + + /** Journalist for reporting output */ + SmartPtr<Journalist> jnlst_; + + /** RegisteredOptions */ + SmartPtr<RegisteredOptions> reg_options_; + + /** OptionsList used for the application */ + SmartPtr<OptionsList> options_; + + /** Object for storing statistics about the most recent + * optimization run. */ + SmartPtr<SolveStatistics> statistics_; + + /** Object with the algorithm sceleton. + */ + SmartPtr<IpoptAlgorithm> alg_; + + /** IpoptNLP Object for the NLP. We keep this around for a + * ReOptimize warm start. */ + SmartPtr<IpoptNLP> ip_nlp_; + + /** IpoptData Object for the NLP. We keep this around for a + * ReOptimize warm start. + */ + SmartPtr<IpoptData> ip_data_; + + /** IpoptCalculatedQuantities Object for the NLP. We keep this + * around for a ReOptimize warm start. + */ + SmartPtr<IpoptCalculatedQuantities> ip_cq_; + + /** Pointer to the TNLPAdapter used to convert the TNLP to an NLP. + * We keep this around for the ReOptimizerTNLP call. */ + SmartPtr<NLP> nlp_adapter_; + + /** @name Algorithmic parameters */ + //@{ + /** Flag indicating if we are to use the inexact linear solver option */ + bool inexact_algorithm_; + /** Flag indicating if all bounds should be replaced by inequality + * constraints. This is necessary for the inexact algorithm. */ + bool replace_bounds_; + /** Flag indicating if the NLP:FinalizeSolution method should not + * be called after optimization. */ + bool skip_finalize_solution_call_; + //@} + }; + +} // namespace Ipopt + +extern "C" IPOPT_EXPORT(class Ipopt::IpoptApplication *) IpoptApplicationFactory(); + +#endif diff --git a/thirdparty/windows/include/coin/IpIpoptCalculatedQuantities.hpp b/thirdparty/windows/include/coin/IpIpoptCalculatedQuantities.hpp new file mode 100644 index 0000000..986a299 --- /dev/null +++ b/thirdparty/windows/include/coin/IpIpoptCalculatedQuantities.hpp @@ -0,0 +1,742 @@ +// Copyright (C) 2004, 2008 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpIpoptCalculatedQuantities.hpp 1586 2009-10-27 15:55:03Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPIPOPTCALCULATEDQUANTITIES_HPP__ +#define __IPIPOPTCALCULATEDQUANTITIES_HPP__ + +#include "IpSmartPtr.hpp" +#include "IpCachedResults.hpp" + +#include <string> + +namespace Ipopt +{ + class IpoptNLP; + class IpoptData; + class Vector; + class Matrix; + class SymMatrix; + class Journalist; + class OptionsList; + class RegisteredOptions; + + /** Norm types */ + enum ENormType { + NORM_1=0, + NORM_2, + NORM_MAX + }; + + /** Base class for additional calculated quantities that is special + * to a particular type of algorithm, such as the CG penalty + * function, or using iterative linear solvers. The regular + * IpoptCalculatedQuantities object should be given a derivation of + * this base class when it is created. */ + class IpoptAdditionalCq : public ReferencedObject + { + public: + /**@name Constructors/Destructors */ + //@{ + /** Default Constructor */ + IpoptAdditionalCq() + {} + + /** Default destructor */ + virtual ~IpoptAdditionalCq() + {} + //@} + + /** This method is called to initialize the global algorithmic + * parameters. The parameters are taken from the OptionsList + * object. */ + virtual bool Initialize(const Journalist& jnlst, + const OptionsList& options, + const std::string& prefix) = 0; + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Copy Constructor */ + IpoptAdditionalCq(const IpoptAdditionalCq&); + + /** Overloaded Equals Operator */ + void operator=(const IpoptAdditionalCq&); + //@} + }; + + /** Class for all IPOPT specific calculated quantities. + * + */ + class IpoptCalculatedQuantities : public ReferencedObject + { + public: + + /**@name Constructors/Destructors */ + //@{ + /** Constructor */ + IpoptCalculatedQuantities(const SmartPtr<IpoptNLP>& ip_nlp, + const SmartPtr<IpoptData>& ip_data); + /** Default destructor */ + virtual ~IpoptCalculatedQuantities(); + //@} + + /** Method for setting pointer for additional calculated + * quantities. This needs to be called before Initialized. */ + void SetAddCq(SmartPtr<IpoptAdditionalCq> add_cq) + { + DBG_ASSERT(!HaveAddCq()); + add_cq_ = add_cq; + } + + /** Method detecting if additional object for calculated + * quantities has already been set */ + bool HaveAddCq() + { + return IsValid(add_cq_); + } + + /** This method must be called to initialize the global + * algorithmic parameters. The parameters are taken from the + * OptionsList object. */ + bool Initialize(const Journalist& jnlst, + const OptionsList& options, + const std::string& prefix); + + /** @name Slacks */ + //@{ + /** Slacks for x_L (at current iterate) */ + SmartPtr<const Vector> curr_slack_x_L(); + /** Slacks for x_U (at current iterate) */ + SmartPtr<const Vector> curr_slack_x_U(); + /** Slacks for s_L (at current iterate) */ + SmartPtr<const Vector> curr_slack_s_L(); + /** Slacks for s_U (at current iterate) */ + SmartPtr<const Vector> curr_slack_s_U(); + /** Slacks for x_L (at trial point) */ + SmartPtr<const Vector> trial_slack_x_L(); + /** Slacks for x_U (at trial point) */ + SmartPtr<const Vector> trial_slack_x_U(); + /** Slacks for s_L (at trial point) */ + SmartPtr<const Vector> trial_slack_s_L(); + /** Slacks for s_U (at trial point) */ + SmartPtr<const Vector> trial_slack_s_U(); + /** Indicating whether or not we "fudged" the slacks */ + Index AdjustedTrialSlacks(); + /** Reset the flags for "fudged" slacks */ + void ResetAdjustedTrialSlacks(); + //@} + + /** @name Objective function */ + //@{ + /** Value of objective function (at current point) */ + virtual Number curr_f(); + /** Unscaled value of the objective function (at the current point) */ + virtual Number unscaled_curr_f(); + /** Value of objective function (at trial point) */ + virtual Number trial_f(); + /** Unscaled value of the objective function (at the trial point) */ + virtual Number unscaled_trial_f(); + /** Gradient of objective function (at current point) */ + SmartPtr<const Vector> curr_grad_f(); + /** Gradient of objective function (at trial point) */ + SmartPtr<const Vector> trial_grad_f(); + //@} + + /** @name Barrier Objective Function */ + //@{ + /** Barrier Objective Function Value + * (at current iterate with current mu) + */ + virtual Number curr_barrier_obj(); + /** Barrier Objective Function Value + * (at trial point with current mu) + */ + virtual Number trial_barrier_obj(); + + /** Gradient of barrier objective function with respect to x + * (at current point with current mu) */ + SmartPtr<const Vector> curr_grad_barrier_obj_x(); + /** Gradient of barrier objective function with respect to s + * (at current point with current mu) */ + SmartPtr<const Vector> curr_grad_barrier_obj_s(); + + /** Gradient of the damping term with respect to x (times + * kappa_d) */ + SmartPtr<const Vector> grad_kappa_times_damping_x(); + /** Gradient of the damping term with respect to s (times + * kappa_d) */ + SmartPtr<const Vector> grad_kappa_times_damping_s(); + //@} + + /** @name Constraints */ + //@{ + /** c(x) (at current point) */ + SmartPtr<const Vector> curr_c(); + /** unscaled c(x) (at current point) */ + SmartPtr<const Vector> unscaled_curr_c(); + /** c(x) (at trial point) */ + SmartPtr<const Vector> trial_c(); + /** d(x) (at current point) */ + SmartPtr<const Vector> curr_d(); + /** unscaled d(x) (at current point) */ + SmartPtr<const Vector> unscaled_curr_d(); + /** d(x) (at trial point) */ + SmartPtr<const Vector> trial_d(); + /** d(x) - s (at current point) */ + SmartPtr<const Vector> curr_d_minus_s(); + /** d(x) - s (at trial point) */ + SmartPtr<const Vector> trial_d_minus_s(); + /** Jacobian of c (at current point) */ + SmartPtr<const Matrix> curr_jac_c(); + /** Jacobian of c (at trial point) */ + SmartPtr<const Matrix> trial_jac_c(); + /** Jacobian of d (at current point) */ + SmartPtr<const Matrix> curr_jac_d(); + /** Jacobian of d (at trial point) */ + SmartPtr<const Matrix> trial_jac_d(); + /** Product of Jacobian (evaluated at current point) of C + * transpose with general vector */ + SmartPtr<const Vector> curr_jac_cT_times_vec(const Vector& vec); + /** Product of Jacobian (evaluated at trial point) of C + * transpose with general vector */ + SmartPtr<const Vector> trial_jac_cT_times_vec(const Vector& vec); + /** Product of Jacobian (evaluated at current point) of D + * transpose with general vector */ + SmartPtr<const Vector> curr_jac_dT_times_vec(const Vector& vec); + /** Product of Jacobian (evaluated at trial point) of D + * transpose with general vector */ + SmartPtr<const Vector> trial_jac_dT_times_vec(const Vector& vec); + /** Product of Jacobian (evaluated at current point) of C + * transpose with current y_c */ + SmartPtr<const Vector> curr_jac_cT_times_curr_y_c(); + /** Product of Jacobian (evaluated at trial point) of C + * transpose with trial y_c */ + SmartPtr<const Vector> trial_jac_cT_times_trial_y_c(); + /** Product of Jacobian (evaluated at current point) of D + * transpose with current y_d */ + SmartPtr<const Vector> curr_jac_dT_times_curr_y_d(); + /** Product of Jacobian (evaluated at trial point) of D + * transpose with trial y_d */ + SmartPtr<const Vector> trial_jac_dT_times_trial_y_d(); + /** Product of Jacobian (evaluated at current point) of C + * with general vector */ + SmartPtr<const Vector> curr_jac_c_times_vec(const Vector& vec); + /** Product of Jacobian (evaluated at current point) of D + * with general vector */ + SmartPtr<const Vector> curr_jac_d_times_vec(const Vector& vec); + /** Constraint Violation (at current iterate). This value should + * be used in the line search, and not curr_primal_infeasibility(). + * What type of norm is used depends on constr_viol_normtype */ + virtual Number curr_constraint_violation(); + /** Constraint Violation (at trial point). This value should + * be used in the line search, and not curr_primal_infeasibility(). + * What type of norm is used depends on constr_viol_normtype */ + virtual Number trial_constraint_violation(); + /** Real constraint violation in a given norm (at current + * iterate). This considers the inequality constraints without + * slacks. */ + virtual Number curr_nlp_constraint_violation(ENormType NormType); + /** Unscaled real constraint violation in a given norm (at current + * iterate). This considers the inequality constraints without + * slacks. */ + virtual Number unscaled_curr_nlp_constraint_violation(ENormType NormType); + //@} + + /** @name Hessian matrices */ + //@{ + /** exact Hessian at current iterate (uncached) */ + SmartPtr<const SymMatrix> curr_exact_hessian(); + //@} + + /** @name primal-dual error and its components */ + //@{ + /** x-part of gradient of Lagrangian function (at current point) */ + SmartPtr<const Vector> curr_grad_lag_x(); + /** x-part of gradient of Lagrangian function (at trial point) */ + SmartPtr<const Vector> trial_grad_lag_x(); + /** s-part of gradient of Lagrangian function (at current point) */ + SmartPtr<const Vector> curr_grad_lag_s(); + /** s-part of gradient of Lagrangian function (at trial point) */ + SmartPtr<const Vector> trial_grad_lag_s(); + /** x-part of gradient of Lagrangian function (at current point) + including linear damping term */ + SmartPtr<const Vector> curr_grad_lag_with_damping_x(); + /** s-part of gradient of Lagrangian function (at current point) + including linear damping term */ + SmartPtr<const Vector> curr_grad_lag_with_damping_s(); + /** Complementarity for x_L (for current iterate) */ + SmartPtr<const Vector> curr_compl_x_L(); + /** Complementarity for x_U (for current iterate) */ + SmartPtr<const Vector> curr_compl_x_U(); + /** Complementarity for s_L (for current iterate) */ + SmartPtr<const Vector> curr_compl_s_L(); + /** Complementarity for s_U (for current iterate) */ + SmartPtr<const Vector> curr_compl_s_U(); + /** Complementarity for x_L (for trial iterate) */ + SmartPtr<const Vector> trial_compl_x_L(); + /** Complementarity for x_U (for trial iterate) */ + SmartPtr<const Vector> trial_compl_x_U(); + /** Complementarity for s_L (for trial iterate) */ + SmartPtr<const Vector> trial_compl_s_L(); + /** Complementarity for s_U (for trial iterate) */ + SmartPtr<const Vector> trial_compl_s_U(); + /** Relaxed complementarity for x_L (for current iterate and current mu) */ + SmartPtr<const Vector> curr_relaxed_compl_x_L(); + /** Relaxed complementarity for x_U (for current iterate and current mu) */ + SmartPtr<const Vector> curr_relaxed_compl_x_U(); + /** Relaxed complementarity for s_L (for current iterate and current mu) */ + SmartPtr<const Vector> curr_relaxed_compl_s_L(); + /** Relaxed complementarity for s_U (for current iterate and current mu) */ + SmartPtr<const Vector> curr_relaxed_compl_s_U(); + + /** Primal infeasibility in a given norm (at current iterate). */ + virtual Number curr_primal_infeasibility(ENormType NormType); + /** Primal infeasibility in a given norm (at trial point) */ + virtual Number trial_primal_infeasibility(ENormType NormType); + + /** Dual infeasibility in a given norm (at current iterate) */ + virtual Number curr_dual_infeasibility(ENormType NormType); + /** Dual infeasibility in a given norm (at trial iterate) */ + virtual Number trial_dual_infeasibility(ENormType NormType); + /** Unscaled dual infeasibility in a given norm (at current iterate) */ + virtual Number unscaled_curr_dual_infeasibility(ENormType NormType); + + /** Complementarity (for all complementarity conditions together) + * in a given norm (at current iterate) */ + virtual Number curr_complementarity(Number mu, ENormType NormType); + /** Complementarity (for all complementarity conditions together) + * in a given norm (at trial iterate) */ + virtual Number trial_complementarity(Number mu, ENormType NormType); + /** Complementarity (for all complementarity conditions together) + * in a given norm (at current iterate) without NLP scaling. */ + virtual Number unscaled_curr_complementarity(Number mu, ENormType NormType); + + /** Centrality measure (in spirit of the -infinity-neighborhood. */ + Number CalcCentralityMeasure(const Vector& compl_x_L, + const Vector& compl_x_U, + const Vector& compl_s_L, + const Vector& compl_s_U); + /** Centrality measure at current point */ + virtual Number curr_centrality_measure(); + + /** Total optimality error for the original NLP at the current + * iterate, using scaling factors based on multipliers. Note + * that here the constraint violation is measured without slacks + * (nlp_constraint_violation) */ + virtual Number curr_nlp_error(); + /** Total optimality error for the original NLP at the current + * iterate, but using no scaling based on multipliers, and no + * scaling for the NLP. Note that here the constraint violation + * is measured without slacks (nlp_constraint_violation) */ + virtual Number unscaled_curr_nlp_error(); + + /** Total optimality error for the barrier problem at the + * current iterate, using scaling factors based on multipliers. */ + virtual Number curr_barrier_error(); + + /** Norm of the primal-dual system for a given mu (at current + * iterate). The norm is defined as the sum of the 1-norms of + * dual infeasibiliy, primal infeasibility, and complementarity, + * all divided by the number of elements of the vectors of which + * the norm is taken. + */ + virtual Number curr_primal_dual_system_error(Number mu); + /** Norm of the primal-dual system for a given mu (at trial + * iterate). The norm is defined as the sum of the 1-norms of + * dual infeasibiliy, primal infeasibility, and complementarity, + * all divided by the number of elements of the vectors of which + * the norm is taken. + */ + virtual Number trial_primal_dual_system_error(Number mu); + //@} + + /** @name Computing fraction-to-the-boundary step sizes */ + //@{ + /** Fraction to the boundary from (current) primal variables x and s + * for a given step */ + Number primal_frac_to_the_bound(Number tau, + const Vector& delta_x, + const Vector& delta_s); + /** Fraction to the boundary from (current) primal variables x and s + * for internal (current) step */ + Number curr_primal_frac_to_the_bound(Number tau); + /** Fraction to the boundary from (current) dual variables z and v + * for a given step */ + Number dual_frac_to_the_bound(Number tau, + const Vector& delta_z_L, + const Vector& delta_z_U, + const Vector& delta_v_L, + const Vector& delta_v_U); + /** Fraction to the boundary from (current) dual variables z and v + * for a given step, without caching */ + Number uncached_dual_frac_to_the_bound(Number tau, + const Vector& delta_z_L, + const Vector& delta_z_U, + const Vector& delta_v_L, + const Vector& delta_v_U); + /** Fraction to the boundary from (current) dual variables z and v + * for internal (current) step */ + Number curr_dual_frac_to_the_bound(Number tau); + /** Fraction to the boundary from (current) slacks for a given + * step in the slacks. Usually, one will use the + * primal_frac_to_the_bound method to compute the primal fraction + * to the boundary step size, but if it is cheaper to provide the + * steps in the slacks directly (e.g. when the primal step sizes + * are only temporary), the this method is more efficient. This + * method does not cache computations. */ + Number uncached_slack_frac_to_the_bound(Number tau, + const Vector& delta_x_L, + const Vector& delta_x_U, + const Vector& delta_s_L, + const Vector& delta_s_U); + //@} + + /** @name Sigma matrices */ + //@{ + SmartPtr<const Vector> curr_sigma_x(); + SmartPtr<const Vector> curr_sigma_s(); + //@} + + /** average of current values of the complementarities */ + Number curr_avrg_compl(); + /** average of trial values of the complementarities */ + Number trial_avrg_compl(); + + /** inner_product of current barrier obj. fn. gradient with + * current search direction */ + Number curr_gradBarrTDelta(); + + /** Compute the norm of a specific type of a set of vectors (uncached) */ + Number + CalcNormOfType(ENormType NormType, + std::vector<SmartPtr<const Vector> > vecs); + + /** Compute the norm of a specific type of two vectors (uncached) */ + Number + CalcNormOfType(ENormType NormType, + const Vector& vec1, const Vector& vec2); + + /** Norm type used for calculating constraint violation */ + ENormType constr_viol_normtype() const + { + return constr_viol_normtype_; + } + + /** Method returning true if this is a square problem */ + bool IsSquareProblem() const; + + /** Method returning the IpoptNLP object. This should only be + * used with care! */ + SmartPtr<IpoptNLP>& GetIpoptNLP() + { + return ip_nlp_; + } + + IpoptAdditionalCq& AdditionalCq() + { + DBG_ASSERT(IsValid(add_cq_)); + return *add_cq_; + } + + /** Methods for IpoptType */ + //@{ + /** Called by IpoptType to register the options */ + static void RegisterOptions(SmartPtr<RegisteredOptions> roptions); + //@} + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + IpoptCalculatedQuantities(); + + /** Copy Constructor */ + IpoptCalculatedQuantities(const IpoptCalculatedQuantities&); + + /** Overloaded Equals Operator */ + void operator=(const IpoptCalculatedQuantities&); + //@} + + /** @name Pointers for easy access to data and NLP information */ + //@{ + /** Ipopt NLP object */ + SmartPtr<IpoptNLP> ip_nlp_; + /** Ipopt Data object */ + SmartPtr<IpoptData> ip_data_; + /** Chen-Goldfarb specific calculated quantities */ + SmartPtr<IpoptAdditionalCq> add_cq_; + //@} + + /** @name Algorithmic Parameters that can be set throught the + * options list. Those parameters are initialize by calling the + * Initialize method.*/ + //@{ + /** Parameter in formula for computing overall primal-dual + * optimality error */ + Number s_max_; + /** Weighting factor for the linear damping term added to the + * barrier objective funciton. */ + Number kappa_d_; + /** fractional movement allowed in bounds */ + Number slack_move_; + /** Norm type to be used when calculating the constraint violation */ + ENormType constr_viol_normtype_; + /** Flag indicating whether the TNLP with identical structure has + * already been solved before. */ + bool warm_start_same_structure_; + //@} + + /** @name Caches for slacks */ + //@{ + CachedResults< SmartPtr<Vector> > curr_slack_x_L_cache_; + CachedResults< SmartPtr<Vector> > curr_slack_x_U_cache_; + CachedResults< SmartPtr<Vector> > curr_slack_s_L_cache_; + CachedResults< SmartPtr<Vector> > curr_slack_s_U_cache_; + CachedResults< SmartPtr<Vector> > trial_slack_x_L_cache_; + CachedResults< SmartPtr<Vector> > trial_slack_x_U_cache_; + CachedResults< SmartPtr<Vector> > trial_slack_s_L_cache_; + CachedResults< SmartPtr<Vector> > trial_slack_s_U_cache_; + Index num_adjusted_slack_x_L_; + Index num_adjusted_slack_x_U_; + Index num_adjusted_slack_s_L_; + Index num_adjusted_slack_s_U_; + //@} + + /** @name Cached for objective function stuff */ + //@{ + CachedResults<Number> curr_f_cache_; + CachedResults<Number> trial_f_cache_; + CachedResults< SmartPtr<const Vector> > curr_grad_f_cache_; + CachedResults< SmartPtr<const Vector> > trial_grad_f_cache_; + //@} + + /** @name Caches for barrier function stuff */ + //@{ + CachedResults<Number> curr_barrier_obj_cache_; + CachedResults<Number> trial_barrier_obj_cache_; + CachedResults< SmartPtr<const Vector> > curr_grad_barrier_obj_x_cache_; + CachedResults< SmartPtr<const Vector> > curr_grad_barrier_obj_s_cache_; + CachedResults< SmartPtr<const Vector> > grad_kappa_times_damping_x_cache_; + CachedResults< SmartPtr<const Vector> > grad_kappa_times_damping_s_cache_; + //@} + + /** @name Caches for constraint stuff */ + //@{ + CachedResults< SmartPtr<const Vector> > curr_c_cache_; + CachedResults< SmartPtr<const Vector> > trial_c_cache_; + CachedResults< SmartPtr<const Vector> > curr_d_cache_; + CachedResults< SmartPtr<const Vector> > trial_d_cache_; + CachedResults< SmartPtr<const Vector> > curr_d_minus_s_cache_; + CachedResults< SmartPtr<const Vector> > trial_d_minus_s_cache_; + CachedResults< SmartPtr<const Matrix> > curr_jac_c_cache_; + CachedResults< SmartPtr<const Matrix> > trial_jac_c_cache_; + CachedResults< SmartPtr<const Matrix> > curr_jac_d_cache_; + CachedResults< SmartPtr<const Matrix> > trial_jac_d_cache_; + CachedResults< SmartPtr<const Vector> > curr_jac_cT_times_vec_cache_; + CachedResults< SmartPtr<const Vector> > trial_jac_cT_times_vec_cache_; + CachedResults< SmartPtr<const Vector> > curr_jac_dT_times_vec_cache_; + CachedResults< SmartPtr<const Vector> > trial_jac_dT_times_vec_cache_; + CachedResults< SmartPtr<const Vector> > curr_jac_c_times_vec_cache_; + CachedResults< SmartPtr<const Vector> > curr_jac_d_times_vec_cache_; + CachedResults<Number> curr_constraint_violation_cache_; + CachedResults<Number> trial_constraint_violation_cache_; + CachedResults<Number> curr_nlp_constraint_violation_cache_; + CachedResults<Number> unscaled_curr_nlp_constraint_violation_cache_; + //@} + + /** Cache for the exact Hessian */ + CachedResults< SmartPtr<const SymMatrix> > curr_exact_hessian_cache_; + + /** @name Components of primal-dual error */ + //@{ + CachedResults< SmartPtr<const Vector> > curr_grad_lag_x_cache_; + CachedResults< SmartPtr<const Vector> > trial_grad_lag_x_cache_; + CachedResults< SmartPtr<const Vector> > curr_grad_lag_s_cache_; + CachedResults< SmartPtr<const Vector> > trial_grad_lag_s_cache_; + CachedResults< SmartPtr<const Vector> > curr_grad_lag_with_damping_x_cache_; + CachedResults< SmartPtr<const Vector> > curr_grad_lag_with_damping_s_cache_; + CachedResults< SmartPtr<const Vector> > curr_compl_x_L_cache_; + CachedResults< SmartPtr<const Vector> > curr_compl_x_U_cache_; + CachedResults< SmartPtr<const Vector> > curr_compl_s_L_cache_; + CachedResults< SmartPtr<const Vector> > curr_compl_s_U_cache_; + CachedResults< SmartPtr<const Vector> > trial_compl_x_L_cache_; + CachedResults< SmartPtr<const Vector> > trial_compl_x_U_cache_; + CachedResults< SmartPtr<const Vector> > trial_compl_s_L_cache_; + CachedResults< SmartPtr<const Vector> > trial_compl_s_U_cache_; + CachedResults< SmartPtr<const Vector> > curr_relaxed_compl_x_L_cache_; + CachedResults< SmartPtr<const Vector> > curr_relaxed_compl_x_U_cache_; + CachedResults< SmartPtr<const Vector> > curr_relaxed_compl_s_L_cache_; + CachedResults< SmartPtr<const Vector> > curr_relaxed_compl_s_U_cache_; + CachedResults<Number> curr_primal_infeasibility_cache_; + CachedResults<Number> trial_primal_infeasibility_cache_; + CachedResults<Number> curr_dual_infeasibility_cache_; + CachedResults<Number> trial_dual_infeasibility_cache_; + CachedResults<Number> unscaled_curr_dual_infeasibility_cache_; + CachedResults<Number> curr_complementarity_cache_; + CachedResults<Number> trial_complementarity_cache_; + CachedResults<Number> curr_centrality_measure_cache_; + CachedResults<Number> curr_nlp_error_cache_; + CachedResults<Number> unscaled_curr_nlp_error_cache_; + CachedResults<Number> curr_barrier_error_cache_; + CachedResults<Number> curr_primal_dual_system_error_cache_; + CachedResults<Number> trial_primal_dual_system_error_cache_; + //@} + + /** @name Caches for fraction to the boundary step sizes */ + //@{ + CachedResults<Number> primal_frac_to_the_bound_cache_; + CachedResults<Number> dual_frac_to_the_bound_cache_; + //@} + + /** @name Caches for sigma matrices */ + //@{ + CachedResults< SmartPtr<const Vector> > curr_sigma_x_cache_; + CachedResults< SmartPtr<const Vector> > curr_sigma_s_cache_; + //@} + + /** Cache for average of current complementarity */ + CachedResults<Number> curr_avrg_compl_cache_; + /** Cache for average of trial complementarity */ + CachedResults<Number> trial_avrg_compl_cache_; + + /** Cache for grad barrier obj. fn inner product with step */ + CachedResults<Number> curr_gradBarrTDelta_cache_; + + /** @name Indicator vectors required for the linear damping terms + * to handle unbounded solution sets. */ + //@{ + /** Indicator vector for selecting the elements in x that have + * only lower bounds. */ + SmartPtr<Vector> dampind_x_L_; + /** Indicator vector for selecting the elements in x that have + * only upper bounds. */ + SmartPtr<Vector> dampind_x_U_; + /** Indicator vector for selecting the elements in s that have + * only lower bounds. */ + SmartPtr<Vector> dampind_s_L_; + /** Indicator vector for selecting the elements in s that have + * only upper bounds. */ + SmartPtr<Vector> dampind_s_U_; + //@} + + /** @name Temporary vectors for intermediate calcuations. We keep + * these around to avoid unnecessarily many new allocations of + * Vectors. */ + //@{ + SmartPtr<Vector> tmp_x_; + SmartPtr<Vector> tmp_s_; + SmartPtr<Vector> tmp_c_; + SmartPtr<Vector> tmp_d_; + SmartPtr<Vector> tmp_x_L_; + SmartPtr<Vector> tmp_x_U_; + SmartPtr<Vector> tmp_s_L_; + SmartPtr<Vector> tmp_s_U_; + + /** Accessor methods for the temporary vectors */ + Vector& Tmp_x(); + Vector& Tmp_s(); + Vector& Tmp_c(); + Vector& Tmp_d(); + Vector& Tmp_x_L(); + Vector& Tmp_x_U(); + Vector& Tmp_s_L(); + Vector& Tmp_s_U(); + //@} + + /** flag indicating if Initialize method has been called (for + * debugging) */ + bool initialize_called_; + + /** @name Auxiliary functions */ + //@{ + /** Compute new vector containing the slack to a lower bound + * (uncached) + */ + SmartPtr<Vector> CalcSlack_L(const Matrix& P, + const Vector& x, + const Vector& x_bound); + /** Compute new vector containing the slack to a upper bound + * (uncached) + */ + SmartPtr<Vector> CalcSlack_U(const Matrix& P, + const Vector& x, + const Vector& x_bound); + /** Compute barrier term at given point + * (uncached) + */ + Number CalcBarrierTerm(Number mu, + const Vector& slack_x_L, + const Vector& slack_x_U, + const Vector& slack_s_L, + const Vector& slack_s_U); + + /** Compute complementarity for slack / multiplier pair */ + SmartPtr<const Vector> CalcCompl(const Vector& slack, + const Vector& mult); + + /** Compute fraction to the boundary parameter for lower and upper bounds */ + Number CalcFracToBound(const Vector& slack_L, + Vector& tmp_L, + const Matrix& P_L, + const Vector& slack_U, + Vector& tmp_U, + const Matrix& P_U, + const Vector& delta, + Number tau); + + /** Compute the scaling factors for the optimality error. */ + void ComputeOptimalityErrorScaling(const Vector& y_c, const Vector& y_d, + const Vector& z_L, const Vector& z_U, + const Vector& v_L, const Vector& v_U, + Number s_max, + Number& s_d, Number& s_c); + + /** Check if slacks are becoming too small. If slacks are + * becoming too small, they are change. The return value is the + * number of corrected slacks. */ + Index CalculateSafeSlack(SmartPtr<Vector>& slack, + const SmartPtr<const Vector>& bound, + const SmartPtr<const Vector>& curr_point, + const SmartPtr<const Vector>& multiplier); + + /** Computes the indicator vectors that can be used to filter out + * those entries in the slack_... variables, that correspond to + * variables with only lower and upper bounds. This is required + * for the linear damping term in the barrier objective function + * to handle unbounded solution sets. */ + void ComputeDampingIndicators(SmartPtr<const Vector>& dampind_x_L, + SmartPtr<const Vector>& dampind_x_U, + SmartPtr<const Vector>& dampind_s_L, + SmartPtr<const Vector>& dampind_s_U); + + /** Check if we are in the restoration phase. Returns true, if the + * ip_nlp is of the type RestoIpoptNLP. ToDo: We probably want to + * handle this more elegant and don't have an explicit dependency + * here. Now I added this because otherwise the caching doesn't + * work properly since the restoration phase objective function + * depends on the current barrier parameter. */ + bool in_restoration_phase(); + + //@} + }; + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpJournalist.hpp b/thirdparty/windows/include/coin/IpJournalist.hpp new file mode 100644 index 0000000..25ccef9 --- /dev/null +++ b/thirdparty/windows/include/coin/IpJournalist.hpp @@ -0,0 +1,487 @@ +// Copyright (C) 2004, 2009 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpJournalist.hpp 1587 2009-10-27 16:09:21Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPJOURNALIST_HPP__ +#define __IPJOURNALIST_HPP__ + +#include "IpoptConfig.h" +#include "IpTypes.hpp" +#include "IpReferenced.hpp" +#include "IpSmartPtr.hpp" + +#ifdef HAVE_CSTDARG +# include <cstdarg> +#else +# ifdef HAVE_STDARG_H +# include <stdarg.h> +# else +# error "don't have header file for stdarg" +# endif +#endif + +#include <string> +#include <vector> +#include <ostream> + +namespace Ipopt +{ + + // forward declarations + class Journal; + class FileJournal; + + /**@name Journalist Enumerations. */ + //@{ + /** Print Level Enum. */ + enum EJournalLevel { + J_INSUPPRESSIBLE=-1, + J_NONE=0, + J_ERROR, + J_STRONGWARNING, + J_SUMMARY, + J_WARNING, + J_ITERSUMMARY, + J_DETAILED, + J_MOREDETAILED, + J_VECTOR, + J_MOREVECTOR, + J_MATRIX, + J_MOREMATRIX, + J_ALL, + J_LAST_LEVEL + }; + + /** Category Selection Enum. */ + enum EJournalCategory { + J_DBG=0, + J_STATISTICS, + J_MAIN, + J_INITIALIZATION, + J_BARRIER_UPDATE, + J_SOLVE_PD_SYSTEM, + J_FRAC_TO_BOUND, + J_LINEAR_ALGEBRA, + J_LINE_SEARCH, + J_HESSIAN_APPROXIMATION, + J_SOLUTION, + J_DOCUMENTATION, + J_NLP, + J_TIMING_STATISTICS, + J_USER_APPLICATION /** This can be used by the user's application*/ , + J_USER1 /** This can be used by the user's application*/ , + J_USER2 /** This can be used by the user's application*/ , + J_USER3 /** This can be used by the user's application*/ , + J_USER4 /** This can be used by the user's application*/ , + J_USER5 /** This can be used by the user's application*/ , + J_USER6 /** This can be used by the user's application*/ , + J_USER7 /** This can be used by the user's application*/ , + J_USER8 /** This can be used by the user's application*/ , + J_USER9 /** This can be used by the user's application*/ , + J_USER10 /** This can be used by the user's application*/ , + J_USER11 /** This can be used by the user's application*/ , + J_USER12 /** This can be used by the user's application*/ , + J_USER13 /** This can be used by the user's application*/ , + J_USER14 /** This can be used by the user's application*/ , + J_USER15 /** This can be used by the user's application*/ , + J_USER16 /** This can be used by the user's application*/ , + J_USER17 /** This can be used by the user's application*/ , + J_LAST_CATEGORY + }; + //@} + + /** Class responsible for all message output. + * This class is responsible for all messaging and output. + * The "printing" code or "author" should send ALL messages to the + * Journalist, indicating an appropriate category and print level. + * The journalist then decides, based on reader specified + * acceptance criteria, which message is actually printed in which + * journals. + * This allows the printing code to send everything, while the + * "reader" can decide what they really want to see. + * + * Authors: + * Authors use the + * Journals: You can add as many Journals as you like to the + * Journalist with the AddJournal or the AddFileJournal methods. + * Each one represents a different printing location (or file). + * Then, you can call the "print" methods of the Journalist to output + * information to each of the journals. + * + * Acceptance Criteria: Each print message should be flagged + * appropriately with an EJournalCategory and EJournalLevel. + * + * The AddFileJournal + * method returns a pointer to the newly created Journal object + * (if successful) so you can set Acceptance criteria for that + * particular location. + * + */ + class Journalist : public ReferencedObject + { + public: + /**@name Constructor / Desructor. */ + //@{ + /** Constructor. */ + Journalist(); + + /** Destructor... */ + virtual ~Journalist(); + //@} + + /**@name Author Methods. + * These methods are used by authoring code, or code that wants + * to report some information. + */ + //@{ + /** Method to print a formatted string */ + virtual void Printf(EJournalLevel level, EJournalCategory category, + const char* format, ...) const; + + /** Method to print a long string including indentation. The + * string is printed starting at the current position. If the + * position (counting started at the current position) exceeds + * max_length, a new line is inserted, and indent_spaces many + * spaces are printed before the string is continued. This is + * for example used during the printing of the option + * documentation. */ + virtual void PrintStringOverLines(EJournalLevel level, EJournalCategory category, + Index indent_spaces, Index max_length, + const std::string& line) const; + + /** Method to print a formatted string with indentation */ + virtual void PrintfIndented(EJournalLevel level, + EJournalCategory category, + Index indent_level, + const char* format, ...) const; + + /** Method to print a formatted string + * using the va_list argument. */ + virtual void VPrintf(EJournalLevel level, + EJournalCategory category, + const char* pformat, + va_list ap) const; + + /** Method to print a formatted string with indentation, + * using the va_list argument. */ + virtual void VPrintfIndented(EJournalLevel level, + EJournalCategory category, + Index indent_level, + const char* pformat, + va_list ap) const; + + /** Method that returns true if there is a Journal that would + * write output for the given JournalLevel and JournalCategory. + * This is useful if expensive computation would be required for + * a particular output. The author code can check with this + * method if the computations are indeed required. + */ + virtual bool ProduceOutput(EJournalLevel level, + EJournalCategory category) const; + + + /** Method that flushes the current buffer for all Journalists. + Calling this method after one optimization run helps to avoid + cluttering output with that produced by other parts of the + program (e.g. written in Fortran) */ + virtual void FlushBuffer() const; + //@} + + /**@name Reader Methods. + * These methods are used by the reader. The reader will setup the + * journalist with each output file and the acceptance + * criteria for that file. + * + * Use these methods to setup the journals (files or other output). + * These are the internal objects that keep track of the print levels + * for each category. Then use the internal Journal objects to + * set specific print levels for each category (or keep defaults). + * + */ + //@{ + /** Add a new journal. The location_name is a string identifier, + * which can be used to obtain the pointer to the new Journal at + * a later point using the GetJournal method. + * The default_level is + * used to initialize the * printing level for all categories. + */ + virtual bool AddJournal(const SmartPtr<Journal> jrnl); + + /** Add a new FileJournal. fname is the name + * of the * file to which this Journal corresponds. Use + * fname="stdout" * for stdout, and use fname="stderr" for + * stderr. This method * returns the Journal pointer so you can + * set specific acceptance criteria. It returns NULL if there + * was a problem creating a new Journal. + */ + virtual SmartPtr<Journal> AddFileJournal( + const std::string& location_name, /** identifier */ + const std::string& fname, + EJournalLevel default_level = J_WARNING + ); + + /** Get an existing journal. You can use this method to change + * the acceptance criteria at runtime. + */ + virtual SmartPtr<Journal> GetJournal(const std::string& location_name); + + /** Delete all journals curently known by the journalist. */ + virtual void DeleteAllJournals(); + //@} + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Copy Constructor */ + Journalist(const Journalist&); + + /** Overloaded Equals Operator */ + void operator=(const Journalist&); + //@} + + //** Private Data Members. */ + //@{ + std::vector< SmartPtr<Journal> > journals_; + //@} + }; + + /** Journal class (part of the Journalist implementation.). This + * class is the base class for all Journals. It controls the + * acceptance criteria for print statements etc. Derived classes + * like the FileJournal - output those messages to specific locations + */ + class Journal : public ReferencedObject + { + public: + /** Constructor. */ + Journal(const std::string& name, EJournalLevel default_level); + + /** Destructor. */ + virtual ~Journal(); + + /** Get the name of the Journal */ + virtual std::string Name(); + + /** Set the print level for a particular category. */ + virtual void SetPrintLevel( + EJournalCategory category, EJournalLevel level + ); + + /** Set the print level for all category. */ + virtual void SetAllPrintLevels( + EJournalLevel level + ); + + /**@name Journal Output Methods. These methods are called by the + * Journalist who first checks if the output print level and category + * are acceptable. + * Calling the Print methods explicitly (instead of through the + * Journalist will output the message regardless of print level + * and category. You should use the Journalist to print & flush instead + */ + //@{ + /** Ask if a particular print level/category is accepted by the + * journal. + */ + virtual bool IsAccepted( + EJournalCategory category, EJournalLevel level + ) const; + + /** Print to the designated output location */ + virtual void Print(EJournalCategory category, EJournalLevel level, + const char* str) + { + PrintImpl(category, level, str); + } + + /** Printf to the designated output location */ + virtual void Printf(EJournalCategory category, EJournalLevel level, + const char* pformat, va_list ap) + { + PrintfImpl(category, level, pformat, ap); + } + + /** Flush output buffer.*/ + virtual void FlushBuffer() + { + FlushBufferImpl(); + } + //@} + + protected: + /**@name Implementation version of Print methods. Derived classes + * should overload the Impl methods. + */ + //@{ + /** Print to the designated output location */ + virtual void PrintImpl(EJournalCategory category, EJournalLevel level, + const char* str)=0; + + /** Printf to the designated output location */ + virtual void PrintfImpl(EJournalCategory category, EJournalLevel level, + const char* pformat, va_list ap)=0; + + /** Flush output buffer.*/ + virtual void FlushBufferImpl()=0; + //@} + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + Journal(); + + /** Copy Constructor */ + Journal(const Journal&); + + /** Overloaded Equals Operator */ + void operator=(const Journal&); + //@} + + /** Name of the output location */ + std::string name_; + + /** vector of integers indicating the level for each category */ + Index print_levels_[J_LAST_CATEGORY]; + }; + + + /** FileJournal class. This is a particular Journal implementation that + * writes to a file for output. It can write to (stdout, stderr, or disk) + * by using "stdout" and "stderr" as filenames. + */ + class FileJournal : public Journal + { + public: + /** Constructor. */ + FileJournal(const std::string& name, EJournalLevel default_level); + + /** Destructor. */ + virtual ~FileJournal(); + + /** Open a new file for the output location. + * Special Names: stdout means stdout, + * : stderr means stderr. + * + * Return code is false only if the file with the given name + * could not be opened. + */ + virtual bool Open(const char* fname); + + protected: + /**@name Implementation version of Print methods - Overloaded from + * Journal base class. + */ + //@{ + /** Print to the designated output location */ + virtual void PrintImpl(EJournalCategory category, EJournalLevel level, + const char* str); + + /** Printf to the designated output location */ + virtual void PrintfImpl(EJournalCategory category, EJournalLevel level, + const char* pformat, va_list ap); + + /** Flush output buffer.*/ + virtual void FlushBufferImpl(); + //@} + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + FileJournal(); + + /** Copy Constructor */ + FileJournal(const FileJournal&); + + /** Overloaded Equals Operator */ + void operator=(const FileJournal&); + //@} + + /** FILE pointer for the output destination */ + FILE* file_; + }; + + /** StreamJournal class. This is a particular Journal implementation that + * writes to a stream for output. + */ + class StreamJournal : public Journal + { + public: + /** Constructor. */ + StreamJournal(const std::string& name, EJournalLevel default_level); + + /** Destructor. */ + virtual ~StreamJournal() + {} + + /** Setting the output stream pointer */ + void SetOutputStream(std::ostream* os); + + protected: + /**@name Implementation version of Print methods - Overloaded from + * Journal base class. + */ + //@{ + /** Print to the designated output location */ + virtual void PrintImpl(EJournalCategory category, EJournalLevel level, + const char* str); + + /** Printf to the designated output location */ + virtual void PrintfImpl(EJournalCategory category, EJournalLevel level, + const char* pformat, va_list ap); + + /** Flush output buffer.*/ + virtual void FlushBufferImpl(); + //@} + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + StreamJournal(); + + /** Copy Constructor */ + StreamJournal(const StreamJournal&); + + /** Overloaded Equals Operator */ + void operator=(const StreamJournal&); + //@} + + /** pointer to output stream for the output destination */ + std::ostream* os_; + + /** buffer for sprintf. Being generous in size here... */ + char buffer_[32768]; + }; +} + +#endif diff --git a/thirdparty/windows/include/coin/IpMatrix.hpp b/thirdparty/windows/include/coin/IpMatrix.hpp new file mode 100644 index 0000000..93b04e1 --- /dev/null +++ b/thirdparty/windows/include/coin/IpMatrix.hpp @@ -0,0 +1,342 @@ +// Copyright (C) 2004, 2008 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpMatrix.hpp 1280 2008-08-10 21:19:31Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPMATRIX_HPP__ +#define __IPMATRIX_HPP__ + +#include "IpVector.hpp" + +namespace Ipopt +{ + + /* forward declarations */ + class MatrixSpace; + + /** Matrix Base Class. This is the base class for all derived matrix + * types. All Matrices, such as Jacobian and Hessian matrices, as + * well as possibly the iteration matrices needed for the step + * computation, are of this type. + * + * Deriving from Matrix: Overload the protected XXX_Impl method. + */ + class Matrix : public TaggedObject + { + public: + /** @name Constructor/Destructor */ + //@{ + /** Constructor. It has to be given a pointer to the + * corresponding MatrixSpace. + */ + Matrix(const MatrixSpace* owner_space) + : + TaggedObject(), + owner_space_(owner_space), + valid_cache_tag_(0) + {} + + /** Destructor */ + virtual ~Matrix() + {} + //@} + + /**@name Operations of the Matrix on a Vector */ + //@{ + /** Matrix-vector multiply. Computes y = alpha * Matrix * x + + * beta * y. Do not overload. Overload MultVectorImpl instead. + */ + void MultVector(Number alpha, const Vector& x, Number beta, + Vector& y) const + { + MultVectorImpl(alpha, x, beta, y); + } + + /** Matrix(transpose) vector multiply. Computes y = alpha * + * Matrix^T * x + beta * y. Do not overload. Overload + * TransMultVectorImpl instead. + */ + void TransMultVector(Number alpha, const Vector& x, Number beta, + Vector& y) const + { + TransMultVectorImpl(alpha, x, beta, y); + } + //@} + + /** @name Methods for specialized operations. A prototype + * implementation is provided, but for efficient implementation + * those should be specially implemented. + */ + //@{ + /** X = X + alpha*(Matrix S^{-1} Z). Should be implemented + * efficiently for the ExansionMatrix + */ + void AddMSinvZ(Number alpha, const Vector& S, const Vector& Z, + Vector& X) const; + + /** X = S^{-1} (r + alpha*Z*M^Td). Should be implemented + * efficiently for the ExansionMatrix + */ + void SinvBlrmZMTdBr(Number alpha, const Vector& S, + const Vector& R, const Vector& Z, + const Vector& D, Vector& X) const; + //@} + + /** Method for determining if all stored numbers are valid (i.e., + * no Inf or Nan). */ + bool HasValidNumbers() const; + + /** @name Information about the size of the matrix */ + //@{ + /** Number of rows */ + Index NRows() const; + + /** Number of columns */ + Index NCols() const; + //@} + + /** @name Norms of the individual rows and columns */ + //@{ + /** Compute the max-norm of the rows in the matrix. The result is + * stored in rows_norms. The vector is assumed to be initialized + * of init is false. */ + void ComputeRowAMax(Vector& rows_norms, bool init=true) const + { + DBG_ASSERT(NRows() == rows_norms.Dim()); + if (init) rows_norms.Set(0.); + ComputeRowAMaxImpl(rows_norms, init); + } + /** Compute the max-norm of the columns in the matrix. The result + * is stored in cols_norms The vector is assumed to be initialized + * of init is false. */ + void ComputeColAMax(Vector& cols_norms, bool init=true) const + { + DBG_ASSERT(NCols() == cols_norms.Dim()); + if (init) cols_norms.Set(0.); + ComputeColAMaxImpl(cols_norms, init); + } + //@} + + /** Print detailed information about the matrix. Do not overload. + * Overload PrintImpl instead. + */ + //@{ + virtual void Print(SmartPtr<const Journalist> jnlst, + EJournalLevel level, + EJournalCategory category, + const std::string& name, + Index indent=0, + const std::string& prefix="") const; + virtual void Print(const Journalist& jnlst, + EJournalLevel level, + EJournalCategory category, + const std::string& name, + Index indent=0, + const std::string& prefix="") const; + //@} + + /** Return the owner MatrixSpace*/ + SmartPtr<const MatrixSpace> OwnerSpace() const; + + protected: + /** @name implementation methods (derived classes MUST + * overload these pure virtual protected methods. + */ + //@{ + /** Matrix-vector multiply. Computes y = alpha * Matrix * x + + * beta * y + */ + virtual void MultVectorImpl(Number alpha, const Vector& x, Number beta, Vector& y) const =0; + + /** Matrix(transpose) vector multiply. + * Computes y = alpha * Matrix^T * x + beta * y + */ + virtual void TransMultVectorImpl(Number alpha, const Vector& x, Number beta, Vector& y) const =0; + + /** X = X + alpha*(Matrix S^{-1} Z). Prototype for this + * specialize method is provided, but for efficient + * implementation it should be overloaded for the expansion matrix. + */ + virtual void AddMSinvZImpl(Number alpha, const Vector& S, const Vector& Z, + Vector& X) const; + + /** X = S^{-1} (r + alpha*Z*M^Td). Should be implemented + * efficiently for the ExpansionMatrix. + */ + virtual void SinvBlrmZMTdBrImpl(Number alpha, const Vector& S, + const Vector& R, const Vector& Z, + const Vector& D, Vector& X) const; + + /** Method for determining if all stored numbers are valid (i.e., + * no Inf or Nan). A default implementation always returning true + * is provided, but if possible it should be implemented. */ + virtual bool HasValidNumbersImpl() const + { + return true; + } + + /** Compute the max-norm of the rows in the matrix. The result is + * stored in rows_norms. The vector is assumed to be + * initialized. */ + virtual void ComputeRowAMaxImpl(Vector& rows_norms, bool init) const = 0; + /** Compute the max-norm of the columns in the matrix. The result + * is stored in cols_norms. The vector is assumed to be + * initialized. */ + virtual void ComputeColAMaxImpl(Vector& cols_norms, bool init) const = 0; + + /** Print detailed information about the matrix. */ + virtual void PrintImpl(const Journalist& jnlst, + EJournalLevel level, + EJournalCategory category, + const std::string& name, + Index indent, + const std::string& prefix) const =0; + //@} + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** default constructor */ + Matrix(); + + /** Copy constructor */ + Matrix(const Matrix&); + + /** Overloaded Equals Operator */ + Matrix& operator=(const Matrix&); + //@} + + const SmartPtr<const MatrixSpace> owner_space_; + + /**@name CachedResults data members */ + //@{ + mutable TaggedObject::Tag valid_cache_tag_; + mutable bool cached_valid_; + //@} + }; + + + /** MatrixSpace base class, corresponding to the Matrix base class. + * For each Matrix implementation, a corresponding MatrixSpace has + * to be implemented. A MatrixSpace is able to create new Matrices + * of a specific type. The MatrixSpace should also store + * information that is common to all Matrices of that type. For + * example, the dimensions of a Matrix is stored in the MatrixSpace + * base class. + */ + class MatrixSpace : public ReferencedObject + { + public: + /** @name Constructors/Destructors */ + //@{ + /** Constructor, given the number rows and columns of all matrices + * generated by this MatrixSpace. + */ + MatrixSpace(Index nRows, Index nCols) + : + nRows_(nRows), + nCols_(nCols) + {} + + /** Destructor */ + virtual ~MatrixSpace() + {} + //@} + + /** Pure virtual method for creating a new Matrix of the + * corresponding type. + */ + virtual Matrix* MakeNew() const=0; + + /** Accessor function for the number of rows. */ + Index NRows() const + { + return nRows_; + } + /** Accessor function for the number of columns. */ + Index NCols() const + { + return nCols_; + } + + /** Method to test if a given matrix belongs to a particular + * matrix space. + */ + bool IsMatrixFromSpace(const Matrix& matrix) const + { + return (matrix.OwnerSpace() == this); + } + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** default constructor */ + MatrixSpace(); + + /** Copy constructor */ + MatrixSpace(const MatrixSpace&); + + /** Overloaded Equals Operator */ + MatrixSpace& operator=(const MatrixSpace&); + //@} + + /** Number of rows for all matrices of this type. */ + const Index nRows_; + /** Number of columns for all matrices of this type. */ + const Index nCols_; + }; + + + /* Inline Methods */ + inline + Index Matrix::NRows() const + { + return owner_space_->NRows(); + } + + inline + Index Matrix::NCols() const + { + return owner_space_->NCols(); + } + + inline + SmartPtr<const MatrixSpace> Matrix::OwnerSpace() const + { + return owner_space_; + } + +} // namespace Ipopt + +// Macro definitions for debugging matrices +#if COIN_IPOPT_VERBOSITY == 0 +# define DBG_PRINT_MATRIX(__verbose_level, __mat_name, __mat) +#else +# define DBG_PRINT_MATRIX(__verbose_level, __mat_name, __mat) \ + if (dbg_jrnl.Verbosity() >= (__verbose_level)) { \ + if (dbg_jrnl.Jnlst()!=NULL) { \ + (__mat).Print(dbg_jrnl.Jnlst(), \ + J_ERROR, J_DBG, \ + __mat_name, \ + dbg_jrnl.IndentationLevel()*2, \ + "# "); \ + } \ + } +#endif // #if COIN_IPOPT_VERBOSITY == 0 + +#endif diff --git a/thirdparty/windows/include/coin/IpNLP.hpp b/thirdparty/windows/include/coin/IpNLP.hpp new file mode 100644 index 0000000..20ee64b --- /dev/null +++ b/thirdparty/windows/include/coin/IpNLP.hpp @@ -0,0 +1,243 @@ +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpNLP.hpp 1312 2008-08-29 22:21:40Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPNLP_HPP__ +#define __IPNLP_HPP__ + +#include "IpUtils.hpp" +#include "IpVector.hpp" +#include "IpSmartPtr.hpp" +#include "IpMatrix.hpp" +#include "IpSymMatrix.hpp" +#include "IpOptionsList.hpp" +#include "IpAlgTypes.hpp" +#include "IpReturnCodes.hpp" + +namespace Ipopt +{ + // forward declarations + class IpoptData; + class IpoptCalculatedQuantities; + class IteratesVector; + + /** Brief Class Description. + * Detailed Class Description. + */ + class NLP : public ReferencedObject + { + public: + /**@name Constructors/Destructors */ + //@{ + /** Default constructor */ + NLP() + {} + + /** Default destructor */ + virtual ~NLP() + {} + //@} + + /** Exceptions */ + //@{ + DECLARE_STD_EXCEPTION(USER_SCALING_NOT_IMPLEMENTED); + DECLARE_STD_EXCEPTION(INVALID_NLP); + //@} + + /** @name NLP Initialization (overload in + * derived classes).*/ + //@{ + /** Overload if you want the chance to process options or parameters that + * may be specific to the NLP */ + virtual bool ProcessOptions(const OptionsList& options, + const std::string& prefix) + { + return true; + } + + /** Method for creating the derived vector / matrix types. The + * Hess_lagrangian_space pointer can be NULL if a quasi-Newton + * options is chosen. */ + virtual bool GetSpaces(SmartPtr<const VectorSpace>& x_space, + SmartPtr<const VectorSpace>& c_space, + SmartPtr<const VectorSpace>& d_space, + SmartPtr<const VectorSpace>& x_l_space, + SmartPtr<const MatrixSpace>& px_l_space, + SmartPtr<const VectorSpace>& x_u_space, + SmartPtr<const MatrixSpace>& px_u_space, + SmartPtr<const VectorSpace>& d_l_space, + SmartPtr<const MatrixSpace>& pd_l_space, + SmartPtr<const VectorSpace>& d_u_space, + SmartPtr<const MatrixSpace>& pd_u_space, + SmartPtr<const MatrixSpace>& Jac_c_space, + SmartPtr<const MatrixSpace>& Jac_d_space, + SmartPtr<const SymMatrixSpace>& Hess_lagrangian_space)=0; + + /** Method for obtaining the bounds information */ + virtual bool GetBoundsInformation(const Matrix& Px_L, + Vector& x_L, + const Matrix& Px_U, + Vector& x_U, + const Matrix& Pd_L, + Vector& d_L, + const Matrix& Pd_U, + Vector& d_U)=0; + + /** Method for obtaining the starting point for all the + * iterates. ToDo it might not make sense to ask for initial + * values for v_L and v_U? */ + virtual bool GetStartingPoint( + SmartPtr<Vector> x, + bool need_x, + SmartPtr<Vector> y_c, + bool need_y_c, + SmartPtr<Vector> y_d, + bool need_y_d, + SmartPtr<Vector> z_L, + bool need_z_L, + SmartPtr<Vector> z_U, + bool need_z_U + )=0; + + /** Method for obtaining an entire iterate as a warmstart point. + * The incoming IteratesVector has to be filled. The default + * dummy implementation returns false. */ + virtual bool GetWarmStartIterate(IteratesVector& warm_start_iterate) + { + return false; + } + //@} + + /** @name NLP evaluation routines (overload + * in derived classes. */ + //@{ + virtual bool Eval_f(const Vector& x, Number& f) = 0; + + virtual bool Eval_grad_f(const Vector& x, Vector& g_f) = 0; + + virtual bool Eval_c(const Vector& x, Vector& c) = 0; + + virtual bool Eval_jac_c(const Vector& x, Matrix& jac_c) = 0; + + virtual bool Eval_d(const Vector& x, Vector& d) = 0; + + virtual bool Eval_jac_d(const Vector& x, Matrix& jac_d) = 0; + + virtual bool Eval_h(const Vector& x, + Number obj_factor, + const Vector& yc, + const Vector& yd, + SymMatrix& h) = 0; + //@} + + /** @name NLP solution routines. Have default dummy + * implementations that can be overloaded. */ + //@{ + /** This method is called at the very end of the optimization. It + * provides the final iterate to the user, so that it can be + * stored as the solution. The status flag indicates the outcome + * of the optimization, where SolverReturn is defined in + * IpAlgTypes.hpp. */ + virtual void FinalizeSolution(SolverReturn status, + const Vector& x, const Vector& z_L, + const Vector& z_U, + const Vector& c, const Vector& d, + const Vector& y_c, const Vector& y_d, + Number obj_value, + const IpoptData* ip_data, + IpoptCalculatedQuantities* ip_cq) + {} + + /** This method is called once per iteration, after the iteration + * summary output has been printed. It provides the current + * information to the user to do with it anything she wants. It + * also allows the user to ask for a premature termination of the + * optimization by returning false, in which case Ipopt will + * terminate with a corresponding return status. The basic + * information provided in the argument list has the quantities + * values printed in the iteration summary line. If more + * information is required, a user can obtain it from the IpData + * and IpCalculatedQuantities objects. However, note that the + * provided quantities are all for the problem that Ipopt sees, + * i.e., the quantities might be scaled, fixed variables might be + * sorted out, etc. The status indicates things like whether the + * algorithm is in the restoration phase... In the restoration + * phase, the dual variables are probably not not changing. */ + virtual bool IntermediateCallBack(AlgorithmMode mode, + Index iter, Number obj_value, + Number inf_pr, Number inf_du, + Number mu, Number d_norm, + Number regularization_size, + Number alpha_du, Number alpha_pr, + Index ls_trials, + const IpoptData* ip_data, + IpoptCalculatedQuantities* ip_cq) + { + return true; + } + //@} + + /** Routines to get the scaling parameters. These do not need to + * be overloaded unless the options are set for User scaling + */ + //@{ + virtual void GetScalingParameters( + const SmartPtr<const VectorSpace> x_space, + const SmartPtr<const VectorSpace> c_space, + const SmartPtr<const VectorSpace> d_space, + Number& obj_scaling, + SmartPtr<Vector>& x_scaling, + SmartPtr<Vector>& c_scaling, + SmartPtr<Vector>& d_scaling) const + { + THROW_EXCEPTION(USER_SCALING_NOT_IMPLEMENTED, + "You have set options for user provided scaling, but have" + " not implemented GetScalingParameters in the NLP interface"); + } + //@} + + /** Method for obtaining the subspace in which the limited-memory + * Hessian approximation should be done. This is only called if + * the limited-memory Hessian approximation is chosen. Since the + * Hessian is zero in the space of all variables that appear in + * the problem functions only linearly, this allows the user to + * provide a VectorSpace for all nonlinear variables, and an + * ExpansionMatrix to lift from this VectorSpace to the + * VectorSpace of the primal variables x. If the returned values + * are NULL, it is assumed that the Hessian is to be approximated + * in the space of all x variables. The default instantiation of + * this method returns NULL, and a user only has to overwrite + * this method if the approximation is to be done only in a + * subspace. */ + virtual void + GetQuasiNewtonApproximationSpaces(SmartPtr<VectorSpace>& approx_space, + SmartPtr<Matrix>& P_approx) + { + approx_space = NULL; + P_approx = NULL; + } + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Copy Constructor */ + NLP(const NLP&); + + /** Overloaded Equals Operator */ + void operator=(const NLP&); + //@} + }; + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpObserver.hpp b/thirdparty/windows/include/coin/IpObserver.hpp new file mode 100644 index 0000000..55ef738 --- /dev/null +++ b/thirdparty/windows/include/coin/IpObserver.hpp @@ -0,0 +1,358 @@ +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpObserver.hpp 1019 2007-06-24 03:52:34Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPOBSERVER_HPP__ +#define __IPOBSERVER_HPP__ + +#include "IpUtils.hpp" +#include <vector> +#include <algorithm> + +//#define IP_DEBUG_OBSERVER +#if COIN_IPOPT_CHECKLEVEL > 2 +# define IP_DEBUG_OBSERVER +#endif +#ifdef IP_DEBUG_OBSERVER +# include "IpDebug.hpp" +#endif + +namespace Ipopt +{ + /** Forward declarations */ + class Subject; + + /** Slight Variation of the Observer Design Pattern. + * This class implements the Observer class of the + * Observer Design Pattern. An Observer "Attach"es + * to a Subject, indicating that it would like to + * be notified of changes in the Subject. + * Any derived class wishing to recieve notifications + * from a Subject should inherit off of + * Observer and overload the protected method, + * RecieveNotification_(...). + */ + class Observer + { + public: +#ifdef IP_DEBUG_OBSERVER + + static const Index dbg_verbosity; +#endif + + /**@name Constructors/Destructors */ + //@{ + /** Default Constructor */ + Observer() + {} + + /** Default destructor */ + virtual ~Observer(); + //@} + + /** Enumeration specifying the type of notification */ + enum NotifyType + { + NT_All, + NT_BeingDestroyed, + NT_Changed + }; + + protected: + /** Derived classes should call this method + * to request an "Attach" to a Subject. Do + * not call "Attach" explicitly on the Subject + * since further processing is done here + */ + void RequestAttach(NotifyType notify_type, const Subject* subject); + + /** Derived classes should call this method + * to request a "Detach" to a Subject. Do + * not call "Detach" explicitly on the Subject + * since further processing is done here + */ + void RequestDetach(NotifyType notify_type, const Subject* subject); + + /** Derived classes should overload this method to + * recieve the requested notification from + * attached Subjects + */ + virtual void RecieveNotification(NotifyType notify_type, const Subject* subject)=0; + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Copy Constructor */ + Observer(const Observer&); + + /** Overloaded Equals Operator */ + void operator=(const Observer&); + //@} + + /** A list of the subjects currently being + * observed. */ + std::vector<const Subject*> subjects_; + + /** Private Method for Recieving Notification + * should only be called by the friend class + * Subject. This method will, in turn, call + * the overloaded RecieveNotification method + * for the derived class to process. + */ + void ProcessNotification(NotifyType notify_type, const Subject* subject); + + friend class Subject; + }; + + /** Slight Variation of the Observer Design Pattern (Subject part). + * This class implements the Subject class of the Observer Design + * Pattern. An Observer "Attach"es to a Subject, indicating that it + * would like to be notified of changes in the Subject. Any + * derived class that is to be observed has to inherit off the + * Subject base class. If the subject needs to notify the + * Observer, it calls the Notify method. + */ + class Subject + { + public: +#ifdef IP_DEBUG_OBSERVER + + static const Index dbg_verbosity; +#endif + + /**@name Constructors/Destructors */ + //@{ + /** Default Constructor */ + Subject() + {} + + /** Default destructor */ + virtual ~Subject(); + //@} + + /**@name Methods to Add and Remove Observers. + * Currently, the notify_type flags are not used, + * and Observers are attached in general and will + * recieve all notifications (of the type requested + * and possibly of types not requested). It is + * up to the observer to ignore the types they + * are not interested in. The NotifyType in the + * parameter list is so a more efficient mechanism + * depending on type could be implemented later if + * necessary.*/ + //@{ + + /** Attach the specified observer + * (i.e., begin recieving notifications). */ + void AttachObserver(Observer::NotifyType notify_type, Observer* observer) const; + + /** Detach the specified observer + * (i.e., no longer recieve notifications). */ + void DetachObserver(Observer::NotifyType notify_type, Observer* observer) const; + //@} + + protected: + + void Notify(Observer::NotifyType notify_type) const; + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Copy Constructor */ + Subject(const Subject&); + + /** Overloaded Equals Operator */ + void operator=(const Subject&); + //@} + + mutable std::vector<Observer*> observers_; + + }; + + /* inline methods */ + inline + Observer::~Observer() + { +#ifdef IP_DEBUG_OBSERVER + DBG_START_METH("Observer::~Observer", dbg_verbosity); + if (DBG_VERBOSITY()>=1) { + for (Index i=0; i<(Index)subjects_.size(); i++) { + DBG_PRINT((1,"subjects_[%d] = 0x%x\n", i, subjects_[i])); + } + } +#endif + // Detach all subjects + for (Int i=(Int)(subjects_.size()-1); i>=0; i--) { +#ifdef IP_DEBUG_OBSERVER + DBG_PRINT((1,"About to detach subjects_[%d] = 0x%x\n", i, subjects_[i])); +#endif + + RequestDetach(NT_All, subjects_[i]); + } + } + + inline + void Observer::RequestAttach(NotifyType notify_type, const Subject* subject) + { +#ifdef IP_DEBUG_OBSERVER + DBG_START_METH("Observer::RequestAttach", dbg_verbosity); + + // Add the subject to the list if it does not already exist + std::vector<const Subject*>::iterator attached_subject; + attached_subject = std::find(subjects_.begin(), subjects_.end(), subject); + DBG_ASSERT(attached_subject == subjects_.end()); + DBG_ASSERT(subject); +#endif + + // add the subject to the list + subjects_.push_back(subject); + // Attach the observer to the subject + subject->AttachObserver(notify_type, this); + } + + inline + void Observer::RequestDetach(NotifyType notify_type, const Subject* subject) + { +#ifdef IP_DEBUG_OBSERVER + DBG_START_METH("Observer::RequestDetach", dbg_verbosity); + DBG_PRINT((1, "Requesting detach of subject: 0x%x\n", subject)); + DBG_ASSERT(subject); +#endif + + if (subject) { + std::vector<const Subject*>::iterator attached_subject; + attached_subject = std::find(subjects_.begin(), subjects_.end(), subject); +#ifdef IP_DEBUG_OBSERVER + + DBG_ASSERT(attached_subject != subjects_.end()); +#endif + + if (attached_subject != subjects_.end()) { +#ifdef IP_DEBUG_OBSERVER + DBG_PRINT((1, "Removing subject: 0x%x from the list\n", subject)); +#endif + + subjects_.erase(attached_subject); + } + + // Detach the observer from the subject + subject->DetachObserver(notify_type, this); + } + } + + inline + void Observer::ProcessNotification(NotifyType notify_type, const Subject* subject) + { +#ifdef IP_DEBUG_OBSERVER + DBG_START_METH("Observer::ProcessNotification", dbg_verbosity); + DBG_ASSERT(subject); +#endif + + if (subject) { + std::vector<const Subject*>::iterator attached_subject; + attached_subject = std::find(subjects_.begin(), subjects_.end(), subject); + + // We must be processing a notification for a + // subject that was previously attached. +#ifdef IP_DEBUG_OBSERVER + + DBG_ASSERT(attached_subject != subjects_.end()); +#endif + + this->RecieveNotification(notify_type, subject); + + if (notify_type == NT_BeingDestroyed) { + // the subject is going away, remove it from our list + subjects_.erase(attached_subject); + } + } + } + + inline + Subject::~Subject() + { +#ifdef IP_DEBUG_OBSERVER + DBG_START_METH("Subject::~Subject", dbg_verbosity); +#endif + + std::vector<Observer*>::iterator iter; + for (iter = observers_.begin(); iter != observers_.end(); iter++) { + (*iter)->ProcessNotification(Observer::NT_BeingDestroyed, this); + } + } + + inline + void Subject::AttachObserver(Observer::NotifyType notify_type, Observer* observer) const + { +#ifdef IP_DEBUG_OBSERVER + DBG_START_METH("Subject::AttachObserver", dbg_verbosity); + // current implementation notifies all observers of everything + // they must filter the notifications that they are not interested + // in (i.e. a hub, not a router) + DBG_ASSERT(observer); + + std::vector<Observer*>::iterator attached_observer; + attached_observer = std::find(observers_.begin(), observers_.end(), observer); + DBG_ASSERT(attached_observer == observers_.end()); + + DBG_ASSERT(observer); +#endif + + observers_.push_back(observer); + } + + inline + void Subject::DetachObserver(Observer::NotifyType notify_type, Observer* observer) const + { +#ifdef IP_DEBUG_OBSERVER + DBG_START_METH("Subject::DetachObserver", dbg_verbosity); + DBG_ASSERT(observer); +#endif + + if (observer) { + std::vector<Observer*>::iterator attached_observer; + attached_observer = std::find(observers_.begin(), observers_.end(), observer); +#ifdef IP_DEBUG_OBSERVER + + DBG_ASSERT(attached_observer != observers_.end()); +#endif + + if (attached_observer != observers_.end()) { + observers_.erase(attached_observer); + } + } + } + + inline + void Subject::Notify(Observer::NotifyType notify_type) const + { +#ifdef IP_DEBUG_OBSERVER + DBG_START_METH("Subject::Notify", dbg_verbosity); +#endif + + std::vector<Observer*>::iterator iter; + for (iter = observers_.begin(); iter != observers_.end(); iter++) { + (*iter)->ProcessNotification(notify_type, this); + } + } + + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpOptionsList.hpp b/thirdparty/windows/include/coin/IpOptionsList.hpp new file mode 100644 index 0000000..098174a --- /dev/null +++ b/thirdparty/windows/include/coin/IpOptionsList.hpp @@ -0,0 +1,289 @@ +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpOptionsList.hpp 1587 2009-10-27 16:09:21Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPOPTLIST_HPP__ +#define __IPOPTLIST_HPP__ + +#include "IpUtils.hpp" +#include "IpReferenced.hpp" +#include "IpException.hpp" +#include "IpRegOptions.hpp" + +#include <iostream> +#include <map> + +namespace Ipopt +{ + /** Exception that can be used to indicate errors with options */ + DECLARE_STD_EXCEPTION(OPTION_INVALID); + + /** This class stores a list of user set options. Each options is + * identified by a case-insensitive keyword (tag). Its value is + * stored internally as a string (always lower case), but for + * convenience set and get methods are provided to obtain Index and + * Number type values. For each keyword we also keep track of how + * often the value of an option has been requested by a get method. + */ + class OptionsList : public ReferencedObject + { + /** Class for storing the value and counter for each option in + * OptionsList. */ + class OptionValue + { + public: + /**@name Constructors/Destructors */ + //@{ + /** Default constructor (needed for the map) */ + OptionValue() + : + initialized_(false) + {} + + /** Constructor given the value */ + OptionValue(std::string value, bool allow_clobber, bool dont_print) + : + value_(value), + counter_(0), + initialized_(true), + allow_clobber_(allow_clobber), + dont_print_(dont_print) + {} + + /** Copy Constructor */ + OptionValue(const OptionValue& copy) + : + value_(copy.value_), + counter_(copy.counter_), + initialized_(copy.initialized_), + allow_clobber_(copy.allow_clobber_), + dont_print_(copy.dont_print_) + {} + + /** Equals operator */ + void operator=(const OptionValue& copy) + { + value_=copy.value_; + counter_=copy.counter_; + initialized_=copy.initialized_; + allow_clobber_=copy.allow_clobber_; + dont_print_=copy.dont_print_; + } + + /** Default Destructor */ + ~OptionValue() + {} + //@} + + /** Method for retrieving the value of an option. Calling this + * method will increase the counter by one. */ + std::string GetValue() const + { + DBG_ASSERT(initialized_); + counter_++; + return value_; + } + + /** Method for retrieving the value without increasing the + * counter */ + std::string Value() const + { + DBG_ASSERT(initialized_); + return value_; + } + + /** Method for accessing current value of the request counter */ + Index Counter() const + { + DBG_ASSERT(initialized_); + return counter_; + } + + /** True if the option can be overwritten */ + bool AllowClobber() const + { + DBG_ASSERT(initialized_); + return allow_clobber_; + } + + /** True if this option is not to show up in the + * print_user_options output */ + bool DontPrint() const + { + DBG_ASSERT(initialized_); + return dont_print_; + } + + private: + /** Value for this option */ + std::string value_; + + /** Counter for requests */ + mutable Index counter_; + + /** for debugging */ + bool initialized_; + + /** True if the option can be overwritten */ + bool allow_clobber_; + + /** True if this option is not to show up in the + * print_user_options output */ + bool dont_print_; + }; + + public: + /**@name Constructors/Destructors */ + //@{ + OptionsList(SmartPtr<RegisteredOptions> reg_options, SmartPtr<Journalist> jnlst) + : reg_options_(reg_options), jnlst_(jnlst) + {} + + OptionsList() + {} + + /** Copy Constructor */ + OptionsList(const OptionsList& copy) + { + // copy all the option strings and values + options_ = copy.options_; + // copy the registered options pointer + reg_options_ = copy.reg_options_; + } + + /** Default destructor */ + virtual ~OptionsList() + {} + + /** Overloaded Equals Operator */ + virtual void operator=(const OptionsList& source) + { + options_ = source.options_; + reg_options_ = source.reg_options_; + jnlst_ = source.jnlst_; + } + //@} + + /** Method for clearing all previously set options */ + virtual void clear() + { + options_.clear(); + } + + /** @name Get / Set Methods */ + //@{ + virtual void SetRegisteredOptions(const SmartPtr<RegisteredOptions> reg_options) + { + reg_options_ = reg_options; + } + virtual void SetJournalist(const SmartPtr<Journalist> jnlst) + { + jnlst_ = jnlst; + } + //@} + /** @name Methods for setting options */ + //@{ + virtual bool SetStringValue(const std::string& tag, const std::string& value, + bool allow_clobber = true, bool dont_print = false); + virtual bool SetNumericValue(const std::string& tag, Number value, + bool allow_clobber = true, bool dont_print = false); + virtual bool SetIntegerValue(const std::string& tag, Index value, + bool allow_clobber = true, bool dont_print = false); + //@} + + /** @name Methods for setting options only if they have not been + * set before*/ + //@{ + virtual bool SetStringValueIfUnset(const std::string& tag, const std::string& value, + bool allow_clobber = true, bool dont_print = false); + virtual bool SetNumericValueIfUnset(const std::string& tag, Number value, + bool allow_clobber = true, bool dont_print = false); + virtual bool SetIntegerValueIfUnset(const std::string& tag, Index value, + bool allow_clobber = true, bool dont_print = false); + //@} + + /** @name Methods for retrieving values from the options list. If + * a tag is not found, the methods return false, and value is set + * to the default value defined in the registered options. */ + //@{ + virtual bool GetStringValue(const std::string& tag, std::string& value, + const std::string& prefix) const; + virtual bool GetEnumValue(const std::string& tag, Index& value, + const std::string& prefix) const; + virtual bool GetBoolValue(const std::string& tag, bool& value, + const std::string& prefix) const; + virtual bool GetNumericValue(const std::string& tag, Number& value, + const std::string& prefix) const; + virtual bool GetIntegerValue(const std::string& tag, Index& value, + const std::string& prefix) const; + //@} + + /** Get a string with the list of all options (tag, value, counter) */ + virtual void PrintList(std::string& list) const; + + /** Get a string with the list of all options set by the user + * (tag, value, use/notused). Here, options with dont_print flag + * set to true are not printed. */ + virtual void PrintUserOptions(std::string& list) const; + + /** Read options from the stream is. Returns false if + * an error was encountered. */ + virtual bool ReadFromStream(const Journalist& jnlst, std::istream& is); + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + // OptionsList(); + + //@} + + /** map for storing the options */ + std::map< std::string, OptionValue > options_; + + /** list of all the registered options to validate against */ + SmartPtr<RegisteredOptions> reg_options_; + + /** Journalist for writing error messages, etc. */ + SmartPtr<Journalist> jnlst_; + + /** auxilliary method for converting sting to all lower-case + * letters */ + const std::string& lowercase(const std::string tag) const; + + /** auxilliary method for finding the value for a tag in the + * options list. This method first looks for the concatenated + * string prefix+tag (if prefix is not ""), and if this is not + * found, it looks for tag. The return value is true iff + * prefix+tag or tag is found. In that case, the corresponding + * string value is copied into value. */ + bool find_tag(const std::string& tag, const std::string& prefix, + std::string& value) const; + + /** tells whether or not we can clobber a particular option. + * returns true if the option does not already exist, or if + * the option exists but is set to allow_clobber + */ + bool will_allow_clobber(const std::string& tag) const; + + /** read the next token from stream is. Returns false, if EOF was + * reached before a tokens was ecountered. */ + bool readnexttoken(std::istream& is, std::string& token); + + /** auxilliary string set by lowercase method */ + mutable std::string lowercase_buffer_; + }; + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpReferenced.hpp b/thirdparty/windows/include/coin/IpReferenced.hpp new file mode 100644 index 0000000..6f40e3e --- /dev/null +++ b/thirdparty/windows/include/coin/IpReferenced.hpp @@ -0,0 +1,249 @@ +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpReferenced.hpp 1019 2007-06-24 03:52:34Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPREFERENCED_HPP__ +#define __IPREFERENCED_HPP__ + +#include "IpTypes.hpp" +#include "IpDebug.hpp" + +#include <list> + +namespace Ipopt +{ + + /** Psydo-class, from which everything has to inherit that wants to + * use be registered as a Referencer for a ReferencedObject. + */ + class Referencer + {} + ; + + /** ReferencedObject class. + * This is part of the implementation of an intrusive smart pointer + * design. This class stores the reference count of all the smart + * pointers that currently reference it. See the documentation for + * the SmartPtr class for more details. + * + * A SmartPtr behaves much like a raw pointer, but manages the lifetime + * of an object, deleting the object automatically. This class implements + * a reference-counting, intrusive smart pointer design, where all + * objects pointed to must inherit off of ReferencedObject, which + * stores the reference count. Although this is intrusive (native types + * and externally authored classes require wrappers to be referenced + * by smart pointers), it is a safer design. A more detailed discussion of + * these issues follows after the usage information. + * + * Usage Example: + * Note: to use the SmartPtr, all objects to which you point MUST + * inherit off of ReferencedObject. + * + * \verbatim + * + * In MyClass.hpp... + * + * #include "IpReferenced.hpp" + + * namespace Ipopt { + * + * class MyClass : public ReferencedObject // must derive from ReferencedObject + * { + * ... + * } + * } // namespace Ipopt + * + * + * In my_usage.cpp... + * + * #include "IpSmartPtr.hpp" + * #include "MyClass.hpp" + * + * void func(AnyObject& obj) + * { + * SmartPtr<MyClass> ptr_to_myclass = new MyClass(...); + * // ptr_to_myclass now points to a new MyClass, + * // and the reference count is 1 + * + * ... + * + * obj.SetMyClass(ptr_to_myclass); + * // Here, let's assume that AnyObject uses a + * // SmartPtr<MyClass> internally here. + * // Now, both ptr_to_myclass and the internal + * // SmartPtr in obj point to the same MyClass object + * // and its reference count is 2. + * + * ... + * + * // No need to delete ptr_to_myclass, this + * // will be done automatically when the + * // reference count drops to zero. + * + * } + * + * \endverbatim + * + * Other Notes: + * The SmartPtr implements both dereference operators -> & *. + * The SmartPtr does NOT implement a conversion operator to + * the raw pointer. Use the GetRawPtr() method when this + * is necessary. Make sure that the raw pointer is NOT + * deleted. + * The SmartPtr implements the comparison operators == & != + * for a variety of types. Use these instead of + * \verbatim + * if (GetRawPtr(smrt_ptr) == ptr) // Don't use this + * \endverbatim + * SmartPtr's, as currently implemented, do NOT handle circular references. + * For example: consider a higher level object using SmartPtrs to point to + * A and B, but A and B also point to each other (i.e. A has a SmartPtr + * to B and B has a SmartPtr to A). In this scenario, when the higher + * level object is finished with A and B, their reference counts will + * never drop to zero (since they reference each other) and they + * will not be deleted. This can be detected by memory leak tools like + * valgrind. If the circular reference is necessary, the problem can be + * overcome by a number of techniques: + * + * 1) A and B can have a method that "releases" each other, that is + * they set their internal SmartPtrs to NULL. + * \verbatim + * void AClass::ReleaseCircularReferences() + * { + * smart_ptr_to_B = NULL; + * } + * \endverbatim + * Then, the higher level class can call these methods before + * it is done using A & B. + * + * 2) Raw pointers can be used in A and B to reference each other. + * Here, an implicit assumption is made that the lifetime is + * controlled by the higher level object and that A and B will + * both exist in a controlled manner. Although this seems + * dangerous, in many situations, this type of referencing + * is very controlled and this is reasonably safe. + * + * 3) This SmartPtr class could be redesigned with the Weak/Strong + * design concept. Here, the SmartPtr is identified as being + * Strong (controls lifetime of the object) or Weak (merely + * referencing the object). The Strong SmartPtr increments + * (and decrements) the reference count in ReferencedObject + * but the Weak SmartPtr does not. In the example above, + * the higher level object would have Strong SmartPtrs to + * A and B, but A and B would have Weak SmartPtrs to each + * other. Then, when the higher level object was done with + * A and B, they would be deleted. The Weak SmartPtrs in A + * and B would not decrement the reference count and would, + * of course, not delete the object. This idea is very similar + * to item (2), where it is implied that the sequence of events + * is controlled such that A and B will not call anything using + * their pointers following the higher level delete (i.e. in + * their destructors!). This is somehow safer, however, because + * code can be written (however expensive) to perform run-time + * detection of this situation. For example, the ReferencedObject + * could store pointers to all Weak SmartPtrs that are referencing + * it and, in its destructor, tell these pointers that it is + * dying. They could then set themselves to NULL, or set an + * internal flag to detect usage past this point. + * + * Comments on Non-Intrusive Design: + * In a non-intrusive design, the reference count is stored somewhere other + * than the object being referenced. This means, unless the reference + * counting pointer is the first referencer, it must get a pointer to the + * referenced object from another smart pointer (so it has access to the + * reference count location). In this non-intrusive design, if we are + * pointing to an object with a smart pointer (or a number of smart + * pointers), and we then give another smart pointer the address through + * a RAW pointer, we will have two independent, AND INCORRECT, reference + * counts. To avoid this pitfall, we use an intrusive reference counting + * technique where the reference count is stored in the object being + * referenced. + */ + class ReferencedObject + { + public: + ReferencedObject() + : + reference_count_(0) + {} + + virtual ~ReferencedObject() + { + DBG_ASSERT(reference_count_ == 0); + } + + Index ReferenceCount() const; + + void AddRef(const Referencer* referencer) const; + + void ReleaseRef(const Referencer* referencer) const; + + private: + mutable Index reference_count_; + +# ifdef REF_DEBUG + + mutable std::list<const Referencer*> referencers_; +# endif + + }; + + /* inline methods */ + inline + Index ReferencedObject::ReferenceCount() const + { + // DBG_START_METH("ReferencedObject::ReferenceCount()", 0); + // DBG_PRINT((1,"Returning reference_count_ = %d\n", reference_count_)); + return reference_count_; + } + + inline + void ReferencedObject::AddRef(const Referencer* referencer) const + { + // DBG_START_METH("ReferencedObject::AddRef(const Referencer* referencer)", 0); + reference_count_++; + // DBG_PRINT((1, "New reference_count_ = %d\n", reference_count_)); +# ifdef REF_DEBUG + + referencers_.push_back(referencer); +# endif + + } + + inline + void ReferencedObject::ReleaseRef(const Referencer* referencer) const + { + // DBG_START_METH("ReferencedObject::ReleaseRef(const Referencer* referencer)", + // 0); + reference_count_--; + // DBG_PRINT((1, "New reference_count_ = %d\n", reference_count_)); + +# ifdef REF_DEBUG + + bool found = false; + std::list<const Referencer*>::iterator iter; + for (iter = referencers_.begin(); iter != referencers_.end(); iter++) { + if ((*iter) == referencer) { + found = true; + break; + } + } + + // cannot call release on a reference that was never added... + DBG_ASSERT(found); + + if (found) { + referencers_.erase(iter); + } +# endif + + } + + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpRegOptions.hpp b/thirdparty/windows/include/coin/IpRegOptions.hpp new file mode 100644 index 0000000..0e3c904 --- /dev/null +++ b/thirdparty/windows/include/coin/IpRegOptions.hpp @@ -0,0 +1,651 @@ +// Copyright (C) 2004, 2007 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpRegOptions.hpp 1587 2009-10-27 16:09:21Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2005-06-18 + +#ifndef __IPREGOPTIONS_HPP__ +#define __IPREGOPTIONS_HPP__ + +#include "IpUtils.hpp" +#include "IpReferenced.hpp" +#include "IpException.hpp" +#include "IpSmartPtr.hpp" + +#include <map> + +namespace Ipopt +{ + + enum RegisteredOptionType + { + OT_Number, + OT_Integer, + OT_String, + OT_Unknown + }; + + /** Base class for registered options. The derived types are more + * specific to a string option or a Number (real) option, etc. + */ + class RegisteredOption : public ReferencedObject + { + public: + /** Constructors / Destructors */ + //@{ + RegisteredOption() + : + type_(OT_Unknown), + has_lower_(false), + has_upper_(false), + counter_(0) + {} + + RegisteredOption(const std::string& name, + const std::string& short_description, + const std::string& long_description, + const std::string& registering_category) + : + name_(name), + short_description_(short_description), + long_description_(long_description), + registering_category_(registering_category), + type_(OT_Unknown), + has_lower_(false), + has_upper_(false), + counter_(next_counter_++) + {} + + RegisteredOption(const RegisteredOption& copy) + : + name_(copy.name_), + short_description_(copy.short_description_), + long_description_(copy.long_description_), + registering_category_(copy.registering_category_), + type_(copy.type_), + has_lower_(copy.has_lower_), + lower_(copy.lower_), + has_upper_(copy.has_upper_), + upper_(copy.upper_), + valid_strings_(copy.valid_strings_), + counter_(copy.counter_) + {} + + virtual ~RegisteredOption() + {} + //@} + + DECLARE_STD_EXCEPTION(ERROR_CONVERTING_STRING_TO_ENUM); + + /** Standard Get / Set Methods */ + //@{ + /** Get the option's name (tag in the input file) */ + virtual const std::string& Name() const + { + return name_; + } + /** Set the option's name (tag in the input file) */ + virtual void SetName(const std::string& name) + { + name_ = name; + } + /** Get the short description */ + virtual const std::string& ShortDescription() const + { + return short_description_; + } + /** Get the long description */ + virtual const std::string& LongDescription() const + { + return long_description_; + } + /** Set the short description */ + virtual void SetShortDescription(const std::string& short_description) + { + short_description_ = short_description; + } + /** Set the long description */ + virtual void SetLongDescription(const std::string& long_description) + { + long_description_ = long_description; + } + /** Get the registering class */ + virtual const std::string& RegisteringCategory() const + { + return registering_category_; + } + /** Set the registering class */ + virtual void SetRegisteringCategory(const std::string& registering_category) + { + registering_category_ = registering_category; + } + /** Get the Option's type */ + virtual const RegisteredOptionType& Type() const + { + return type_; + } + /** Get the Option's type */ + virtual void SetType(const RegisteredOptionType& type) + { + type_ = type; + } + /** Counter */ + virtual Index Counter() const + { + return counter_; + } + //@} + + /** @name Get / Set methods valid for specific types - NOTE: the Type + * must be set before calling these methods. + */ + //@{ + /** check if the option has a lower bound - can be called for + * OT_Number & OT_Integer*/ + virtual const bool& HasLower() const + { + DBG_ASSERT(type_ == OT_Number || type_ == OT_Integer); + return has_lower_; + } + /** check if the lower bound is strict - can be called for + OT_Number */ + virtual const bool& LowerStrict() const + { + DBG_ASSERT(type_ == OT_Number && has_lower_ == true); + return lower_strict_; + } + /** get the Number version of the lower bound - can be called for + * OT_Number */ + virtual Number LowerNumber() const + { + DBG_ASSERT(has_lower_ == true && type_ == OT_Number); + return lower_; + } + /** set the Number version of the lower bound - can be called for + * OT_Number */ + virtual void SetLowerNumber(const Number& lower, const bool& strict) + { + DBG_ASSERT(type_ == OT_Number); + lower_ = lower; + lower_strict_ = strict, has_lower_ = true; + } + /** get the Integer version of the lower bound can be called for + * OT_Integer*/ + virtual Index LowerInteger() const + { + DBG_ASSERT(has_lower_ == true && type_ == OT_Integer); + return (Index)lower_; + } + /** set the Integer version of the lower bound - can be called for + * OT_Integer */ + virtual void SetLowerInteger(const Index& lower) + { + DBG_ASSERT(type_ == OT_Integer); + lower_ = (Number)lower; + has_lower_ = true; + } + /** check if the option has an upper bound - can be called for + * OT_Number & OT_Integer*/ + virtual const bool& HasUpper() const + { + DBG_ASSERT(type_ == OT_Number || type_ == OT_Integer); + return has_upper_; + } + /** check if the upper bound is strict - can be called for + * OT_Number */ + virtual const bool& UpperStrict() const + { + DBG_ASSERT(type_ == OT_Number && has_upper_ == true); + return upper_strict_; + } + /** get the Number version of the upper bound - can be called for + * OT_Number */ + virtual Number UpperNumber() const + { + DBG_ASSERT(has_upper_ == true && type_ == OT_Number); + return upper_; + } + /** set the Number version of the upper bound - can be called for + * OT_Number */ + virtual void SetUpperNumber(const Number& upper, const bool& strict) + { + DBG_ASSERT(type_ == OT_Number); + upper_ = upper; + upper_strict_ = strict; + has_upper_ = true; + } + /** get the Integer version of the upper bound - can be called for + * OT_Integer*/ + virtual Index UpperInteger() const + { + DBG_ASSERT(has_upper_ == true && type_ == OT_Integer); + return (Index)upper_; + } + /** set the Integer version of the upper bound - can be called for + * OT_Integer */ + virtual void SetUpperInteger(const Index& upper) + { + DBG_ASSERT(type_ == OT_Integer); + upper_ = (Number)upper; + has_upper_ = true; + } + /** method to add valid string entries - can be called for + * OT_String */ + virtual void AddValidStringSetting(const std::string value, + const std::string description) + { + DBG_ASSERT(type_ == OT_String); + valid_strings_.push_back(string_entry(value, description)); + } + /** get the default as a Number - can be called for OT_Number */ + virtual Number DefaultNumber() const + { + DBG_ASSERT(type_ == OT_Number); + return default_number_; + } + /** Set the default as a Number - can be called for OT_Number */ + virtual void SetDefaultNumber(const Number& default_value) + { + DBG_ASSERT(type_ == OT_Number); + default_number_ = default_value; + } + /** get the default as an Integer - can be called for OT_Integer*/ + virtual Index DefaultInteger() const + { + DBG_ASSERT(type_ == OT_Integer); + return (Index)default_number_; + } + /** Set the default as an Integer - can be called for + OT_Integer */ + virtual void SetDefaultInteger(const Index& default_value) + { + DBG_ASSERT(type_ == OT_Integer); + default_number_ = (Number)default_value; + } + /** get the default as a string - can be called for OT_String */ + virtual std::string DefaultString() const + { + DBG_ASSERT(type_ == OT_String); + return default_string_; + } + /** get the default as a string, but as the index of the string in + * the list - helps map from a string to an enum- can be called + * for OT_String */ + virtual Index DefaultStringAsEnum() const + { + DBG_ASSERT(type_ == OT_String); + return MapStringSettingToEnum(default_string_); + } + /** Set the default as a string - can be called for OT_String */ + virtual void SetDefaultString(const std::string& default_value) + { + DBG_ASSERT(type_ == OT_String); + default_string_ = default_value; + } + /** Check if the Number value is a valid setting - can be called + * for OT_Number */ + virtual bool IsValidNumberSetting(const Number& value) const + { + DBG_ASSERT(type_ == OT_Number); + if (has_lower_ && ((lower_strict_ == true && value <= lower_) || + (lower_strict_ == false && value < lower_))) { + return false; + } + if (has_upper_ && ((upper_strict_ == true && value >= upper_) || + (upper_strict_ == false && value > upper_))) { + return false; + } + return true; + } + /** Check if the Integer value is a valid setting - can be called + * for OT_Integer */ + virtual bool IsValidIntegerSetting(const Index& value) const + { + DBG_ASSERT(type_ == OT_Integer); + if (has_lower_ && value < lower_) { + return false; + } + if (has_upper_ && value > upper_) { + return false; + } + return true; + } + /** Check if the String value is a valid setting - can be called + * for OT_String */ + virtual bool IsValidStringSetting(const std::string& value) const; + + /** Map a user setting (allowing any case) to the case used when + * the setting was registered. + */ + virtual std::string MapStringSetting(const std::string& value) const; + + /** Map a user setting (allowing any case) to the index of the + * matched setting in the list of string settings. Helps map a + * string setting to an enumeration. + */ + virtual Index MapStringSettingToEnum(const std::string& value) const; + //@} + + /** output a description of the option */ + virtual void OutputDescription(const Journalist& jnlst) const; + /** output a more concise version */ + virtual void OutputShortDescription(const Journalist& jnlst) const; + /** output a latex version */ + virtual void OutputLatexDescription(const Journalist& jnlst) const; + + private: + std::string name_; + std::string short_description_; + std::string long_description_; + std::string registering_category_; + RegisteredOptionType type_; + + bool has_lower_; + bool lower_strict_; + Number lower_; + bool has_upper_; + bool upper_strict_; + Number upper_; + Number default_number_; + + void MakeValidLatexString(std::string source, std::string& dest) const; + std::string MakeValidLatexNumber(Number value) const; + + /** Compare two strings and return true if they are equal (case + insensitive comparison) */ + bool string_equal_insensitive(const std::string& s1, + const std::string& s2) const; + + /** class to hold the valid string settings for a string option */ + class string_entry + { + public: + string_entry(const std::string& value, const std::string& description) + : value_(value), description_(description) + {} + std::string value_; + std::string description_; + }; + + std::vector<string_entry> valid_strings_; + std::string default_string_; + + /** Has the information as how many-th option this one was + * registered. */ + const Index counter_; + + static Index next_counter_; + }; + + /** Class for storing registered options. Used for validation and + * documentation. + */ + class RegisteredOptions : public ReferencedObject + { + public: + /** Constructors / Destructors */ + //@{ + /** Standard Constructor */ + RegisteredOptions() + : + current_registering_category_("Uncategorized") + {} + + /** Standard Destructor */ + virtual ~RegisteredOptions() + {} + //@} + + DECLARE_STD_EXCEPTION(OPTION_ALREADY_REGISTERED); + + /** Methods to interact with registered options */ + //@{ + /** set the registering class. All subsequent options will be + * added with the registered class */ + virtual void SetRegisteringCategory(const std::string& registering_category) + { + current_registering_category_ = registering_category; + } + + /** retrieve the value of the current registering category */ + virtual std::string RegisteringCategory() + { + return current_registering_category_; + } + + /** Add a Number option (with no restrictions) */ + virtual void AddNumberOption(const std::string& name, + const std::string& short_description, + Number default_value, + const std::string& long_description=""); + /** Add a Number option (with a lower bound) */ + virtual void AddLowerBoundedNumberOption(const std::string& name, + const std::string& short_description, + Number lower, bool strict, + Number default_value, + const std::string& long_description=""); + /** Add a Number option (with a upper bound) */ + virtual void AddUpperBoundedNumberOption(const std::string& name, + const std::string& short_description, + Number upper, bool strict, + Number default_value, + const std::string& long_description=""); + /** Add a Number option (with a both bounds) */ + virtual void AddBoundedNumberOption(const std::string& name, + const std::string& short_description, + Number lower, bool lower_strict, + Number upper, bool upper_strict, + Number default_value, + const std::string& long_description=""); + /** Add a Integer option (with no restrictions) */ + virtual void AddIntegerOption(const std::string& name, + const std::string& short_description, + Index default_value, + const std::string& long_description=""); + /** Add a Integer option (with a lower bound) */ + virtual void AddLowerBoundedIntegerOption(const std::string& name, + const std::string& short_description, + Index lower, Index default_value, + const std::string& long_description=""); + /** Add a Integer option (with a upper bound) */ + virtual void AddUpperBoundedIntegerOption(const std::string& name, + const std::string& short_description, + Index upper, Index default_value, + const std::string& long_description=""); + /** Add a Integer option (with a both bounds) */ + virtual void AddBoundedIntegerOption(const std::string& name, + const std::string& short_description, + Index lower, Index upper, + Index default_value, + const std::string& long_description=""); + + /** Add a String option (with no restrictions) */ + virtual void AddStringOption(const std::string& name, + const std::string& short_description, + const std::string& default_value, + const std::vector<std::string>& settings, + const std::vector<std::string>& descriptions, + const std::string& long_description=""); + /** Methods that make adding string options with only a few + * entries easier */ + virtual void AddStringOption1(const std::string& name, + const std::string& short_description, + const std::string& default_value, + const std::string& setting1, + const std::string& description1, + const std::string& long_description=""); + virtual void AddStringOption2(const std::string& name, + const std::string& short_description, + const std::string& default_value, + const std::string& setting1, + const std::string& description1, + const std::string& setting2, + const std::string& description2, + const std::string& long_description=""); + virtual void AddStringOption3(const std::string& name, + const std::string& short_description, + const std::string& default_value, + const std::string& setting1, + const std::string& description1, + const std::string& setting2, + const std::string& description2, + const std::string& setting3, + const std::string& description3, + const std::string& long_description=""); + virtual void AddStringOption4(const std::string& name, + const std::string& short_description, + const std::string& default_value, + const std::string& setting1, + const std::string& description1, + const std::string& setting2, + const std::string& description2, + const std::string& setting3, + const std::string& description3, + const std::string& setting4, + const std::string& description4, + const std::string& long_description=""); + virtual void AddStringOption5(const std::string& name, + const std::string& short_description, + const std::string& default_value, + const std::string& setting1, + const std::string& description1, + const std::string& setting2, + const std::string& description2, + const std::string& setting3, + const std::string& description3, + const std::string& setting4, + const std::string& description4, + const std::string& setting5, + const std::string& description5, + const std::string& long_description=""); + virtual void AddStringOption6(const std::string& name, + const std::string& short_description, + const std::string& default_value, + const std::string& setting1, + const std::string& description1, + const std::string& setting2, + const std::string& description2, + const std::string& setting3, + const std::string& description3, + const std::string& setting4, + const std::string& description4, + const std::string& setting5, + const std::string& description5, + const std::string& setting6, + const std::string& description6, + const std::string& long_description=""); + virtual void AddStringOption7(const std::string& name, + const std::string& short_description, + const std::string& default_value, + const std::string& setting1, + const std::string& description1, + const std::string& setting2, + const std::string& description2, + const std::string& setting3, + const std::string& description3, + const std::string& setting4, + const std::string& description4, + const std::string& setting5, + const std::string& description5, + const std::string& setting6, + const std::string& description6, + const std::string& setting7, + const std::string& description7, + const std::string& long_description=""); + virtual void AddStringOption8(const std::string& name, + const std::string& short_description, + const std::string& default_value, + const std::string& setting1, + const std::string& description1, + const std::string& setting2, + const std::string& description2, + const std::string& setting3, + const std::string& description3, + const std::string& setting4, + const std::string& description4, + const std::string& setting5, + const std::string& description5, + const std::string& setting6, + const std::string& description6, + const std::string& setting7, + const std::string& description7, + const std::string& setting8, + const std::string& description8, + const std::string& long_description=""); + virtual void AddStringOption9(const std::string& name, + const std::string& short_description, + const std::string& default_value, + const std::string& setting1, + const std::string& description1, + const std::string& setting2, + const std::string& description2, + const std::string& setting3, + const std::string& description3, + const std::string& setting4, + const std::string& description4, + const std::string& setting5, + const std::string& description5, + const std::string& setting6, + const std::string& description6, + const std::string& setting7, + const std::string& description7, + const std::string& setting8, + const std::string& description8, + const std::string& setting9, + const std::string& description9, + const std::string& long_description=""); + virtual void AddStringOption10(const std::string& name, + const std::string& short_description, + const std::string& default_value, + const std::string& setting1, + const std::string& description1, + const std::string& setting2, + const std::string& description2, + const std::string& setting3, + const std::string& description3, + const std::string& setting4, + const std::string& description4, + const std::string& setting5, + const std::string& description5, + const std::string& setting6, + const std::string& description6, + const std::string& setting7, + const std::string& description7, + const std::string& setting8, + const std::string& description8, + const std::string& setting9, + const std::string& description9, + const std::string& setting10, + const std::string& description10, + const std::string& long_description=""); + + /** Get a registered option - this will return NULL if the option + * does not exist */ + virtual SmartPtr<const RegisteredOption> GetOption(const std::string& name); + + /** Output documentation for the options - gives a description, + * etc. */ + virtual void OutputOptionDocumentation(const Journalist& jnlst, std::list<std::string>& categories); + + /** Output documentation in Latex format to include in a latex file */ + virtual void OutputLatexOptionDocumentation(const Journalist& jnlst, std::list<std::string>& categories); + //@} + + typedef std::map<std::string, SmartPtr<RegisteredOption> > RegOptionsList; + + /** Giving access to iteratable representation of the registered + * options */ + virtual const RegOptionsList& RegisteredOptionsList () const + { + return registered_options_; + } + + private: + std::string current_registering_category_; + std::map<std::string, SmartPtr<RegisteredOption> > registered_options_; + }; +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpReturnCodes.h b/thirdparty/windows/include/coin/IpReturnCodes.h new file mode 100644 index 0000000..54cf0ae --- /dev/null +++ b/thirdparty/windows/include/coin/IpReturnCodes.h @@ -0,0 +1,18 @@ +/*********************************************************************** +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpReturnCodes.h 735 2006-06-04 06:10:05Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 +************************************************************************/ + +#ifndef __IPRETURNCODES_H__ +#define __IPRETURNCODES_H__ + +/* include from a common include file */ + +#include "IpReturnCodes_inc.h" + +#endif diff --git a/thirdparty/windows/include/coin/IpReturnCodes.hpp b/thirdparty/windows/include/coin/IpReturnCodes.hpp new file mode 100644 index 0000000..8c688b7 --- /dev/null +++ b/thirdparty/windows/include/coin/IpReturnCodes.hpp @@ -0,0 +1,21 @@ +/*********************************************************************** +// Copyright (C) 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpReturnCodes.hpp 1324 2008-09-16 14:19:26Z andreasw $ +// +// Authors: Andreas Waechter IBM 2006-03-01 +************************************************************************/ + +#ifndef __IPRETURNCODES_HPP__ +#define __IPRETURNCODES_HPP__ + +/* include from a common include file */ + +namespace Ipopt +{ +#include "IpReturnCodes_inc.h" +} + +#endif diff --git a/thirdparty/windows/include/coin/IpReturnCodes.inc b/thirdparty/windows/include/coin/IpReturnCodes.inc new file mode 100644 index 0000000..033d47f --- /dev/null +++ b/thirdparty/windows/include/coin/IpReturnCodes.inc @@ -0,0 +1,70 @@ +C Copyright (C) 2005, 2009 International Business Machines and others. +C All Rights Reserved. +C This code is published under the Common Public License. +C +C $Id: IpReturnCodes.inc 1430 2009-04-20 20:58:25Z andreasw $ +C +C Author: Andreas Waechter IBM 2005-08-11 +C + INTEGER IP_SOLVE_SUCCEEDED + PARAMETER( IP_SOLVE_SUCCEEDED = 0 ) + + INTEGER IP_ACCEPTABLE_LEVEL + PARAMETER( IP_ACCEPTABLE_LEVEL = 1 ) + + INTEGER IP_INFEASIBLE_PROBLEM + PARAMETER( IP_INFEASIBLE_PROBLEM = 2 ) + + INTEGER IP_SEARCH_DIRECTION_TOO_SMALL + PARAMETER( IP_SEARCH_DIRECTION_TOO_SMALL = 3 ) + + INTEGER IP_DIVERGING_ITERATES + PARAMETER( IP_DIVERGING_ITERATES = 4 ) + + INTEGER IP_USER_REQUESTED_STOP + PARAMETER( IP_USER_REQUESTED_STOP = 5 ) + + INTEGER IP_FEASIBLE_POINT_FOUND + PARAMETER( IP_FEASIBLE_POINT_FOUND = 6 ) + + INTEGER IP_ITERATION_EXCEEDED + PARAMETER( IP_ITERATION_EXCEEDED = -1 ) + + INTEGER IP_RESTORATION_FAILED + PARAMETER( IP_RESTORATION_FAILED = -2 ) + + INTEGER IP_ERROR_IN_STEP_COMPUTATION + PARAMETER( IP_ERROR_IN_STEP_COMPUTATION = -3 ) + + INTEGER IP_CPUTIME_EXCEEDED + PARAMETER( IP_CPUTIME_EXCEEDED = -4 ) + + INTEGER IP_NOT_ENOUGH_DEGREES_OF_FRE + PARAMETER( IP_NOT_ENOUGH_DEGREES_OF_FRE = -10 ) + + INTEGER IP_INVALID_PROBLEM_DEFINITION + PARAMETER( IP_INVALID_PROBLEM_DEFINITION = -11) + + INTEGER IP_INVALID_OPTION + PARAMETER( IP_INVALID_OPTION = -12 ) + + INTEGER IP_INVALID_NUMBER_DETECTED + PARAMETER( IP_INVALID_NUMBER_DETECTED = -13 ) + + INTEGER IP_UNRECOVERABLE_EXCEPTION + PARAMETER( IP_UNRECOVERABLE_EXCEPTION = -100 ) + + INTEGER IP_NON_IPOPT_EXCEPTION + PARAMETER( IP_NON_IPOPT_EXCEPTION = -101 ) + + INTEGER IP_INSUFFICIENT_MEMORY + PARAMETER( IP_INSUFFICIENT_MEMORY = -102 ) + + INTEGER IP_INTERNAL_ERROR + PARAMETER( IP_INTERNAL_ERROR = -199 ) + + INTEGER IP_REGULAR_MODE + PARAMETER( IP_REGULAR_MODE = 0 ) + + INTEGER IP_RESTORATION_PHASE_MODE + PARAMETER( IP_RESTORATION_PHASE_MODE = 1 ) diff --git a/thirdparty/windows/include/coin/IpReturnCodes_inc.h b/thirdparty/windows/include/coin/IpReturnCodes_inc.h new file mode 100644 index 0000000..2de94bb --- /dev/null +++ b/thirdparty/windows/include/coin/IpReturnCodes_inc.h @@ -0,0 +1,46 @@ +/*********************************************************************** +// Copyright (C) 2004, 2009 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpReturnCodes_inc.h 1430 2009-04-20 20:58:25Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 +************************************************************************/ + +/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ +/* !!!!!!!!!!!!!!!! REMEMBER TO UPDATE IpReturnCodes.inc !!!!!!!!!!!!!!!! */ +/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */ + +/** Return codes for the Optimize call for an application */ +enum ApplicationReturnStatus + { + Solve_Succeeded=0, + Solved_To_Acceptable_Level=1, + Infeasible_Problem_Detected=2, + Search_Direction_Becomes_Too_Small=3, + Diverging_Iterates=4, + User_Requested_Stop=5, + Feasible_Point_Found=6, + + Maximum_Iterations_Exceeded=-1, + Restoration_Failed=-2, + Error_In_Step_Computation=-3, + Maximum_CpuTime_Exceeded=-4, + Not_Enough_Degrees_Of_Freedom=-10, + Invalid_Problem_Definition=-11, + Invalid_Option=-12, + Invalid_Number_Detected=-13, + + Unrecoverable_Exception=-100, + NonIpopt_Exception_Thrown=-101, + Insufficient_Memory=-102, + Internal_Error=-199 + }; + +/** enum to indicate the mode in which the algorithm is */ +enum AlgorithmMode + { + RegularMode=0, + RestorationPhaseMode=1 + }; diff --git a/thirdparty/windows/include/coin/IpSmartPtr.hpp b/thirdparty/windows/include/coin/IpSmartPtr.hpp new file mode 100644 index 0000000..ef7e705 --- /dev/null +++ b/thirdparty/windows/include/coin/IpSmartPtr.hpp @@ -0,0 +1,670 @@ +// Copyright (C) 2004, 2007 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpSmartPtr.hpp 1019 2007-06-24 03:52:34Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPSMARTPTR_HPP__ +#define __IPSMARTPTR_HPP__ + +#include "IpReferenced.hpp" + +#include "IpDebug.hpp" +#if COIN_IPOPT_CHECKLEVEL > 2 +# define IP_DEBUG_SMARTPTR +#endif + +namespace Ipopt +{ + + /** Template class for Smart Pointers. + * A SmartPtr behaves much like a raw pointer, but manages the lifetime + * of an object, deleting the object automatically. This class implements + * a reference-counting, intrusive smart pointer design, where all + * objects pointed to must inherit off of ReferencedObject, which + * stores the reference count. Although this is intrusive (native types + * and externally authored classes require wrappers to be referenced + * by smart pointers), it is a safer design. A more detailed discussion of + * these issues follows after the usage information. + * + * Usage Example: + * Note: to use the SmartPtr, all objects to which you point MUST + * inherit off of ReferencedObject. + * + * \verbatim + * + * In MyClass.hpp... + * + * #include "IpReferenced.hpp" + + * namespace Ipopt { + * + * class MyClass : public ReferencedObject // must derive from ReferencedObject + * { + * ... + * } + * } // namespace Ipopt + * + * + * In my_usage.cpp... + * + * #include "IpSmartPtr.hpp" + * #include "MyClass.hpp" + * + * void func(AnyObject& obj) + * { + * SmartPtr<MyClass> ptr_to_myclass = new MyClass(...); + * // ptr_to_myclass now points to a new MyClass, + * // and the reference count is 1 + * + * ... + * + * obj.SetMyClass(ptr_to_myclass); + * // Here, let's assume that AnyObject uses a + * // SmartPtr<MyClass> internally here. + * // Now, both ptr_to_myclass and the internal + * // SmartPtr in obj point to the same MyClass object + * // and its reference count is 2. + * + * ... + * + * // No need to delete ptr_to_myclass, this + * // will be done automatically when the + * // reference count drops to zero. + * + * } + * + * \endverbatim + * + * It is not necessary to use SmartPtr's in all cases where an + * object is used that has been allocated "into" a SmartPtr. It is + * possible to just pass objects by reference or regular pointers, + * even if lower down in the stack a SmartPtr is to be held on to. + * Everything should work fine as long as a pointer created by "new" + * is immediately passed into a SmartPtr, and if SmartPtr's are used + * to hold on to objects. + * + * Other Notes: + * The SmartPtr implements both dereference operators -> & *. + * The SmartPtr does NOT implement a conversion operator to + * the raw pointer. Use the GetRawPtr() method when this + * is necessary. Make sure that the raw pointer is NOT + * deleted. + * The SmartPtr implements the comparison operators == & != + * for a variety of types. Use these instead of + * \verbatim + * if (GetRawPtr(smrt_ptr) == ptr) // Don't use this + * \endverbatim + * SmartPtr's, as currently implemented, do NOT handle circular references. + * For example: consider a higher level object using SmartPtrs to point to + * A and B, but A and B also point to each other (i.e. A has a SmartPtr + * to B and B has a SmartPtr to A). In this scenario, when the higher + * level object is finished with A and B, their reference counts will + * never drop to zero (since they reference each other) and they + * will not be deleted. This can be detected by memory leak tools like + * valgrind. If the circular reference is necessary, the problem can be + * overcome by a number of techniques: + * + * 1) A and B can have a method that "releases" each other, that is + * they set their internal SmartPtrs to NULL. + * \verbatim + * void AClass::ReleaseCircularReferences() + * { + * smart_ptr_to_B = NULL; + * } + * \endverbatim + * Then, the higher level class can call these methods before + * it is done using A & B. + * + * 2) Raw pointers can be used in A and B to reference each other. + * Here, an implicit assumption is made that the lifetime is + * controlled by the higher level object and that A and B will + * both exist in a controlled manner. Although this seems + * dangerous, in many situations, this type of referencing + * is very controlled and this is reasonably safe. + * + * 3) This SmartPtr class could be redesigned with the Weak/Strong + * design concept. Here, the SmartPtr is identified as being + * Strong (controls lifetime of the object) or Weak (merely + * referencing the object). The Strong SmartPtr increments + * (and decrements) the reference count in ReferencedObject + * but the Weak SmartPtr does not. In the example above, + * the higher level object would have Strong SmartPtrs to + * A and B, but A and B would have Weak SmartPtrs to each + * other. Then, when the higher level object was done with + * A and B, they would be deleted. The Weak SmartPtrs in A + * and B would not decrement the reference count and would, + * of course, not delete the object. This idea is very similar + * to item (2), where it is implied that the sequence of events + * is controlled such that A and B will not call anything using + * their pointers following the higher level delete (i.e. in + * their destructors!). This is somehow safer, however, because + * code can be written (however expensive) to perform run-time + * detection of this situation. For example, the ReferencedObject + * could store pointers to all Weak SmartPtrs that are referencing + * it and, in its destructor, tell these pointers that it is + * dying. They could then set themselves to NULL, or set an + * internal flag to detect usage past this point. + * + * Comments on Non-Intrusive Design: + * In a non-intrusive design, the reference count is stored somewhere other + * than the object being referenced. This means, unless the reference + * counting pointer is the first referencer, it must get a pointer to the + * referenced object from another smart pointer (so it has access to the + * reference count location). In this non-intrusive design, if we are + * pointing to an object with a smart pointer (or a number of smart + * pointers), and we then give another smart pointer the address through + * a RAW pointer, we will have two independent, AND INCORRECT, reference + * counts. To avoid this pitfall, we use an intrusive reference counting + * technique where the reference count is stored in the object being + * referenced. + */ + template<class T> + class SmartPtr : public Referencer + { + public: +#define dbg_smartptr_verbosity 0 + + /**@name Constructors/Destructors */ + //@{ + /** Default constructor, initialized to NULL */ + SmartPtr(); + + /** Copy constructor, initialized from copy */ + SmartPtr(const SmartPtr<T>& copy); + + /** Constructor, initialized from T* ptr */ + SmartPtr(T* ptr); + + /** Destructor, automatically decrements the + * reference count, deletes the object if + * necessary.*/ + ~SmartPtr(); + //@} + + /**@name Overloaded operators. */ + //@{ + /** Overloaded arrow operator, allows the user to call + * methods using the contained pointer. */ + T* operator->() const; + + /** Overloaded dereference operator, allows the user + * to dereference the contained pointer. */ + T& operator*() const; + + /** Overloaded equals operator, allows the user to + * set the value of the SmartPtr from a raw pointer */ + SmartPtr<T>& operator=(T* rhs); + + /** Overloaded equals operator, allows the user to + * set the value of the SmartPtr from another + * SmartPtr */ + SmartPtr<T>& operator=(const SmartPtr<T>& rhs); + + /** Overloaded equality comparison operator, allows the + * user to compare the value of two SmartPtrs */ + template <class U1, class U2> + friend + bool operator==(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs); + + /** Overloaded equality comparison operator, allows the + * user to compare the value of a SmartPtr with a raw pointer. */ + template <class U1, class U2> + friend + bool operator==(const SmartPtr<U1>& lhs, U2* raw_rhs); + + /** Overloaded equality comparison operator, allows the + * user to compare the value of a raw pointer with a SmartPtr. */ + template <class U1, class U2> + friend + bool operator==(U1* lhs, const SmartPtr<U2>& raw_rhs); + + /** Overloaded in-equality comparison operator, allows the + * user to compare the value of two SmartPtrs */ + template <class U1, class U2> + friend + bool operator!=(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs); + + /** Overloaded in-equality comparison operator, allows the + * user to compare the value of a SmartPtr with a raw pointer. */ + template <class U1, class U2> + friend + bool operator!=(const SmartPtr<U1>& lhs, U2* raw_rhs); + + /** Overloaded in-equality comparison operator, allows the + * user to compare the value of a SmartPtr with a raw pointer. */ + template <class U1, class U2> + friend + bool operator!=(U1* lhs, const SmartPtr<U2>& raw_rhs); + //@} + + /**@name friend method declarations. */ + //@{ + /** Returns the raw pointer contained. + * Use to get the value of + * the raw ptr (i.e. to pass to other + * methods/functions, etc.) + * Note: This method does NOT copy, + * therefore, modifications using this + * value modify the underlying object + * contained by the SmartPtr, + * NEVER delete this returned value. + */ + template <class U> + friend + U* GetRawPtr(const SmartPtr<U>& smart_ptr); + + /** Returns a const pointer */ + template <class U> + friend + SmartPtr<const U> ConstPtr(const SmartPtr<U>& smart_ptr); + + /** Returns true if the SmartPtr is NOT NULL. + * Use this to check if the SmartPtr is not null + * This is preferred to if(GetRawPtr(sp) != NULL) + */ + template <class U> + friend + bool IsValid(const SmartPtr<U>& smart_ptr); + + /** Returns true if the SmartPtr is NULL. + * Use this to check if the SmartPtr IsNull. + * This is preferred to if(GetRawPtr(sp) == NULL) + */ + template <class U> + friend + bool IsNull(const SmartPtr<U>& smart_ptr); + //@} + + private: + /**@name Private Data/Methods */ + //@{ + /** Actual raw pointer to the object. */ + T* ptr_; + + /** Set the value of the internal raw pointer + * from another raw pointer, releasing the + * previously referenced object if necessary. */ + SmartPtr<T>& SetFromRawPtr_(T* rhs); + + /** Set the value of the internal raw pointer + * from a SmartPtr, releasing the previously referenced + * object if necessary. */ + SmartPtr<T>& SetFromSmartPtr_(const SmartPtr<T>& rhs); + + /** Release the currently referenced object. */ + void ReleasePointer_(); + //@} + }; + + /**@name SmartPtr friend function declarations.*/ + //@{ + template <class U> + U* GetRawPtr(const SmartPtr<U>& smart_ptr); + + template <class U> + SmartPtr<const U> ConstPtr(const SmartPtr<U>& smart_ptr); + + template <class U> + bool IsNull(const SmartPtr<U>& smart_ptr); + + template <class U> + bool IsValid(const SmartPtr<U>& smart_ptr); + + template <class U1, class U2> + bool operator==(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs); + + template <class U1, class U2> + bool operator==(const SmartPtr<U1>& lhs, U2* raw_rhs); + + template <class U1, class U2> + bool operator==(U1* lhs, const SmartPtr<U2>& raw_rhs); + + template <class U1, class U2> + bool operator!=(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs); + + template <class U1, class U2> + bool operator!=(const SmartPtr<U1>& lhs, U2* raw_rhs); + + template <class U1, class U2> + bool operator!=(U1* lhs, const SmartPtr<U2>& raw_rhs); + + //@} + + + template <class T> + SmartPtr<T>::SmartPtr() + : + ptr_(NULL) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_METH("SmartPtr<T>::SmartPtr()", dbg_smartptr_verbosity); +#endif + +#ifdef CHECK_SMARTPTR + + const ReferencedObject* trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ + = ptr_; + trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ = NULL; +#endif + + } + + + template <class T> + SmartPtr<T>::SmartPtr(const SmartPtr<T>& copy) + : + ptr_(NULL) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_METH("SmartPtr<T>::SmartPtr(const SmartPtr<T>& copy)", dbg_smartptr_verbosity); +#endif + +#ifdef CHECK_SMARTPTR + + const ReferencedObject* trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ + = ptr_; + trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ = NULL; +#endif + + (void) SetFromSmartPtr_(copy); + } + + + template <class T> + SmartPtr<T>::SmartPtr(T* ptr) + : + ptr_(NULL) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_METH("SmartPtr<T>::SmartPtr(T* ptr)", dbg_smartptr_verbosity); +#endif + +#ifdef CHECK_SMARTPTR + + const ReferencedObject* trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ + = ptr_; + trying_to_use_SmartPtr_with_an_object_that_does_not_inherit_from_ReferencedObject_ = NULL; +#endif + + (void) SetFromRawPtr_(ptr); + } + + template <class T> + SmartPtr<T>::~SmartPtr() + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_METH("SmartPtr<T>::~SmartPtr(T* ptr)", dbg_smartptr_verbosity); +#endif + + ReleasePointer_(); + } + + + template <class T> + T* SmartPtr<T>::operator->() const + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_METH("T* SmartPtr<T>::operator->()", dbg_smartptr_verbosity); +#endif + + // cannot deref a null pointer +#if COIN_IPOPT_CHECKLEVEL > 0 + + assert(ptr_); +#endif + + return ptr_; + } + + + template <class T> + T& SmartPtr<T>::operator*() const + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_METH("T& SmartPtr<T>::operator*()", dbg_smartptr_verbosity); +#endif + + // cannot dereference a null pointer +#if COIN_IPOPT_CHECKLEVEL > 0 + + assert(ptr_); +#endif + + return *ptr_; + } + + + template <class T> + SmartPtr<T>& SmartPtr<T>::operator=(T* rhs) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_METH("SmartPtr<T>& SmartPtr<T>::operator=(T* rhs)", dbg_smartptr_verbosity); +#endif + + return SetFromRawPtr_(rhs); + } + + + template <class T> + SmartPtr<T>& SmartPtr<T>::operator=(const SmartPtr<T>& rhs) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_METH( + "SmartPtr<T>& SmartPtr<T>::operator=(const SmartPtr<T>& rhs)", + dbg_smartptr_verbosity); +#endif + + return SetFromSmartPtr_(rhs); + } + + + template <class T> + SmartPtr<T>& SmartPtr<T>::SetFromRawPtr_(T* rhs) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_METH( + "SmartPtr<T>& SmartPtr<T>::SetFromRawPtr_(T* rhs)", dbg_smartptr_verbosity); +#endif + + // Release any old pointer + ReleasePointer_(); + + if (rhs != NULL) { + rhs->AddRef(this); + ptr_ = rhs; + } + + return *this; + } + + template <class T> + SmartPtr<T>& SmartPtr<T>::SetFromSmartPtr_(const SmartPtr<T>& rhs) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_METH( + "SmartPtr<T>& SmartPtr<T>::SetFromSmartPtr_(const SmartPtr<T>& rhs)", + dbg_smartptr_verbosity); +#endif + + T* ptr = GetRawPtr(rhs); + /* AW: I changed this so that NULL is correctly copied from the + right hand side */ + // if (ptr != NULL) { + // SetFromRawPtr_(ptr); + // } + SetFromRawPtr_(ptr); + + return (*this); + } + + + template <class T> + void SmartPtr<T>::ReleasePointer_() + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_METH( + "void SmartPtr<T>::ReleasePointer()", + dbg_smartptr_verbosity); +#endif + + if (ptr_) { + ptr_->ReleaseRef(this); + if (ptr_->ReferenceCount() == 0) { + delete ptr_; + } + ptr_ = NULL; + } + } + + + template <class U> + U* GetRawPtr(const SmartPtr<U>& smart_ptr) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_FUN( + "T* GetRawPtr(const SmartPtr<T>& smart_ptr)", + 0); +#endif + + return smart_ptr.ptr_; + } + + template <class U> + SmartPtr<const U> ConstPtr(const SmartPtr<U>& smart_ptr) + { + // compiler should implicitly cast + return GetRawPtr(smart_ptr); + } + + template <class U> + bool IsValid(const SmartPtr<U>& smart_ptr) + { + return !IsNull(smart_ptr); + } + + template <class U> + bool IsNull(const SmartPtr<U>& smart_ptr) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_FUN( + "bool IsNull(const SmartPtr<T>& smart_ptr)", + 0); +#endif + + return (smart_ptr.ptr_ == NULL); + } + + + template <class U1, class U2> + bool ComparePointers(const U1* lhs, const U2* rhs) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_FUN( + "bool ComparePtrs(const U1* lhs, const U2* rhs)", + dbg_smartptr_verbosity); +#endif + + if (lhs == rhs) { + return true; + } + + // Even if lhs and rhs point to the same object + // with different interfaces U1 and U2, we cannot guarantee that + // the value of the pointers will be equivalent. We can + // guarantee this if we convert to void* + const void* v_lhs = static_cast<const void*>(lhs); + const void* v_rhs = static_cast<const void*>(rhs); + if (v_lhs == v_rhs) { + return true; + } + + // They must not be the same + return false; + } + + template <class U1, class U2> + bool operator==(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_FUN( + "bool operator==(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs)", + dbg_smartptr_verbosity); +#endif + + U1* raw_lhs = GetRawPtr(lhs); + U2* raw_rhs = GetRawPtr(rhs); + return ComparePointers(raw_lhs, raw_rhs); + } + + template <class U1, class U2> + bool operator==(const SmartPtr<U1>& lhs, U2* raw_rhs) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_FUN( + "bool operator==(SmartPtr<U1>& lhs, U2* rhs)", + dbg_smartptr_verbosity); +#endif + + U1* raw_lhs = GetRawPtr(lhs); + return ComparePointers(raw_lhs, raw_rhs); + } + + template <class U1, class U2> + bool operator==(U1* raw_lhs, const SmartPtr<U2>& rhs) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_FUN( + "bool operator==(U1* raw_lhs, SmartPtr<U2>& rhs)", + dbg_smartptr_verbosity); +#endif + + const U2* raw_rhs = GetRawPtr(rhs); + return ComparePointers(raw_lhs, raw_rhs); + } + + template <class U1, class U2> + bool operator!=(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_FUN( + "bool operator!=(const SmartPtr<U1>& lhs, const SmartPtr<U2>& rhs)", + dbg_smartptr_verbosity); +#endif + + bool retValue = operator==(lhs, rhs); + return !retValue; + } + + template <class U1, class U2> + bool operator!=(const SmartPtr<U1>& lhs, U2* raw_rhs) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_FUN( + "bool operator!=(SmartPtr<U1>& lhs, U2* rhs)", + dbg_smartptr_verbosity); +#endif + + bool retValue = operator==(lhs, raw_rhs); + return !retValue; + } + + template <class U1, class U2> + bool operator!=(U1* raw_lhs, const SmartPtr<U2>& rhs) + { +#ifdef IP_DEBUG_SMARTPTR + DBG_START_FUN( + "bool operator!=(U1* raw_lhs, SmartPtr<U2>& rhs)", + dbg_smartptr_verbosity); +#endif + + bool retValue = operator==(raw_lhs, rhs); + return !retValue; + } + +} // namespace Ipopt + +#endif + diff --git a/thirdparty/windows/include/coin/IpSolveStatistics.hpp b/thirdparty/windows/include/coin/IpSolveStatistics.hpp new file mode 100644 index 0000000..e248939 --- /dev/null +++ b/thirdparty/windows/include/coin/IpSolveStatistics.hpp @@ -0,0 +1,136 @@ +// Copyright (C) 2005, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpSolveStatistics.hpp 1587 2009-10-27 16:09:21Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2005-08-15 + +#ifndef __IPSOLVESTATISTICS_HPP__ +#define __IPSOLVESTATISTICS_HPP__ + +#include "IpReferenced.hpp" +#include "IpSmartPtr.hpp" + +namespace Ipopt +{ + // forward declaration (to avoid inclusion of too many header files) + class IpoptNLP; + class IpoptData; + class IpoptCalculatedQuantities; + + /** This class collects statistics about an optimziation run, such + * as iteration count, final infeasibilities etc. It is meant to + * provide such information to a user of Ipopt during the + * finalize_solution call. + */ + class SolveStatistics : public ReferencedObject + { + public: + /**@name Constructors/Destructors */ + //@{ + /** Default constructor. It takes in those collecting Ipopt + * objects that can provide the statistics information. Those + * statistics are retrieved at the time of the constructor + * call. */ + SolveStatistics(const SmartPtr<IpoptNLP>& ip_nlp, + const SmartPtr<IpoptData>& ip_data, + const SmartPtr<IpoptCalculatedQuantities>& ip_cq); + + /** Default destructor */ + virtual ~SolveStatistics() + {} + //@} + + /** @name Accessor methods for retrieving different kind of solver + * statistics information */ + //@{ + /** Iteration counts. */ + virtual Index IterationCount() const; + /** Total CPU time, including function evaluations. */ + virtual Number TotalCPUTime() const; + /** Number of NLP function evaluations. */ + virtual void NumberOfEvaluations(Index& num_obj_evals, + Index& num_constr_evals, + Index& num_obj_grad_evals, + Index& num_constr_jac_evals, + Index& num_hess_evals) const; + /** Unscaled solution infeasibilities */ + virtual void Infeasibilities(Number& dual_inf, + Number& constr_viol, + Number& complementarity, + Number& kkt_error) const; + /** Scaled solution infeasibilities */ + virtual void ScaledInfeasibilities(Number& scaled_dual_inf, + Number& scaled_constr_viol, + Number& scaled_complementarity, + Number& scaled_kkt_error) const; + /** Final value of objective function */ + virtual Number FinalObjective() const; + /** Final scaled value of objective function */ + virtual Number FinalScaledObjective() const; + //@} + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + SolveStatistics(); + + /** Copy Constructor */ + SolveStatistics(const SolveStatistics&); + + /** Overloaded Equals Operator */ + void operator=(const SolveStatistics&); + //@} + + /** @name Fields for storing the statistics data */ + //@{ + /** Number of iterations. */ + Index num_iters_; + /* Total CPU time */ + Number total_cpu_time_; + /** Number of objective function evaluations. */ + Index num_obj_evals_; + /** Number of constraints evaluations (max of equality and + * inequality) */ + Index num_constr_evals_; + /** Number of objective gradient evaluations. */ + Index num_obj_grad_evals_; + /** Number of constraint Jacobian evaluations. */ + Index num_constr_jac_evals_; + /** Number of Lagrangian Hessian evaluations. */ + Index num_hess_evals_; + + /** Final scaled value of objective function */ + Number scaled_obj_val_; + /** Final unscaled value of objective function */ + Number obj_val_; + /** Final scaled dual infeasibility (max-norm) */ + Number scaled_dual_inf_; + /** Final unscaled dual infeasibility (max-norm) */ + Number dual_inf_; + /** Final scaled constraint violation (max-norm) */ + Number scaled_constr_viol_; + /** Final unscaled constraint violation (max-norm) */ + Number constr_viol_; + /** Final scaled complementarity error (max-norm) */ + Number scaled_compl_; + /** Final unscaled complementarity error (max-norm) */ + Number compl_; + /** Final overall scaled KKT error (max-norm) */ + Number scaled_kkt_error_; + /** Final overall unscaled KKT error (max-norm) */ + Number kkt_error_; + //@} + }; + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpStdCInterface.h b/thirdparty/windows/include/coin/IpStdCInterface.h new file mode 100644 index 0000000..151a8f5 --- /dev/null +++ b/thirdparty/windows/include/coin/IpStdCInterface.h @@ -0,0 +1,235 @@ +/************************************************************************* + Copyright (C) 2004, 2006 International Business Machines and others. + All Rights Reserved. + This code is published under the Common Public License. + + $Id: IpStdCInterface.h 1586 2009-10-27 15:55:03Z andreasw $ + + Authors: Carl Laird, Andreas Waechter IBM 2004-09-02 + *************************************************************************/ + +#ifndef __IPSTDCINTERFACE_H__ +#define __IPSTDCINTERFACE_H__ + +#ifndef IPOPT_EXPORT +#ifdef _MSC_VER +#ifdef IPOPT_DLL +#define IPOPT_EXPORT(type) __declspec(dllexport) type __cdecl +#else +#define IPOPT_EXPORT(type) type __cdecl +#endif +#else +#define IPOPT_EXPORT(type) type +#endif +#endif + +#ifdef __cplusplus +extern "C" +{ +#endif + + /** Type for all number. We need to make sure that this is + identical with what is defined in Common/IpTypes.hpp */ + typedef double Number; + + /** Type for all incides. We need to make sure that this is + identical with what is defined in Common/IpTypes.hpp */ + typedef int Index; + + /** Type for all integers. We need to make sure that this is + identical with what is defined in Common/IpTypes.hpp */ + typedef int Int; + + /* This includes the SolverReturn enum type */ +#include "IpReturnCodes.h" + + /** Structure collecting all information about the problem + * definition and solve statistics etc. This is defined in the + * source file. */ + struct IpoptProblemInfo; + + /** Pointer to a Ipopt Problem. */ + typedef struct IpoptProblemInfo* IpoptProblem; + + /** define a boolean type for C */ + typedef int Bool; +#ifndef TRUE +# define TRUE (1) +#endif +#ifndef FALSE +# define FALSE (0) +#endif + + /** A pointer for anything that is to be passed between the called + * and individual callback function */ + typedef void * UserDataPtr; + + /** Type defining the callback function for evaluating the value of + * the objective function. Return value should be set to false if + * there was a problem doing the evaluation. */ + typedef Bool (*Eval_F_CB)(Index n, Number* x, Bool new_x, + Number* obj_value, UserDataPtr user_data); + + /** Type defining the callback function for evaluating the gradient of + * the objective function. Return value should be set to false if + * there was a problem doing the evaluation. */ + typedef Bool (*Eval_Grad_F_CB)(Index n, Number* x, Bool new_x, + Number* grad_f, UserDataPtr user_data); + + /** Type defining the callback function for evaluating the value of + * the constraint functions. Return value should be set to false if + * there was a problem doing the evaluation. */ + typedef Bool (*Eval_G_CB)(Index n, Number* x, Bool new_x, + Index m, Number* g, UserDataPtr user_data); + + /** Type defining the callback function for evaluating the Jacobian of + * the constrant functions. Return value should be set to false if + * there was a problem doing the evaluation. */ + typedef Bool (*Eval_Jac_G_CB)(Index n, Number *x, Bool new_x, + Index m, Index nele_jac, + Index *iRow, Index *jCol, Number *values, + UserDataPtr user_data); + + /** Type defining the callback function for evaluating the Hessian of + * the Lagrangian function. Return value should be set to false if + * there was a problem doing the evaluation. */ + typedef Bool (*Eval_H_CB)(Index n, Number *x, Bool new_x, Number obj_factor, + Index m, Number *lambda, Bool new_lambda, + Index nele_hess, Index *iRow, Index *jCol, + Number *values, UserDataPtr user_data); + + /** Function for creating a new Ipopt Problem object. This function + * returns an object that can be passed to the IpoptSolve call. It + * contains the basic definition of the optimization problem, such + * as number of variables and constraints, bounds on variables and + * constraints, information about the derivatives, and the callback + * function for the computation of the optimization problem + * functions and derivatives. During this call, the options file + * PARAMS.DAT is read as well. + * + * If NULL is returned, there was a problem with one of the inputs + * or reading the options file. */ + IPOPT_EXPORT(IpoptProblem) CreateIpoptProblem( + Index n /** Number of optimization variables */ + , Number* x_L /** Lower bounds on variables. This array of + size n is copied internally, so that the + caller can change the incoming data after + return without that IpoptProblem is + modified. Any value less or equal than + the number specified by option + 'nlp_lower_bound_inf' is interpreted to + be minus infinity. */ + , Number* x_U /** Upper bounds on variables. This array of + size n is copied internally, so that the + caller can change the incoming data after + return without that IpoptProblem is + modified. Any value greater or equal + than the number specified by option + 'nlp_upper_bound_inf' is interpreted to + be plus infinity. */ + , Index m /** Number of constraints. */ + , Number* g_L /** Lower bounds on constraints. This array of + size m is copied internally, so that the + caller can change the incoming data after + return without that IpoptProblem is + modified. Any value less or equal than + the number specified by option + 'nlp_lower_bound_inf' is interpreted to + be minus infinity. */ + , Number* g_U /** Upper bounds on constraints. This array of + size m is copied internally, so that the + caller can change the incoming data after + return without that IpoptProblem is + modified. Any value greater or equal + than the number specified by option + 'nlp_upper_bound_inf' is interpreted to + be plus infinity. */ + , Index nele_jac /** Number of non-zero elements in constraint + Jacobian. */ + , Index nele_hess /** Number of non-zero elements in Hessian of + Lagrangian. */ + , Index index_style /** indexing style for iRow & jCol, + 0 for C style, 1 for Fortran style */ + , Eval_F_CB eval_f /** Callback function for evaluating + objective function */ + , Eval_G_CB eval_g /** Callback function for evaluating + constraint functions */ + , Eval_Grad_F_CB eval_grad_f + /** Callback function for evaluating gradient + of objective function */ + , Eval_Jac_G_CB eval_jac_g + /** Callback function for evaluating Jacobian + of constraint functions */ + , Eval_H_CB eval_h /** Callback function for evaluating Hessian + of Lagrangian function */ + ); + + /** Method for freeing a previously created IpoptProblem. After + freeing an IpoptProblem, it cannot be used anymore. */ + IPOPT_EXPORT(void) FreeIpoptProblem(IpoptProblem ipopt_problem); + + + /** Function for adding a string option. Returns FALSE the option + * could not be set (e.g., if keyword is unknown) */ + IPOPT_EXPORT(Bool) AddIpoptStrOption(IpoptProblem ipopt_problem, char* keyword, char* val); + + /** Function for adding a Number option. Returns FALSE the option + * could not be set (e.g., if keyword is unknown) */ + IPOPT_EXPORT(Bool) AddIpoptNumOption(IpoptProblem ipopt_problem, char* keyword, Number val); + + /** Function for adding an Int option. Returns FALSE the option + * could not be set (e.g., if keyword is unknown) */ + IPOPT_EXPORT(Bool) AddIpoptIntOption(IpoptProblem ipopt_problem, char* keyword, Int val); + + /** Function for opening an output file for a given name with given + * printlevel. Returns false, if there was a problem opening the + * file. */ + IPOPT_EXPORT(Bool) OpenIpoptOutputFile(IpoptProblem ipopt_problem, char* file_name, + Int print_level); + + /** Optional function for setting scaling parameter for the NLP. + * This corresponds to the get_scaling_parameters method in TNLP. + * If the pointers x_scaling or g_scaling are NULL, then no scaling + * for x resp. g is done. */ + IPOPT_EXPORT(Bool) SetIpoptProblemScaling(IpoptProblem ipopt_problem, + Number obj_scaling, + Number* x_scaling, + Number* g_scaling); + + /** Function calling the Ipopt optimization algorithm for a problem + previously defined with CreateIpoptProblem. The return + specified outcome of the optimization procedure (e.g., success, + failure etc). + */ + IPOPT_EXPORT(enum ApplicationReturnStatus) IpoptSolve( + IpoptProblem ipopt_problem + /** Problem that is to be optimized. Ipopt + will use the options previously specified with + AddIpoptOption (etc) for this problem. */ + , Number* x /** Input: Starting point + Output: Optimal solution */ + , Number* g /** Values of constraint at final point + (output only - ignored if set to NULL) */ + , Number* obj_val /** Final value of objective function + (output only - ignored if set to NULL) */ + , Number* mult_g /** Final multipliers for constraints + (output only - ignored if set to NULL) */ + , Number* mult_x_L /** Final multipliers for lower variable bounds + (output only - ignored if set to NULL) */ + , Number* mult_x_U /** Final multipliers for upper variable bounds + (output only - ignored if set to NULL) */ + , UserDataPtr user_data + /** Pointer to user data. This will be + passed unmodified to the callback + functions. */ + ); + + /** + void IpoptStatisticsCounts; + + void IpoptStatisticsInfeasibilities; */ +#ifdef __cplusplus +} /* extern "C" { */ +#endif + +#endif diff --git a/thirdparty/windows/include/coin/IpSymMatrix.hpp b/thirdparty/windows/include/coin/IpSymMatrix.hpp new file mode 100644 index 0000000..736541e --- /dev/null +++ b/thirdparty/windows/include/coin/IpSymMatrix.hpp @@ -0,0 +1,159 @@ +// Copyright (C) 2004, 2008 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpSymMatrix.hpp 1280 2008-08-10 21:19:31Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPSYMMATRIX_HPP__ +#define __IPSYMMATRIX_HPP__ + +#include "IpUtils.hpp" +#include "IpMatrix.hpp" + +namespace Ipopt +{ + + /* forward declarations */ + class SymMatrixSpace; + + /** This is the base class for all derived symmetric matrix types. + */ + class SymMatrix : public Matrix + { + public: + /** @name Constructor/Destructor */ + //@{ + /** Constructor, taking the owner_space. + */ + SymMatrix(const SymMatrixSpace* owner_space); + + /** Destructor */ + virtual ~SymMatrix() + {} + //@} + + /** @name Information about the size of the matrix */ + //@{ + /** Dimension of the matrix (number of rows and columns) */ + Index Dim() const; + //@} + + SmartPtr<const SymMatrixSpace> OwnerSymMatrixSpace() const; + + protected: + /** @name Overloaded methods from Matrix. */ + //@{ + /** Since the matrix is + * symmetric, it is only necessary to implement the + * MultVectorImpl method in a class that inherits from this base + * class. If the TransMultVectorImpl is called, this base class + * automatically calls MultVectorImpl instead. */ + virtual void TransMultVectorImpl(Number alpha, const Vector& x, Number beta, + Vector& y) const + { + // Since this matrix is symetric, this is the same operation as + // MultVector + MultVector(alpha, x, beta, y); + } + /** Since the matrix is symmetric, the row and column max norms + * are identical */ + virtual void ComputeColAMaxImpl(Vector& cols_norms, bool init) const + { + ComputeRowAMaxImpl(cols_norms, init); + } + //@} + + private: + /** Copy of the owner space ptr as a SymMatrixSpace instead + * of a MatrixSpace + */ + const SymMatrixSpace* owner_space_; + }; + + + /** SymMatrixSpace base class, corresponding to the SymMatrix base + * class. */ + class SymMatrixSpace : public MatrixSpace + { + public: + /** @name Constructors/Destructors */ + //@{ + /** Constructor, given the dimension (identical to the number of + * rows and columns). + */ + SymMatrixSpace(Index dim) + : + MatrixSpace(dim,dim) + {} + + /** Destructor */ + virtual ~SymMatrixSpace() + {} + //@} + + /** Pure virtual method for creating a new matrix of this specific + * type. */ + virtual SymMatrix* MakeNewSymMatrix() const=0; + + /** Overloaded MakeNew method for the MatrixSpace base class. + */ + virtual Matrix* MakeNew() const + { + return MakeNewSymMatrix(); + } + + /** Accessor method for the dimension of the matrices in this + * matrix space. + */ + Index Dim() const + { + DBG_ASSERT(NRows() == NCols()); + return NRows(); + } + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** default constructor */ + SymMatrixSpace(); + + /* Copy constructor */ + SymMatrixSpace(const SymMatrixSpace&); + + /** Overloaded Equals Operator */ + SymMatrixSpace& operator=(const SymMatrixSpace&); + //@} + + }; + + /* inline methods */ + inline + SymMatrix::SymMatrix(const SymMatrixSpace* owner_space) + : + Matrix(owner_space), + owner_space_(owner_space) + {} + + inline + Index SymMatrix::Dim() const + { + return owner_space_->Dim(); + } + + inline + SmartPtr<const SymMatrixSpace> SymMatrix::OwnerSymMatrixSpace() const + { + return owner_space_; + } + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpTNLP.hpp b/thirdparty/windows/include/coin/IpTNLP.hpp new file mode 100644 index 0000000..c97ba88 --- /dev/null +++ b/thirdparty/windows/include/coin/IpTNLP.hpp @@ -0,0 +1,279 @@ +// Copyright (C) 2004, 2009 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpTNLP.hpp 1462 2009-06-02 04:17:13Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPTNLP_HPP__ +#define __IPTNLP_HPP__ + +#include "IpUtils.hpp" +#include "IpReferenced.hpp" +#include "IpException.hpp" +#include "IpAlgTypes.hpp" +#include "IpReturnCodes.hpp" + +#include <map> + +namespace Ipopt +{ + // forward declarations + class IpoptData; + class IpoptCalculatedQuantities; + class IteratesVector; + + /** Base class for all NLP's that use standard triplet matrix form + * and dense vectors. This is the standard base class for all + * NLP's that use the standard triplet matrix form (as for Harwell + * routines) and dense vectors. The class TNLPAdapter then converts + * this interface to an interface that can be used directly by + * ipopt. + * + * This interface presents the problem form: + * + * min f(x) + * + * s.t. gL <= g(x) <= gU + * + * xL <= x <= xU + * + * In order to specify an equality constraint, set gL_i = gU_i = + * rhs. The value that indicates "infinity" for the bounds + * (i.e. the variable or constraint has no lower bound (-infinity) + * or upper bound (+infinity)) is set through the option + * nlp_lower_bound_inf and nlp_upper_bound_inf. To indicate that a + * variable has no upper or lower bound, set the bound to + * -ipopt_inf or +ipopt_inf respectively + */ + class TNLP : public ReferencedObject + { + public: + /** Type of the constraints*/ + enum LinearityType + { + LINEAR/** Constraint/Variable is linear.*/, + NON_LINEAR/**Constraint/Varaible is non-linear.*/ + }; + + /**@name Constructors/Destructors */ + //@{ + TNLP() + {} + + /** Default destructor */ + virtual ~TNLP() + {} + //@} + + DECLARE_STD_EXCEPTION(INVALID_TNLP); + + /**@name methods to gather information about the NLP */ + //@{ + /** overload this method to return the number of variables + * and constraints, and the number of non-zeros in the jacobian and + * the hessian. The index_style parameter lets you specify C or Fortran + * style indexing for the sparse matrix iRow and jCol parameters. + * C_STYLE is 0-based, and FORTRAN_STYLE is 1-based. + */ + enum IndexStyleEnum { C_STYLE=0, FORTRAN_STYLE=1 }; + virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, + Index& nnz_h_lag, IndexStyleEnum& index_style)=0; + + typedef std::map<std::string, std::vector<std::string> > StringMetaDataMapType; + typedef std::map<std::string, std::vector<Index> > IntegerMetaDataMapType; + typedef std::map<std::string, std::vector<Number> > NumericMetaDataMapType; + + /** overload this method to return any meta data for + * the variables and the constraints */ + virtual bool get_var_con_metadata(Index n, + StringMetaDataMapType& var_string_md, + IntegerMetaDataMapType& var_integer_md, + NumericMetaDataMapType& var_numeric_md, + Index m, + StringMetaDataMapType& con_string_md, + IntegerMetaDataMapType& con_integer_md, + NumericMetaDataMapType& con_numeric_md) + + { + return false; + } + + /** overload this method to return the information about the bound + * on the variables and constraints. The value that indicates + * that a bound does not exist is specified in the parameters + * nlp_lower_bound_inf and nlp_upper_bound_inf. By default, + * nlp_lower_bound_inf is -1e19 and nlp_upper_bound_inf is + * 1e19. (see TNLPAdapter) */ + virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u, + Index m, Number* g_l, Number* g_u)=0; + + /** overload this method to return scaling parameters. This is + * only called if the options are set to retrieve user scaling. + * There, use_x_scaling (or use_g_scaling) should get set to true + * only if the variables (or constraints) are to be scaled. This + * method should return true only if the scaling parameters could + * be provided. + */ + virtual bool get_scaling_parameters(Number& obj_scaling, + bool& use_x_scaling, Index n, + Number* x_scaling, + bool& use_g_scaling, Index m, + Number* g_scaling) + { + return false; + } + + /** overload this method to return the variables linearity + * (TNLP::Linear or TNLP::NonLinear). The var_types + * array should be allocated with length at least n. (default implementation + * just return false and does not fill the array).*/ + virtual bool get_variables_linearity(Index n, LinearityType* var_types) + { + return false; + } + + /** overload this method to return the constraint linearity. + * array should be alocated with length at least n. (default implementation + * just return false and does not fill the array).*/ + virtual bool get_constraints_linearity(Index m, LinearityType* const_types) + { + return false; + } + + /** overload this method to return the starting point. The bool + * variables indicate whether the algorithm wants you to + * initialize x, z_L/z_u, and lambda, respectively. If, for some + * reason, the algorithm wants you to initialize these and you + * cannot, return false, which will cause Ipopt to stop. You + * will have to run Ipopt with different options then. + */ + virtual bool get_starting_point(Index n, bool init_x, Number* x, + bool init_z, Number* z_L, Number* z_U, + Index m, bool init_lambda, + Number* lambda)=0; + + /** overload this method to provide an Ipopt iterate (already in + * the form Ipopt requires it internally) for a warm start. + * Since this is only for expert users, a default dummy + * implementation is provided and returns false. */ + virtual bool get_warm_start_iterate(IteratesVector& warm_start_iterate) + { + return false; + } + + /** overload this method to return the value of the objective function */ + virtual bool eval_f(Index n, const Number* x, bool new_x, + Number& obj_value)=0; + + /** overload this method to return the vector of the gradient of + * the objective w.r.t. x */ + virtual bool eval_grad_f(Index n, const Number* x, bool new_x, + Number* grad_f)=0; + + /** overload this method to return the vector of constraint values */ + virtual bool eval_g(Index n, const Number* x, bool new_x, + Index m, Number* g)=0; + /** overload this method to return the jacobian of the + * constraints. The vectors iRow and jCol only need to be set + * once. The first call is used to set the structure only (iRow + * and jCol will be non-NULL, and values will be NULL) For + * subsequent calls, iRow and jCol will be NULL. */ + virtual bool eval_jac_g(Index n, const Number* x, bool new_x, + Index m, Index nele_jac, Index* iRow, + Index *jCol, Number* values)=0; + + /** overload this method to return the hessian of the + * lagrangian. The vectors iRow and jCol only need to be set once + * (during the first call). The first call is used to set the + * structure only (iRow and jCol will be non-NULL, and values + * will be NULL) For subsequent calls, iRow and jCol will be + * NULL. This matrix is symmetric - specify the lower diagonal + * only. A default implementation is provided, in case the user + * wants to se quasi-Newton approximations to estimate the second + * derivatives and doesn't not neet to implement this method. */ + virtual bool eval_h(Index n, const Number* x, bool new_x, + Number obj_factor, Index m, const Number* lambda, + bool new_lambda, Index nele_hess, + Index* iRow, Index* jCol, Number* values) + { + return false; + } + //@} + + /** @name Solution Methods */ + //@{ + /** This method is called when the algorithm is complete so the TNLP can store/write the solution */ + virtual void finalize_solution(SolverReturn status, + Index n, const Number* x, const Number* z_L, const Number* z_U, + Index m, const Number* g, const Number* lambda, + Number obj_value, + const IpoptData* ip_data, + IpoptCalculatedQuantities* ip_cq)=0; + + /** Intermediate Callback method for the user. Providing dummy + * default implementation. For details see IntermediateCallBack + * in IpNLP.hpp. */ + virtual bool intermediate_callback(AlgorithmMode mode, + Index iter, Number obj_value, + Number inf_pr, Number inf_du, + Number mu, Number d_norm, + Number regularization_size, + Number alpha_du, Number alpha_pr, + Index ls_trials, + const IpoptData* ip_data, + IpoptCalculatedQuantities* ip_cq) + { + return true; + } + //@} + + /** @name Methods for quasi-Newton approximation. If the second + * derivatives are approximated by Ipopt, it is better to do this + * only in the space of nonlinear variables. The following + * methods are call by Ipopt if the quasi-Newton approximation is + * selected. If -1 is returned as number of nonlinear variables, + * Ipopt assumes that all variables are nonlinear. Otherwise, it + * calls get_list_of_nonlinear_variables with an array into which + * the indices of the nonlinear variables should be written - the + * array has the lengths num_nonlin_vars, which is identical with + * the return value of get_number_of_nonlinear_variables(). It + * is assumed that the indices are counted starting with 1 in the + * FORTRAN_STYLE, and 0 for the C_STYLE. */ + //@{ + virtual Index get_number_of_nonlinear_variables() + { + return -1; + } + + virtual bool get_list_of_nonlinear_variables(Index num_nonlin_vars, + Index* pos_nonlin_vars) + { + return false; + } + //@} + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + //TNLP(); + + /** Copy Constructor */ + TNLP(const TNLP&); + + /** Overloaded Equals Operator */ + void operator=(const TNLP&); + //@} + }; + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpTNLPReducer.hpp b/thirdparty/windows/include/coin/IpTNLPReducer.hpp new file mode 100644 index 0000000..2e880f4 --- /dev/null +++ b/thirdparty/windows/include/coin/IpTNLPReducer.hpp @@ -0,0 +1,180 @@ +// Copyright (C) 2008 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpTNLPReducer.hpp 1324 2008-09-16 14:19:26Z andreasw $ +// +// Authors: Andreas Waechter IBM 2008-08-10 + +#ifndef __IPTNLPREDUCER_HPP__ +#define __IPTNLPREDUCER_HPP__ + +#include "IpTNLP.hpp" + +namespace Ipopt +{ + /** This is a wrapper around a given TNLP class that takes out a + * list of constraints that are given to the constructor. It is + * provided for convenience, if one wants to experiment with + * problems that consist of only a subset of the constraints. But + * keep in mind that this is not efficient, since behind the scenes + * we are still evaluation all functions and derivatives, and are + * making copies of the original data. */ + class TNLPReducer : public TNLP + { + public: + /**@name Constructors/Destructors */ + //@{ + /** Constructor is given the indices of the constraints that + * should be taken out of the problem statement, as well as the + * original TNLP. */ + TNLPReducer(TNLP& tnlp, Index n_g_skip, const Index* index_g_skip, + Index n_xL_skip, const Index* index_xL_skip, + Index n_xU_skip, const Index* index_xU_skip, + Index n_x_fix, const Index* index_f_fix); + + /** Default destructor */ + virtual ~TNLPReducer(); + //@} + + /** @name Overloaded methods from TNLP */ + virtual bool get_nlp_info(Index& n, Index& m, Index& nnz_jac_g, + Index& nnz_h_lag, IndexStyleEnum& index_style); + + virtual bool get_bounds_info(Index n, Number* x_l, Number* x_u, + Index m, Number* g_l, Number* g_u); + + virtual bool get_scaling_parameters(Number& obj_scaling, + bool& use_x_scaling, Index n, + Number* x_scaling, + bool& use_g_scaling, Index m, + Number* g_scaling); + + virtual bool get_variables_linearity(Index n, LinearityType* var_types); + + virtual bool get_constraints_linearity(Index m, LinearityType* const_types); + + virtual bool get_starting_point(Index n, bool init_x, Number* x, + bool init_z, Number* z_L, Number* z_U, + Index m, bool init_lambda, + Number* lambda); + + virtual bool get_warm_start_iterate(IteratesVector& warm_start_iterate); + + virtual bool eval_f(Index n, const Number* x, bool new_x, + Number& obj_value); + + virtual bool eval_grad_f(Index n, const Number* x, bool new_x, + Number* grad_f); + + virtual bool eval_g(Index n, const Number* x, bool new_x, + Index m, Number* g); + + virtual bool eval_jac_g(Index n, const Number* x, bool new_x, + Index m, Index nele_jac, Index* iRow, + Index *jCol, Number* values); + + virtual bool eval_h(Index n, const Number* x, bool new_x, + Number obj_factor, Index m, const Number* lambda, + bool new_lambda, Index nele_hess, + Index* iRow, Index* jCol, Number* values); + + virtual void finalize_solution(SolverReturn status, + Index n, const Number* x, const Number* z_L, const Number* z_U, + Index m, const Number* g, const Number* lambda, + Number obj_value, + const IpoptData* ip_data, + IpoptCalculatedQuantities* ip_cq); + + virtual bool intermediate_callback(AlgorithmMode mode, + Index iter, Number obj_value, + Number inf_pr, Number inf_du, + Number mu, Number d_norm, + Number regularization_size, + Number alpha_du, Number alpha_pr, + Index ls_trials, + const IpoptData* ip_data, + IpoptCalculatedQuantities* ip_cq); + + virtual Index get_number_of_nonlinear_variables(); + + virtual bool get_list_of_nonlinear_variables(Index num_nonlin_vars, + Index* pos_nonlin_vars); + //@} + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default Constructor */ + TNLPReducer(); + + /** Copy Constructor */ + TNLPReducer(const TNLPReducer&); + + /** Overloaded Equals Operator */ + void operator=(const TNLPReducer&); + //@} + + /** @name original TNLP */ + //@{ + SmartPtr<TNLP> tnlp_; + Index m_orig_; + Index nnz_jac_g_orig_; + //@} + + /** Number of constraints to be skipped */ + Index n_g_skip_; + + /** Array of indices of the constraints that are to be skipped. + * This is provided at the beginning in the constructor. */ + Index* index_g_skip_; + + /** Index style for original problem. Internally, we use C-Style + * now. */ + IndexStyleEnum index_style_orig_; + + /** Map from original constraints to new constraints. A -1 means + * that a constraint is skipped. */ + Index* g_keep_map_; + + /** Number of constraints in reduced NLP */ + Index m_reduced_; + + /** Number of Jacobian nonzeros in the reduced NLP */ + Index nnz_jac_g_reduced_; + + /** Number of Jacobian nonzeros that are skipped */ + Index nnz_jac_g_skipped_; + + /** Array of Jacobian elements that are to be skipped. This is in + * increasing order. */ + Index* jac_g_skipped_; + + /** Number of lower variable bounds to be skipped. */ + Index n_xL_skip_; + + /** Array of indices of the lower variable bounds to be skipped. */ + Index* index_xL_skip_; + + /** Number of upper variable bounds to be skipped. */ + Index n_xU_skip_; + + /** Array of indices of the upper variable bounds to be skipped. */ + Index* index_xU_skip_; + + /** Number of variables that are to be fixed to initial value. */ + Index n_x_fix_; + + /** Array of indices of the variables that are to be fixed. */ + Index* index_x_fix_; + }; + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpTaggedObject.hpp b/thirdparty/windows/include/coin/IpTaggedObject.hpp new file mode 100644 index 0000000..b49ef04 --- /dev/null +++ b/thirdparty/windows/include/coin/IpTaggedObject.hpp @@ -0,0 +1,149 @@ +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpTaggedObject.hpp 1019 2007-06-24 03:52:34Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPTAGGEDOBJECT_HPP__ +#define __IPTAGGEDOBJECT_HPP__ + +#include "IpUtils.hpp" +#include "IpDebug.hpp" +#include "IpReferenced.hpp" +#include "IpObserver.hpp" +#include <limits> + +namespace Ipopt +{ + + /** TaggedObject class. + * Often, certain calculations or operations are expensive, + * and it can be very inefficient to perform these calculations + * again if the input to the calculation has not changed + * since the result was last stored. + * This base class provides an efficient mechanism to update + * a tag, indicating that the object has changed. + * Users of a TaggedObject class, need their own Tag data + * member to keep track of the state of the TaggedObject, the + * last time they performed a calculation. A basic use case for + * users of a class inheriting off of TaggedObject follows like + * this: + * + * Initialize your own Tag to zero in constructor. + * + * + * + * Before an expensive calculation, + * check if the TaggedObject has changed, passing in + * your own Tag, indicating the last time you used + * the object for the calculation. If it has changed, + * perform the calculation again, and store the result. + * If it has not changed, simply return the stored result. + * + * Here is a simple example: + \verbatim + if (vector.HasChanged(my_vector_tag_)) { + my_vector_tag_ = vector.GetTag(); + result = PerformExpensiveCalculation(vector); + return result; + } + else { + return result; + } + \endverbatim + * + * Objects derived from TaggedObject: + * Objects derived from TaggedObject must indicate that they have changed to + * the base class using the protected member function ObjectChanged(). For + * example, a Vector class, inside its own set method, MUST call + * ObjectChanged() to update the internally stored tag for comparison. + */ + class TaggedObject : public ReferencedObject, public Subject + { + public: + /** Type for the Tag values */ + typedef unsigned int Tag; + + /** Constructor. */ + TaggedObject() + : + Subject() + { + ObjectChanged(); + } + + /** Destructor. */ + virtual ~TaggedObject() + {} + + /** Users of TaggedObjects call this to + * update their own internal tags every time + * they perform the expensive operation. + */ + Tag GetTag() const + { + return tag_; + } + + /** Users of TaggedObjects call this to + * check if the object HasChanged since + * they last updated their own internal + * tag. + */ + bool HasChanged(const Tag comparison_tag) const + { + return (comparison_tag == tag_) ? false : true; + } + protected: + /** Objects derived from TaggedObject MUST call this + * method every time their internal state changes to + * update the internal tag for comparison + */ + void ObjectChanged() + { + DBG_START_METH("TaggedObject::ObjectChanged()", 0); + tag_ = unique_tag_; + unique_tag_++; + DBG_ASSERT(unique_tag_ < std::numeric_limits<Tag>::max()); + // The Notify method from the Subject base class notifies all + // registed Observers that this subject has changed. + Notify(Observer::NT_Changed); + } + private: + /**@name Default Compiler Generated Methods (Hidden to avoid + * implicit creation/calling). These methods are not implemented + * and we do not want the compiler to implement them for us, so we + * declare them private and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Copy Constructor */ + TaggedObject(const TaggedObject&); + + /** Overloaded Equals Operator */ + void operator=(const TaggedObject&); + //@} + + /** static data member that is incremented every + * time ANY TaggedObject changes. This allows us + * to obtain a unique Tag when the object changes + */ + static Tag unique_tag_; + + /** The tag indicating the current state of the object. + * We use this to compare against the comparison_tag + * in the HasChanged method. This member is updated + * from the unique_tag_ every time the object changes. + */ + Tag tag_; + + /** The index indicating the cache priority for this + * TaggedObject. If a result that depended on this + * TaggedObject is cached, it will be cached with this + * priority + */ + Index cache_priority_; + }; +} // namespace Ipopt +#endif diff --git a/thirdparty/windows/include/coin/IpTimedTask.hpp b/thirdparty/windows/include/coin/IpTimedTask.hpp new file mode 100644 index 0000000..3533708 --- /dev/null +++ b/thirdparty/windows/include/coin/IpTimedTask.hpp @@ -0,0 +1,114 @@ +// Copyright (C) 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpTimedTask.hpp 1430 2009-04-20 20:58:25Z andreasw $ +// +// Authors: Andreas Waechter IBM 2005-09-19 + +#ifndef __IPTIMEDTASK_HPP__ +#define __IPTIMEDTASK_HPP__ + +#include "IpUtils.hpp" + +namespace Ipopt +{ + /** This class is used to collect timing information for a + * particular task. */ + class TimedTask + { + public: + /**@name Constructors/Destructors */ + //@{ + /** Default constructor. */ + TimedTask() + : + total_time_(0.), + start_called_(false), + end_called_(true) + {} + + /** Default destructor */ + ~TimedTask() + {} + //@} + + /** Method for resetting time to zero. */ + void Reset() + { + total_time_ = 0.; + start_called_ = false; + end_called_ = true; + } + + /** Method that is called before execution of the task. */ + void Start() + { + DBG_ASSERT(end_called_); + DBG_ASSERT(!start_called_); + end_called_ = false; + start_called_ = true; + start_time_ = CpuTime(); + } + + /** Method that is called after execution of the task. */ + void End() + { + DBG_ASSERT(!end_called_); + DBG_ASSERT(start_called_); + end_called_ = true; + start_called_ = false; + total_time_ += CpuTime() - start_time_; + } + + /** Method that is called after execution of the task for which + * timing might have been started. This only updates the timing + * if the timing has indeed been conducted. This is useful to + * stop timing after catching exceptions. */ + void EndIfStarted() + { + if (start_called_) { + end_called_ = true; + start_called_ = false; + total_time_ += CpuTime() - start_time_; + } + DBG_ASSERT(end_called_); + } + + /** Method returning total time spend for task so far. */ + Number TotalTime() const + { + DBG_ASSERT(end_called_); + return total_time_; + } + + private: + /**@name Default Compiler Generated Methods (Hidden to avoid + * implicit creation/calling). These methods are not + * implemented and we do not want the compiler to implement them + * for us, so we declare them private and do not define + * them. This ensures that they will not be implicitly + * created/called. */ + //@{ + /** Copy Constructor */ + TimedTask(const TimedTask&); + + /** Overloaded Equals Operator */ + void operator=(const TimedTask&); + //@} + + /** Time at beginning of task. */ + Number start_time_; + /** Total time for task measured so far. */ + Number total_time_; + + /** @name fields for debugging */ + //@{ + bool start_called_; + bool end_called_; + //@} + + }; +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpTypes.hpp b/thirdparty/windows/include/coin/IpTypes.hpp new file mode 100644 index 0000000..3f8b189 --- /dev/null +++ b/thirdparty/windows/include/coin/IpTypes.hpp @@ -0,0 +1,23 @@ +// Copyright (C) 2004, 2006 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpTypes.hpp 735 2006-06-04 06:10:05Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPTYPES_HPP__ +#define __IPTYPES_HPP__ + +namespace Ipopt +{ + /** Type of all numbers */ + typedef double Number; + /** Type of all indices of vectors, matrices etc */ + typedef int Index; + /** Type of default integer */ + typedef int Int; + +} // namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpUtils.hpp b/thirdparty/windows/include/coin/IpUtils.hpp new file mode 100644 index 0000000..55c8fd4 --- /dev/null +++ b/thirdparty/windows/include/coin/IpUtils.hpp @@ -0,0 +1,125 @@ +// Copyright (C) 2004, 2009 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpUtils.hpp 1521 2009-07-15 22:26:15Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPUTILS_HPP__ +#define __IPUTILS_HPP__ + +// Standard Ip Include Files +#include "IpTypes.hpp" +#include "IpDebug.hpp" + +namespace Ipopt +{ + + inline Index Max(Index a, Index b) + { + return ((a) > (b) ? (a) : (b)); + } + + inline Index Max(Index a, Index b, Index c) + { + Index max = Max(a,b); + max = Max(max, c); + return max; + } + + inline Index Max(Index a, Index b, Index c, Index d) + { + Index max = Max(a, b, c); + max = Max(max, d); + return max; + } + + inline Index Min(Index a, Index b) + { + return ((a) < (b) ? (a) : (b)); + } + + inline Index Min(Index a, Index b, Index c) + { + Index min = Min(a,b); + min = Min(min, c); + return min; + } + + inline Index Min(Index a, Index b, Index c, Index d) + { + Index min = Min(a, b, c); + min = Min(min, d); + return min; + } + + /////////////////////////////////////////// + + inline Number Max(Number a, Number b) + { + return ((a) > (b) ? (a) : (b)); + } + + inline Number Max(Number a, Number b, Number c) + { + Number max = Max(a,b); + max = Max(max, c); + return max; + } + + inline Number Max(Number a, Number b, Number c, Number d) + { + Number max = Max(a, b, c); + max = Max(max, d); + return max; + } + + inline Number Min(Number a, Number b) + { + return ((a) < (b) ? (a) : (b)); + } + + inline Number Min(Number a, Number b, Number c) + { + Number min = Min(a,b); + min = Min(min, c); + return min; + } + + inline Number Min(Number a, Number b, Number c, Number d) + { + Number min = Min(a, b, c); + min = Min(min, d); + return min; + } + + /** Function returning true iff the argument is a valid double number + * (not NaN or Inf). */ + bool IsFiniteNumber(Number val); + + /** Function returning a random number between 0 and 1 */ + Number IpRandom01(); + + /** Function resetting the random number generator */ + void IpResetRandom01(); + + /** method determining CPU executed since start of program */ + Number CpuTime(); + + /** Function for getting a string with the current wallclock time */ + double WallclockTime(); + + /** Method for comparing two numbers within machine precision. The + * return value is true if lhs is less or equal the rhs, relaxing + * this inequality by something a little larger than machine + * precision relative to the absolute value of BasVal. */ + bool Compare_le(Number lhs, Number rhs, Number BasVal); + + /** Method for printing a formatted output to a string with given size. + */ + int Snprintf(char* str, long size, const char* format, ...); + +} //namespace Ipopt + +#endif diff --git a/thirdparty/windows/include/coin/IpVector.hpp b/thirdparty/windows/include/coin/IpVector.hpp new file mode 100644 index 0000000..3b35846 --- /dev/null +++ b/thirdparty/windows/include/coin/IpVector.hpp @@ -0,0 +1,744 @@ +// Copyright (C) 2004, 2008 International Business Machines and others. +// All Rights Reserved. +// This code is published under the Common Public License. +// +// $Id: IpVector.hpp 1316 2008-09-10 18:42:05Z andreasw $ +// +// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13 + +#ifndef __IPVECTOR_HPP__ +#define __IPVECTOR_HPP__ + +#include "IpTypes.hpp" +#include "IpTaggedObject.hpp" +#include "IpCachedResults.hpp" +#include "IpSmartPtr.hpp" +#include "IpJournalist.hpp" +#include "IpException.hpp" + +#include <vector> + +namespace Ipopt +{ + /** Exception that can be used to flag unimplemented linear algebra + * methods */ + DECLARE_STD_EXCEPTION(UNIMPLEMENTED_LINALG_METHOD_CALLED); + + /* forward declarations */ + class VectorSpace; + + /** Vector Base Class. + * This is the base class for all derived vector types. Those vectors + * are meant to store entities like iterates, Lagrangian multipliers, + * constraint values etc. The implementation of a vector type depends + * on the computational environment (e.g. just a double array on a shared + * memory machine, or distributed double arrays for a distributed + * memory machine.) + * + * Deriving from Vector: This class inherits from tagged object to + * implement an advanced caching scheme. Because of this, the + * TaggedObject method ObjectChanged() must be called each time the + * Vector changes. If you overload the XXXX_Impl protected methods, + * this taken care of (along with caching if possible) for you. If + * you have additional methods in your derived class that change the + * underlying data (vector values), you MUST remember to call + * ObjectChanged() AFTER making the change! + */ + class Vector : public TaggedObject + { + public: + /** @name Constructor/Destructor */ + //@{ + /** Constructor. It has to be given a pointer to the + * corresponding VectorSpace. + */ + Vector(const VectorSpace* owner_space); + + /** Destructor */ + virtual ~Vector(); + //@} + + /** Create new Vector of the same type with uninitialized data */ + Vector* MakeNew() const; + + /** Create new Vector of the same type and copy the data over */ + Vector* MakeNewCopy() const; + + /**@name Standard BLAS-1 Operations + * (derived classes do NOT overload these + * methods, instead, overload the + * protected versions of these methods). */ + //@{ + /** Copy the data of the vector x into this vector (DCOPY). */ + void Copy(const Vector& x); + + /** Scales the vector by scalar alpha (DSCAL) */ + void Scal(Number alpha); + + /** Add the multiple alpha of vector x to this vector (DAXPY) */ + void Axpy(Number alpha, const Vector &x); + + /** Computes inner product of vector x with this (DDOT) */ + Number Dot(const Vector &x) const; + + /** Computes the 2-norm of this vector (DNRM2) */ + Number Nrm2() const; + + /** Computes the 1-norm of this vector (DASUM) */ + Number Asum() const; + + /** Computes the max-norm of this vector (based on IDAMAX) */ + Number Amax() const; + //@} + + /** @name Additional (Non-BLAS) Vector Methods + * (derived classes do NOT overload these + * methods, instead, overload the + * protected versions of these methods). */ + //@{ + /** Set each element in the vector to the scalar alpha. */ + void Set(Number alpha); + + /** Element-wise division \f$y_i \gets y_i/x_i\f$*/ + void ElementWiseDivide(const Vector& x); + + /** Element-wise multiplication \f$y_i \gets y_i*x_i\f$ */ + void ElementWiseMultiply(const Vector& x); + + /** Element-wise max against entries in x */ + void ElementWiseMax(const Vector& x); + + /** Element-wise min against entries in x */ + void ElementWiseMin(const Vector& x); + + /** Reciprocates the entries in the vector */ + void ElementWiseReciprocal(); + + /** Absolute values of the entries in the vector */ + void ElementWiseAbs(); + + /** Element-wise square root of the entries in the vector */ + void ElementWiseSqrt(); + + /** Replaces the vector values with their sgn values + ( -1 if x_i < 0, 0 if x_i == 0, and 1 if x_i > 0) + */ + void ElementWiseSgn(); + + /** Add scalar to every vector component */ + void AddScalar(Number scalar); + + /** Returns the maximum value in the vector */ + Number Max() const; + + /** Returns the minimum value in the vector */ + Number Min() const; + + /** Returns the sum of the vector entries */ + Number Sum() const; + + /** Returns the sum of the logs of each vector entry */ + Number SumLogs() const; + //@} + + /** @name Methods for specialized operations. A prototype + * implementation is provided, but for efficient implementation + * those should be specially implemented. + */ + //@{ + /** Add one vector, y = a * v1 + c * y. This is automatically + * reduced to call AddTwoVectors. */ + void AddOneVector(Number a, const Vector& v1, Number c); + + /** Add two vectors, y = a * v1 + b * v2 + c * y. Here, this + * vector is y */ + void AddTwoVectors(Number a, const Vector& v1, + Number b, const Vector& v2, Number c); + /** Fraction to the boundary parameter. Computes \f$\alpha = + * \max\{\bar\alpha\in(0,1] : x + \bar\alpha \Delta \geq (1-\tau)x\}\f$ + */ + Number FracToBound(const Vector& delta, Number tau) const; + /** Add the quotient of two vectors, y = a * z/s + c * y. */ + void AddVectorQuotient(Number a, const Vector& z, const Vector& s, + Number c); + //@} + + /** Method for determining if all stored numbers are valid (i.e., + * no Inf or Nan). */ + bool HasValidNumbers() const; + + /** @name Accessor methods */ + //@{ + /** Dimension of the Vector */ + Index Dim() const; + + /** Return the owner VectorSpace*/ + SmartPtr<const VectorSpace> OwnerSpace() const; + //@} + + /** @name Output methods + * (derived classes do NOT overload these + * methods, instead, overload the + * protected versions of these methods). */ + //@{ + /** Print the entire vector */ + void Print(SmartPtr<const Journalist> jnlst, + EJournalLevel level, + EJournalCategory category, + const std::string& name, + Index indent=0, + const std::string& prefix="") const; + void Print(const Journalist& jnlst, + EJournalLevel level, + EJournalCategory category, + const std::string& name, + Index indent=0, + const std::string& prefix="") const; + //@} + + protected: + /** @name implementation methods (derived classes MUST + * overload these pure virtual protected methods.) + */ + //@{ + /** Copy the data of the vector x into this vector (DCOPY). */ + virtual void CopyImpl(const Vector& x)=0; + + /** Scales the vector by scalar alpha (DSCAL) */ + virtual void ScalImpl(Number alpha)=0; + + /** Add the multiple alpha of vector x to this vector (DAXPY) */ + virtual void AxpyImpl(Number alpha, const Vector &x)=0; + + /** Computes inner product of vector x with this (DDOT) */ + virtual Number DotImpl(const Vector &x) const =0; + + /** Computes the 2-norm of this vector (DNRM2) */ + virtual Number Nrm2Impl() const =0; + + /** Computes the 1-norm of this vector (DASUM) */ + virtual Number AsumImpl() const =0; + + /** Computes the max-norm of this vector (based on IDAMAX) */ + virtual Number AmaxImpl() const =0; + + /** Set each element in the vector to the scalar alpha. */ + virtual void SetImpl(Number alpha)=0; + + /** Element-wise division \f$y_i \gets y_i/x_i\f$*/ + virtual void ElementWiseDivideImpl(const Vector& x)=0; + + /** Element-wise multiplication \f$y_i \gets y_i*x_i\f$ */ + virtual void ElementWiseMultiplyImpl(const Vector& x)=0; + + /** Element-wise max against entries in x */ + virtual void ElementWiseMaxImpl(const Vector& x)=0; + + /** Element-wise min against entries in x */ + virtual void ElementWiseMinImpl(const Vector& x)=0; + + /** Reciprocates the elements of the vector */ + virtual void ElementWiseReciprocalImpl()=0; + + /** Take elementwise absolute values of the elements of the vector */ + virtual void ElementWiseAbsImpl()=0; + + /** Take elementwise square-root of the elements of the vector */ + virtual void ElementWiseSqrtImpl()=0; + + /** Replaces entries with sgn of the entry */ + virtual void ElementWiseSgnImpl()=0; + + /** Add scalar to every component of vector */ + virtual void AddScalarImpl(Number scalar)=0; + + /** Max value in the vector */ + virtual Number MaxImpl() const=0; + + /** Min number in the vector */ + virtual Number MinImpl() const=0; + + /** Sum of entries in the vector */ + virtual Number SumImpl() const=0; + + /** Sum of logs of entries in the vector */ + virtual Number SumLogsImpl() const=0; + + /** Add two vectors (a * v1 + b * v2). Result is stored in this + vector. */ + virtual void AddTwoVectorsImpl(Number a, const Vector& v1, + Number b, const Vector& v2, Number c); + + /** Fraction to boundary parameter. */ + virtual Number FracToBoundImpl(const Vector& delta, Number tau) const; + + /** Add the quotient of two vectors */ + virtual void AddVectorQuotientImpl(Number a, const Vector& z, + const Vector& s, Number c); + + /** Method for determining if all stored numbers are valid (i.e., + * no Inf or Nan). A default implementation using Asum is + * provided. */ + virtual bool HasValidNumbersImpl() const; + + /** Print the entire vector */ + virtual void PrintImpl(const Journalist& jnlst, + EJournalLevel level, + EJournalCategory category, + const std::string& name, + Index indent, + const std::string& prefix) const =0; + //@} + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** Default constructor */ + Vector(); + + /** Copy constructor */ + Vector(const Vector&); + + /** Overloaded Equals Operator */ + Vector& operator=(const Vector&); + //@} + + /** Vector Space */ + const SmartPtr<const VectorSpace> owner_space_; + + /**@name CachedResults data members */ + //@{ + /** Cache for dot products */ + mutable CachedResults<Number> dot_cache_; + + mutable TaggedObject::Tag nrm2_cache_tag_; + mutable Number cached_nrm2_; + + mutable TaggedObject::Tag asum_cache_tag_; + mutable Number cached_asum_; + + mutable TaggedObject::Tag amax_cache_tag_; + mutable Number cached_amax_; + + mutable TaggedObject::Tag max_cache_tag_; + mutable Number cached_max_; + + mutable TaggedObject::Tag min_cache_tag_; + mutable Number cached_min_; + + mutable TaggedObject::Tag sum_cache_tag_; + mutable Number cached_sum_; + + mutable TaggedObject::Tag sumlogs_cache_tag_; + mutable Number cached_sumlogs_; + + mutable TaggedObject::Tag valid_cache_tag_; + mutable bool cached_valid_; + + // AW: I removed this cache since it gets in the way for the + // quality function search + // /** Cache for FracToBound */ + // mutable CachedResults<Number> frac_to_bound_cache_; + //@} + + }; + + /** VectorSpace base class, corresponding to the Vector base class. + * For each Vector implementation, a corresponding VectorSpace has + * to be implemented. A VectorSpace is able to create new Vectors + * of a specific type. The VectorSpace should also store + * information that is common to all Vectors of that type. For + * example, the dimension of a Vector is stored in the VectorSpace + * base class. + */ + class VectorSpace : public ReferencedObject + { + public: + /** @name Constructors/Destructors */ + //@{ + /** Constructor, given the dimension of all vectors generated by + * this VectorSpace. + */ + VectorSpace(Index dim); + + /** Destructor */ + virtual ~VectorSpace() + {} + //@} + + /** Pure virtual method for creating a new Vector of the + * corresponding type. + */ + virtual Vector* MakeNew() const=0; + + /** Accessor function for the dimension of the vectors of this type.*/ + Index Dim() const + { + return dim_; + } + + private: + /**@name Default Compiler Generated Methods + * (Hidden to avoid implicit creation/calling). + * These methods are not implemented and + * we do not want the compiler to implement + * them for us, so we declare them private + * and do not define them. This ensures that + * they will not be implicitly created/called. */ + //@{ + /** default constructor */ + VectorSpace(); + + /** Copy constructor */ + VectorSpace(const VectorSpace&); + + /** Overloaded Equals Operator */ + VectorSpace& operator=(const VectorSpace&); + //@} + + /** Dimension of the vectors in this vector space. */ + const Index dim_; + }; + + /* inline methods */ + inline + Vector::~Vector() + {} + + inline + Vector::Vector(const VectorSpace* owner_space) + : + TaggedObject(), + owner_space_(owner_space), + dot_cache_(10), + nrm2_cache_tag_(0), + asum_cache_tag_(0), + amax_cache_tag_(0), + max_cache_tag_(0), + min_cache_tag_(0), + sum_cache_tag_(0), + sumlogs_cache_tag_(0), + cached_valid_(0) + { + DBG_ASSERT(IsValid(owner_space_)); + } + + inline + Vector* Vector::MakeNew() const + { + return owner_space_->MakeNew(); + } + + inline + Vector* Vector::MakeNewCopy() const + { + // ToDo: We can probably copy also the cached values for Norms etc here + Vector* copy = MakeNew(); + copy->Copy(*this); + return copy; + } + + inline + void Vector::Copy(const Vector& x) + { + CopyImpl(x); + ObjectChanged(); + // Also copy any cached scalar values from the original vector + // ToDo: Check if that is too much overhead + TaggedObject::Tag x_tag = x.GetTag(); + if (x_tag == x.nrm2_cache_tag_) { + nrm2_cache_tag_ = GetTag(); + cached_nrm2_ = x.cached_nrm2_; + } + if (x_tag == x.asum_cache_tag_) { + asum_cache_tag_ = GetTag(); + cached_asum_ = x.cached_asum_; + } + if (x_tag == x.amax_cache_tag_) { + amax_cache_tag_ = GetTag(); + cached_amax_ = x.cached_amax_; + } + if (x_tag == x.max_cache_tag_) { + max_cache_tag_ = GetTag(); + cached_max_ = x.cached_max_; + } + if (x_tag == x.min_cache_tag_) { + min_cache_tag_ = GetTag(); + cached_min_ = x.cached_min_; + } + if (x_tag == x.sum_cache_tag_) { + sum_cache_tag_ = GetTag(); + cached_sum_ = x.cached_sum_; + } + if (x_tag == x.sumlogs_cache_tag_) { + sumlogs_cache_tag_ = GetTag(); + cached_sumlogs_ = x.cached_sumlogs_; + } + } + + inline + void Vector::Axpy(Number alpha, const Vector &x) + { + AxpyImpl(alpha, x); + ObjectChanged(); + } + + inline + Number Vector::Dot(const Vector &x) const + { + // The current implementation of the caching doesn't allow to have + // a dependency of something with itself. Therefore, we use the + // Nrm2 method if the dot product is to be taken with the vector + // itself. Might be more efficient anyway. + if (this==&x) { + Number nrm2 = Nrm2(); + return nrm2*nrm2; + } + Number retValue; + if (!dot_cache_.GetCachedResult2Dep(retValue, this, &x)) { + retValue = DotImpl(x); + dot_cache_.AddCachedResult2Dep(retValue, this, &x); + } + return retValue; + } + + inline + Number Vector::Nrm2() const + { + if (nrm2_cache_tag_ != GetTag()) { + cached_nrm2_ = Nrm2Impl(); + nrm2_cache_tag_ = GetTag(); + } + return cached_nrm2_; + } + + inline + Number Vector::Asum() const + { + if (asum_cache_tag_ != GetTag()) { + cached_asum_ = AsumImpl(); + asum_cache_tag_ = GetTag(); + } + return cached_asum_; + } + + inline + Number Vector::Amax() const + { + if (amax_cache_tag_ != GetTag()) { + cached_amax_ = AmaxImpl(); + amax_cache_tag_ = GetTag(); + } + return cached_amax_; + } + + inline + Number Vector::Sum() const + { + if (sum_cache_tag_ != GetTag()) { + cached_sum_ = SumImpl(); + sum_cache_tag_ = GetTag(); + } + return cached_sum_; + } + + inline + Number Vector::SumLogs() const + { + if (sumlogs_cache_tag_ != GetTag()) { + cached_sumlogs_ = SumLogsImpl(); + sumlogs_cache_tag_ = GetTag(); + } + return cached_sumlogs_; + } + + inline + void Vector::ElementWiseSgn() + { + ElementWiseSgnImpl(); + ObjectChanged(); + } + + inline + void Vector::Set(Number alpha) + { + // Could initialize caches here + SetImpl(alpha); + ObjectChanged(); + } + + inline + void Vector::ElementWiseDivide(const Vector& x) + { + ElementWiseDivideImpl(x); + ObjectChanged(); + } + + inline + void Vector::ElementWiseMultiply(const Vector& x) + { + ElementWiseMultiplyImpl(x); + ObjectChanged(); + } + + inline + void Vector::ElementWiseReciprocal() + { + ElementWiseReciprocalImpl(); + ObjectChanged(); + } + + inline + void Vector::ElementWiseMax(const Vector& x) + { + // Could initialize some caches here + ElementWiseMaxImpl(x); + ObjectChanged(); + } + + inline + void Vector::ElementWiseMin(const Vector& x) + { + // Could initialize some caches here + ElementWiseMinImpl(x); + ObjectChanged(); + } + + inline + void Vector::ElementWiseAbs() + { + // Could initialize some caches here + ElementWiseAbsImpl(); + ObjectChanged(); + } + + inline + void Vector::ElementWiseSqrt() + { + ElementWiseSqrtImpl(); + ObjectChanged(); + } + + inline + void Vector::AddScalar(Number scalar) + { + // Could initialize some caches here + AddScalarImpl(scalar); + ObjectChanged(); + } + + inline + Number Vector::Max() const + { + if (max_cache_tag_ != GetTag()) { + cached_max_ = MaxImpl(); + max_cache_tag_ = GetTag(); + } + return cached_max_; + } + + inline + Number Vector::Min() const + { + if (min_cache_tag_ != GetTag()) { + cached_min_ = MinImpl(); + min_cache_tag_ = GetTag(); + } + return cached_min_; + } + + inline + void Vector::AddOneVector(Number a, const Vector& v1, Number c) + { + AddTwoVectors(a, v1, 0., v1, c); + } + + inline + void Vector::AddTwoVectors(Number a, const Vector& v1, + Number b, const Vector& v2, Number c) + { + AddTwoVectorsImpl(a, v1, b, v2, c); + ObjectChanged(); + } + + inline + Number Vector::FracToBound(const Vector& delta, Number tau) const + { + /* AW: I avoid the caching here, since it leads to overhead in the + quality function search. Caches for this are in + CalculatedQuantities. + Number retValue; + std::vector<const TaggedObject*> tdeps(1); + tdeps[0] = δ + std::vector<Number> sdeps(1); + sdeps[0] = tau; + if (!frac_to_bound_cache_.GetCachedResult(retValue, tdeps, sdeps)) { + retValue = FracToBoundImpl(delta, tau); + frac_to_bound_cache_.AddCachedResult(retValue, tdeps, sdeps); + } + return retValue; + */ + return FracToBoundImpl(delta, tau); + } + + inline + void Vector::AddVectorQuotient(Number a, const Vector& z, + const Vector& s, Number c) + { + AddVectorQuotientImpl(a, z, s, c); + ObjectChanged(); + } + + inline + bool Vector::HasValidNumbers() const + { + if (valid_cache_tag_ != GetTag()) { + cached_valid_ = HasValidNumbersImpl(); + valid_cache_tag_ = GetTag(); + } + return cached_valid_; + } + + inline + Index Vector::Dim() const + { + return owner_space_->Dim(); + } + + inline + SmartPtr<const VectorSpace> Vector::OwnerSpace() const + { + return owner_space_; + } + + inline + VectorSpace::VectorSpace(Index dim) + : + dim_(dim) + {} + +} // namespace Ipopt + +// Macro definitions for debugging vectors +#if COIN_IPOPT_VERBOSITY == 0 +# define DBG_PRINT_VECTOR(__verbose_level, __vec_name, __vec) +#else +# define DBG_PRINT_VECTOR(__verbose_level, __vec_name, __vec) \ + if (dbg_jrnl.Verbosity() >= (__verbose_level)) { \ + if (dbg_jrnl.Jnlst()!=NULL) { \ + (__vec).Print(dbg_jrnl.Jnlst(), \ + J_ERROR, J_DBG, \ + __vec_name, \ + dbg_jrnl.IndentationLevel()*2, \ + "# "); \ + } \ + } +#endif //if COIN_IPOPT_VERBOSITY == 0 + +#endif diff --git a/thirdparty/windows/include/coin/IpoptConfig.h b/thirdparty/windows/include/coin/IpoptConfig.h new file mode 100644 index 0000000..2552d69 --- /dev/null +++ b/thirdparty/windows/include/coin/IpoptConfig.h @@ -0,0 +1,101 @@ +#ifndef HAVE_CONFIG_H +#define HAVE_CONFIG_H +#endif +/* + * Include file for the configuration of Ipopt. + * + * On systems where the code is configured with the configure script + * (i.e., compilation is always done with HAVE_CONFIG_H defined), this + * header file includes the automatically generated header file, and + * undefines macros that might configure with other Config.h files. + * + * On systems that are compiled in other ways (e.g., with the + * Developer Studio), a header files is included to define those + * macros that depend on the operating system and the compiler. The + * macros that define the configuration of the particular user setting + * (e.g., presence of other COIN packages or third party code) are set + * here. The project maintainer needs to remember to update this file + * and choose reasonable defines. A user can modify the default + * setting by editing this file here. + * + */ + +#ifndef __IPOPTCONFIG_H__ +#define __IPOPTCONFIG_H__ + +#ifdef HAVE_CONFIG_H +#include "config_ipopt.h" + +/* undefine macros that could conflict with those in other config.h + files */ +#undef PACKAGE +#undef PACKAGE_BUGREPORT +#undef PACKAGE_NAME +#undef PACKAGE_STRING +#undef PACKAGE_TARNAME +#undef PACKAGE_VERSION +#undef VERSION + +#else /* HAVE_CONFIG_H */ + +/* include the COIN-wide system specific configure header */ +#include "configall_system.h" + +#define IPOPT_VERSION "3.8.0" + +/***************************************************************************/ +/* HERE DEFINE THE CONFIGURATION SPECIFIC MACROS */ +/***************************************************************************/ + +/* Define to the debug sanity check level (0 is no test) */ +#define COIN_IPOPT_CHECKLEVEL 0 + +/* Define to the debug verbosity level (0 is no output) */ +#define COIN_IPOPT_VERBOSITY 0 + +/* If defined, the Ampl Solver Library is available. */ +#define COIN_HAS_ASL 1 + +/* If defined, the BLAS Library is available. */ +#define COIN_HAS_BLAS 1 + +/* Define to 1 if the Ipopt package is used */ +#define COIN_HAS_IPOPT 1 + +/* If defined, the LAPACK Library is available. */ +#define COIN_HAS_LAPACK 1 + +/* Define to 1 if the linear solver loader should be compiled to allow dynamic + loading of shared libraries with linear solvers */ +/* #undef HAVE_LINEARSOLVERLOADER */ + +/* Define to 1 if MA27 is available */ +#define HAVE_MA27 1 + +/* Define to 1 if MA57 is available */ +/* #undef HAVE_MA57 */ + +/* Define to 1 if MC19 is available */ +#define HAVE_MC19 1 + +/* Define to 1 if MUMPS is available */ +/* #undef HAVE_MUMPS */ + +/* Define to 1 if Pardiso is available */ +/* #undef HAVE_PARDISO */ + +/* Define to 1 if you are using the parallel version of Pardiso */ +/* #undef HAVE_PARDISO_PARALLEL */ + +/* Define to 1 if TAUCS is available */ +/* #undef HAVE_TAUCS */ + +/* Define to 1 if WSMP is available */ +/* #undef HAVE_WSMP */ + +#endif /* HAVE_CONFIG_H */ + +/* Type of Fortran integer translated into C */ +typedef FORTRAN_INTEGER_TYPE ipfint; + +#endif /*__IPOPTCONFIG_H__*/ diff --git a/thirdparty/windows/include/coin/OsiAuxInfo.hpp b/thirdparty/windows/include/coin/OsiAuxInfo.hpp new file mode 100644 index 0000000..182d981 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiAuxInfo.hpp @@ -0,0 +1,206 @@ +// Copyright (C) 2006, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef OsiAuxInfo_H +#define OsiAuxInfo_H + +class OsiSolverInterface; + +//############################################################################# +/** This class allows for a more structured use of algorithmic tweaking to + an OsiSolverInterface. It is designed to replace the simple use of + appData_ pointer. + + This has been done to make it easier to use NonLinear solvers and other + exotic beasts in a branch and bound mode. After this class definition + there is one for a derived class for just such a purpose. + +*/ + +class OsiAuxInfo { +public: + // Default Constructor + OsiAuxInfo (void * appData = NULL); + + // Copy Constructor + OsiAuxInfo (const OsiAuxInfo & rhs); + // Destructor + virtual ~OsiAuxInfo(); + + /// Clone + virtual OsiAuxInfo * clone() const; + /// Assignment operator + OsiAuxInfo & operator=(const OsiAuxInfo& rhs); + + /// Get application data + inline void * getApplicationData() const + { return appData_;} +protected: + /// Pointer to user-defined data structure + void * appData_; +}; +//############################################################################# +/** This class allows for the use of more exotic solvers e.g. Non-Linear or Volume. + + You can derive from this although at present I can't see the need. +*/ + +class OsiBabSolver : public OsiAuxInfo { +public: + // Default Constructor + OsiBabSolver (int solverType=0); + + // Copy Constructor + OsiBabSolver (const OsiBabSolver & rhs); + // Destructor + virtual ~OsiBabSolver(); + + /// Clone + virtual OsiAuxInfo * clone() const; + /// Assignment operator + OsiBabSolver & operator=(const OsiBabSolver& rhs); + + /// Update solver + inline void setSolver(const OsiSolverInterface * solver) + { solver_ = solver;} + /// Update solver + inline void setSolver(const OsiSolverInterface & solver) + { solver_ = &solver;} + + /** returns 0 if no heuristic solution, 1 if valid solution + with better objective value than one passed in + Sets solution values if good, sets objective value + numberColumns is size of newSolution + */ + int solution(double & objectiveValue, + double * newSolution, int numberColumns); + /** Set solution and objective value. + Number of columns and optimization direction taken from current solver. + Size of solution is numberColumns (may be padded or truncated in function) */ + void setSolution(const double * solution, int numberColumns, double objectiveValue); + + /** returns true if the object stores a solution, false otherwise. If there + is a solution then solutionValue and solution will be filled out as well. + In that case the user needs to allocate solution to be a big enough + array. + */ + bool hasSolution(double & solutionValue, double * solution); + + /** Sets solver type + 0 - normal LP solver + 1 - DW - may also return heuristic solutions + 2 - NLP solver or similar - can't compute objective value just from solution + check solver to see if feasible and what objective value is + - may also return heuristic solution + 3 - NLP solver or similar - can't compute objective value just from solution + check this (rather than solver) to see if feasible and what objective value is. + Using Outer Approximation so called lp based + - may also return heuristic solution + 4 - normal solver but cuts are needed for integral solution + */ + inline void setSolverType(int value) + { solverType_=value;} + /** gets solver type + 0 - normal LP solver + 1 - DW - may also return heuristic solutions + 2 - NLP solver or similar - can't compute objective value just from solution + check this (rather than solver) to see if feasible and what objective value is + - may also return heuristic solution + 3 - NLP solver or similar - can't compute objective value just from solution + check this (rather than solver) to see if feasible and what objective value is. + Using Outer Approximation so called lp based + - may also return heuristic solution + 4 - normal solver but cuts are needed for integral solution + */ + inline int solverType() const + { return solverType_;} + /** Return true if getting solution may add cuts so hot start etc will + be obsolete */ + inline bool solutionAddsCuts() const + { return solverType_==3;} + /// Return true if we should try cuts at root even if looks satisfied + inline bool alwaysTryCutsAtRootNode() const + { return solverType_==4;} + /** Returns true if can use solver objective or feasible values, + otherwise use mipBound etc */ + inline bool solverAccurate() const + { return solverType_==0||solverType_==2||solverType_==4;} + /// Returns true if can use reduced costs for fixing + inline bool reducedCostsAccurate() const + { return solverType_==0||solverType_==4;} + /// Get objective (well mip bound) + double mipBound() const; + /// Returns true if node feasible + bool mipFeasible() const; + /// Set mip bound (only used for some solvers) + inline void setMipBound(double value) + { mipBound_ = value;} + /// Get objective value of saved solution + inline double bestObjectiveValue() const + { return bestObjectiveValue_;} + /// Says whether we want to try cuts at all + inline bool tryCuts() const + { return solverType_!=2;} + /// Says whether we have a warm start (so can do strong branching) + inline bool warmStart() const + { return solverType_!=2;} + /** Get bit mask for odd actions of solvers + 1 - solution or bound arrays may move in mysterious ways e.g. cplex + 2 - solver may want bounds before branch + */ + inline int extraCharacteristics() const + { return extraCharacteristics_;} + /** Set bit mask for odd actions of solvers + 1 - solution or bound arrays may move in mysterious ways e.g. cplex + 2 - solver may want bounds before branch + */ + inline void setExtraCharacteristics(int value) + { extraCharacteristics_=value;} + /// Pointer to lower bounds before branch (only if extraCharacteristics set) + inline const double * beforeLower() const + { return beforeLower_;} + /// Set pointer to lower bounds before branch (only if extraCharacteristics set) + inline void setBeforeLower(const double * array) + { beforeLower_ = array;} + /// Pointer to upper bounds before branch (only if extraCharacteristics set) + inline const double * beforeUpper() const + { return beforeUpper_;} + /// Set pointer to upper bounds before branch (only if extraCharacteristics set) + inline void setBeforeUpper(const double * array) + { beforeUpper_ = array;} +protected: + /// Objective value of best solution (if there is one) (minimization) + double bestObjectiveValue_; + /// Current lower bound on solution ( if > 1.0e50 infeasible) + double mipBound_; + /// Solver to use for getting/setting solutions etc + const OsiSolverInterface * solver_; + /// Best integer feasible solution + double * bestSolution_; + /// Pointer to lower bounds before branch (only if extraCharacteristics set) + const double * beforeLower_; + /// Pointer to upper bounds before branch (only if extraCharacteristics set) + const double * beforeUpper_; + /** Solver type + 0 - normal LP solver + 1 - DW - may also return heuristic solutions + 2 - NLP solver or similar - can't compute objective value just from solution + check this (rather than solver) to see if feasible and what objective value is + - may also return heuristic solution + 3 - NLP solver or similar - can't compute objective value just from solution + check this (rather than solver) to see if feasible and what objective value is. + Using Outer Approximation so called lp based + - may also return heuristic solution + */ + int solverType_; + /// Size of solution + int sizeSolution_; + /** Bit mask for odd actions of solvers + 1 - solution or bound arrays may move in mysterious ways e.g. cplex + 2 - solver may want bounds before branch + */ + int extraCharacteristics_; +}; + +#endif diff --git a/thirdparty/windows/include/coin/OsiBranchingObject.hpp b/thirdparty/windows/include/coin/OsiBranchingObject.hpp new file mode 100644 index 0000000..78b6984 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiBranchingObject.hpp @@ -0,0 +1,1005 @@ +// Copyright (C) 2006, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef OsiBranchingObject_H +#define OsiBranchingObject_H + +#include <cassert> +#include <string> +#include <vector> + +#include "CoinError.hpp" +#include "CoinTypes.hpp" + +class OsiSolverInterface; +class OsiSolverBranch; + +class OsiBranchingObject; +class OsiBranchingInformation; + +//############################################################################# +//This contains the abstract base class for an object and for branching. +//It also contains a simple integer class +//############################################################################# + +/** Abstract base class for `objects'. + + The branching model used in Osi is based on the idea of an <i>object</i>. + In the abstract, an object is something that has a feasible region, can be + evaluated for infeasibility, can be branched on (<i>i.e.</i>, there's some + constructive action to be taken to move toward feasibility), and allows + comparison of the effect of branching. + + This class (OsiObject) is the base class for an object. To round out the + branching model, the class OsiBranchingObject describes how to perform a + branch, and the class OsiBranchDecision describes how to compare two + OsiBranchingObjects. + + To create a new type of object you need to provide three methods: + #infeasibility(), #feasibleRegion(), and #createBranch(), described below. + + This base class is primarily virtual to allow for any form of structure. + Any form of discontinuity is allowed. + + As there is an overhead in getting information from solvers and because + other useful information is available there is also an OsiBranchingInformation + class which can contain pointers to information. + If used it must at minimum contain pointers to current value of objective, + maximum allowed objective and pointers to arrays for bounds and solution + and direction of optimization. Also integer and primal tolerance. + + Classes which inherit might have other information such as depth, number of + solutions, pseudo-shadow prices etc etc. + May be easier just to throw in here - as I keep doing +*/ +class OsiObject { + +public: + + /// Default Constructor + OsiObject (); + + /// Copy constructor + OsiObject ( const OsiObject &); + + /// Assignment operator + OsiObject & operator=( const OsiObject& rhs); + + /// Clone + virtual OsiObject * clone() const=0; + + /// Destructor + virtual ~OsiObject (); + + /** Infeasibility of the object + + This is some measure of the infeasibility of the object. 0.0 + indicates that the object is satisfied. + + The preferred branching direction is returned in whichWay, where for + normal two-way branching 0 is down, 1 is up + + This is used to prepare for strong branching but should also think of + case when no strong branching + + The object may also compute an estimate of cost of going "up" or "down". + This will probably be based on pseudo-cost ideas + + This should also set mutable infeasibility_ and whichWay_ + This is for instant re-use for speed + + Default for this just calls infeasibility with OsiBranchingInformation + NOTE - Convention says that an infeasibility of COIN_DBL_MAX means + object has worked out it can't be satisfied! + */ + double infeasibility(const OsiSolverInterface * solver,int &whichWay) const ; + // Faster version when more information available + virtual double infeasibility(const OsiBranchingInformation * info, int &whichWay) const =0; + // This does NOT set mutable stuff + virtual double checkInfeasibility(const OsiBranchingInformation * info) const; + + /** For the variable(s) referenced by the object, + look at the current solution and set bounds to match the solution. + Returns measure of how much it had to move solution to make feasible + */ + virtual double feasibleRegion(OsiSolverInterface * solver) const ; + /** For the variable(s) referenced by the object, + look at the current solution and set bounds to match the solution. + Returns measure of how much it had to move solution to make feasible + Faster version + */ + virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const =0; + + /** Create a branching object and indicate which way to branch first. + + The branching object has to know how to create branches (fix + variables, etc.) + */ + virtual OsiBranchingObject * createBranch(OsiSolverInterface * /*solver*/, + const OsiBranchingInformation * /*info*/, + int /*way*/) const {throw CoinError("Need code","createBranch","OsiBranchingObject"); return NULL; } + + /** \brief Return true if object can take part in normal heuristics + */ + virtual bool canDoHeuristics() const + {return true;} + /** \brief Return true if object can take part in move to nearest heuristic + */ + virtual bool canMoveToNearest() const + {return false;} + /** Column number if single column object -1 otherwise, + Used by heuristics + */ + virtual int columnNumber() const; + /// Return Priority - note 1 is highest priority + inline int priority() const + { return priority_;} + /// Set priority + inline void setPriority(int priority) + { priority_ = priority;} + /** \brief Return true if branch should only bound variables + */ + virtual bool boundBranch() const + {return true;} + /// Return true if knows how to deal with Pseudo Shadow Prices + virtual bool canHandleShadowPrices() const + { return false;} + /// Return maximum number of ways branch may have + inline int numberWays() const + { return numberWays_;} + /// Set maximum number of ways branch may have + inline void setNumberWays(int numberWays) + { numberWays_ = static_cast<short int>(numberWays) ; } + /** Return preferred way to branch. If two + then way=0 means down and 1 means up, otherwise + way points to preferred branch + */ + inline void setWhichWay(int way) + { whichWay_ = static_cast<short int>(way) ; } + /** Return current preferred way to branch. If two + then way=0 means down and 1 means up, otherwise + way points to preferred branch + */ + inline int whichWay() const + { return whichWay_;} + /// Get pre-emptive preferred way of branching - -1 off, 0 down, 1 up (for 2-way) + virtual int preferredWay() const + { return -1;} + /// Return infeasibility + inline double infeasibility() const + { return infeasibility_;} + /// Return "up" estimate (default 1.0e-5) + virtual double upEstimate() const; + /// Return "down" estimate (default 1.0e-5) + virtual double downEstimate() const; + /** Reset variable bounds to their original values. + Bounds may be tightened, so it may be good to be able to reset them to + their original values. + */ + virtual void resetBounds(const OsiSolverInterface * ) {} + /** Change column numbers after preprocessing + */ + virtual void resetSequenceEtc(int , const int * ) {} + /// Updates stuff like pseudocosts before threads + virtual void updateBefore(const OsiObject * ) {} + /// Updates stuff like pseudocosts after threads finished + virtual void updateAfter(const OsiObject * , const OsiObject * ) {} + +protected: + /// data + + /// Computed infeasibility + mutable double infeasibility_; + /// Computed preferred way to branch + mutable short whichWay_; + /// Maximum number of ways on branch + short numberWays_; + /// Priority + int priority_; + +}; +/// Define a class to add a bit of complexity to OsiObject +/// This assumes 2 way branching + + +class OsiObject2 : public OsiObject { + +public: + + /// Default Constructor + OsiObject2 (); + + /// Copy constructor + OsiObject2 ( const OsiObject2 &); + + /// Assignment operator + OsiObject2 & operator=( const OsiObject2& rhs); + + /// Destructor + virtual ~OsiObject2 (); + + /// Set preferred way of branching - -1 off, 0 down, 1 up (for 2-way) + inline void setPreferredWay(int value) + {preferredWay_=value;} + + /// Get preferred way of branching - -1 off, 0 down, 1 up (for 2-way) + virtual int preferredWay() const + { return preferredWay_;} +protected: + /// Preferred way of branching - -1 off, 0 down, 1 up (for 2-way) + int preferredWay_; + /// "Infeasibility" on other way + mutable double otherInfeasibility_; + +}; + +/** \brief Abstract branching object base class + + In the abstract, an OsiBranchingObject contains instructions for how to + branch. We want an abstract class so that we can describe how to branch on + simple objects (<i>e.g.</i>, integers) and more exotic objects + (<i>e.g.</i>, cliques or hyperplanes). + + The #branch() method is the crucial routine: it is expected to be able to + step through a set of branch arms, executing the actions required to create + each subproblem in turn. The base class is primarily virtual to allow for + a wide range of problem modifications. + + See OsiObject for an overview of the two classes (OsiObject and + OsiBranchingObject) which make up Osi's branching + model. +*/ + +class OsiBranchingObject { + +public: + + /// Default Constructor + OsiBranchingObject (); + + /// Constructor + OsiBranchingObject (OsiSolverInterface * solver, double value); + + /// Copy constructor + OsiBranchingObject ( const OsiBranchingObject &); + + /// Assignment operator + OsiBranchingObject & operator=( const OsiBranchingObject& rhs); + + /// Clone + virtual OsiBranchingObject * clone() const=0; + + /// Destructor + virtual ~OsiBranchingObject (); + + /// The number of branch arms created for this branching object + inline int numberBranches() const + {return numberBranches_;} + + /// The number of branch arms left for this branching object + inline int numberBranchesLeft() const + {return numberBranches_-branchIndex_;} + + /// Increment the number of branch arms left for this branching object + inline void incrementNumberBranchesLeft() + { numberBranches_ ++;} + + /** Set the number of branch arms left for this branching object + Just for forcing + */ + inline void setNumberBranchesLeft(int /*value*/) + {/*assert (value==1&&!branchIndex_);*/ numberBranches_=1;} + + /// Decrement the number of branch arms left for this branching object + inline void decrementNumberBranchesLeft() + {branchIndex_++;} + + /** \brief Execute the actions required to branch, as specified by the + current state of the branching object, and advance the object's + state. + Returns change in guessed objective on next branch + */ + virtual double branch(OsiSolverInterface * solver)=0; + /** \brief Execute the actions required to branch, as specified by the + current state of the branching object, and advance the object's + state. + Returns change in guessed objective on next branch + */ + virtual double branch() {return branch(NULL);} + /** \brief Return true if branch should fix variables + */ + virtual bool boundBranch() const + {return true;} + /** Get the state of the branching object + This is just the branch index + */ + inline int branchIndex() const + {return branchIndex_;} + + /** Set the state of the branching object. + */ + inline void setBranchingIndex(int branchIndex) + { branchIndex_ = static_cast<short int>(branchIndex) ; } + + /// Current value + inline double value() const + {return value_;} + + /// Return pointer back to object which created + inline const OsiObject * originalObject() const + {return originalObject_;} + /// Set pointer back to object which created + inline void setOriginalObject(const OsiObject * object) + {originalObject_=object;} + /** Double checks in case node can change its mind! + Returns objective value + Can change objective etc */ + virtual void checkIsCutoff(double ) {} + /// For debug + int columnNumber() const; + /** \brief Print something about branch - only if log level high + */ + virtual void print(const OsiSolverInterface * =NULL) const {} + +protected: + + /// Current value - has some meaning about branch + double value_; + + /// Pointer back to object which created + const OsiObject * originalObject_; + + /** Number of branches + */ + int numberBranches_; + + /** The state of the branching object. i.e. branch index + This starts at 0 when created + */ + short branchIndex_; + +}; +/* This contains information + This could also contain pseudo shadow prices + or information for dealing with computing and trusting pseudo-costs +*/ +class OsiBranchingInformation { + +public: + + /// Default Constructor + OsiBranchingInformation (); + + /** Useful Constructor + (normalSolver true if has matrix etc etc) + copySolution true if constructot should make a copy + */ + OsiBranchingInformation (const OsiSolverInterface * solver, bool normalSolver,bool copySolution=false); + + /// Copy constructor + OsiBranchingInformation ( const OsiBranchingInformation &); + + /// Assignment operator + OsiBranchingInformation & operator=( const OsiBranchingInformation& rhs); + + /// Clone + virtual OsiBranchingInformation * clone() const; + + /// Destructor + virtual ~OsiBranchingInformation (); + + // Note public +public: + /// data + + /** State of search + 0 - no solution + 1 - only heuristic solutions + 2 - branched to a solution + 3 - no solution but many nodes + */ + int stateOfSearch_; + /// Value of objective function (in minimization sense) + double objectiveValue_; + /// Value of objective cutoff (in minimization sense) + double cutoff_; + /// Direction 1.0 for minimization, -1.0 for maximization + double direction_; + /// Integer tolerance + double integerTolerance_; + /// Primal tolerance + double primalTolerance_; + /// Maximum time remaining before stopping on time + double timeRemaining_; + /// Dual to use if row bound violated (if negative then pseudoShadowPrices off) + double defaultDual_; + /// Pointer to solver + mutable const OsiSolverInterface * solver_; + /// The number of columns + int numberColumns_; + /// Pointer to current lower bounds on columns + mutable const double * lower_; + /// Pointer to current solution + mutable const double * solution_; + /// Pointer to current upper bounds on columns + mutable const double * upper_; + /// Highly optional target (hot start) solution + const double * hotstartSolution_; + /// Pointer to duals + const double * pi_; + /// Pointer to row activity + const double * rowActivity_; + /// Objective + const double * objective_; + /// Pointer to current lower bounds on rows + const double * rowLower_; + /// Pointer to current upper bounds on rows + const double * rowUpper_; + /// Elements in column copy of matrix + const double * elementByColumn_; + /// Column starts + const CoinBigIndex * columnStart_; + /// Column lengths + const int * columnLength_; + /// Row indices + const int * row_; + /** Useful region of length CoinMax(numberColumns,2*numberRows) + This is allocated and deleted before OsiObject::infeasibility + It is zeroed on entry and should be so on exit + It only exists if defaultDual_>=0.0 + */ + double * usefulRegion_; + /// Useful index region to go with usefulRegion_ + int * indexRegion_; + /// Number of solutions found + int numberSolutions_; + /// Number of branching solutions found (i.e. exclude heuristics) + int numberBranchingSolutions_; + /// Depth in tree + int depth_; + /// TEMP + bool owningSolution_; +}; + +/// This just adds two-wayness to a branching object + +class OsiTwoWayBranchingObject : public OsiBranchingObject { + +public: + + /// Default constructor + OsiTwoWayBranchingObject (); + + /** Create a standard tw0-way branch object + + Specifies a simple two-way branch. + Specify way = -1 to set the object state to perform the down arm first, + way = 1 for the up arm. + */ + OsiTwoWayBranchingObject (OsiSolverInterface *solver,const OsiObject * originalObject, + int way , double value) ; + + /// Copy constructor + OsiTwoWayBranchingObject ( const OsiTwoWayBranchingObject &); + + /// Assignment operator + OsiTwoWayBranchingObject & operator= (const OsiTwoWayBranchingObject& rhs); + + /// Destructor + virtual ~OsiTwoWayBranchingObject (); + + using OsiBranchingObject::branch ; + /** \brief Sets the bounds for the variable according to the current arm + of the branch and advances the object state to the next arm. + state. + Returns change in guessed objective on next branch + */ + virtual double branch(OsiSolverInterface * solver)=0; + + inline int firstBranch() const { return firstBranch_; } + /// Way returns -1 on down +1 on up + inline int way() const + { return !branchIndex_ ? firstBranch_ : -firstBranch_;} +protected: + /// Which way was first branch -1 = down, +1 = up + int firstBranch_; +}; +/// Define a single integer class + + +class OsiSimpleInteger : public OsiObject2 { + +public: + + /// Default Constructor + OsiSimpleInteger (); + + /// Useful constructor - passed solver index + OsiSimpleInteger (const OsiSolverInterface * solver, int iColumn); + + /// Useful constructor - passed solver index and original bounds + OsiSimpleInteger (int iColumn, double lower, double upper); + + /// Copy constructor + OsiSimpleInteger ( const OsiSimpleInteger &); + + /// Clone + virtual OsiObject * clone() const; + + /// Assignment operator + OsiSimpleInteger & operator=( const OsiSimpleInteger& rhs); + + /// Destructor + virtual ~OsiSimpleInteger (); + + using OsiObject::infeasibility ; + /// Infeasibility - large is 0.5 + virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const; + + using OsiObject::feasibleRegion ; + /** Set bounds to fix the variable at the current (integer) value. + + Given an integer value, set the lower and upper bounds to fix the + variable. Returns amount it had to move variable. + */ + virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const; + + /** Creates a branching object + + The preferred direction is set by \p way, 0 for down, 1 for up. + */ + virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const; + + + /// Set solver column number + inline void setColumnNumber(int value) + {columnNumber_=value;} + + /** Column number if single column object -1 otherwise, + so returns >= 0 + Used by heuristics + */ + virtual int columnNumber() const; + + /// Original bounds + inline double originalLowerBound() const + { return originalLower_;} + inline void setOriginalLowerBound(double value) + { originalLower_=value;} + inline double originalUpperBound() const + { return originalUpper_;} + inline void setOriginalUpperBound(double value) + { originalUpper_=value;} + /** Reset variable bounds to their original values. + Bounds may be tightened, so it may be good to be able to reset them to + their original values. + */ + virtual void resetBounds(const OsiSolverInterface * solver) ; + /** Change column numbers after preprocessing + */ + virtual void resetSequenceEtc(int numberColumns, const int * originalColumns); + + /// Return "up" estimate (default 1.0e-5) + virtual double upEstimate() const; + /// Return "down" estimate (default 1.0e-5) + virtual double downEstimate() const; + /// Return true if knows how to deal with Pseudo Shadow Prices + virtual bool canHandleShadowPrices() const + { return false;} +protected: + /// data + /// Original lower bound + double originalLower_; + /// Original upper bound + double originalUpper_; + /// Column number in solver + int columnNumber_; + +}; +/** Simple branching object for an integer variable + + This object can specify a two-way branch on an integer variable. For each + arm of the branch, the upper and lower bounds on the variable can be + independently specified. 0 -> down, 1-> up. +*/ + +class OsiIntegerBranchingObject : public OsiTwoWayBranchingObject { + +public: + + /// Default constructor + OsiIntegerBranchingObject (); + + /** Create a standard floor/ceiling branch object + + Specifies a simple two-way branch. Let \p value = x*. One arm of the + branch will be lb <= x <= floor(x*), the other ceil(x*) <= x <= ub. + Specify way = -1 to set the object state to perform the down arm first, + way = 1 for the up arm. + */ + OsiIntegerBranchingObject (OsiSolverInterface *solver,const OsiSimpleInteger * originalObject, + int way , double value) ; + /** Create a standard floor/ceiling branch object + + Specifies a simple two-way branch in a more flexible way. One arm of the + branch will be lb <= x <= downUpperBound, the other upLowerBound <= x <= ub. + Specify way = -1 to set the object state to perform the down arm first, + way = 1 for the up arm. + */ + OsiIntegerBranchingObject (OsiSolverInterface *solver,const OsiSimpleInteger * originalObject, + int way , double value, double downUpperBound, double upLowerBound) ; + + /// Copy constructor + OsiIntegerBranchingObject ( const OsiIntegerBranchingObject &); + + /// Assignment operator + OsiIntegerBranchingObject & operator= (const OsiIntegerBranchingObject& rhs); + + /// Clone + virtual OsiBranchingObject * clone() const; + + /// Destructor + virtual ~OsiIntegerBranchingObject (); + + using OsiBranchingObject::branch ; + /** \brief Sets the bounds for the variable according to the current arm + of the branch and advances the object state to the next arm. + state. + Returns change in guessed objective on next branch + */ + virtual double branch(OsiSolverInterface * solver); + + using OsiBranchingObject::print ; + /** \brief Print something about branch - only if log level high + */ + virtual void print(const OsiSolverInterface * solver=NULL); + +protected: + // Probably could get away with just value which is already stored + /// Lower [0] and upper [1] bounds for the down arm (way_ = -1) + double down_[2]; + /// Lower [0] and upper [1] bounds for the up arm (way_ = 1) + double up_[2]; +}; + + +/** Define Special Ordered Sets of type 1 and 2. These do not have to be + integer - so do not appear in lists of integers. + + which_ points columns of matrix +*/ + + +class OsiSOS : public OsiObject2 { + +public: + + // Default Constructor + OsiSOS (); + + /** Useful constructor - which are indices + and weights are also given. If null then 0,1,2.. + type is SOS type + */ + OsiSOS (const OsiSolverInterface * solver, int numberMembers, + const int * which, const double * weights, int type=1); + + // Copy constructor + OsiSOS ( const OsiSOS &); + + /// Clone + virtual OsiObject * clone() const; + + // Assignment operator + OsiSOS & operator=( const OsiSOS& rhs); + + // Destructor + virtual ~OsiSOS (); + + using OsiObject::infeasibility ; + /// Infeasibility - large is 0.5 + virtual double infeasibility(const OsiBranchingInformation * info,int & whichWay) const; + + using OsiObject::feasibleRegion ; + /** Set bounds to fix the variable at the current (integer) value. + + Given an integer value, set the lower and upper bounds to fix the + variable. Returns amount it had to move variable. + */ + virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const; + + /** Creates a branching object + + The preferred direction is set by \p way, 0 for down, 1 for up. + */ + virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const; + /// Return "up" estimate (default 1.0e-5) + virtual double upEstimate() const; + /// Return "down" estimate (default 1.0e-5) + virtual double downEstimate() const; + + /// Redoes data when sequence numbers change + virtual void resetSequenceEtc(int numberColumns, const int * originalColumns); + + /// Number of members + inline int numberMembers() const + {return numberMembers_;} + + /// Members (indices in range 0 ... numberColumns-1) + inline const int * members() const + {return members_;} + + /// SOS type + inline int sosType() const + {return sosType_;} + + /// SOS type + inline int setType() const + {return sosType_;} + + /** Array of weights */ + inline const double * weights() const + { return weights_;} + + /** \brief Return true if object can take part in normal heuristics + */ + virtual bool canDoHeuristics() const + {return (sosType_==1&&integerValued_);} + /// Set whether set is integer valued or not + inline void setIntegerValued(bool yesNo) + { integerValued_=yesNo;} + /// Return true if knows how to deal with Pseudo Shadow Prices + virtual bool canHandleShadowPrices() const + { return true;} + /// Set number of members + inline void setNumberMembers(int value) + {numberMembers_=value;} + + /// Members (indices in range 0 ... numberColumns-1) + inline int * mutableMembers() const + {return members_;} + + /// Set SOS type + inline void setSosType(int value) + {sosType_=value;} + + /** Array of weights */ + inline double * mutableWeights() const + { return weights_;} +protected: + /// data + + /// Members (indices in range 0 ... numberColumns-1) + int * members_; + /// Weights + double * weights_; + + /// Number of members + int numberMembers_; + /// SOS type + int sosType_; + /// Whether integer valued + bool integerValued_; +}; + +/** Branching object for Special ordered sets + + */ +class OsiSOSBranchingObject : public OsiTwoWayBranchingObject { + +public: + + // Default Constructor + OsiSOSBranchingObject (); + + // Useful constructor + OsiSOSBranchingObject (OsiSolverInterface * solver, const OsiSOS * originalObject, + int way, + double separator); + + // Copy constructor + OsiSOSBranchingObject ( const OsiSOSBranchingObject &); + + // Assignment operator + OsiSOSBranchingObject & operator=( const OsiSOSBranchingObject& rhs); + + /// Clone + virtual OsiBranchingObject * clone() const; + + // Destructor + virtual ~OsiSOSBranchingObject (); + + using OsiBranchingObject::branch ; + /// Does next branch and updates state + virtual double branch(OsiSolverInterface * solver); + + using OsiBranchingObject::print ; + /** \brief Print something about branch - only if log level high + */ + virtual void print(const OsiSolverInterface * solver=NULL); +private: + /// data +}; +/** Lotsize class */ + + +class OsiLotsize : public OsiObject2 { + +public: + + // Default Constructor + OsiLotsize (); + + /* Useful constructor - passed model index. + Also passed valid values - if range then pairs + */ + OsiLotsize (const OsiSolverInterface * solver, int iColumn, + int numberPoints, const double * points, bool range=false); + + // Copy constructor + OsiLotsize ( const OsiLotsize &); + + /// Clone + virtual OsiObject * clone() const; + + // Assignment operator + OsiLotsize & operator=( const OsiLotsize& rhs); + + // Destructor + virtual ~OsiLotsize (); + + using OsiObject::infeasibility ; + /// Infeasibility - large is 0.5 + virtual double infeasibility(const OsiBranchingInformation * info, int & whichWay) const; + + using OsiObject::feasibleRegion ; + /** Set bounds to contain the current solution. + + More precisely, for the variable associated with this object, take the + value given in the current solution, force it within the current bounds + if required, then set the bounds to fix the variable at the integer + nearest the solution value. Returns amount it had to move variable. + */ + virtual double feasibleRegion(OsiSolverInterface * solver, const OsiBranchingInformation * info) const; + + /** Creates a branching object + + The preferred direction is set by \p way, 0 for down, 1 for up. + */ + virtual OsiBranchingObject * createBranch(OsiSolverInterface * solver, const OsiBranchingInformation * info, int way) const; + + + /// Set solver column number + inline void setColumnNumber(int value) + {columnNumber_=value;} + + /** Column number if single column object -1 otherwise, + so returns >= 0 + Used by heuristics + */ + virtual int columnNumber() const; + /** Reset original upper and lower bound values from the solver. + + Handy for updating bounds held in this object after bounds held in the + solver have been tightened. + */ + virtual void resetBounds(const OsiSolverInterface * solver); + + /** Finds range of interest so value is feasible in range range_ or infeasible + between hi[range_] and lo[range_+1]. Returns true if feasible. + */ + bool findRange(double value, double integerTolerance) const; + + /** Returns floor and ceiling + */ + virtual void floorCeiling(double & floorLotsize, double & ceilingLotsize, double value, + double tolerance) const; + + /// Original bounds + inline double originalLowerBound() const + { return bound_[0];} + inline double originalUpperBound() const + { return bound_[rangeType_*numberRanges_-1];} + /// Type - 1 points, 2 ranges + inline int rangeType() const + { return rangeType_;} + /// Number of points + inline int numberRanges() const + { return numberRanges_;} + /// Ranges + inline double * bound() const + { return bound_;} + /** Change column numbers after preprocessing + */ + virtual void resetSequenceEtc(int numberColumns, const int * originalColumns); + + /// Return "up" estimate (default 1.0e-5) + virtual double upEstimate() const; + /// Return "down" estimate (default 1.0e-5) + virtual double downEstimate() const; + /// Return true if knows how to deal with Pseudo Shadow Prices + virtual bool canHandleShadowPrices() const + { return true;} + /** \brief Return true if object can take part in normal heuristics + */ + virtual bool canDoHeuristics() const + {return false;} + +private: + /// data + + /// Column number in model + int columnNumber_; + /// Type - 1 points, 2 ranges + int rangeType_; + /// Number of points + int numberRanges_; + // largest gap + double largestGap_; + /// Ranges + double * bound_; + /// Current range + mutable int range_; +}; + + +/** Lotsize branching object + + This object can specify a two-way branch on an integer variable. For each + arm of the branch, the upper and lower bounds on the variable can be + independently specified. + + Variable_ holds the index of the integer variable in the integerVariable_ + array of the model. +*/ + +class OsiLotsizeBranchingObject : public OsiTwoWayBranchingObject { + +public: + + /// Default constructor + OsiLotsizeBranchingObject (); + + /** Create a lotsize floor/ceiling branch object + + Specifies a simple two-way branch. Let \p value = x*. One arm of the + branch will be is lb <= x <= valid range below(x*), the other valid range above(x*) <= x <= ub. + Specify way = -1 to set the object state to perform the down arm first, + way = 1 for the up arm. + */ + OsiLotsizeBranchingObject (OsiSolverInterface *solver,const OsiLotsize * originalObject, + int way , double value) ; + + /// Copy constructor + OsiLotsizeBranchingObject ( const OsiLotsizeBranchingObject &); + + /// Assignment operator + OsiLotsizeBranchingObject & operator= (const OsiLotsizeBranchingObject& rhs); + + /// Clone + virtual OsiBranchingObject * clone() const; + + /// Destructor + virtual ~OsiLotsizeBranchingObject (); + + using OsiBranchingObject::branch ; + /** \brief Sets the bounds for the variable according to the current arm + of the branch and advances the object state to the next arm. + state. + Returns change in guessed objective on next branch + */ + virtual double branch(OsiSolverInterface * solver); + + using OsiBranchingObject::print ; + /** \brief Print something about branch - only if log level high + */ + virtual void print(const OsiSolverInterface * solver=NULL); + +protected: + /// Lower [0] and upper [1] bounds for the down arm (way_ = -1) + double down_[2]; + /// Lower [0] and upper [1] bounds for the up arm (way_ = 1) + double up_[2]; +}; +#endif diff --git a/thirdparty/windows/include/coin/OsiChooseVariable.hpp b/thirdparty/windows/include/coin/OsiChooseVariable.hpp new file mode 100644 index 0000000..1613bca --- /dev/null +++ b/thirdparty/windows/include/coin/OsiChooseVariable.hpp @@ -0,0 +1,534 @@ +// Copyright (C) 2006, International Business Machines +// Corporation and others. All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +#ifndef OsiChooseVariable_H +#define OsiChooseVariable_H + +#include <string> +#include <vector> + +#include "CoinWarmStartBasis.hpp" +#include "OsiBranchingObject.hpp" + +class OsiSolverInterface; +class OsiHotInfo; + +/** This class chooses a variable to branch on + + The base class just chooses the variable and direction without strong branching but it + has information which would normally be used by strong branching e.g. to re-enter + having fixed a variable but using same candidates for strong branching. + + The flow is : + a) initialize the process. This decides on strong branching list + and stores indices of all infeasible objects + b) do strong branching on list. If list is empty then just + choose one candidate and return without strong branching. If not empty then + go through list and return best. However we may find that the node is infeasible + or that we can fix a variable. If so we return and it is up to user to call + again (after fixing a variable). +*/ + +class OsiChooseVariable { + +public: + + /// Default Constructor + OsiChooseVariable (); + + /// Constructor from solver (so we can set up arrays etc) + OsiChooseVariable (const OsiSolverInterface * solver); + + /// Copy constructor + OsiChooseVariable (const OsiChooseVariable &); + + /// Assignment operator + OsiChooseVariable & operator= (const OsiChooseVariable& rhs); + + /// Clone + virtual OsiChooseVariable * clone() const; + + /// Destructor + virtual ~OsiChooseVariable (); + + /** Sets up strong list and clears all if initialize is true. + Returns number of infeasibilities. + If returns -1 then has worked out node is infeasible! + */ + virtual int setupList ( OsiBranchingInformation *info, bool initialize); + /** Choose a variable + Returns - + -1 Node is infeasible + 0 Normal termination - we have a candidate + 1 All looks satisfied - no candidate + 2 We can change the bound on a variable - but we also have a strong branching candidate + 3 We can change the bound on a variable - but we have a non-strong branching candidate + 4 We can change the bound on a variable - no other candidates + We can pick up branch from bestObjectIndex() and bestWhichWay() + We can pick up a forced branch (can change bound) from firstForcedObjectIndex() and firstForcedWhichWay() + If we have a solution then we can pick up from goodObjectiveValue() and goodSolution() + If fixVariables is true then 2,3,4 are all really same as problem changed + */ + virtual int chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables); + /// Returns true if solution looks feasible against given objects + virtual bool feasibleSolution(const OsiBranchingInformation * info, + const double * solution, + int numberObjects, + const OsiObject ** objects); + /// Saves a good solution + void saveSolution(const OsiSolverInterface * solver); + /// Clears out good solution after use + void clearGoodSolution(); + /// Given a candidate fill in useful information e.g. estimates + virtual void updateInformation( const OsiBranchingInformation *info, + int branch, OsiHotInfo * hotInfo); +#if 1 + /// Given a branch fill in useful information e.g. estimates + virtual void updateInformation( int whichObject, int branch, + double changeInObjective, double changeInValue, + int status); +#endif + /// Objective value for feasible solution + inline double goodObjectiveValue() const + { return goodObjectiveValue_;} + /// Estimate of up change or change on chosen if n-way + inline double upChange() const + { return upChange_;} + /// Estimate of down change or max change on other possibilities if n-way + inline double downChange() const + { return downChange_;} + /// Good solution - deleted by finalize + inline const double * goodSolution() const + { return goodSolution_;} + /// Index of chosen object + inline int bestObjectIndex() const + { return bestObjectIndex_;} + /// Set index of chosen object + inline void setBestObjectIndex(int value) + { bestObjectIndex_ = value;} + /// Preferred way of chosen object + inline int bestWhichWay() const + { return bestWhichWay_;} + /// Set preferred way of chosen object + inline void setBestWhichWay(int value) + { bestWhichWay_ = value;} + /// Index of forced object + inline int firstForcedObjectIndex() const + { return firstForcedObjectIndex_;} + /// Set index of forced object + inline void setFirstForcedObjectIndex(int value) + { firstForcedObjectIndex_ = value;} + /// Preferred way of forced object + inline int firstForcedWhichWay() const + { return firstForcedWhichWay_;} + /// Set preferred way of forced object + inline void setFirstForcedWhichWay(int value) + { firstForcedWhichWay_ = value;} + /// Get the number of objects unsatisfied at this node - accurate on first pass + inline int numberUnsatisfied() const + {return numberUnsatisfied_;} + /// Number of objects to choose for strong branching + inline int numberStrong() const + { return numberStrong_;} + /// Set number of objects to choose for strong branching + inline void setNumberStrong(int value) + { numberStrong_ = value;} + /// Number left on strong list + inline int numberOnList() const + { return numberOnList_;} + /// Number of strong branches actually done + inline int numberStrongDone() const + { return numberStrongDone_;} + /// Number of strong iterations actually done + inline int numberStrongIterations() const + { return numberStrongIterations_;} + /// Number of strong branches which changed bounds + inline int numberStrongFixed() const + { return numberStrongFixed_;} + /// List of candidates + inline const int * candidates() const + { return list_;} + /// Trust results from strong branching for changing bounds + inline bool trustStrongForBound() const + { return trustStrongForBound_;} + /// Set trust results from strong branching for changing bounds + inline void setTrustStrongForBound(bool yesNo) + { trustStrongForBound_ = yesNo;} + /// Trust results from strong branching for valid solution + inline bool trustStrongForSolution() const + { return trustStrongForSolution_;} + /// Set trust results from strong branching for valid solution + inline void setTrustStrongForSolution(bool yesNo) + { trustStrongForSolution_ = yesNo;} + /// Set solver and redo arrays + void setSolver (const OsiSolverInterface * solver); + /** Return status - + -1 Node is infeasible + 0 Normal termination - we have a candidate + 1 All looks satisfied - no candidate + 2 We can change the bound on a variable - but we also have a strong branching candidate + 3 We can change the bound on a variable - but we have a non-strong branching candidate + 4 We can change the bound on a variable - no other candidates + We can pick up branch from bestObjectIndex() and bestWhichWay() + We can pick up a forced branch (can change bound) from firstForcedObjectIndex() and firstForcedWhichWay() + If we have a solution then we can pick up from goodObjectiveValue() and goodSolution() + */ + inline int status() const + { return status_;} + inline void setStatus(int value) + { status_ = value;} + + +protected: + // Data + /// Objective value for feasible solution + double goodObjectiveValue_; + /// Estimate of up change or change on chosen if n-way + double upChange_; + /// Estimate of down change or max change on other possibilities if n-way + double downChange_; + /// Good solution - deleted by finalize + double * goodSolution_; + /// List of candidates + int * list_; + /// Useful array (for sorting etc) + double * useful_; + /// Pointer to solver + const OsiSolverInterface * solver_; + /* Status - + -1 Node is infeasible + 0 Normal termination - we have a candidate + 1 All looks satisfied - no candidate + 2 We can change the bound on a variable - but we also have a strong branching candidate + 3 We can change the bound on a variable - but we have a non-strong branching candidate + 4 We can change the bound on a variable - no other candidates + */ + int status_; + /// Index of chosen object + int bestObjectIndex_; + /// Preferred way of chosen object + int bestWhichWay_; + /// Index of forced object + int firstForcedObjectIndex_; + /// Preferred way of forced object + int firstForcedWhichWay_; + /// The number of objects unsatisfied at this node. + int numberUnsatisfied_; + /// Number of objects to choose for strong branching + int numberStrong_; + /// Number left on strong list + int numberOnList_; + /// Number of strong branches actually done + int numberStrongDone_; + /// Number of strong iterations actually done + int numberStrongIterations_; + /// Number of bound changes due to strong branching + int numberStrongFixed_; + /// List of unsatisfied objects - first numberOnList_ for strong branching + /// Trust results from strong branching for changing bounds + bool trustStrongForBound_; + /// Trust results from strong branching for valid solution + bool trustStrongForSolution_; +}; + +/** This class is the placeholder for the pseudocosts used by OsiChooseStrong. + It can also be used by any other pseudocost based strong branching + algorithm. +*/ + +class OsiPseudoCosts { +protected: + // Data + /// Total of all changes up + double * upTotalChange_; + /// Total of all changes down + double * downTotalChange_; + /// Number of times up + int * upNumber_; + /// Number of times down + int * downNumber_; + /// Number of objects (could be found from solver) + int numberObjects_; + /// Number before we trust + int numberBeforeTrusted_; + +private: + void gutsOfDelete(); + void gutsOfCopy(const OsiPseudoCosts& rhs); + +public: + OsiPseudoCosts(); + virtual ~OsiPseudoCosts(); + OsiPseudoCosts(const OsiPseudoCosts& rhs); + OsiPseudoCosts& operator=(const OsiPseudoCosts& rhs); + + /// Number of times before trusted + inline int numberBeforeTrusted() const + { return numberBeforeTrusted_; } + /// Set number of times before trusted + inline void setNumberBeforeTrusted(int value) + { numberBeforeTrusted_ = value; } + /// Initialize the pseudocosts with n entries + void initialize(int n); + /// Give the number of objects for which pseudo costs are stored + inline int numberObjects() const + { return numberObjects_; } + + /** @name Accessor methods to pseudo costs data */ + //@{ + inline double* upTotalChange() { return upTotalChange_; } + inline const double* upTotalChange() const { return upTotalChange_; } + + inline double* downTotalChange() { return downTotalChange_; } + inline const double* downTotalChange() const { return downTotalChange_; } + + inline int* upNumber() { return upNumber_; } + inline const int* upNumber() const { return upNumber_; } + + inline int* downNumber() { return downNumber_; } + inline const int* downNumber() const { return downNumber_; } + //@} + + /// Given a candidate fill in useful information e.g. estimates + virtual void updateInformation(const OsiBranchingInformation *info, + int branch, OsiHotInfo * hotInfo); +#if 1 + /// Given a branch fill in useful information e.g. estimates + virtual void updateInformation( int whichObject, int branch, + double changeInObjective, double changeInValue, + int status); +#endif +}; + +/** This class chooses a variable to branch on + + This chooses the variable and direction with reliability strong branching. + + The flow is : + a) initialize the process. This decides on strong branching list + and stores indices of all infeasible objects + b) do strong branching on list. If list is empty then just + choose one candidate and return without strong branching. If not empty then + go through list and return best. However we may find that the node is infeasible + or that we can fix a variable. If so we return and it is up to user to call + again (after fixing a variable). +*/ + +class OsiChooseStrong : public OsiChooseVariable { + +public: + + /// Default Constructor + OsiChooseStrong (); + + /// Constructor from solver (so we can set up arrays etc) + OsiChooseStrong (const OsiSolverInterface * solver); + + /// Copy constructor + OsiChooseStrong (const OsiChooseStrong &); + + /// Assignment operator + OsiChooseStrong & operator= (const OsiChooseStrong& rhs); + + /// Clone + virtual OsiChooseVariable * clone() const; + + /// Destructor + virtual ~OsiChooseStrong (); + + /** Sets up strong list and clears all if initialize is true. + Returns number of infeasibilities. + If returns -1 then has worked out node is infeasible! + */ + virtual int setupList ( OsiBranchingInformation *info, bool initialize); + /** Choose a variable + Returns - + -1 Node is infeasible + 0 Normal termination - we have a candidate + 1 All looks satisfied - no candidate + 2 We can change the bound on a variable - but we also have a strong branching candidate + 3 We can change the bound on a variable - but we have a non-strong branching candidate + 4 We can change the bound on a variable - no other candidates + We can pick up branch from bestObjectIndex() and bestWhichWay() + We can pick up a forced branch (can change bound) from firstForcedObjectIndex() and firstForcedWhichWay() + If we have a solution then we can pick up from goodObjectiveValue() and goodSolution() + If fixVariables is true then 2,3,4 are all really same as problem changed + */ + virtual int chooseVariable( OsiSolverInterface * solver, OsiBranchingInformation *info, bool fixVariables); + + /** Pseudo Shadow Price mode + 0 - off + 1 - use if no strong info + 2 - use if strong not trusted + 3 - use even if trusted + */ + inline int shadowPriceMode() const + { return shadowPriceMode_;} + /// Set Shadow price mode + inline void setShadowPriceMode(int value) + { shadowPriceMode_ = value;} + + /** Accessor method to pseudo cost object*/ + const OsiPseudoCosts& pseudoCosts() const + { return pseudoCosts_; } + + /** Accessor method to pseudo cost object*/ + OsiPseudoCosts& pseudoCosts() + { return pseudoCosts_; } + + /** A feww pass-through methods to access members of pseudoCosts_ as if they + were members of OsiChooseStrong object */ + inline int numberBeforeTrusted() const { + return pseudoCosts_.numberBeforeTrusted(); } + inline void setNumberBeforeTrusted(int value) { + pseudoCosts_.setNumberBeforeTrusted(value); } + inline int numberObjects() const { + return pseudoCosts_.numberObjects(); } + +protected: + + /** This is a utility function which does strong branching on + a list of objects and stores the results in OsiHotInfo.objects. + On entry the object sequence is stored in the OsiHotInfo object + and maybe more. + It returns - + -1 - one branch was infeasible both ways + 0 - all inspected - nothing can be fixed + 1 - all inspected - some can be fixed (returnCriterion==0) + 2 - may be returning early - one can be fixed (last one done) (returnCriterion==1) + 3 - returning because max time + + */ + int doStrongBranching( OsiSolverInterface * solver, + OsiBranchingInformation *info, + int numberToDo, int returnCriterion); + + /** Clear out the results array */ + void resetResults(int num); + +protected: + /** Pseudo Shadow Price mode + 0 - off + 1 - use and multiply by strong info + 2 - use + */ + int shadowPriceMode_; + + /** The pseudo costs for the chooser */ + OsiPseudoCosts pseudoCosts_; + + /** The results of the strong branching done on the candidates where the + pseudocosts were not sufficient */ + OsiHotInfo* results_; + /** The number of OsiHotInfo objetcs that contain information */ + int numResults_; +}; + +/** This class contains the result of strong branching on a variable + When created it stores enough information for strong branching +*/ + +class OsiHotInfo { + +public: + + /// Default Constructor + OsiHotInfo (); + + /// Constructor from useful information + OsiHotInfo ( OsiSolverInterface * solver, + const OsiBranchingInformation *info, + const OsiObject * const * objects, + int whichObject); + + /// Copy constructor + OsiHotInfo (const OsiHotInfo &); + + /// Assignment operator + OsiHotInfo & operator= (const OsiHotInfo& rhs); + + /// Clone + virtual OsiHotInfo * clone() const; + + /// Destructor + virtual ~OsiHotInfo (); + + /** Fill in useful information after strong branch. + Return status + */ + int updateInformation( const OsiSolverInterface * solver, const OsiBranchingInformation * info, + OsiChooseVariable * choose); + /// Original objective value + inline double originalObjectiveValue() const + { return originalObjectiveValue_;} + /// Up change - invalid if n-way + inline double upChange() const + { assert (branchingObject_->numberBranches()==2); return changes_[1];} + /// Down change - invalid if n-way + inline double downChange() const + { assert (branchingObject_->numberBranches()==2); return changes_[0];} + /// Set up change - invalid if n-way + inline void setUpChange(double value) + { assert (branchingObject_->numberBranches()==2); changes_[1] = value;} + /// Set down change - invalid if n-way + inline void setDownChange(double value) + { assert (branchingObject_->numberBranches()==2); changes_[0] = value;} + /// Change on way k + inline double change(int k) const + { return changes_[k];} + + /// Up iteration count - invalid if n-way + inline int upIterationCount() const + { assert (branchingObject_->numberBranches()==2); return iterationCounts_[1];} + /// Down iteration count - invalid if n-way + inline int downIterationCount() const + { assert (branchingObject_->numberBranches()==2); return iterationCounts_[0];} + /// Iteration count on way k + inline int iterationCount(int k) const + { return iterationCounts_[k];} + + /// Up status - invalid if n-way + inline int upStatus() const + { assert (branchingObject_->numberBranches()==2); return statuses_[1];} + /// Down status - invalid if n-way + inline int downStatus() const + { assert (branchingObject_->numberBranches()==2); return statuses_[0];} + /// Set up status - invalid if n-way + inline void setUpStatus(int value) + { assert (branchingObject_->numberBranches()==2); statuses_[1] = value;} + /// Set down status - invalid if n-way + inline void setDownStatus(int value) + { assert (branchingObject_->numberBranches()==2); statuses_[0] = value;} + /// Status on way k + inline int status(int k) const + { return statuses_[k];} + /// Branching object + inline OsiBranchingObject * branchingObject() const + { return branchingObject_;} + inline int whichObject() const + { return whichObject_;} + +protected: + // Data + /// Original objective value + double originalObjectiveValue_; + /// Objective changes + double * changes_; + /// Iteration counts + int * iterationCounts_; + /** Status + -1 - not done + 0 - feasible and finished + 1 - infeasible + 2 - not finished + */ + int * statuses_; + /// Branching object + OsiBranchingObject * branchingObject_; + /// Which object on list + int whichObject_; +}; + + +#endif diff --git a/thirdparty/windows/include/coin/OsiClpSolverInterface.hpp b/thirdparty/windows/include/coin/OsiClpSolverInterface.hpp new file mode 100644 index 0000000..ebc7e64 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiClpSolverInterface.hpp @@ -0,0 +1,1509 @@ +// $Id$ +// 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 OsiClpSolverInterface_H +#define OsiClpSolverInterface_H + +#include <string> +#include <cfloat> +#include <map> + +#include "ClpSimplex.hpp" +#include "ClpLinearObjective.hpp" +#include "CoinPackedMatrix.hpp" +#include "OsiSolverInterface.hpp" +#include "CoinWarmStartBasis.hpp" +#include "ClpEventHandler.hpp" +#include "ClpNode.hpp" +#include "CoinIndexedVector.hpp" +#include "CoinFinite.hpp" + +class OsiRowCut; +class OsiClpUserSolver; +class OsiClpDisasterHandler; +class CoinSet; +static const double OsiClpInfinity = COIN_DBL_MAX; + +//############################################################################# + +/** Clp Solver Interface + +Instantiation of OsiClpSolverInterface for the Model Algorithm. + +*/ + +class OsiClpSolverInterface : + virtual public OsiSolverInterface { + friend void OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir); + +public: + //--------------------------------------------------------------------------- + /**@name Solve methods */ + //@{ + /// Solve initial LP relaxation + virtual void initialSolve(); + + /// Resolve an LP relaxation after problem modification + virtual void resolve(); + + /// Resolve an LP relaxation after problem modification (try GUB) + virtual void resolveGub(int needed); + + /// Invoke solver's built-in enumeration algorithm + virtual void branchAndBound(); + + /** Solve when primal column and dual row solutions are near-optimal + options - 0 no presolve (use primal and dual) + 1 presolve (just use primal) + 2 no presolve (just use primal) + basis - 0 use all slack basis + 1 try and put some in basis + */ + void crossover(int options,int basis); + //@} + + /*! @name OsiSimplexInterface methods + \brief Methods for the Osi Simplex API. + + The current implementation should work for both minimisation and + maximisation in mode 1 (tableau access). In mode 2 (single pivot), only + minimisation is supported as of 100907. + */ + //@{ + /** \brief Simplex API capability. + + Returns + - 0 if no simplex API + - 1 if can just do getBInv etc + - 2 if has all OsiSimplex methods + */ + virtual int canDoSimplexInterface() const; + + /*! \brief Enables simplex mode 1 (tableau access) + + Tells solver that calls to getBInv etc are about to take place. + Underlying code may need mutable as this may be called from + CglCut::generateCuts which is const. If that is too horrific then + each solver e.g. BCP or CBC will have to do something outside + main loop. + */ + virtual void enableFactorization() const; + + /*! \brief Undo any setting changes made by #enableFactorization */ + virtual void disableFactorization() const; + + /** Returns true if a basis is available + AND problem is optimal. This should be used to see if + the BInvARow type operations are possible and meaningful. + */ + virtual bool basisIsAvailable() const; + + /** The following two methods may be replaced by the + methods of OsiSolverInterface using OsiWarmStartBasis if: + 1. OsiWarmStartBasis resize operation is implemented + more efficiently and + 2. It is ensured that effects on the solver are the same + + Returns a basis status of the structural/artificial variables + At present as warm start i.e 0 free, 1 basic, 2 upper, 3 lower + + NOTE artificials are treated as +1 elements so for <= rhs + artificial will be at lower bound if constraint is tight + + This means that Clpsimplex flips artificials as it works + in terms of row activities + */ + virtual void getBasisStatus(int* cstat, int* rstat) const; + + /** Set the status of structural/artificial variables and + factorize, update solution etc + + NOTE artificials are treated as +1 elements so for <= rhs + artificial will be at lower bound if constraint is tight + + This means that Clpsimplex flips artificials as it works + in terms of row activities + Returns 0 if OK, 1 if problem is bad e.g. duplicate elements, too large ... + */ + virtual int setBasisStatus(const int* cstat, const int* rstat); + + ///Get the reduced gradient for the cost vector c + virtual void getReducedGradient(double* columnReducedCosts, + double * duals, + const double * c) const ; + + ///Get a row of the tableau (slack part in slack if not NULL) + virtual void getBInvARow(int row, double* z, double * slack=NULL) const; + + /** Get a row of the tableau (slack part in slack if not NULL) + If keepScaled is true then scale factors not applied after so + user has to use coding similar to what is in this method + */ + virtual void getBInvARow(int row, CoinIndexedVector * z, CoinIndexedVector * slack=NULL, + bool keepScaled=false) const; + + ///Get a row of the basis inverse + virtual void getBInvRow(int row, double* z) const; + + ///Get a column of the tableau + virtual void getBInvACol(int col, double* vec) const ; + + ///Get a column of the tableau + virtual void getBInvACol(int col, CoinIndexedVector * vec) const ; + + /** Update (i.e. ftran) the vector passed in. + Unscaling is applied after - can't be applied before + */ + + virtual void getBInvACol(CoinIndexedVector * vec) const ; + + ///Get a column of the basis inverse + virtual void getBInvCol(int col, double* vec) const ; + + /** Get basic indices (order of indices corresponds to the + order of elements in a vector retured by getBInvACol() and + getBInvCol()). + */ + virtual void getBasics(int* index) const; + + /*! \brief Enables simplex mode 2 (individual pivot control) + + This method is supposed to ensure that all typical things (like + reduced costs, etc.) are updated when individual pivots are executed + and can be queried by other methods. + */ + virtual void enableSimplexInterface(bool doingPrimal); + /// Copy across enabled stuff from one solver to another + void copyEnabledSuff(OsiClpSolverInterface & rhs); + + /*! \brief Undo setting changes made by #enableSimplexInterface */ + virtual void disableSimplexInterface(); + /// Copy across enabled stuff from one solver to another + void copyEnabledStuff(ClpSimplex & rhs); + + /** Perform a pivot by substituting a colIn for colOut in the basis. + The status of the leaving variable is given in statOut. Where + 1 is to upper bound, -1 to lower bound + Return code is 0 for okay, + 1 if inaccuracy forced re-factorization (should be okay) and + -1 for singular factorization + */ + virtual int pivot(int colIn, int colOut, int outStatus); + + /** Obtain a result of the primal pivot + Outputs: colOut -- leaving column, outStatus -- its status, + t -- step size, and, if dx!=NULL, *dx -- primal ray direction. + Inputs: colIn -- entering column, sign -- direction of its change (+/-1). + Both for colIn and colOut, artificial variables are index by + the negative of the row index minus 1. + Return code (for now): 0 -- leaving variable found, + -1 -- everything else? + Clearly, more informative set of return values is required + Primal and dual solutions are updated + */ + virtual int primalPivotResult(int colIn, int sign, + int& colOut, int& outStatus, + double& t, CoinPackedVector* dx); + + /** Obtain a result of the dual pivot (similar to the previous method) + Differences: entering variable and a sign of its change are now + the outputs, the leaving variable and its statuts -- the inputs + If dx!=NULL, then *dx contains dual ray + Return code: same + */ + virtual int dualPivotResult(int& colIn, int& sign, + int colOut, int outStatus, + double& t, CoinPackedVector* dx); + + + //@} + //--------------------------------------------------------------------------- + /**@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 clp 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. + */ + //@{ + // Set an integer parameter + bool setIntParam(OsiIntParam key, int value); + // Set an double parameter + bool setDblParam(OsiDblParam key, double value); + // Set a string parameter + bool setStrParam(OsiStrParam key, const std::string & value); + // Get an integer parameter + bool getIntParam(OsiIntParam key, int& value) const; + // Get an double parameter + bool getDblParam(OsiDblParam key, double& value) const; + // Get a string parameter + bool getStrParam(OsiStrParam key, std::string& value) const; + // Set a hint parameter - overrides OsiSolverInterface + virtual bool setHintParam(OsiHintParam key, bool yesNo=true, + OsiHintStrength strength=OsiHintTry, + void * otherInformation=NULL); + //@} + + //--------------------------------------------------------------------------- + ///@name Methods returning info on how the solution process terminated + //@{ + /// Are there a numerical difficulties? + virtual bool isAbandoned() const; + /// Is optimality proven? + virtual bool isProvenOptimal() const; + /// Is primal infeasiblity proven? + virtual bool isProvenPrimalInfeasible() const; + /// Is dual infeasiblity proven? + virtual bool isProvenDualInfeasible() const; + /// Is the given primal objective limit reached? + virtual bool isPrimalObjectiveLimitReached() const; + /// Is the given dual objective limit reached? + virtual bool isDualObjectiveLimitReached() const; + /// Iteration limit reached? + virtual bool isIterationLimitReached() const; + //@} + + //--------------------------------------------------------------------------- + /**@name WarmStart related methods */ + //@{ + + /*! \brief Get an empty warm start object + + This routine returns an empty CoinWarmStartBasis object. Its purpose is + to provide a way to give a client a warm start basis object of the + appropriate type, which can resized and modified as desired. + */ + + virtual CoinWarmStart *getEmptyWarmStart () const; + + /// Get warmstarting information + virtual CoinWarmStart* getWarmStart() const; + /// Get warmstarting information + inline CoinWarmStartBasis* getPointerToWarmStart() + { return &basis_;} + /// Get warmstarting information + inline const CoinWarmStartBasis* getConstPointerToWarmStart() const + { return &basis_;} + /** Set warmstarting information. Return true/false depending on whether + the warmstart information was accepted or not. */ + virtual bool setWarmStart(const CoinWarmStart* warmstart); + /** \brief Get warm start information. + + Return warm start information for the current state of the solver + interface. If there is no valid warm start information, an empty warm + start object wil be returned. This does not necessarily create an + object - may just point to one. must Delete set true if user + should delete returned object. + OsiClp version always returns pointer and false. + */ + virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ; + + /// Set column status in ClpSimplex and warmStart + void setColumnStatus(int iColumn, ClpSimplex::Status status); + + //@} + + //--------------------------------------------------------------------------- + /**@name Hotstart related methods (primarily used in strong branching). + The user can create a hotstart (a snapshot) of the optimization process + then reoptimize over and over again always starting from there.<br> + <strong>NOTE</strong>: between hotstarted optimizations only + bound changes are allowed. */ + //@{ + /// Create a hotstart point of the optimization process + virtual void markHotStart(); + /// Optimize starting from the hotstart + virtual void solveFromHotStart(); + /// Delete the snapshot + virtual void unmarkHotStart(); + /** Start faster dual - returns negative if problems 1 if infeasible, + 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 + When set resolve does less work + */ + int startFastDual(int options); + /// Stop fast dual + void stopFastDual(); + /// Sets integer tolerance and increment + void setStuff(double tolerance,double increment); + /// Return a conflict analysis cut from small model + OsiRowCut * smallModelCut(const double * originalLower, const double * originalUpper, + int numberRowsAtContinuous,const int * whichGenerator, + int typeCut=0); + /** Return a conflict analysis cut from model + If type is 0 then genuine cut, if 1 then only partially processed + */ + OsiRowCut * modelCut(const double * originalLower, const double * originalUpper, + int numberRowsAtContinuous,const int * whichGenerator, + int typeCut=0); + //@} + + //--------------------------------------------------------------------------- + /**@name Problem information methods + + These methods call the solver's query routines to return + information about the problem referred to by the current object. + Querying a problem that has no data associated with it result in + zeros for the number of rows and columns, and NULL pointers from + the methods that return vectors. + + Const pointers returned from any data-query method are valid as + long as the data is unchanged and the solver is not called. + */ + //@{ + /**@name Methods related to querying the input data */ + //@{ + /// Get number of columns + virtual int getNumCols() const { + return modelPtr_->numberColumns(); } + + /// Get number of rows + virtual int getNumRows() const { + return modelPtr_->numberRows(); } + + /// Get number of nonzero elements + virtual int getNumElements() const { + int retVal = 0; + const CoinPackedMatrix * matrix =modelPtr_->matrix(); + if ( matrix != NULL ) retVal=matrix->getNumElements(); + return retVal; } + + /// Return name of row if one exists or Rnnnnnnn + /// maxLen is currently ignored and only there to match the signature from the base class! + virtual std::string getRowName(int rowIndex, + unsigned maxLen = static_cast<unsigned>(std::string::npos)) const; + + /// Return name of column if one exists or Cnnnnnnn + /// maxLen is currently ignored and only there to match the signature from the base class! + virtual std::string getColName(int colIndex, + unsigned maxLen = static_cast<unsigned>(std::string::npos)) const; + + + /// Get pointer to array[getNumCols()] of column lower bounds + virtual const double * getColLower() const { return modelPtr_->columnLower(); } + + /// Get pointer to array[getNumCols()] of column upper bounds + virtual const double * getColUpper() const { return modelPtr_->columnUpper(); } + + /** Get pointer to array[getNumRows()] of row constraint senses. + <ul> + <li>'L' <= constraint + <li>'E' = constraint + <li>'G' >= constraint + <li>'R' ranged constraint + <li>'N' free constraint + </ul> + */ + virtual const char * getRowSense() const; + + /** Get pointer to array[getNumRows()] of rows right-hand sides + <ul> + <li> if rowsense()[i] == 'L' then rhs()[i] == rowupper()[i] + <li> if rowsense()[i] == 'G' then rhs()[i] == rowlower()[i] + <li> if rowsense()[i] == 'R' then rhs()[i] == rowupper()[i] + <li> if rowsense()[i] == 'N' then rhs()[i] == 0.0 + </ul> + */ + virtual const double * getRightHandSide() const ; + + /** Get pointer to array[getNumRows()] of row ranges. + <ul> + <li> if rowsense()[i] == 'R' then + rowrange()[i] == rowupper()[i] - rowlower()[i] + <li> if rowsense()[i] != 'R' then + rowrange()[i] is undefined + </ul> + */ + virtual const double * getRowRange() const ; + + /// Get pointer to array[getNumRows()] of row lower bounds + virtual const double * getRowLower() const { return modelPtr_->rowLower(); } + + /// Get pointer to array[getNumRows()] of row upper bounds + virtual const double * getRowUpper() const { return modelPtr_->rowUpper(); } + + /// Get pointer to array[getNumCols()] of objective function coefficients + virtual const double * getObjCoefficients() const + { if (fakeMinInSimplex_) + return linearObjective_ ; + else + return modelPtr_->objective(); } + + /// Get objective function sense (1 for min (default), -1 for max) + virtual double getObjSense() const + { return ((fakeMinInSimplex_)?-modelPtr_->optimizationDirection(): + modelPtr_->optimizationDirection()); } + + /// Return true if column is continuous + virtual bool isContinuous(int colNumber) const; + /// Return true if variable is binary + virtual bool isBinary(int colIndex) const; + + /** Return true if column is integer. + Note: This function returns true if the the column + is binary or a general integer. + */ + virtual bool isInteger(int colIndex) const; + + /// Return true if variable is general integer + virtual bool isIntegerNonBinary(int colIndex) const; + + /// Return true if variable is binary and not fixed at either bound + virtual bool isFreeBinary(int colIndex) const; + /** Return array of column length + 0 - continuous + 1 - binary (may get fixed later) + 2 - general integer (may get fixed later) + */ + virtual const char * getColType(bool refresh=false) const; + + /** Return true if column is integer but does not have to + be declared as such. + Note: This function returns true if the the column + is binary or a general integer. + */ + bool isOptionalInteger(int colIndex) const; + /** Set the index-th variable to be an optional integer variable */ + void setOptionalInteger(int index); + + /// Get pointer to row-wise copy of matrix + virtual const CoinPackedMatrix * getMatrixByRow() const; + + /// Get pointer to column-wise copy of matrix + virtual const CoinPackedMatrix * getMatrixByCol() const; + + /// Get pointer to mutable column-wise copy of matrix + virtual CoinPackedMatrix * getMutableMatrixByCol() const; + + /// Get solver's value for infinity + virtual double getInfinity() const { return OsiClpInfinity; } + //@} + + /**@name Methods related to querying the solution */ + //@{ + /// Get pointer to array[getNumCols()] of primal solution vector + virtual const double * getColSolution() const; + + /// Get pointer to array[getNumRows()] of dual prices + virtual const double * getRowPrice() const; + + /// Get a pointer to array[getNumCols()] of reduced costs + virtual const double * getReducedCost() const; + + /** Get pointer to array[getNumRows()] of row activity levels (constraint + matrix times the solution vector */ + virtual const double * getRowActivity() const; + + /// Get objective function value + virtual double getObjValue() const; + + /** Get how many iterations it took to solve the problem (whatever + "iteration" mean to the solver. */ + virtual int getIterationCount() const + { return modelPtr_->numberIterations(); } + + /** Get as many dual rays as the solver can provide. (In case of proven + primal infeasibility there should be at least one.) + + The first getNumRows() ray components will always be associated with + the row duals (as returned by getRowPrice()). If \c fullRay is true, + the final getNumCols() entries will correspond to the ray components + associated with the nonbasic variables. If the full ray is requested + and the method cannot provide it, it will throw an exception. + + <strong>NOTE for implementers of solver interfaces:</strong> <br> + The double pointers in the vector should point to arrays of length + getNumRows() and they should be allocated via new[]. <br> + + <strong>NOTE for users of solver interfaces:</strong> <br> + It is the user's responsibility to free the double pointers in the + vector using delete[]. + */ + virtual std::vector<double*> getDualRays(int maxNumRays, + bool fullRay = false) const; + /** Get as many primal rays as the solver can provide. (In case of proven + dual infeasibility there should be at least one.) + + <strong>NOTE for implementers of solver interfaces:</strong> <br> + The double pointers in the vector should point to arrays of length + getNumCols() and they should be allocated via new[]. <br> + + <strong>NOTE for users of solver interfaces:</strong> <br> + It is the user's responsibility to free the double pointers in the + vector using delete[]. + */ + virtual std::vector<double*> getPrimalRays(int maxNumRays) const; + + //@} + //@} + + //--------------------------------------------------------------------------- + + /**@name Problem modifying methods */ + //@{ + //------------------------------------------------------------------------- + /**@name Changing bounds on variables and constraints */ + //@{ + /** Set an objective function coefficient */ + virtual void setObjCoeff( int elementIndex, double elementValue ); + + /** Set a single column lower bound<br> + Use -DBL_MAX for -infinity. */ + virtual void setColLower( int elementIndex, double elementValue ); + + /** Set a single column upper bound<br> + Use DBL_MAX for infinity. */ + virtual void setColUpper( int elementIndex, double elementValue ); + + /** Set a single column lower and upper bound */ + virtual void setColBounds( int elementIndex, + double lower, double upper ); + + /** Set the bounds on a number of columns simultaneously<br> + 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 + <em>either</em> bound changes + @param boundList the new lower/upper bound pairs for the variables + */ + virtual void setColSetBounds(const int* indexFirst, + const int* indexLast, + const double* boundList); + + /** Set a single row lower bound<br> + Use -DBL_MAX for -infinity. */ + virtual void setRowLower( int elementIndex, double elementValue ); + + /** Set a single row upper bound<br> + Use DBL_MAX for infinity. */ + virtual void setRowUpper( int elementIndex, double elementValue ) ; + + /** Set a single row lower and upper bound */ + virtual void setRowBounds( int elementIndex, + double lower, double upper ) ; + + /** Set the type of a single row<br> */ + virtual void setRowType(int index, char sense, double rightHandSide, + double range); + + /** Set the bounds on a number of rows simultaneously<br> + The default implementation just invokes setRowLower() and + setRowUpper() over and over again. + @param indexFirst,indexLast pointers to the beginning and after the + end of the array of the indices of the constraints whose + <em>either</em> bound changes + @param boundList the new lower/upper bound pairs for the constraints + */ + virtual void setRowSetBounds(const int* indexFirst, + const int* indexLast, + const double* boundList); + + /** Set the type of a number of rows simultaneously<br> + The default implementation just invokes setRowType() + over and over again. + @param indexFirst,indexLast pointers to the beginning and after the + end of the array of the indices of the constraints whose + <em>any</em> characteristics changes + @param senseList the new senses + @param rhsList the new right hand sides + @param rangeList the new ranges + */ + virtual void setRowSetTypes(const int* indexFirst, + const int* indexLast, + const char* senseList, + const double* rhsList, + const double* rangeList); + /** Set the objective coefficients for all columns + array [getNumCols()] is an array of values for the objective. + This defaults to a series of set operations and is here for speed. + */ + virtual void setObjective(const double * array); + + /** Set the lower bounds for all columns + array [getNumCols()] is an array of values for the objective. + This defaults to a series of set operations and is here for speed. + */ + virtual void setColLower(const double * array); + + /** Set the upper bounds for all columns + array [getNumCols()] is an array of values for the objective. + This defaults to a series of set operations and is here for speed. + */ + virtual void setColUpper(const double * array); + +// using OsiSolverInterface::setRowName ; + /// Set name of row +// virtual void setRowName(int rowIndex, std::string & name) ; + virtual void setRowName(int rowIndex, std::string name) ; + +// using OsiSolverInterface::setColName ; + /// Set name of column +// virtual void setColName(int colIndex, std::string & name) ; + virtual void setColName(int colIndex, std::string name) ; + + //@} + + //------------------------------------------------------------------------- + /**@name Integrality related changing methods */ + //@{ + /** Set the index-th variable to be a continuous variable */ + virtual void setContinuous(int index); + /** Set the index-th variable to be an integer variable */ + virtual void setInteger(int index); + /** Set the variables listed in indices (which is of length len) to be + continuous variables */ + virtual void setContinuous(const int* indices, int len); + /** Set the variables listed in indices (which is of length len) to be + integer variables */ + virtual void setInteger(const int* indices, int len); + /// Number of SOS sets + inline int numberSOS() const + { return numberSOS_;} + /// SOS set info + inline const CoinSet * setInfo() const + { return setInfo_;} + /** \brief Identify integer variables and SOS and create corresponding objects. + + Record integer variables and create an OsiSimpleInteger object for each + one. All existing OsiSimpleInteger objects will be destroyed. + If the solver supports SOS then do the same for SOS. + If justCount then no objects created and we just store numberIntegers_ + Returns number of SOS + */ + + virtual int findIntegersAndSOS(bool justCount); + //@} + + //------------------------------------------------------------------------- + /// Set objective function sense (1 for min (default), -1 for max,) + virtual void setObjSense(double s ) + { modelPtr_->setOptimizationDirection( s < 0 ? -1 : 1); } + + /** Set the primal solution column values + + colsol[numcols()] is an array of values of the problem column + variables. These values are copied to memory owned by the + solver object or the solver. They will be returned as the + result of colsol() until changed by another call to + setColsol() or by a call to any solver routine. Whether the + solver makes use of the solution in any way is + solver-dependent. + */ + virtual void setColSolution(const double * colsol); + + /** Set dual solution vector + + rowprice[numrows()] is an array of values of the problem row + dual variables. These values are copied to memory owned by the + solver object or the solver. They will be returned as the + result of rowprice() until changed by another call to + setRowprice() or by a call to any solver routine. Whether the + solver makes use of the solution in any way is + solver-dependent. + */ + virtual void setRowPrice(const double * rowprice); + + //------------------------------------------------------------------------- + /**@name Methods to expand a problem.<br> + Note that if a column is added then by default it will correspond to a + continuous variable. */ + //@{ + + //using OsiSolverInterface::addCol ; + /** */ + virtual void addCol(const CoinPackedVectorBase& vec, + const double collb, const double colub, + const double obj); + /*! \brief Add a named column (primal variable) to the problem. + */ + virtual void addCol(const CoinPackedVectorBase& vec, + const double collb, const double colub, + const double obj, std::string name) ; + /** Add a column (primal variable) to the problem. */ + virtual void addCol(int numberElements, const int * rows, const double * elements, + const double collb, const double colub, + const double obj) ; + /*! \brief Add a named column (primal variable) to the problem. + */ + virtual void addCol(int numberElements, + const int* rows, const double* elements, + const double collb, const double colub, + const double obj, std::string name) ; + /** */ + virtual void addCols(const int numcols, + const CoinPackedVectorBase * const * cols, + const double* collb, const double* colub, + const double* obj); + /** */ + virtual void addCols(const int numcols, + const int * columnStarts, const int * rows, const double * elements, + const double* collb, const double* colub, + const double* obj); + /** */ + virtual void deleteCols(const int num, const int * colIndices); + + /** */ + virtual void addRow(const CoinPackedVectorBase& vec, + const double rowlb, const double rowub); + /** */ + /*! \brief Add a named row (constraint) to the problem. + + The default implementation adds the row, then changes the name. This + can surely be made more efficient within an OsiXXX class. + */ + virtual void addRow(const CoinPackedVectorBase& vec, + const double rowlb, const double rowub, + std::string name) ; + virtual void addRow(const CoinPackedVectorBase& vec, + const char rowsen, const double rowrhs, + const double rowrng); + /** Add a row (constraint) to the problem. */ + virtual void addRow(int numberElements, const int * columns, const double * element, + const double rowlb, const double rowub) ; + /*! \brief Add a named row (constraint) to the problem. + */ + virtual void addRow(const CoinPackedVectorBase& vec, + const char rowsen, const double rowrhs, + const double rowrng, std::string name) ; + /** */ + virtual void addRows(const int numrows, + const CoinPackedVectorBase * const * rows, + const double* rowlb, const double* rowub); + /** */ + virtual void addRows(const int numrows, + const CoinPackedVectorBase * const * rows, + const char* rowsen, const double* rowrhs, + const double* rowrng); + + /** */ + virtual void addRows(const int numrows, + const int * rowStarts, const int * columns, const double * element, + const double* rowlb, const double* rowub); + /// + void modifyCoefficient(int row, int column, double newElement, + bool keepZero=false) + {modelPtr_->modifyCoefficient(row,column,newElement, keepZero);} + + /** */ + virtual void deleteRows(const int num, const int * rowIndices); + /** If solver wants it can save a copy of "base" (continuous) model here + */ + virtual void saveBaseModel() ; + /** Strip off rows to get to this number of rows. + If solver wants it can restore a copy of "base" (continuous) model here + */ + virtual void restoreBaseModel(int numberRows); + + //----------------------------------------------------------------------- + /** Apply a collection of row cuts which are all effective. + applyCuts seems to do one at a time which seems inefficient. + */ + virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts); + /** Apply a collection of row cuts which are all effective. + applyCuts seems to do one at a time which seems inefficient. + This uses array of pointers + */ + virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts); + /** Apply a collection of cuts. + + Only cuts which have an <code>effectiveness >= effectivenessLb</code> + are applied. + <ul> + <li> ReturnCode.getNumineffective() -- number of cuts which were + not applied because they had an + <code>effectiveness < effectivenessLb</code> + <li> ReturnCode.getNuminconsistent() -- number of invalid cuts + <li> ReturnCode.getNuminconsistentWrtIntegerModel() -- number of + cuts that are invalid with respect to this integer model + <li> ReturnCode.getNuminfeasible() -- number of cuts that would + make this integer model infeasible + <li> ReturnCode.getNumApplied() -- number of integer cuts which + were applied to the integer model + <li> cs.size() == getNumineffective() + + getNuminconsistent() + + getNuminconsistentWrtIntegerModel() + + getNuminfeasible() + + getNumApplied() + </ul> + */ + virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs, + double effectivenessLb = 0.0); + + //@} + //@} + + //--------------------------------------------------------------------------- + +public: + + /**@name Methods to input a problem */ + //@{ + /** Load in an problem by copying the arguments (the constraints on the + rows are given by lower and upper bounds). If a pointer is NULL then the + following values are the default: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>rowub</code>: all rows have upper bound infinity + <li> <code>rowlb</code>: all rows have lower bound -infinity + <li> <code>obj</code>: all variables have 0 objective coefficient + </ul> + */ + virtual void loadProblem(const CoinPackedMatrix& matrix, + const double* collb, const double* colub, + const double* obj, + const double* rowlb, const double* rowub); + + /** Load in an problem by assuming ownership of the arguments (the + constraints on the rows are given by lower and upper bounds). For + default values see the previous method. <br> + <strong>WARNING</strong>: The arguments passed to this method will be + freed using the C++ <code>delete</code> and <code>delete[]</code> + functions. + */ + virtual void assignProblem(CoinPackedMatrix*& matrix, + double*& collb, double*& colub, double*& obj, + double*& rowlb, double*& rowub); + + /** Load in an problem by copying the arguments (the constraints on the + rows are given by sense/rhs/range triplets). If a pointer is NULL then the + following values are the default: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>obj</code>: all variables have 0 objective coefficient + <li> <code>rowsen</code>: all rows are >= + <li> <code>rowrhs</code>: all right hand sides are 0 + <li> <code>rowrng</code>: 0 for the ranged rows + </ul> + */ + virtual void loadProblem(const CoinPackedMatrix& matrix, + const double* collb, const double* colub, + const double* obj, + const char* rowsen, const double* rowrhs, + const double* rowrng); + + /** Load in an problem by assuming ownership of the arguments (the + constraints on the rows are given by sense/rhs/range triplets). For + default values see the previous method. <br> + <strong>WARNING</strong>: The arguments passed to this method will be + freed using the C++ <code>delete</code> and <code>delete[]</code> + functions. + */ + virtual void assignProblem(CoinPackedMatrix*& matrix, + double*& collb, double*& colub, double*& obj, + char*& rowsen, double*& rowrhs, + double*& rowrng); + + /** Just like the other loadProblem() methods except that the matrix is + given as a ClpMatrixBase. */ + virtual void loadProblem(const ClpMatrixBase& matrix, + const double* collb, const double* colub, + const double* obj, + const double* rowlb, const double* rowub) ; + + /** Just like the other loadProblem() methods except that the matrix is + given in a standard column major ordered format (without gaps). */ + virtual 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); + + /** Just like the other loadProblem() methods except that the matrix is + given in a standard column major ordered format (without gaps). */ + virtual 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 char* rowsen, const double* rowrhs, + const double* rowrng); + /// This loads a model from a coinModel object - returns number of errors + virtual int loadFromCoinModel ( CoinModel & modelObject, bool keepSolution=false); + + using OsiSolverInterface::readMps ; + /** Read an mps file from the given filename (defaults to Osi reader) - returns + number of errors (see OsiMpsReader class) */ + virtual int readMps(const char *filename, + const char *extension = "mps") ; + /** Read an mps file from the given filename returns + number of errors (see OsiMpsReader class) */ + int readMps(const char *filename,bool keepNames,bool allowErrors); + /// Read an mps file + virtual int readMps (const char *filename, const char*extension, + int & numberSets, CoinSet ** & sets); + + /** Write the problem into an mps file of the given filename. + If objSense is non zero then -1.0 forces the code to write a + maximization objective and +1.0 to write a minimization one. + If 0.0 then solver can do what it wants */ + virtual void writeMps(const char *filename, + const char *extension = "mps", + double objSense=0.0) const; + /** Write the problem into an mps file of the given filename, + names may be null. formatType is + 0 - normal + 1 - extra accuracy + 2 - IEEE hex (later) + + Returns non-zero on I/O error + */ + virtual int writeMpsNative(const char *filename, + const char ** rowNames, const char ** columnNames, + int formatType=0,int numberAcross=2, + double objSense=0.0) const ; + /// Read file in LP format (with names) + virtual int readLp(const char *filename, const double epsilon = 1e-5); + /** Write the problem into an Lp file of the given filename. + If objSense is non zero then -1.0 forces the code to write a + maximization objective and +1.0 to write a minimization one. + If 0.0 then solver can do what it wants. + This version calls writeLpNative with names */ + virtual void writeLp(const char *filename, + const char *extension = "lp", + double epsilon = 1e-5, + int numberAcross = 10, + int decimals = 5, + double objSense = 0.0, + bool useRowNames = true) const; + /** Write the problem into the file pointed to by the parameter fp. + Other parameters are similar to + those of writeLp() with first parameter filename. + */ + virtual void writeLp(FILE *fp, + double epsilon = 1e-5, + int numberAcross = 10, + int decimals = 5, + double objSense = 0.0, + bool useRowNames = true) const; + /** + I (JJF) am getting annoyed because I can't just replace a matrix. + The default behavior of this is do nothing so only use where that would not matter + e.g. strengthening a matrix for MIP + */ + virtual void replaceMatrixOptional(const CoinPackedMatrix & matrix); + /// And if it does matter (not used at present) + virtual void replaceMatrix(const CoinPackedMatrix & matrix) ; + //@} + + /**@name Message handling (extra for Clp messages). + Normally I presume you would want the same language. + If not then you could use underlying model pointer */ + //@{ + /** Pass in a message handler + + It is the client's responsibility to destroy a message handler installed + by this routine; it will not be destroyed when the solver interface is + destroyed. + */ + virtual void passInMessageHandler(CoinMessageHandler * handler); + /// Set language + void newLanguage(CoinMessages::Language language); + void setLanguage(CoinMessages::Language language) + {newLanguage(language);} + /// Set log level (will also set underlying solver's log level) + void setLogLevel(int value); + /// Create C++ lines to get to current state + void generateCpp( FILE * fp); + //@} + //--------------------------------------------------------------------------- + + /**@name Clp specific public interfaces */ + //@{ + /// Get pointer to Clp model + ClpSimplex * getModelPtr() const ; + /// Set pointer to Clp model and return old + inline ClpSimplex * swapModelPtr(ClpSimplex * newModel) + { ClpSimplex * model = modelPtr_; modelPtr_=newModel;return model;} + /// Get special options + inline unsigned int specialOptions() const + { return specialOptions_;} + void setSpecialOptions(unsigned int value); + /// Last algorithm used , 1 = primal, 2 = dual other unknown + inline int lastAlgorithm() const + { return lastAlgorithm_;} + /// Set last algorithm used , 1 = primal, 2 = dual other unknown + inline void setLastAlgorithm(int value) + { lastAlgorithm_ = value;} + /// Get scaling action option + inline int cleanupScaling() const + { return cleanupScaling_;} + /** Set Scaling option + When scaling is on it is possible that the scaled problem + is feasible but the unscaled is not. Clp returns a secondary + status code to that effect. This option allows for a cleanup. + If you use it I would suggest 1. + This only affects actions when scaled optimal + 0 - no action + 1 - clean up using dual if primal infeasibility + 2 - clean up using dual if dual infeasibility + 3 - clean up using dual if primal or dual infeasibility + 11,12,13 - as 1,2,3 but use primal + */ + inline void setCleanupScaling(int value) + { cleanupScaling_=value;} + /** Get smallest allowed element in cut. + If smaller than this then ignored */ + inline double smallestElementInCut() const + { return smallestElementInCut_;} + /** Set smallest allowed element in cut. + If smaller than this then ignored */ + inline void setSmallestElementInCut(double value) + { smallestElementInCut_=value;} + /** Get smallest change in cut. + If (upper-lower)*element < this then element is + taken out and cut relaxed. + (upper-lower) is taken to be at least 1.0 and + this is assumed >= smallestElementInCut_ + */ + inline double smallestChangeInCut() const + { return smallestChangeInCut_;} + /** Set smallest change in cut. + If (upper-lower)*element < this then element is + taken out and cut relaxed. + (upper-lower) is taken to be at least 1.0 and + this is assumed >= smallestElementInCut_ + */ + inline void setSmallestChangeInCut(double value) + { smallestChangeInCut_=value;} + /// Pass in initial solve options + inline void setSolveOptions(const ClpSolve & options) + { solveOptions_ = options;} + /** Tighten bounds - lightweight or very lightweight + 0 - normal, 1 lightweight but just integers, 2 lightweight and all + */ + virtual int tightenBounds(int lightweight=0); + /// See if any integer variables make infeasible other way + int infeasibleOtherWay(char * whichWay); + /// Return number of entries in L part of current factorization + virtual CoinBigIndex getSizeL() const; + /// Return number of entries in U part of current factorization + virtual CoinBigIndex getSizeU() const; + /// Get disaster handler + const OsiClpDisasterHandler * disasterHandler() const + { return disasterHandler_;} + /// Pass in disaster handler + void passInDisasterHandler(OsiClpDisasterHandler * handler); + /// Get fake objective + ClpLinearObjective * fakeObjective() const + { return fakeObjective_;} + /// Set fake objective (and take ownership) + void setFakeObjective(ClpLinearObjective * fakeObjective); + /// Set fake objective + void setFakeObjective(double * fakeObjective); + /*! \brief Set up solver for repeated use by Osi interface. + + The normal usage does things like keeping factorization around so can be + used. Will also do things like keep scaling and row copy of matrix if + matrix does not change. + + \p senseOfAdventure: + - 0 - safe stuff as above + - 1 - will take more risks - if it does not work then bug which will be + fixed + - 2 - don't bother doing most extreme termination checks e.g. don't bother + re-factorizing if less than 20 iterations. + - 3 - Actually safer than 1 (mainly just keeps factorization) + + \p printOut + - -1 always skip round common messages instead of doing some work + - 0 skip if normal defaults + - 1 leaves + */ + void setupForRepeatedUse(int senseOfAdventure=0, int printOut=0); + /// Synchronize model (really if no cuts in tree) + virtual void synchronizeModel(); + /*! \brief Set special options in underlying clp solver. + + Safe as const because #modelPtr_ is mutable. + */ + void setSpecialOptionsMutable(unsigned int value) const; + + //@} + + //--------------------------------------------------------------------------- + + /**@name Constructors and destructors */ + //@{ + /// Default Constructor + OsiClpSolverInterface (); + + /// Clone + virtual OsiSolverInterface * clone(bool copyData = true) const; + + /// Copy constructor + OsiClpSolverInterface (const OsiClpSolverInterface &); + + /// Borrow constructor - only delete one copy + OsiClpSolverInterface (ClpSimplex * rhs, bool reallyOwn=false); + + /// Releases so won't error + void releaseClp(); + + /// Assignment operator + OsiClpSolverInterface & operator=(const OsiClpSolverInterface& rhs); + + /// Destructor + virtual ~OsiClpSolverInterface (); + + /// Resets as if default constructor + virtual void reset(); + //@} + + //--------------------------------------------------------------------------- + +protected: + ///@name Protected methods + //@{ + /** Apply a row cut (append to constraint matrix). */ + virtual void applyRowCut(const OsiRowCut& rc); + + /** Apply a column cut (adjust one or more bounds). */ + virtual void applyColCut(const OsiColCut& cc); + //@} + + //--------------------------------------------------------------------------- + +protected: + /**@name Protected methods */ + //@{ + /// The real work of a copy constructor (used by copy and assignment) + void gutsOfDestructor(); + + /// Deletes all mutable stuff + void freeCachedResults() const; + + /// Deletes all mutable stuff for row ranges etc + void freeCachedResults0() const; + + /// Deletes all mutable stuff for matrix etc + void freeCachedResults1() const; + + /// A method that fills up the rowsense_, rhs_ and rowrange_ arrays + void extractSenseRhsRange() const; + + /// + void fillParamMaps(); + /** Warm start + + NOTE artificials are treated as +1 elements so for <= rhs + artificial will be at lower bound if constraint is tight + + This means that Clpsimplex flips artificials as it works + in terms of row activities + */ + CoinWarmStartBasis getBasis(ClpSimplex * model) const; + /** Sets up working basis as a copy of input + + NOTE artificials are treated as +1 elements so for <= rhs + artificial will be at lower bound if constraint is tight + + This means that Clpsimplex flips artificials as it works + in terms of row activities + */ + void setBasis( const CoinWarmStartBasis & basis, ClpSimplex * model); + /// Crunch down problem a bit + void crunch(); + /// Extend scale factors + void redoScaleFactors(int numberRows,const CoinBigIndex * starts, + const int * indices, const double * elements); +public: + /** Sets up working basis as a copy of input and puts in as basis + */ + void setBasis( const CoinWarmStartBasis & basis); + /// Just puts current basis_ into ClpSimplex model + inline void setBasis( ) + { setBasis(basis_,modelPtr_);} + /// Warm start difference from basis_ to statusArray + CoinWarmStartDiff * getBasisDiff(const unsigned char * statusArray) const ; + /// Warm start from statusArray + CoinWarmStartBasis * getBasis(const unsigned char * statusArray) const ; + /// Delete all scale factor stuff and reset option + void deleteScaleFactors(); + /// If doing fast hot start then ranges are computed + inline const double * upRange() const + { return rowActivity_;} + inline const double * downRange() const + { return columnActivity_;} + /// Pass in range array + inline void passInRanges(int * array) + { whichRange_=array;} + /// Pass in sos stuff from AMPl + void setSOSData(int numberSOS,const char * type, + const int * start,const int * indices, const double * weights=NULL); + /// Compute largest amount any at continuous away from bound + void computeLargestAway(); + /// Get largest amount continuous away from bound + inline double largestAway() const + { return largestAway_;} + /// Set largest amount continuous away from bound + inline void setLargestAway(double value) + { largestAway_ = value;} + /// Sort of lexicographic resolve + void lexSolve(); + //@} + +protected: + /**@name Protected member data */ + //@{ + /// Clp model represented by this class instance + mutable ClpSimplex * modelPtr_; + //@} + /**@name Cached information derived from the OSL model */ + //@{ + /// Pointer to dense vector of row sense indicators + mutable char *rowsense_; + + /// Pointer to dense vector of row right-hand side values + mutable double *rhs_; + + /** Pointer to dense vector of slack upper bounds for range + constraints (undefined for non-range rows) + */ + mutable double *rowrange_; + + /** A pointer to the warmstart information to be used in the hotstarts. + This is NOT efficient and more thought should be given to it... */ + mutable CoinWarmStartBasis* ws_; + /** also save row and column information for hot starts + only used in hotstarts so can be casual */ + mutable double * rowActivity_; + mutable double * columnActivity_; + /// Stuff for fast dual + ClpNodeStuff stuff_; + /// Number of SOS sets + int numberSOS_; + /// SOS set info + CoinSet * setInfo_; + /// Alternate model (hot starts) - but also could be permanent and used for crunch + ClpSimplex * smallModel_; + /// factorization for hot starts + ClpFactorization * factorization_; + /** Smallest allowed element in cut. + If smaller than this then ignored */ + double smallestElementInCut_; + /** Smallest change in cut. + If (upper-lower)*element < this then element is + taken out and cut relaxed. */ + double smallestChangeInCut_; + /// Largest amount continuous away from bound + double largestAway_; + /// Arrays for hot starts + char * spareArrays_; + /** Warmstart information to be used in resolves. */ + CoinWarmStartBasis basis_; + /** The original iteration limit before hotstarts started. */ + int itlimOrig_; + + /*! \brief Last algorithm used + + Coded as + - 0 invalid + - 1 primal + - 2 dual + - -911 disaster in the algorithm that was attempted + - 999 current solution no longer optimal due to change in problem or + basis + */ + mutable int lastAlgorithm_; + + /// To say if destructor should delete underlying model + bool notOwned_; + + /// Pointer to row-wise copy of problem matrix coefficients. + mutable CoinPackedMatrix *matrixByRow_; + + /// Pointer to row-wise copy of continuous problem matrix coefficients. + CoinPackedMatrix *matrixByRowAtContinuous_; + + /// Pointer to integer information + char * integerInformation_; + + /** Pointer to variables for which we want range information + The number is in [0] + memory is not owned by OsiClp + */ + int * whichRange_; + + //std::map<OsiIntParam, ClpIntParam> intParamMap_; + //std::map<OsiDblParam, ClpDblParam> dblParamMap_; + //std::map<OsiStrParam, ClpStrParam> strParamMap_; + + /*! \brief Faking min to get proper dual solution signs in simplex API */ + mutable bool fakeMinInSimplex_ ; + /*! \brief Linear objective + + Normally a pointer to the linear coefficient array in the clp objective. + An independent copy when #fakeMinInSimplex_ is true, because we need + something permanent to point to when #getObjCoefficients is called. + */ + mutable double *linearObjective_; + + /// To save data in OsiSimplex stuff + mutable ClpDataSave saveData_; + /// Options for initialSolve + ClpSolve solveOptions_; + /** Scaling option + When scaling is on it is possible that the scaled problem + is feasible but the unscaled is not. Clp returns a secondary + status code to that effect. This option allows for a cleanup. + If you use it I would suggest 1. + This only affects actions when scaled optimal + 0 - no action + 1 - clean up using dual if primal infeasibility + 2 - clean up using dual if dual infeasibility + 3 - clean up using dual if primal or dual infeasibility + 11,12,13 - as 1,2,3 but use primal + */ + int cleanupScaling_; + /** Special options + 0x80000000 off + 0 simple stuff for branch and bound + 1 try and keep work regions as much as possible + 2 do not use any perturbation + 4 allow exit before re-factorization + 8 try and re-use factorization if no cuts + 16 use standard strong branching rather than clp's + 32 Just go to first factorization in fast dual + 64 try and tighten bounds in crunch + 128 Model will only change in column bounds + 256 Clean up model before hot start + 512 Give user direct access to Clp regions in getBInvARow etc (i.e., + do not unscale, and do not return result in getBInv parameters; + you have to know where to look for the answer) + 1024 Don't "borrow" model in initialSolve + 2048 Don't crunch + 4096 quick check for optimality + Bits above 8192 give where called from in Cbc + At present 0 is normal, 1 doing fast hotstarts, 2 is can do quick check + 65536 Keep simple i.e. no crunch etc + 131072 Try and keep scaling factors around + 262144 Don't try and tighten bounds (funny global cuts) + 524288 Fake objective and 0-1 + 1048576 Don't recompute ray after crunch + 2097152 + */ + mutable unsigned int specialOptions_; + /// Copy of model when option 131072 set + ClpSimplex * baseModel_; + /// Number of rows when last "scaled" + int lastNumberRows_; + /// Continuous model + ClpSimplex * continuousModel_; + /// Possible disaster handler + OsiClpDisasterHandler * disasterHandler_ ; + /// Fake objective + ClpLinearObjective * fakeObjective_; + /// Row scale factors (has inverse at end) + CoinDoubleArrayWithLength rowScale_; + /// Column scale factors (has inverse at end) + CoinDoubleArrayWithLength columnScale_; + //@} +}; + +class OsiClpDisasterHandler : public ClpDisasterHandler { +public: + /**@name Virtual methods that the derived classe should provide. + */ + //@{ + /// Into simplex + virtual void intoSimplex(); + /// Checks if disaster + virtual bool check() const ; + /// saves information for next attempt + virtual void saveInfo(); + /// Type of disaster 0 can fix, 1 abort + virtual int typeOfDisaster(); + //@} + + + /**@name Constructors, destructor */ + + //@{ + /** Default constructor. */ + OsiClpDisasterHandler(OsiClpSolverInterface * model = NULL); + /** Destructor */ + virtual ~OsiClpDisasterHandler(); + // Copy + OsiClpDisasterHandler(const OsiClpDisasterHandler&); + // Assignment + OsiClpDisasterHandler& operator=(const OsiClpDisasterHandler&); + /// Clone + virtual ClpDisasterHandler * clone() const; + + //@} + + /**@name Sets/gets */ + + //@{ + /** set model. */ + void setOsiModel(OsiClpSolverInterface * model); + /// Get model + inline OsiClpSolverInterface * osiModel() const + { return osiModel_;} + /// Set where from + inline void setWhereFrom(int value) + { whereFrom_=value;} + /// Get where from + inline int whereFrom() const + { return whereFrom_;} + /// Set phase + inline void setPhase(int value) + { phase_=value;} + /// Get phase + inline int phase() const + { return phase_;} + /// are we in trouble + bool inTrouble() const; + + //@} + + +protected: + /**@name Data members + The data members are protected to allow access for derived classes. */ + //@{ + /// Pointer to model + OsiClpSolverInterface * osiModel_; + /** Where from + 0 dual (resolve) + 1 crunch + 2 primal (resolve) + 4 dual (initialSolve) + 6 primal (initialSolve) + */ + int whereFrom_; + /** phase + 0 initial + 1 trying continuing with back in and maybe different perturb + 2 trying continuing with back in and different scaling + 3 trying dual from all slack + 4 trying primal from previous stored basis + */ + int phase_; + /// Are we in trouble + bool inTrouble_; + //@} +}; +// So unit test can find out if NDEBUG set +bool OsiClpHasNDEBUG(); +//############################################################################# +/** A function that tests the methods in the OsiClpSolverInterface class. */ +void OsiClpSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir); +#endif diff --git a/thirdparty/windows/include/coin/OsiColCut.hpp b/thirdparty/windows/include/coin/OsiColCut.hpp new file mode 100644 index 0000000..c98eb5c --- /dev/null +++ b/thirdparty/windows/include/coin/OsiColCut.hpp @@ -0,0 +1,324 @@ +// 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 OsiColCut_H +#define OsiColCut_H + +#include <string> + +#include "CoinPackedVector.hpp" + +#include "OsiCollections.hpp" +#include "OsiCut.hpp" + +/** Column Cut Class + +Column Cut Class has: + <ul> + <li>a sparse vector of column lower bounds + <li>a sparse vector of column upper bounds + </ul> +*/ +class OsiColCut : public OsiCut { + friend void OsiColCutUnitTest(const OsiSolverInterface * baseSiP, + const std::string & mpsDir); + +public: + + //---------------------------------------------------------------- + + /**@name Setting column bounds */ + //@{ + /// Set column lower bounds + inline void setLbs( + int nElements, + const int * colIndices, + const double * lbElements ); + + /// Set column lower bounds from a packed vector + inline void setLbs( const CoinPackedVector & lbs ); + + /// Set column upper bounds + inline void setUbs( + int nElements, + const int * colIndices, + const double * ubElements ); + + /// Set column upper bounds from a packed vector + inline void setUbs( const CoinPackedVector & ubs ); + //@} + + //---------------------------------------------------------------- + + /**@name Getting column bounds */ + //@{ + /// Get column lower bounds + inline const CoinPackedVector & lbs() const; + /// Get column upper bounds + inline const CoinPackedVector & ubs() const; + //@} + + /**@name Comparison operators */ + //@{ +#if __GNUC__ != 2 + using OsiCut::operator== ; +#endif + /** equal - true if lower bounds, upper bounds, + and OsiCut are equal. + */ + inline virtual bool operator==(const OsiColCut& rhs) const; + +#if __GNUC__ != 2 + using OsiCut::operator!= ; +#endif + /// not equal + inline virtual bool operator!=(const OsiColCut& rhs) const; + //@} + + + //---------------------------------------------------------------- + + /**@name Sanity checks on cut */ + //@{ + /** Returns true if the cut is consistent with respect to itself. + This checks to ensure that: + <ul> + <li>The bound vectors do not have duplicate indices, + <li>The bound vectors indices are >=0 + </ul> + */ + inline virtual bool consistent() const; + + /** Returns true if cut is consistent with respect to the solver + interface's model. This checks to ensure that + the lower & upperbound packed vectors: + <ul> + <li>do not have an index >= the number of column is the model. + </ul> + */ + inline virtual bool consistent(const OsiSolverInterface& im) const; + + /** Returns true if the cut is infeasible with respect to its bounds and the + column bounds in the solver interface's models. + This checks whether: + <ul> + <li>the maximum of the new and existing lower bounds is strictly + greater than the minimum of the new and existing upper bounds. +</ul> + */ + inline virtual bool infeasible(const OsiSolverInterface &im) const; + /** Returns infeasibility of the cut with respect to solution + passed in i.e. is positive if cuts off that solution. + solution is getNumCols() long.. + */ + virtual double violated(const double * solution) const; + //@} + + //---------------------------------------------------------------- + + /**@name Constructors and destructors */ + //@{ + /// Assignment operator + OsiColCut & operator=( const OsiColCut& rhs); + + /// Copy constructor + OsiColCut ( const OsiColCut &); + + /// Default Constructor + OsiColCut (); + + /// Clone + virtual OsiColCut * clone() const; + + /// Destructor + virtual ~OsiColCut (); + //@} + + /**@name Debug stuff */ + //@{ + /// Print cuts in collection + virtual void print() const; + //@} + +private: + + /**@name Private member data */ + //@{ + /// Lower bounds + CoinPackedVector lbs_; + /// Upper bounds + CoinPackedVector ubs_; + //@} + +}; + + + +//------------------------------------------------------------------- +// Set lower & upper bound vectors +//------------------------------------------------------------------- +void OsiColCut::setLbs( + int size, + const int * colIndices, + const double * lbElements ) +{ + lbs_.setVector(size,colIndices,lbElements); +} +// +void OsiColCut::setUbs( + int size, + const int * colIndices, + const double * ubElements ) +{ + ubs_.setVector(size,colIndices,ubElements); +} +// +void OsiColCut::setLbs( const CoinPackedVector & lbs ) +{ + lbs_ = lbs; +} +// +void OsiColCut::setUbs( const CoinPackedVector & ubs ) +{ + ubs_ = ubs; +} + +//------------------------------------------------------------------- +// Get Column Lower Bounds and Column Upper Bounds +//------------------------------------------------------------------- +const CoinPackedVector & OsiColCut::lbs() const +{ + return lbs_; +} +// +const CoinPackedVector & OsiColCut::ubs() const +{ + return ubs_; +} + +//---------------------------------------------------------------- +// == operator +//------------------------------------------------------------------- +bool +OsiColCut::operator==( + const OsiColCut& rhs) const +{ + if ( this->OsiCut::operator!=(rhs) ) + return false; + if ( lbs() != rhs.lbs() ) + return false; + if ( ubs() != rhs.ubs() ) + return false; + return true; +} +// +bool +OsiColCut::operator!=( + const OsiColCut& rhs) const +{ + return !( (*this)==rhs ); +} + +//---------------------------------------------------------------- +// consistent & infeasible +//------------------------------------------------------------------- +bool OsiColCut::consistent() const +{ + const CoinPackedVector & lb = lbs(); + const CoinPackedVector & ub = ubs(); + // Test for consistent cut. + // Are packed vectors consistent? + lb.duplicateIndex("consistent", "OsiColCut"); + ub.duplicateIndex("consistent", "OsiColCut"); + if ( lb.getMinIndex() < 0 ) return false; + if ( ub.getMinIndex() < 0 ) return false; + return true; +} +// +bool OsiColCut::consistent(const OsiSolverInterface& im) const +{ + const CoinPackedVector & lb = lbs(); + const CoinPackedVector & ub = ubs(); + + // Test for consistent cut. + if ( lb.getMaxIndex() >= im.getNumCols() ) return false; + if ( ub.getMaxIndex() >= im.getNumCols() ) return false; + + return true; +} + +#if 0 +bool OsiColCut::feasible(const OsiSolverInterface &im) const +{ + const double * oldColLb = im.getColLower(); + const double * oldColUb = im.getColUpper(); + const CoinPackedVector & cutLbs = lbs(); + const CoinPackedVector & cutUbs = ubs(); + int i; + + for ( i=0; i<cutLbs.size(); i++ ) { + int colIndx = cutLbs.indices()[i]; + double newLb; + if ( cutLbs.elements()[i] > oldColLb[colIndx] ) + newLb = cutLbs.elements()[i]; + else + newLb = oldColLb[colIndx]; + + double newUb = oldColUb[colIndx]; + if ( cutUbs.indexExists(colIndx) ) + if ( cutUbs[colIndx] < newUb ) newUb = cutUbs[colIndx]; + if ( newLb > newUb ) + return false; + } + + for ( i=0; i<cutUbs.size(); i++ ) { + int colIndx = cutUbs.indices()[i]; + double newUb = cutUbs.elements()[i] < oldColUb[colIndx] ? cutUbs.elements()[i] : oldColUb[colIndx]; + double newLb = oldColLb[colIndx]; + if ( cutLbs.indexExists(colIndx) ) + if ( cutLbs[colIndx] > newLb ) newLb = cutLbs[colIndx]; + if ( newUb < newLb ) + return false; + } + + return true; +} +#endif + + +bool OsiColCut::infeasible(const OsiSolverInterface &im) const +{ + const double * oldColLb = im.getColLower(); + const double * oldColUb = im.getColUpper(); + const CoinPackedVector & cutLbs = lbs(); + const CoinPackedVector & cutUbs = ubs(); + int i; + + for ( i=0; i<cutLbs.getNumElements(); i++ ) { + int colIndx = cutLbs.getIndices()[i]; + double newLb= cutLbs.getElements()[i] > oldColLb[colIndx] ? + cutLbs.getElements()[i] : oldColLb[colIndx]; + + double newUb = oldColUb[colIndx]; + if ( cutUbs.isExistingIndex(colIndx) ) + if ( cutUbs[colIndx] < newUb ) newUb = cutUbs[colIndx]; + if ( newLb > newUb ) + return true; + } + + for ( i=0; i<cutUbs.getNumElements(); i++ ) { + int colIndx = cutUbs.getIndices()[i]; + double newUb = cutUbs.getElements()[i] < oldColUb[colIndx] ? + cutUbs.getElements()[i] : oldColUb[colIndx]; + double newLb = oldColLb[colIndx]; + if ( cutLbs.isExistingIndex(colIndx) ) + if ( cutLbs[colIndx] > newLb ) newLb = cutLbs[colIndx]; + if ( newUb < newLb ) + return true; + } + + return false; +} + +#endif diff --git a/thirdparty/windows/include/coin/OsiCollections.hpp b/thirdparty/windows/include/coin/OsiCollections.hpp new file mode 100644 index 0000000..d68df1a --- /dev/null +++ b/thirdparty/windows/include/coin/OsiCollections.hpp @@ -0,0 +1,35 @@ +// 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 OsiCollections_H +#define OsiCollections_H + +#include <vector> + +//Forward declarations +class OsiColCut; +class OsiRowCut; +class OsiCut; + + + +/* Collection Classes */ + +/**@name Typedefs for Standard Template Library collections of Osi Objects. */ +//@{ +/// Vector of int +typedef std::vector<int> OsiVectorInt; +/// Vector of double +typedef std::vector<double> OsiVectorDouble; +/// Vector of OsiColCut pointers +typedef std::vector<OsiColCut *> OsiVectorColCutPtr; +/// Vector of OsiRowCut pointers +typedef std::vector<OsiRowCut *> OsiVectorRowCutPtr; +/// Vector of OsiCut pointers +typedef std::vector<OsiCut *> OsiVectorCutPtr; +//@} + + + +#endif diff --git a/thirdparty/windows/include/coin/OsiConfig.h b/thirdparty/windows/include/coin/OsiConfig.h new file mode 100644 index 0000000..44371a1 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiConfig.h @@ -0,0 +1,19 @@ +/* src/Osi/config_osi.h. Generated by configure. */ +/* src/Osi/config_osi.h.in. */ + +#ifndef __CONFIG_OSI_H__ +#define __CONFIG_OSI_H__ + +/* Version number of project */ +#define OSI_VERSION "0.107.7" + +/* Major Version number of project */ +#define OSI_VERSION_MAJOR 0 + +/* Minor Version number of project */ +#define OSI_VERSION_MINOR 107 + +/* Release Version number of project */ +#define OSI_VERSION_RELEASE 7 + +#endif diff --git a/thirdparty/windows/include/coin/OsiCut.hpp b/thirdparty/windows/include/coin/OsiCut.hpp new file mode 100644 index 0000000..0b2cc5c --- /dev/null +++ b/thirdparty/windows/include/coin/OsiCut.hpp @@ -0,0 +1,245 @@ +// 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 OsiCut_H +#define OsiCut_H + +#include "OsiCollections.hpp" +#include "OsiSolverInterface.hpp" + +/** Base Class for cut. + +The Base cut class contains: + <ul> + <li>a measure of the cut's effectivness + </ul> +*/ + +/* + COIN_NOTEST_DUPLICATE is rooted in CoinUtils. Check there before you + meddle here. +*/ +#ifdef COIN_FAST_CODE +#ifndef COIN_NOTEST_DUPLICATE +#define COIN_NOTEST_DUPLICATE +#endif +#endif + +#ifndef COIN_NOTEST_DUPLICATE +#define COIN_DEFAULT_VALUE_FOR_DUPLICATE true +#else +#define COIN_DEFAULT_VALUE_FOR_DUPLICATE false +#endif + + +class OsiCut { + +public: + + //------------------------------------------------------------------- + /**@name Effectiveness */ + //@{ + /// Set effectiveness + inline void setEffectiveness( double e ); + /// Get effectiveness + inline double effectiveness() const; + //@} + + /**@name GloballyValid */ + //@{ + /// Set globallyValid (nonzero true) + inline void setGloballyValid( bool trueFalse ) + { globallyValid_=trueFalse ? 1 : 0;} + inline void setGloballyValid( ) + { globallyValid_=1;} + inline void setNotGloballyValid( ) + { globallyValid_=0;} + /// Get globallyValid + inline bool globallyValid() const + { return globallyValid_!=0;} + /// Set globallyValid as integer (nonzero true) + inline void setGloballyValidAsInteger( int trueFalse ) + { globallyValid_=trueFalse;} + /// Get globallyValid + inline int globallyValidAsInteger() const + { return globallyValid_;} + //@} + + /**@name Debug stuff */ + //@{ + /// Print cuts in collection + virtual void print() const {} + //@} + +#if 0 + / **@name Times used */ + / /@{ + / // Set times used + inline void setTimesUsed( int t ); + / // Increment times used + inline void incrementTimesUsed(); + / // Get times used + inline int timesUsed() const; + / /@} + + / **@name Times tested */ + / /@{ + / // Set times tested + inline void setTimesTested( int t ); + / // Increment times tested + inline void incrementTimesTested(); + / // Get times tested + inline int timesTested() const; + / /@} +#endif + + //---------------------------------------------------------------- + + /**@name Comparison operators */ + //@{ + ///equal. 2 cuts are equal if there effectiveness are equal + inline virtual bool operator==(const OsiCut& rhs) const; + /// not equal + inline virtual bool operator!=(const OsiCut& rhs) const; + /// less than. True if this.effectiveness < rhs.effectiveness + inline virtual bool operator< (const OsiCut& rhs) const; + /// less than. True if this.effectiveness > rhs.effectiveness + inline virtual bool operator> (const OsiCut& rhs) const; + //@} + + //---------------------------------------------------------------- + // consistent() - returns true if the cut is consistent with repect to itself. + // This might include checks to ensure that a packed vector + // itself does not have a negative index. + // consistent(const OsiSolverInterface& si) - returns true if cut is consistent with + // respect to the solver interface's model. This might include a check to + // make sure a column index is not greater than the number + // of columns in the problem. + // infeasible(const OsiSolverInterface& si) - returns true if the cut is infeasible + // "with respect to itself". This might include a check to ensure + // the lower bound is greater than the upper bound, or if the + // cut simply replaces bounds that the new bounds are feasible with + // respect to the old bounds. + //----------------------------------------------------------------- + /**@name Sanity checks on cut */ + //@{ + /** Returns true if the cut is consistent with respect to itself, + without considering any + data in the model. For example, it might check to ensure + that a column index is not negative. + */ + inline virtual bool consistent() const=0; + + /** Returns true if cut is consistent when considering the solver + interface's model. For example, it might check to ensure + that a column index is not greater than the number of columns + in the model. Assumes consistent() is true. + */ + inline virtual bool consistent(const OsiSolverInterface& si) const=0; + + /** Returns true if the cut is infeasible "with respect to itself" and + cannot be satisfied. This method does NOT check whether adding the + cut to the solver interface's model will make the -model- infeasble. + A cut which returns !infeasible(si) may very well make the model + infeasible. (Of course, adding a cut with returns infeasible(si) + will make the model infeasible.) + + The "with respect to itself" is in quotes becaues + in the case where the cut + simply replaces existing bounds, it may make + sense to test infeasibility with respect to the current bounds + held in the solver interface's model. For example, if the cut + has a single variable in it, it might check that the maximum + of new and existing lower bounds is greater than the minium of + the new and existing upper bounds. + + Assumes that consistent(si) is true.<br> + Infeasible cuts can be a useful mechanism for a cut generator to + inform the solver interface that its detected infeasibility of the + problem. + */ + inline virtual bool infeasible(const OsiSolverInterface &si) const=0; + + /** Returns infeasibility of the cut with respect to solution + passed in i.e. is positive if cuts off that solution. + solution is getNumCols() long.. + */ + virtual double violated(const double * solution) const=0; + //@} + +protected: + + /**@name Constructors and destructors */ + //@{ + /// Default Constructor + OsiCut (); + + /// Copy constructor + OsiCut ( const OsiCut &); + + /// Assignment operator + OsiCut & operator=( const OsiCut& rhs); + + /// Destructor + virtual ~OsiCut (); + //@} + +private: + + /**@name Private member data */ + //@{ + /// Effectiveness + double effectiveness_; + /// If cut has global validity i.e. can be used anywhere in tree + int globallyValid_; +#if 0 + /// Times used + int timesUsed_; + /// Times tested + int timesTested_; +#endif + //@} +}; + + +//------------------------------------------------------------------- +// Set/Get member data +//------------------------------------------------------------------- +void OsiCut::setEffectiveness(double e) { effectiveness_=e; } +double OsiCut::effectiveness() const { return effectiveness_; } + +#if 0 +void OsiCut::setTimesUsed( int t ) { timesUsed_=t; } +void OsiCut::incrementTimesUsed() { timesUsed_++; } +int OsiCut::timesUsed() const { return timesUsed_; } + +void OsiCut::setTimesTested( int t ) { timesTested_=t; } +void OsiCut::incrementTimesTested() { timesTested_++; } +int OsiCut::timesTested() const{ return timesTested_; } +#endif + +//---------------------------------------------------------------- +// == operator +//------------------------------------------------------------------- +bool +OsiCut::operator==(const OsiCut& rhs) const +{ + return effectiveness()==rhs.effectiveness(); +} +bool +OsiCut::operator!=(const OsiCut& rhs) const +{ + return !( (*this)==rhs ); +} +bool +OsiCut::operator< (const OsiCut& rhs) const +{ + return effectiveness()<rhs.effectiveness(); +} +bool +OsiCut::operator> (const OsiCut& rhs) const +{ + return effectiveness()>rhs.effectiveness(); +} +#endif diff --git a/thirdparty/windows/include/coin/OsiCuts.hpp b/thirdparty/windows/include/coin/OsiCuts.hpp new file mode 100644 index 0000000..5eea264 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiCuts.hpp @@ -0,0 +1,474 @@ +// 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 OsiCuts_H +#define OsiCuts_H + +#include "CoinPragma.hpp" + +#include <cmath> +#include <cfloat> +#include "OsiCollections.hpp" +#include "OsiRowCut.hpp" +#include "OsiColCut.hpp" +#include "CoinFloatEqual.hpp" + +/** Collections of row cuts and column cuts +*/ +class OsiCuts { + friend void OsiCutsUnitTest(); + +public: + /**@name Iterator classes + */ + //@{ + /** Iterator + + This is a class for iterating over the collection of cuts. + */ + class iterator { + friend class OsiCuts; + public: + iterator(OsiCuts& cuts); + iterator(const iterator & src); + iterator & operator=( const iterator& rhs); + ~iterator (); + OsiCut* operator*() const { return cutP_; } + iterator operator++(); + + iterator operator++(int) + { + iterator temp = *this; + ++*this; + return temp; + } + + bool operator==(const iterator& it) const { + return (colCutIndex_+rowCutIndex_)==(it.colCutIndex_+it.rowCutIndex_); + } + + bool operator!=(const iterator& it) const { + return !((*this)==it); + } + + bool operator<(const iterator& it) const { + return (colCutIndex_+rowCutIndex_)<(it.colCutIndex_+it.rowCutIndex_); + } + + private: + iterator(); + // *THINK* : how to inline these without sticking the code here (ugly...) + iterator begin(); + iterator end(); + OsiCuts& cuts_; + int rowCutIndex_; + int colCutIndex_; + OsiCut * cutP_; + }; + + /** Const Iterator + + This is a class for iterating over the collection of cuts. + */ + class const_iterator { + friend class OsiCuts; + public: + typedef std::forward_iterator_tag iterator_category; + typedef OsiCut* value_type; + typedef size_t difference_type; + typedef OsiCut ** pointer; + typedef OsiCut *& reference; + + public: + const_iterator(const OsiCuts& cuts); + const_iterator(const const_iterator & src); + const_iterator & operator=( const const_iterator& rhs); + ~const_iterator (); + const OsiCut* operator*() const { return cutP_; } + + const_iterator operator++(); + + const_iterator operator++(int) + { + const_iterator temp = *this; + ++*this; + return temp; + } + + bool operator==(const const_iterator& it) const { + return (colCutIndex_+rowCutIndex_)==(it.colCutIndex_+it.rowCutIndex_); + } + + bool operator!=(const const_iterator& it) const { + return !((*this)==it); + } + + bool operator<(const const_iterator& it) const { + return (colCutIndex_+rowCutIndex_)<(it.colCutIndex_+it.rowCutIndex_); + } + private: + inline const_iterator(); + // *THINK* : how to inline these without sticking the code here (ugly...) + const_iterator begin(); + const_iterator end(); + const OsiCuts * cutsPtr_; + int rowCutIndex_; + int colCutIndex_; + const OsiCut * cutP_; + }; + //@} + + //------------------------------------------------------------------- + // + // Cuts class definition begins here: + // + //------------------------------------------------------------------- + + /** \name Inserting a cut into collection */ + //@{ + /** \brief Insert a row cut */ + inline void insert( const OsiRowCut & rc ); + /** \brief Insert a row cut unless it is a duplicate - cut may get sorted. + Duplicate is defined as CoinAbsFltEq says same*/ + void insertIfNotDuplicate( OsiRowCut & rc , CoinAbsFltEq treatAsSame=CoinAbsFltEq(1.0e-12) ); + /** \brief Insert a row cut unless it is a duplicate - cut may get sorted. + Duplicate is defined as CoinRelFltEq says same*/ + void insertIfNotDuplicate( OsiRowCut & rc , CoinRelFltEq treatAsSame ); + /** \brief Insert a column cut */ + inline void insert( const OsiColCut & cc ); + + /** \brief Insert a row cut. + + The OsiCuts object takes control of the cut object. + On return, \c rcPtr is NULL. + */ + inline void insert( OsiRowCut * & rcPtr ); + /** \brief Insert a column cut. + + The OsiCuts object takes control of the cut object. + On return \c ccPtr is NULL. + */ + inline void insert( OsiColCut * & ccPtr ); +#if 0 + inline void insert( OsiCut * & cPtr ); +#endif + + /** \brief Insert a set of cuts */ + inline void insert(const OsiCuts & cs); + + //@} + + /**@name Number of cuts in collection */ + //@{ + /// Number of row cuts in collection + inline int sizeRowCuts() const; + /// Number of column cuts in collection + inline int sizeColCuts() const; + /// Number of cuts in collection + inline int sizeCuts() const; + //@} + + /**@name Debug stuff */ + //@{ + /// Print cuts in collection + inline void printCuts() const; + //@} + + /**@name Get a cut from collection */ + //@{ + /// Get pointer to i'th row cut + inline OsiRowCut * rowCutPtr(int i); + /// Get const pointer to i'th row cut + inline const OsiRowCut * rowCutPtr(int i) const; + /// Get pointer to i'th column cut + inline OsiColCut * colCutPtr(int i); + /// Get const pointer to i'th column cut + inline const OsiColCut * colCutPtr(int i) const; + + /// Get reference to i'th row cut + inline OsiRowCut & rowCut(int i); + /// Get const reference to i'th row cut + inline const OsiRowCut & rowCut(int i) const; + /// Get reference to i'th column cut + inline OsiColCut & colCut(int i); + /// Get const reference to i'th column cut + inline const OsiColCut & colCut(int i) const; + + /// Get const pointer to the most effective cut + inline const OsiCut * mostEffectiveCutPtr() const; + /// Get pointer to the most effective cut + inline OsiCut * mostEffectiveCutPtr(); + //@} + + /**@name Deleting cut from collection */ + //@{ + /// Remove i'th row cut from collection + inline void eraseRowCut(int i); + /// Remove i'th column cut from collection + inline void eraseColCut(int i); + /// Get pointer to i'th row cut and remove ptr from collection + inline OsiRowCut * rowCutPtrAndZap(int i); + /*! \brief Clear all row cuts without deleting them + + Handy in case one wants to use CGL without managing cuts in one of + the OSI containers. Client is ultimately responsible for deleting the + data structures holding the row cuts. + */ + inline void dumpCuts() ; + /*! \brief Selective delete and clear for row cuts. + + Deletes the cuts specified in \p to_erase then clears remaining cuts + without deleting them. A hybrid of eraseRowCut(int) and dumpCuts(). + Client is ultimately responsible for deleting the data structures + for row cuts not specified in \p to_erase. + */ + inline void eraseAndDumpCuts(const std::vector<int> to_erase) ; + //@} + + /**@name Sorting collection */ + //@{ + /// Cuts with greatest effectiveness are first. + inline void sort(); + //@} + + + /**@name Iterators + Example of using an iterator to sum effectiveness + of all cuts in the collection. + <pre> + double sumEff=0.0; + for ( OsiCuts::iterator it=cuts.begin(); it!=cuts.end(); ++it ) + sumEff+= (*it)->effectiveness(); + </pre> + */ + //@{ + /// Get iterator to beginning of collection + inline iterator begin() { iterator it(*this); it.begin(); return it; } + /// Get const iterator to beginning of collection + inline const_iterator begin() const { const_iterator it(*this); it.begin(); return it; } + /// Get iterator to end of collection + inline iterator end() { iterator it(*this); it.end(); return it; } + /// Get const iterator to end of collection + inline const_iterator end() const { const_iterator it(*this); it.end(); return it; } + //@} + + + /**@name Constructors and destructors */ + //@{ + /// Default constructor + OsiCuts (); + + /// Copy constructor + OsiCuts ( const OsiCuts &); + + /// Assignment operator + OsiCuts & operator=( const OsiCuts& rhs); + + /// Destructor + virtual ~OsiCuts (); + //@} + +private: + //*@name Function operator for sorting cuts by efectiveness */ + //@{ + class OsiCutCompare + { + public: + /// Function for sorting cuts by effectiveness + inline bool operator()(const OsiCut * c1P,const OsiCut * c2P) + { return c1P->effectiveness() > c2P->effectiveness(); } + }; + //@} + + /**@name Private methods */ + //@{ + /// Copy internal data + void gutsOfCopy( const OsiCuts & source ); + /// Delete internal data + void gutsOfDestructor(); + //@} + + /**@name Private member data */ + //@{ + /// Vector of row cuts pointers + OsiVectorRowCutPtr rowCutPtrs_; + /// Vector of column cuts pointers + OsiVectorColCutPtr colCutPtrs_; + //@} + +}; + + +//------------------------------------------------------------------- +// insert cuts into collection +//------------------------------------------------------------------- +void OsiCuts::insert( const OsiRowCut & rc ) +{ + OsiRowCut * newCutPtr = rc.clone(); + //assert(dynamic_cast<OsiRowCut*>(newCutPtr) != NULL ); + rowCutPtrs_.push_back(static_cast<OsiRowCut*>(newCutPtr)); +} +void OsiCuts::insert( const OsiColCut & cc ) +{ + OsiColCut * newCutPtr = cc.clone(); + //assert(dynamic_cast<OsiColCut*>(newCutPtr) != NULL ); + colCutPtrs_.push_back(static_cast<OsiColCut*>(newCutPtr)); +} + +void OsiCuts::insert( OsiRowCut* & rcPtr ) +{ + rowCutPtrs_.push_back(rcPtr); + rcPtr = NULL; +} +void OsiCuts::insert( OsiColCut* &ccPtr ) +{ + colCutPtrs_.push_back(ccPtr); + ccPtr = NULL; +} +#if 0 +void OsiCuts::insert( OsiCut* & cPtr ) +{ + OsiRowCut * rcPtr = dynamic_cast<OsiRowCut*>(cPtr); + if ( rcPtr != NULL ) { + insert( rcPtr ); + cPtr = rcPtr; + } + else { + OsiColCut * ccPtr = dynamic_cast<OsiColCut*>(cPtr); + assert( ccPtr != NULL ); + insert( ccPtr ); + cPtr = ccPtr; + } +} +#endif + +// LANNEZ SEBASTIEN added Thu May 25 01:22:51 EDT 2006 +void OsiCuts::insert(const OsiCuts & cs) +{ + for (OsiCuts::const_iterator it = cs.begin (); it != cs.end (); it++) + { + const OsiRowCut * rCut = dynamic_cast <const OsiRowCut * >(*it); + const OsiColCut * cCut = dynamic_cast <const OsiColCut * >(*it); + assert (rCut || cCut); + if (rCut) + insert (*rCut); + else + insert (*cCut); + } +} + +//------------------------------------------------------------------- +// sort +//------------------------------------------------------------------- +void OsiCuts::sort() +{ + std::sort(colCutPtrs_.begin(),colCutPtrs_.end(),OsiCutCompare()); + std::sort(rowCutPtrs_.begin(),rowCutPtrs_.end(),OsiCutCompare()); +} + + +//------------------------------------------------------------------- +// Get number of in collections +//------------------------------------------------------------------- +int OsiCuts::sizeRowCuts() const { + return static_cast<int>(rowCutPtrs_.size()); } +int OsiCuts::sizeColCuts() const { + return static_cast<int>(colCutPtrs_.size()); } +int OsiCuts::sizeCuts() const { + return static_cast<int>(sizeRowCuts()+sizeColCuts()); } + +//---------------------------------------------------------------- +// Get i'th cut from the collection +//---------------------------------------------------------------- +const OsiRowCut * OsiCuts::rowCutPtr(int i) const { return rowCutPtrs_[i]; } +const OsiColCut * OsiCuts::colCutPtr(int i) const { return colCutPtrs_[i]; } +OsiRowCut * OsiCuts::rowCutPtr(int i) { return rowCutPtrs_[i]; } +OsiColCut * OsiCuts::colCutPtr(int i) { return colCutPtrs_[i]; } + +const OsiRowCut & OsiCuts::rowCut(int i) const { return *rowCutPtr(i); } +const OsiColCut & OsiCuts::colCut(int i) const { return *colCutPtr(i); } +OsiRowCut & OsiCuts::rowCut(int i) { return *rowCutPtr(i); } +OsiColCut & OsiCuts::colCut(int i) { return *colCutPtr(i); } + +//---------------------------------------------------------------- +// Get most effective cut from collection +//---------------------------------------------------------------- +const OsiCut * OsiCuts::mostEffectiveCutPtr() const +{ + const_iterator b=begin(); + const_iterator e=end(); + return *(std::min_element(b,e,OsiCutCompare())); +} +OsiCut * OsiCuts::mostEffectiveCutPtr() +{ + iterator b=begin(); + iterator e=end(); + //return *(std::min_element(b,e,OsiCutCompare())); + OsiCut * retVal = NULL; + double maxEff = COIN_DBL_MIN; + for ( OsiCuts::iterator it=b; it!=e; ++it ) { + if (maxEff < (*it)->effectiveness() ) { + maxEff = (*it)->effectiveness(); + retVal = *it; + } + } + return retVal; +} + +//---------------------------------------------------------------- +// Print all cuts +//---------------------------------------------------------------- +void +OsiCuts::printCuts() const +{ + // do all column cuts first + int i; + int numberColCuts=sizeColCuts(); + for (i=0;i<numberColCuts;i++) { + const OsiColCut * cut = colCutPtr(i); + cut->print(); + } + int numberRowCuts=sizeRowCuts(); + for (i=0;i<numberRowCuts;i++) { + const OsiRowCut * cut = rowCutPtr(i); + cut->print(); + } +} + +//---------------------------------------------------------------- +// Erase i'th cut from the collection +//---------------------------------------------------------------- +void OsiCuts::eraseRowCut(int i) +{ + delete rowCutPtrs_[i]; + rowCutPtrs_.erase( rowCutPtrs_.begin()+i ); +} +void OsiCuts::eraseColCut(int i) +{ + delete colCutPtrs_[i]; + colCutPtrs_.erase( colCutPtrs_.begin()+i ); +} +/// Get pointer to i'th row cut and remove ptr from collection +OsiRowCut * +OsiCuts::rowCutPtrAndZap(int i) +{ + OsiRowCut * cut = rowCutPtrs_[i]; + rowCutPtrs_[i]=NULL; + rowCutPtrs_.erase( rowCutPtrs_.begin()+i ); + return cut; +} +void OsiCuts::dumpCuts() +{ + rowCutPtrs_.clear() ; +} +void OsiCuts::eraseAndDumpCuts(const std::vector<int> to_erase) +{ + for (unsigned i=0; i<to_erase.size(); i++) { + delete rowCutPtrs_[to_erase[i]]; + } + rowCutPtrs_.clear(); +} + + +#endif diff --git a/thirdparty/windows/include/coin/OsiPresolve.hpp b/thirdparty/windows/include/coin/OsiPresolve.hpp new file mode 100644 index 0000000..9ec3d2a --- /dev/null +++ b/thirdparty/windows/include/coin/OsiPresolve.hpp @@ -0,0 +1,252 @@ +// 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 OsiPresolve_H +#define OsiPresolve_H +#include "OsiSolverInterface.hpp" + +class CoinPresolveAction; +#include "CoinPresolveMatrix.hpp" + + +/*! \class OsiPresolve + \brief OSI interface to COIN problem simplification capabilities + + COIN provides a number of classes which implement problem simplification + algorithms (CoinPresolveAction, CoinPrePostsolveMatrix, and derived + classes). The model of operation is as follows: + <ul> + <li> + Create a copy of the original problem. + </li> + <li> + Subject the copy to a series of transformations (the <i>presolve</i> + methods) to produce a presolved model. Each transformation is also + expected to provide a method to reverse the transformation (the + <i>postsolve</i> method). The postsolve methods are collected in a + linked list; the postsolve method for the final presolve transformation + is at the head of the list. + </li> + <li> + Hand the presolved problem to the solver for optimization. + </li> + <li> + Apply the collected postsolve methods to the presolved problem + and solution, restating the solution in terms of the original problem. + </li> + </ul> + + The COIN presolve algorithms are unaware of OSI. The OsiPresolve class takes + care of the interface. Given an OsiSolverInterface \c origModel, it will take + care of creating a clone properly loaded with the presolved problem and ready + for optimization. After optimization, it will apply postsolve + transformations and load the result back into \c origModel. + + Assuming a problem has been loaded into an + \c OsiSolverInterface \c origModel, a bare-bones application looks like this: + \code + OsiPresolve pinfo ; + OsiSolverInterface *presolvedModel ; + // Return an OsiSolverInterface loaded with the presolved problem. + presolvedModel = pinfo.presolvedModel(*origModel,1.0e-8,false,numberPasses) ; + presolvedModel->initialSolve() ; + // Restate the solution and load it back into origModel. + pinfo.postsolve(true) ; + delete presolvedModel ; + \endcode +*/ + + + +class OsiPresolve { +public: + /// Default constructor (empty object) + OsiPresolve(); + + /// Virtual destructor + virtual ~OsiPresolve(); + + /*! \brief Create a new OsiSolverInterface loaded with the presolved problem. + + This method implements the first two steps described in the class + documentation. It clones \c origModel and applies presolve + transformations, storing the resulting list of postsolve + transformations. It returns a pointer to a new OsiSolverInterface loaded + with the presolved problem, or NULL if the problem is infeasible or + unbounded. If \c keepIntegers is true then bounds may be tightened in + the original. Bounds will be moved by up to \c feasibilityTolerance to + try and stay feasible. When \c doStatus is true, the current solution will + be transformed to match the presolved model. + + This should be paired with postsolve(). It is up to the client to + destroy the returned OsiSolverInterface, <i>after</i> calling postsolve(). + + This method is virtual. Override this method if you need to customize + the steps of creating a model to apply presolve transformations. + + In some sense, a wrapper for presolve(CoinPresolveMatrix*). + */ + virtual OsiSolverInterface *presolvedModel(OsiSolverInterface & origModel, + double feasibilityTolerance=0.0, + bool keepIntegers=true, + int numberPasses=5, + const char * prohibited=NULL, + bool doStatus=true, + const char * rowProhibited=NULL); + + /*! \brief Restate the solution to the presolved problem in terms of the + original problem and load it into the original model. + + postsolve() restates the solution in terms of the original problem and + updates the original OsiSolverInterface supplied to presolvedModel(). If + the problem has not been solved to optimality, there are no guarantees. + If you are using an algorithm like simplex that has a concept of a basic + solution, then set updateStatus + + The advantage of going back to the original problem is that it + will be exactly as it was, <i>i.e.</i>, 0.0 will not become 1.0e-19. + + Note that if you modified the original problem after presolving, then you + must ``undo'' these modifications before calling postsolve(). + + In some sense, a wrapper for postsolve(CoinPostsolveMatrix&). + */ + virtual void postsolve(bool updateStatus=true); + + /*! \brief Return a pointer to the presolved model. */ + OsiSolverInterface * model() const; + + /// Return a pointer to the original model + OsiSolverInterface * originalModel() const; + + /// Set the pointer to the original model + void setOriginalModel(OsiSolverInterface *model); + + /// Return a pointer to the original columns + const int * originalColumns() const; + + /// Return a pointer to the original rows + const int * originalRows() const; + + /// Return number of rows in original model + inline int getNumRows() const + { return nrows_;} + + /// Return number of columns in original model + inline int getNumCols() const + { return ncols_;} + + /** "Magic" number. If this is non-zero then any elements with this value + may change and so presolve is very limited in what can be done + to the row and column. This is for non-linear problems. + */ + inline void setNonLinearValue(double value) + { nonLinearValue_ = value;} + inline double nonLinearValue() const + { return nonLinearValue_;} + /*! \brief Fine control over presolve actions + + Set/clear the following bits to allow or suppress actions: + - 0x01 allow duplicate column processing on integer columns + and dual stuff on integers + - 0x02 switch off actions which can change +1 to something else + (doubleton, tripleton, implied free) + - 0x04 allow transfer of costs from singletons and between integer + variables (when advantageous) + - 0x08 do not allow x+y+z=1 transform + - 0x10 allow actions that don't easily unroll + - 0x20 allow dubious gub element reduction + + GUB element reduction is only partially implemented in CoinPresolve (see + gubrow_action) and willl cause an abort at postsolve. It's not clear + what's meant by `dual stuff on integers'. + -- lh, 110605 -- + */ + inline void setPresolveActions(int action) + { presolveActions_ = (presolveActions_&0xffff0000)|(action&0xffff);} + +private: + /*! Original model (solver interface loaded with the original problem). + + Must not be destroyed until after postsolve(). + */ + OsiSolverInterface * originalModel_; + + /*! Presolved model (solver interface loaded with the presolved problem) + + Must be destroyed by the client (using delete) after postsolve(). + */ + OsiSolverInterface * presolvedModel_; + + /*! "Magic" number. If this is non-zero then any elements with this value + may change and so presolve is very limited in what can be done + to the row and column. This is for non-linear problems. + One could also allow for cases where sign of coefficient is known. + */ + double nonLinearValue_; + + /// Original column numbers + int * originalColumn_; + + /// Original row numbers + int * originalRow_; + + /// The list of transformations applied. + const CoinPresolveAction *paction_; + + /*! \brief Number of columns in original model. + + The problem will expand back to its former size as postsolve + transformations are applied. It is efficient to allocate data structures + for the final size of the problem rather than expand them as needed. + */ + int ncols_; + + /*! \brief Number of rows in original model. */ + int nrows_; + + /*! \brief Number of nonzero matrix coefficients in the original model. */ + CoinBigIndex nelems_; + + /** Whether we want to skip dual part of presolve etc. + 1 bit allows duplicate column processing on integer columns + and dual stuff on integers + 4 transfers costs to integer variables + */ + int presolveActions_; + /// Number of major passes + int numberPasses_; + +protected: + /*! \brief Apply presolve transformations to the problem. + + Handles the core activity of applying presolve transformations. + + If you want to apply the individual presolve routines differently, or + perhaps add your own to the mix, define a derived class and override + this method + */ + virtual const CoinPresolveAction *presolve(CoinPresolveMatrix *prob); + + /*! \brief Reverse presolve transformations to recover the solution + to the original problem. + + Handles the core activity of applying postsolve transformations. + + Postsolving is pretty generic; just apply the transformations in reverse + order. You will probably only be interested in overriding this method if + you want to add code to test for consistency while debugging new presolve + techniques. + */ + virtual void postsolve(CoinPostsolveMatrix &prob); + + /*! \brief Destroys queued postsolve actions. + + <i>E.g.</i>, when presolve() determines the problem is infeasible, so that + it will not be necessary to actually solve the presolved problem and + convert the result back to the original problem. + */ + void gutsOfDestroy(); +}; +#endif diff --git a/thirdparty/windows/include/coin/OsiRowCut.hpp b/thirdparty/windows/include/coin/OsiRowCut.hpp new file mode 100644 index 0000000..1332802 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiRowCut.hpp @@ -0,0 +1,331 @@ +// 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 OsiRowCut_H +#define OsiRowCut_H + +#include "CoinPackedVector.hpp" + +#include "OsiCollections.hpp" +#include "OsiCut.hpp" + +//#define OSI_INLINE_ROWCUT_METHODS +#ifdef OSI_INLINE_ROWCUT_METHODS +#define OsiRowCut_inline inline +#else +#define OsiRowCut_inline +#endif + +/** Row Cut Class + +A row cut has: + <ul> + <li>a lower bound<br> + <li>an upper bound<br> + <li>a vector of row elements + </ul> +*/ +class OsiRowCut : public OsiCut { + friend void OsiRowCutUnitTest(const OsiSolverInterface * baseSiP, + const std::string & mpsDir); + +public: + + /**@name Row bounds */ + //@{ + /// Get lower bound + OsiRowCut_inline double lb() const; + /// Set lower bound + OsiRowCut_inline void setLb(double lb); + /// Get upper bound + OsiRowCut_inline double ub() const; + /// Set upper bound + OsiRowCut_inline void setUb(double ub); + //@} + + /**@name Row rhs, sense, range */ + //@{ + /// Get sense ('E', 'G', 'L', 'N', 'R') + char sense() const; + /// Get right-hand side + double rhs() const; + /// Get range (ub - lb for 'R' rows, 0 otherwise) + double range() const; + //@} + + //------------------------------------------------------------------- + /**@name Row elements */ + //@{ + /// Set row elements + OsiRowCut_inline void setRow( + int size, + const int * colIndices, + const double * elements, + bool testForDuplicateIndex = COIN_DEFAULT_VALUE_FOR_DUPLICATE); + /// Set row elements from a packed vector + OsiRowCut_inline void setRow( const CoinPackedVector & v ); + /// Get row elements + OsiRowCut_inline const CoinPackedVector & row() const; + /// Get row elements for changing + OsiRowCut_inline CoinPackedVector & mutableRow() ; + //@} + + /**@name Comparison operators */ + //@{ +#if __GNUC__ != 2 + using OsiCut::operator== ; +#endif + /** equal - true if lower bound, upper bound, row elements, + and OsiCut are equal. + */ + OsiRowCut_inline bool operator==(const OsiRowCut& rhs) const; + +#if __GNUC__ != 2 + using OsiCut::operator!= ; +#endif + /// not equal + OsiRowCut_inline bool operator!=(const OsiRowCut& rhs) const; + //@} + + + //---------------------------------------------------------------- + /**@name Sanity checks on cut */ + //@{ + /** Returns true if the cut is consistent. + This checks to ensure that: + <ul> + <li>The row element vector does not have duplicate indices + <li>The row element vector indices are >= 0 + </ul> + */ + OsiRowCut_inline bool consistent() const; + + /** Returns true if cut is consistent with respect to the solver + interface's model. + This checks to ensure that + <ul> + <li>The row element vector indices are < the number of columns + in the model + </ul> + */ + OsiRowCut_inline bool consistent(const OsiSolverInterface& im) const; + + /** Returns true if the row cut itself is infeasible and cannot be satisfied. + This checks whether + <ul> + <li>the lower bound is strictly greater than the + upper bound. + </ul> + */ + OsiRowCut_inline bool infeasible(const OsiSolverInterface &im) const; + /** Returns infeasibility of the cut with respect to solution + passed in i.e. is positive if cuts off that solution. + solution is getNumCols() long.. + */ + virtual double violated(const double * solution) const; + //@} + + /**@name Arithmetic operators. Apply CoinPackedVector methods to the vector */ + //@{ + /// add <code>value</code> to every vector entry + void operator+=(double value) + { row_ += value; } + + /// subtract <code>value</code> from every vector entry + void operator-=(double value) + { row_ -= value; } + + /// multiply every vector entry by <code>value</code> + void operator*=(double value) + { row_ *= value; } + + /// divide every vector entry by <code>value</code> + void operator/=(double value) + { row_ /= value; } + //@} + + /// Allow access row sorting function + void sortIncrIndex() + {row_.sortIncrIndex();} + + /**@name Constructors and destructors */ + //@{ + /// Assignment operator + OsiRowCut & operator=( const OsiRowCut& rhs); + + /// Copy constructor + OsiRowCut ( const OsiRowCut &); + + /// Clone + virtual OsiRowCut * clone() const; + + /// Default Constructor + OsiRowCut (); + + /** \brief Ownership Constructor + + This constructor assumes ownership of the vectors passed as parameters + for indices and elements. \p colIndices and \p elements will be NULL + on return. + */ + OsiRowCut(double cutlb, double cutub, + int capacity, int size, + int *&colIndices, double *&elements); + + /// Destructor + virtual ~OsiRowCut (); + //@} + + /**@name Debug stuff */ + //@{ + /// Print cuts in collection + virtual void print() const ; + //@} + +private: + + + /**@name Private member data */ + //@{ + /// Row elements + CoinPackedVector row_; + /// Row lower bound + double lb_; + /// Row upper bound + double ub_; + //@} +}; + +#ifdef OSI_INLINE_ROWCUT_METHODS + +//------------------------------------------------------------------- +// Set/Get lower & upper bounds +//------------------------------------------------------------------- +double OsiRowCut::lb() const { return lb_; } +void OsiRowCut::setLb(double lb) { lb_ = lb; } +double OsiRowCut::ub() const { return ub_; } +void OsiRowCut::setUb(double ub) { ub_ = ub; } + +//------------------------------------------------------------------- +// Set row elements +//------------------------------------------------------------------- +void OsiRowCut::setRow(int size, + const int * colIndices, const double * elements) +{ + row_.setVector(size,colIndices,elements); +} +void OsiRowCut::setRow( const CoinPackedVector & v ) +{ + row_ = v; +} + +//------------------------------------------------------------------- +// Get the row +//------------------------------------------------------------------- +const CoinPackedVector & OsiRowCut::row() const +{ + return row_; +} + +//------------------------------------------------------------------- +// Get the row so we can change +//------------------------------------------------------------------- +CoinPackedVector & OsiRowCut::mutableRow() +{ + return row_; +} + +//---------------------------------------------------------------- +// == operator +//------------------------------------------------------------------- +bool +OsiRowCut::operator==(const OsiRowCut& rhs) const +{ + if ( this->OsiCut::operator!=(rhs) ) return false; + if ( row() != rhs.row() ) return false; + if ( lb() != rhs.lb() ) return false; + if ( ub() != rhs.ub() ) return false; + return true; +} +bool +OsiRowCut::operator!=(const OsiRowCut& rhs) const +{ + return !( (*this)==rhs ); +} + + +//---------------------------------------------------------------- +// consistent & infeasible +//------------------------------------------------------------------- +bool OsiRowCut::consistent() const +{ + const CoinPackedVector & r=row(); + r.duplicateIndex("consistent", "OsiRowCut"); + if ( r.getMinIndex() < 0 ) return false; + return true; +} +bool OsiRowCut::consistent(const OsiSolverInterface& im) const +{ + const CoinPackedVector & r=row(); + if ( r.getMaxIndex() >= im.getNumCols() ) return false; + + return true; +} +bool OsiRowCut::infeasible(const OsiSolverInterface &im) const +{ + if ( lb() > ub() ) return true; + + return false; +} + +#endif + +/** Row Cut Class which refers back to row which created it. + It may be useful to strengthen a row rather than add a cut. To do this + we need to know which row is strengthened. This trivial extension + to OsiRowCut does that. + +*/ +class OsiRowCut2 : public OsiRowCut { + +public: + + /**@name Which row */ + //@{ + /// Get row + inline int whichRow() const + { return whichRow_;} + /// Set row + inline void setWhichRow(int row) + { whichRow_=row;} + //@} + + /**@name Constructors and destructors */ + //@{ + /// Assignment operator + OsiRowCut2 & operator=( const OsiRowCut2& rhs); + + /// Copy constructor + OsiRowCut2 ( const OsiRowCut2 &); + + /// Clone + virtual OsiRowCut * clone() const; + + /// Default Constructor + OsiRowCut2 (int row=-1); + + /// Destructor + virtual ~OsiRowCut2 (); + //@} + +private: + + + /**@name Private member data */ + //@{ + /// Which row + int whichRow_; + //@} +}; +#endif diff --git a/thirdparty/windows/include/coin/OsiRowCutDebugger.hpp b/thirdparty/windows/include/coin/OsiRowCutDebugger.hpp new file mode 100644 index 0000000..548e8e3 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiRowCutDebugger.hpp @@ -0,0 +1,187 @@ +// 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 OsiRowCutDebugger_H +#define OsiRowCutDebugger_H + +/*! \file OsiRowCutDebugger.hpp + + \brief Provides a facility to validate cut constraints to ensure that they + do not cut off a given solution. +*/ + +#include <string> + +#include "OsiCuts.hpp" +#include "OsiSolverInterface.hpp" + +/*! \brief Validate cuts against a known solution + + OsiRowCutDebugger provides a facility for validating cuts against a known + solution for a problem. The debugger knows an optimal solution for many of + the miplib3 problems. Check the source for + #activate(const OsiSolverInterface&,const char*) + in OsiRowCutDebugger.cpp for the full set of known problems. + + A full solution vector can be supplied as a parameter with + (#activate(const OsiSolverInterface&,const double*,bool)). + Only the integer values need to be valid. + The default behaviour is to solve an lp relaxation with the integer + variables fixed to the specified values and use the optimal solution to fill + in the continuous variables in the solution. + The debugger can be instructed to preserve the continuous variables (useful + when debugging solvers where the linear relaxation doesn't capture all the + constraints). + + Note that the solution must match the problem held in the solver interface. + If you want to use the row cut debugger on a problem after applying presolve + transformations, your solution must match the presolved problem. (But see + #redoSolution().) +*/ +class OsiRowCutDebugger { + friend void OsiRowCutDebuggerUnitTest(const OsiSolverInterface * siP, + const std::string & mpsDir); + +public: + + /*! @name Validate Row Cuts + + Check that the specified cuts do not cut off the known solution. + */ + //@{ + /*! \brief Check that the set of cuts does not cut off the solution known + to the debugger. + + Check if any generated cuts cut off the solution known to the debugger! + If so then print offending cuts. Return the number of invalid cuts. + */ + virtual int validateCuts(const OsiCuts & cs, int first, int last) const; + + /*! \brief Check that the cut does not cut off the solution known to the + debugger. + + Return true if cut is invalid + */ + virtual bool invalidCut(const OsiRowCut & rowcut) const; + + /*! \brief Returns true if the solution held in the solver is compatible + with the known solution. + + More specifically, returns true if the known solution satisfies the column + bounds held in the solver. + */ + bool onOptimalPath(const OsiSolverInterface &si) const; + //@} + + /*! @name Activate the Debugger + + The debugger is considered to be active when it holds a known solution. + */ + //@{ + /*! \brief Activate a debugger using the name of a problem. + + The debugger knows an optimal solution for most of miplib3. Check the + source code for the full list. Returns true if the debugger is + successfully activated. + */ + bool activate(const OsiSolverInterface &si, const char *model) ; + + /*! \brief Activate a debugger using a full solution array. + + The solution must have one entry for every variable, but only the entries + for integer values are used. By default the debugger will solve an lp + relaxation with the integer variables fixed and fill in values for the + continuous variables from this solution. If the debugger should preserve + the given values for the continuous variables, set \p keepContinuous to + \c true. + + Returns true if debugger activates successfully. + */ + bool activate(const OsiSolverInterface &si, const double* solution, + bool keepContinuous = false) ; + + /// Returns true if the debugger is active + bool active() const; + //@} + + /*! @name Query or Manipulate the Known Solution */ + //@{ + /// Return the known solution + inline const double * optimalSolution() const + { return knownSolution_;} + + /// Return the number of columns in the known solution + inline int numberColumns() const { return (numberColumns_) ; } + + /// Return the value of the objective for the known solution + inline double optimalValue() const { return knownValue_;} + + /*! \brief Edit the known solution to reflect column changes + + Given a translation array \p originalColumns[numberColumns] which can + translate current column indices to original column indices, this method + will edit the solution held in the debugger so that it matches the current + set of columns. + + Useful when the original problem is preprocessed prior to cut generation. + The debugger does keep a record of the changes. + */ + void redoSolution(int numberColumns, const int *originalColumns); + + /// Print optimal solution (returns -1 bad debug, 0 on optimal, 1 not) + int printOptimalSolution(const OsiSolverInterface & si) const; + //@} + + /**@name Constructors and Destructors */ + //@{ + /// Default constructor - no checking + OsiRowCutDebugger (); + + /*! \brief Constructor with name of model. + + See #activate(const OsiSolverInterface&,const char*). + */ + OsiRowCutDebugger(const OsiSolverInterface &si, const char *model) ; + + /*! \brief Constructor with full solution. + + See #activate(const OsiSolverInterface&,const double*,bool). + */ + OsiRowCutDebugger(const OsiSolverInterface &si, const double *solution, + bool enforceOptimality = false) ; + + /// Copy constructor + OsiRowCutDebugger(const OsiRowCutDebugger &); + + /// Assignment operator + OsiRowCutDebugger& operator=(const OsiRowCutDebugger& rhs); + + /// Destructor + virtual ~OsiRowCutDebugger (); + //@} + +private: + + // Private member data + + /**@name Private member data */ + //@{ + /// Value of known solution + double knownValue_; + + /*! \brief Number of columns in known solution + + This must match the number of columns reported by the solver. + */ + int numberColumns_; + + /// array specifying integer variables + bool * integerVariable_; + + /// array specifying known solution + double * knownSolution_; + //@} +}; + +#endif diff --git a/thirdparty/windows/include/coin/OsiSolverBranch.hpp b/thirdparty/windows/include/coin/OsiSolverBranch.hpp new file mode 100644 index 0000000..98c4343 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiSolverBranch.hpp @@ -0,0 +1,152 @@ +// 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 OsiSolverBranch_H +#define OsiSolverBranch_H + +class OsiSolverInterface; +#include "CoinWarmStartBasis.hpp" + +//############################################################################# + +/** Solver Branch Class + + This provides information on a branch as a set of tighter bounds on both ways +*/ + +class OsiSolverBranch { + +public: + ///@name Add and Get methods + //@{ + /// Add a simple branch (i.e. first sets ub of floor(value), second lb of ceil(value)) + void addBranch(int iColumn, double value); + + /// Add bounds - way =-1 is first , +1 is second + void addBranch(int way,int numberTighterLower, const int * whichLower, const double * newLower, + int numberTighterUpper, const int * whichUpper, const double * newUpper); + /// Add bounds - way =-1 is first , +1 is second + void addBranch(int way,int numberColumns,const double * oldLower, const double * newLower, + const double * oldUpper, const double * newUpper); + + /// Apply bounds + void applyBounds(OsiSolverInterface & solver,int way) const; + /// Returns true if current solution satsifies one side of branch + bool feasibleOneWay(const OsiSolverInterface & solver) const; + /// Starts + inline const int * starts() const + { return start_;} + /// Which variables + inline const int * which() const + { return indices_;} + /// Bounds + inline const double * bounds() const + { return bound_;} + //@} + + + ///@name Constructors and destructors + //@{ + /// Default Constructor + OsiSolverBranch(); + + /// Copy constructor + OsiSolverBranch(const OsiSolverBranch & rhs); + + /// Assignment operator + OsiSolverBranch & operator=(const OsiSolverBranch & rhs); + + /// Destructor + ~OsiSolverBranch (); + + //@} + +private: + ///@name Private member data + //@{ + /// Start of lower first, upper first, lower second, upper second + int start_[5]; + /// Column numbers (if >= numberColumns treat as rows) + int * indices_; + /// New bounds + double * bound_; + //@} +}; +//############################################################################# + +/** Solver Result Class + + This provides information on a result as a set of tighter bounds on both ways +*/ + +class OsiSolverResult { + +public: + ///@name Add and Get methods + //@{ + /// Create result + void createResult(const OsiSolverInterface & solver,const double * lowerBefore, + const double * upperBefore); + + /// Restore result + void restoreResult(OsiSolverInterface & solver) const; + + /// Get basis + inline const CoinWarmStartBasis & basis() const + { return basis_;} + + /// Objective value (as minimization) + inline double objectiveValue() const + { return objectiveValue_;} + + /// Primal solution + inline const double * primalSolution() const + { return primalSolution_;} + + /// Dual solution + inline const double * dualSolution() const + { return dualSolution_;} + + /// Extra fixed + inline const OsiSolverBranch & fixed() const + { return fixed_;} + //@} + + + ///@name Constructors and destructors + //@{ + /// Default Constructor + OsiSolverResult(); + + /// Constructor from solver + OsiSolverResult(const OsiSolverInterface & solver,const double * lowerBefore, + const double * upperBefore); + + /// Copy constructor + OsiSolverResult(const OsiSolverResult & rhs); + + /// Assignment operator + OsiSolverResult & operator=(const OsiSolverResult & rhs); + + /// Destructor + ~OsiSolverResult (); + + //@} + +private: + ///@name Private member data + //@{ + /// Value of objective (if >= OsiSolverInterface::getInfinity() then infeasible) + double objectiveValue_; + /// Warm start information + CoinWarmStartBasis basis_; + /// Primal solution (numberColumns) + double * primalSolution_; + /// Dual solution (numberRows) + double * dualSolution_; + /// Which extra variables have been fixed (only way==-1 counts) + OsiSolverBranch fixed_; + //@} +}; +#endif diff --git a/thirdparty/windows/include/coin/OsiSolverInterface.hpp b/thirdparty/windows/include/coin/OsiSolverInterface.hpp new file mode 100644 index 0000000..a581961 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiSolverInterface.hpp @@ -0,0 +1,2143 @@ +// 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 OsiSolverInterface_H +#define OsiSolverInterface_H + +#include <cstdlib> +#include <string> +#include <vector> + +#include "CoinTypes.hpp" +#include "CoinMessageHandler.hpp" +#include "CoinPackedVectorBase.hpp" +#include "CoinPackedMatrix.hpp" +#include "CoinWarmStart.hpp" +#include "CoinFinite.hpp" +#include "CoinError.hpp" + +#include "OsiCollections.hpp" +#include "OsiSolverParameters.hpp" + +class CoinSnapshot; +class CoinLpIO; +class CoinMpsIO; + +class OsiCuts; +class OsiAuxInfo; +class OsiRowCut; +class OsiRowCutDebugger; +class CoinSet; +class CoinBuild; +class CoinModel; +class OsiSolverBranch; +class OsiSolverResult; +class OsiObject; + + +//############################################################################# + +/*! \brief Abstract Base Class for describing an interface to a solver. + + Many OsiSolverInterface query methods return a const pointer to the + requested read-only data. If the model data is changed or the solver + is called, these pointers may no longer be valid and should be + refreshed by invoking the member function to obtain an updated copy + of the pointer. + For example: + \code + OsiSolverInterface solverInterfacePtr ; + const double * ruBnds = solverInterfacePtr->getRowUpper(); + solverInterfacePtr->applyCuts(someSetOfCuts); + // ruBnds is no longer a valid pointer and must be refreshed + ruBnds = solverInterfacePtr->getRowUpper(); + \endcode + + Querying a problem that has no data associated with it will result in + zeros for the number of rows and columns, and NULL pointers from + the methods that return vectors. +*/ + +class OsiSolverInterface { + friend void OsiSolverInterfaceCommonUnitTest( + const OsiSolverInterface* emptySi, + const std::string & mpsDir, + const std::string & netlibDir); + friend void OsiSolverInterfaceMpsUnitTest( + const std::vector<OsiSolverInterface*> & vecSiP, + const std::string & mpsDir); + +public: + + /// Internal class for obtaining status from the applyCuts method + class ApplyCutsReturnCode { + friend class OsiSolverInterface; + friend class OsiClpSolverInterface; + friend class OsiGrbSolverInterface; + + public: + ///@name Constructors and desctructors + //@{ + /// Default constructor + ApplyCutsReturnCode(): + intInconsistent_(0), + extInconsistent_(0), + infeasible_(0), + ineffective_(0), + applied_(0) {} + /// Copy constructor + ApplyCutsReturnCode(const ApplyCutsReturnCode & rhs): + intInconsistent_(rhs.intInconsistent_), + extInconsistent_(rhs.extInconsistent_), + infeasible_(rhs.infeasible_), + ineffective_(rhs.ineffective_), + applied_(rhs.applied_) {} + /// Assignment operator + ApplyCutsReturnCode & operator=(const ApplyCutsReturnCode& rhs) + { + if (this != &rhs) { + intInconsistent_ = rhs.intInconsistent_; + extInconsistent_ = rhs.extInconsistent_; + infeasible_ = rhs.infeasible_; + ineffective_ = rhs.ineffective_; + applied_ = rhs.applied_; + } + return *this; + } + /// Destructor + ~ApplyCutsReturnCode(){} + //@} + + /**@name Accessing return code attributes */ + //@{ + /// Number of logically inconsistent cuts + inline int getNumInconsistent() const + {return intInconsistent_;} + /// Number of cuts inconsistent with the current model + inline int getNumInconsistentWrtIntegerModel() const + {return extInconsistent_;} + /// Number of cuts that cause obvious infeasibility + inline int getNumInfeasible() const + {return infeasible_;} + /// Number of redundant or ineffective cuts + inline int getNumIneffective() const + {return ineffective_;} + /// Number of cuts applied + inline int getNumApplied() const + {return applied_;} + //@} + + private: + /**@name Private methods */ + //@{ + /// Increment logically inconsistent cut counter + inline void incrementInternallyInconsistent(){intInconsistent_++;} + /// Increment model-inconsistent counter + inline void incrementExternallyInconsistent(){extInconsistent_++;} + /// Increment infeasible cut counter + inline void incrementInfeasible(){infeasible_++;} + /// Increment ineffective cut counter + inline void incrementIneffective(){ineffective_++;} + /// Increment applied cut counter + inline void incrementApplied(){applied_++;} + //@} + + ///@name Private member data + //@{ + /// Counter for logically inconsistent cuts + int intInconsistent_; + /// Counter for model-inconsistent cuts + int extInconsistent_; + /// Counter for infeasible cuts + int infeasible_; + /// Counter for ineffective cuts + int ineffective_; + /// Counter for applied cuts + int applied_; + //@} + }; + + //--------------------------------------------------------------------------- + + ///@name Solve methods + //@{ + /// Solve initial LP relaxation + virtual void initialSolve() = 0; + + /*! \brief Resolve an LP relaxation after problem modification + + Note the `re-' in `resolve'. initialSolve() should be used to solve the + problem for the first time. + */ + virtual void resolve() = 0; + + /// Invoke solver's built-in enumeration algorithm + virtual void branchAndBound() = 0; + +#ifdef CBC_NEXT_VERSION + /* + Would it make sense to collect all of these routines in a `MIP Helper' + section? It'd make it easier for users and implementors to find them. + */ + /** + Solve 2**N (N==depth) problems and return solutions and bases. + There are N branches each of which changes bounds on both sides + as given by branch. The user should provide an array of (empty) + results which will be filled in. See OsiSolveResult for more details + (in OsiSolveBranch.?pp) but it will include a basis and primal solution. + + The order of results is left to right at feasible leaf nodes so first one + is down, down, ..... + + Returns number of feasible leaves. Also sets number of solves done and number + of iterations. + + This is provided so a solver can do faster. + + If forceBranch true then branch done even if satisfied + */ + virtual int solveBranches(int depth,const OsiSolverBranch * branch, + OsiSolverResult * result, + int & numberSolves, int & numberIterations, + bool forceBranch=false); +#endif + //@} + + //--------------------------------------------------------------------------- + /**@name Parameter set/get methods + + The set methods return true if the parameter was set to the given value, + false otherwise. When a set method returns false, the original value (if + any) should be unchanged. 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. + + \note + There is a default implementation of the set/get + methods, namely to store/retrieve the given value using an array in the + base class. A specific solver implementation can use this feature, for + example, to store parameters that should be used later on. Implementors + of a solver interface should overload these functions to provide the + proper interface to and accurately reflect the capabilities of a + specific solver. + + The format for hints is slightly different in that a boolean specifies + the sense of the hint and an enum specifies the strength of the hint. + Hints should be initialised when a solver is instantiated. + (See OsiSolverParameters.hpp for defined hint parameters and strength.) + When specifying the sense of the hint, a value of true means to work with + the hint, false to work against it. For example, + <ul> + <li> \code setHintParam(OsiDoScale,true,OsiHintTry) \endcode + is a mild suggestion to the solver to scale the constraint + system. + <li> \code setHintParam(OsiDoScale,false,OsiForceDo) \endcode + tells the solver to disable scaling, or throw an exception if + it cannot comply. + </ul> + As another example, a solver interface could use the value and strength + of the \c OsiDoReducePrint hint to adjust the amount of information + printed by the interface and/or solver. The extent to which a solver + obeys hints is left to the solver. The value and strength returned by + \c getHintParam will match the most recent call to \c setHintParam, + and will not necessarily reflect the solver's ability to comply with the + hint. If the hint strength is \c OsiForceDo, the solver is required to + throw an exception if it cannot perform the specified action. + + \note + As with the other set/get methods, there is a default implementation + which maintains arrays in the base class for hint sense and strength. + The default implementation does not store the \c otherInformation + pointer, and always throws an exception for strength \c OsiForceDo. + Implementors of a solver interface should override these functions to + provide the proper interface to and accurately reflect the capabilities + of a specific solver. + */ + //@{ + //! Set an integer parameter + virtual bool setIntParam(OsiIntParam key, int value) { + if (key == OsiLastIntParam) return (false) ; + intParam_[key] = value; + return true; + } + //! Set a double parameter + virtual bool setDblParam(OsiDblParam key, double value) { + if (key == OsiLastDblParam) return (false) ; + dblParam_[key] = value; + return true; + } + //! Set a string parameter + virtual bool setStrParam(OsiStrParam key, const std::string & value) { + if (key == OsiLastStrParam) return (false) ; + strParam_[key] = value; + return true; + } + /*! \brief Set a hint parameter + + The \c otherInformation parameter can be used to pass in an arbitrary + block of information which is interpreted by the OSI and the underlying + solver. Users are cautioned that this hook is solver-specific. + + Implementors: + The default implementation completely ignores \c otherInformation and + always throws an exception for OsiForceDo. This is almost certainly not + the behaviour you want; you really should override this method. + */ + virtual bool setHintParam(OsiHintParam key, bool yesNo=true, + OsiHintStrength strength=OsiHintTry, + void * /*otherInformation*/ = NULL) { + if (key==OsiLastHintParam) + return false; + hintParam_[key] = yesNo; + hintStrength_[key] = strength; + if (strength == OsiForceDo) + throw CoinError("OsiForceDo illegal", + "setHintParam", "OsiSolverInterface"); + return true; + } + //! Get an integer parameter + virtual bool getIntParam(OsiIntParam key, int& value) const { + if (key == OsiLastIntParam) return (false) ; + value = intParam_[key]; + return true; + } + //! Get a double parameter + virtual bool getDblParam(OsiDblParam key, double& value) const { + if (key == OsiLastDblParam) return (false) ; + value = dblParam_[key]; + return true; + } + //! Get a string parameter + virtual bool getStrParam(OsiStrParam key, std::string& value) const { + if (key == OsiLastStrParam) return (false) ; + value = strParam_[key]; + return true; + } + /*! \brief Get a hint parameter (all information) + + Return all available information for the hint: sense, strength, + and any extra information associated with the hint. + + Implementors: The default implementation will always set + \c otherInformation to NULL. This is almost certainly not the + behaviour you want; you really should override this method. + */ + virtual bool getHintParam(OsiHintParam key, bool& yesNo, + OsiHintStrength& strength, + void *& otherInformation) const { + if (key==OsiLastHintParam) + return false; + yesNo = hintParam_[key]; + strength = hintStrength_[key]; + otherInformation=NULL; + return true; + } + /*! \brief Get a hint parameter (sense and strength only) + + Return only the sense and strength of the hint. + */ + virtual bool getHintParam(OsiHintParam key, bool& yesNo, + OsiHintStrength& strength) const { + if (key==OsiLastHintParam) + return false; + yesNo = hintParam_[key]; + strength = hintStrength_[key]; + return true; + } + /*! \brief Get a hint parameter (sense only) + + Return only the sense (true/false) of the hint. + */ + virtual bool getHintParam(OsiHintParam key, bool& yesNo) const { + if (key==OsiLastHintParam) + return false; + yesNo = hintParam_[key]; + return true; + } + /*! \brief Copy all parameters in this section from one solver to another + + Note that the current implementation also copies the appData block, + message handler, and rowCutDebugger. Arguably these should have + independent copy methods. + */ + void copyParameters(OsiSolverInterface & rhs); + + /** \brief Return the integrality tolerance of the underlying solver. + + We should be able to get an integrality tolerance, but + until that time just use the primal tolerance + + \todo + This method should be replaced; it's architecturally wrong. This + should be an honest dblParam with a keyword. Underlying solvers + that do not support integer variables should return false for set and + get on this parameter. Underlying solvers that support integrality + should add this to the parameters they support, using whatever + tolerance is appropriate. -lh, 091021- + */ + inline double getIntegerTolerance() const + { return dblParam_[OsiPrimalTolerance];} + //@} + + //--------------------------------------------------------------------------- + ///@name Methods returning info on how the solution process terminated + //@{ + /// Are there numerical difficulties? + virtual bool isAbandoned() const = 0; + /// Is optimality proven? + virtual bool isProvenOptimal() const = 0; + /// Is primal infeasibility proven? + virtual bool isProvenPrimalInfeasible() const = 0; + /// Is dual infeasibility proven? + virtual bool isProvenDualInfeasible() const = 0; + /// Is the given primal objective limit reached? + virtual bool isPrimalObjectiveLimitReached() const; + /// Is the given dual objective limit reached? + virtual bool isDualObjectiveLimitReached() const; + /// Iteration limit reached? + virtual bool isIterationLimitReached() const = 0; + //@} + + //--------------------------------------------------------------------------- + /** \name Warm start methods + + Note that the warm start methods return a generic CoinWarmStart object. + The precise characteristics of this object are solver-dependent. Clients + who wish to maintain a maximum degree of solver independence should take + care to avoid unnecessary assumptions about the properties of a warm start + object. + */ + //@{ + /*! \brief Get an empty warm start object + + This routine returns an empty warm start object. Its purpose is + to provide a way for a client to acquire a warm start object of the + appropriate type for the solver, which can then be resized and modified + as desired. + */ + + virtual CoinWarmStart *getEmptyWarmStart () const = 0 ; + + /** \brief Get warm start information. + + Return warm start information for the current state of the solver + interface. If there is no valid warm start information, an empty warm + start object wil be returned. + */ + virtual CoinWarmStart* getWarmStart() const = 0; + /** \brief Get warm start information. + + Return warm start information for the current state of the solver + interface. If there is no valid warm start information, an empty warm + start object wil be returned. This does not necessarily create an + object - may just point to one. must Delete set true if user + should delete returned object. + */ + virtual CoinWarmStart* getPointerToWarmStart(bool & mustDelete) ; + + /** \brief Set warm start information. + + Return true or false depending on whether the warm start information was + accepted or not. + By definition, a call to setWarmStart with a null parameter should + cause the solver interface to refresh its warm start information + from the underlying solver. + */ + virtual bool setWarmStart(const CoinWarmStart* warmstart) = 0; + //@} + + //--------------------------------------------------------------------------- + /**@name Hot start methods + + Primarily used in strong branching. The user can create a hot start + object --- a snapshot of the optimization process --- then reoptimize + over and over again, starting from the same point. + + \note + <ul> + <li> Between hot started optimizations only bound changes are allowed. + <li> The copy constructor and assignment operator should NOT copy any + hot start information. + <li> The default implementation simply extracts a warm start object in + \c markHotStart, resets to the warm start object in + \c solveFromHotStart, and deletes the warm start object in + \c unmarkHotStart. + <em>Actual solver implementations are encouraged to do better.</em> + </ul> + + */ + //@{ + /// Create a hot start snapshot of the optimization process. + virtual void markHotStart(); + /// Optimize starting from the hot start snapshot. + virtual void solveFromHotStart(); + /// Delete the hot start snapshot. + virtual void unmarkHotStart(); + //@} + + //--------------------------------------------------------------------------- + /**@name Problem query methods + + Querying a problem that has no data associated with it will result in + zeros for the number of rows and columns, and NULL pointers from the + methods that return vectors. + + Const pointers returned from any data-query method are valid as long as + the data is unchanged and the solver is not called. + */ + //@{ + /// Get the number of columns + virtual int getNumCols() const = 0; + + /// Get the number of rows + virtual int getNumRows() const = 0; + + /// Get the number of nonzero elements + virtual int getNumElements() const = 0; + + /// Get the number of integer variables + virtual int getNumIntegers() const ; + + /// Get a pointer to an array[getNumCols()] of column lower bounds + virtual const double * getColLower() const = 0; + + /// Get a pointer to an array[getNumCols()] of column upper bounds + virtual const double * getColUpper() const = 0; + + /*! \brief Get a pointer to an array[getNumRows()] of row constraint senses. + + <ul> + <li>'L': <= constraint + <li>'E': = constraint + <li>'G': >= constraint + <li>'R': ranged constraint + <li>'N': free constraint + </ul> + */ + virtual const char * getRowSense() const = 0; + + /*! \brief Get a pointer to an array[getNumRows()] of row right-hand sides + + <ul> + <li> if getRowSense()[i] == 'L' then + getRightHandSide()[i] == getRowUpper()[i] + <li> if getRowSense()[i] == 'G' then + getRightHandSide()[i] == getRowLower()[i] + <li> if getRowSense()[i] == 'R' then + getRightHandSide()[i] == getRowUpper()[i] + <li> if getRowSense()[i] == 'N' then + getRightHandSide()[i] == 0.0 + </ul> + */ + virtual const double * getRightHandSide() const = 0; + + /*! \brief Get a pointer to an array[getNumRows()] of row ranges. + + <ul> + <li> if getRowSense()[i] == 'R' then + getRowRange()[i] == getRowUpper()[i] - getRowLower()[i] + <li> if getRowSense()[i] != 'R' then + getRowRange()[i] is 0.0 + </ul> + */ + virtual const double * getRowRange() const = 0; + + /// Get a pointer to an array[getNumRows()] of row lower bounds + virtual const double * getRowLower() const = 0; + + /// Get a pointer to an array[getNumRows()] of row upper bounds + virtual const double * getRowUpper() const = 0; + + /*! \brief Get a pointer to an array[getNumCols()] of objective + function coefficients. + */ + virtual const double * getObjCoefficients() const = 0; + + /*! \brief Get the objective function sense + + - 1 for minimisation (default) + - -1 for maximisation + */ + virtual double getObjSense() const = 0; + + /// Return true if the variable is continuous + virtual bool isContinuous(int colIndex) const = 0; + + /// Return true if the variable is binary + virtual bool isBinary(int colIndex) const; + + /*! \brief Return true if the variable is integer. + + This method returns true if the variable is binary or general integer. + */ + virtual bool isInteger(int colIndex) const; + + /// Return true if the variable is general integer + virtual bool isIntegerNonBinary(int colIndex) const; + + /// Return true if the variable is binary and not fixed + virtual bool isFreeBinary(int colIndex) const; + + /*! \brief Return an array[getNumCols()] of column types + + \deprecated See #getColType + */ + inline const char *columnType(bool refresh=false) const + { return getColType(refresh); } + + /*! \brief Return an array[getNumCols()] of column types + + - 0 - continuous + - 1 - binary + - 2 - general integer + + If \p refresh is true, the classification of integer variables as + binary or general integer will be reevaluated. If the current bounds + are [0,1], or if the variable is fixed at 0 or 1, it will be classified + as binary, otherwise it will be classified as general integer. + */ + virtual const char * getColType(bool refresh=false) const; + + /// Get a pointer to a row-wise copy of the matrix + virtual const CoinPackedMatrix * getMatrixByRow() const = 0; + + /// Get a pointer to a column-wise copy of the matrix + virtual const CoinPackedMatrix * getMatrixByCol() const = 0; + + /*! \brief Get a pointer to a mutable row-wise copy of the matrix. + + Returns NULL if the request is not meaningful (i.e., the OSI will not + recognise any modifications to the matrix). + */ + virtual CoinPackedMatrix * getMutableMatrixByRow() const {return NULL;} + + /*! \brief Get a pointer to a mutable column-wise copy of the matrix + + Returns NULL if the request is not meaningful (i.e., the OSI will not + recognise any modifications to the matrix). + */ + virtual CoinPackedMatrix * getMutableMatrixByCol() const {return NULL;} + + /// Get the solver's value for infinity + virtual double getInfinity() const = 0; + //@} + + /**@name Solution query methods */ + //@{ + /// Get a pointer to an array[getNumCols()] of primal variable values + virtual const double * getColSolution() const = 0; + + /** Get a pointer to an array[getNumCols()] of primal variable values + guaranteed to be between the column lower and upper bounds. + */ + virtual const double * getStrictColSolution(); + + /// Get pointer to array[getNumRows()] of dual variable values + virtual const double * getRowPrice() const = 0; + + /// Get a pointer to an array[getNumCols()] of reduced costs + virtual const double * getReducedCost() const = 0; + + /** Get a pointer to array[getNumRows()] of row activity levels. + + The row activity for a row is the left-hand side evaluated at the + current solution. + */ + virtual const double * getRowActivity() const = 0; + + /// Get the objective function value. + virtual double getObjValue() const = 0; + + /** Get the number of iterations it took to solve the problem (whatever + `iteration' means to the solver). + */ + virtual int getIterationCount() const = 0; + + /** Get as many dual rays as the solver can provide. In case of proven + primal infeasibility there should (with high probability) be at least + one. + + The first getNumRows() ray components will always be associated with + the row duals (as returned by getRowPrice()). If \c fullRay is true, + the final getNumCols() entries will correspond to the ray components + associated with the nonbasic variables. If the full ray is requested + and the method cannot provide it, it will throw an exception. + + \note + Implementors of solver interfaces note that the double pointers in + the vector should point to arrays of length getNumRows() (fullRay = + false) or (getNumRows()+getNumCols()) (fullRay = true) and they should + be allocated with new[]. + + \note + Clients of solver interfaces note that it is the client's + responsibility to free the double pointers in the vector using + delete[]. Clients are reminded that a problem can be dual and primal + infeasible. + */ + virtual std::vector<double*> getDualRays(int maxNumRays, + bool fullRay = false) const = 0; + + /** Get as many primal rays as the solver can provide. In case of proven + dual infeasibility there should (with high probability) be at least + one. + + \note + Implementors of solver interfaces note that the double pointers in + the vector should point to arrays of length getNumCols() and they + should be allocated with new[]. + + \note + Clients of solver interfaces note that it is the client's + responsibility to free the double pointers in the vector using + delete[]. Clients are reminded that a problem can be dual and primal + infeasible. + */ + virtual std::vector<double*> getPrimalRays(int maxNumRays) const = 0; + + /** Get vector of indices of primal variables which are integer variables + but have fractional values in the current solution. */ + virtual OsiVectorInt getFractionalIndices(const double etol=1.e-05) + const; + //@} + + //------------------------------------------------------------------------- + /**@name Methods to modify the objective, bounds, and solution + + For functions which take a set of indices as parameters + (\c setObjCoeffSet(), \c setColSetBounds(), \c setRowSetBounds(), + \c setRowSetTypes()), the parameters follow the C++ STL iterator + convention: \c indexFirst points to the first index in the + set, and \c indexLast points to a position one past the last index + in the set. + + */ + //@{ + /** Set an objective function coefficient */ + virtual void setObjCoeff( int elementIndex, double elementValue ) = 0; + + /** Set a set of objective function coefficients */ + virtual void setObjCoeffSet(const int* indexFirst, + const int* indexLast, + const double* coeffList); + + /** Set the objective coefficients for all columns. + + array [getNumCols()] is an array of values for the objective. + This defaults to a series of set operations and is here for speed. + */ + virtual void setObjective(const double * array); + + /** Set the objective function sense. + + Use 1 for minimisation (default), -1 for maximisation. + + \note + Implementors note that objective function sense is a parameter of + the OSI, not a property of the problem. Objective sense can be + set prior to problem load and should not be affected by loading a + new problem. + */ + virtual void setObjSense(double s) = 0; + + + /** Set a single column lower bound. + Use -getInfinity() for -infinity. */ + virtual void setColLower( int elementIndex, double elementValue ) = 0; + + /** Set the lower bounds for all columns. + + array [getNumCols()] is an array of values for the lower bounds. + This defaults to a series of set operations and is here for speed. + */ + virtual void setColLower(const double * array); + + /** Set a single column upper bound. + Use getInfinity() for infinity. */ + virtual void setColUpper( int elementIndex, double elementValue ) = 0; + + /** Set the upper bounds for all columns. + + array [getNumCols()] is an array of values for the upper bounds. + This defaults to a series of set operations and is here for speed. + */ + virtual void setColUpper(const double * array); + + + /** Set a single column lower and upper bound. + The default implementation just invokes setColLower() and + setColUpper() */ + virtual void setColBounds( int elementIndex, + double lower, double upper ) { + setColLower(elementIndex, lower); + setColUpper(elementIndex, upper); + } + + /** Set the upper and lower bounds of a set of columns. + + The default implementation just invokes setColBounds() over and over + again. For each column, boundList must contain both a lower and + upper bound, in that order. + */ + virtual void setColSetBounds(const int* indexFirst, + const int* indexLast, + const double* boundList); + + /** Set a single row lower bound. + Use -getInfinity() for -infinity. */ + virtual void setRowLower( int elementIndex, double elementValue ) = 0; + + /** Set a single row upper bound. + Use getInfinity() for infinity. */ + virtual void setRowUpper( int elementIndex, double elementValue ) = 0; + + /** Set a single row lower and upper bound. + The default implementation just invokes setRowLower() and + setRowUpper() */ + virtual void setRowBounds( int elementIndex, + double lower, double upper ) { + setRowLower(elementIndex, lower); + setRowUpper(elementIndex, upper); + } + + /** Set the bounds on a set of rows. + + The default implementation just invokes setRowBounds() over and over + again. For each row, boundList must contain both a lower and + upper bound, in that order. + */ + virtual void setRowSetBounds(const int* indexFirst, + const int* indexLast, + const double* boundList); + + + /** Set the type of a single row */ + virtual void setRowType(int index, char sense, double rightHandSide, + double range) = 0; + + /** Set the type of a set of rows. + The default implementation just invokes setRowType() + over and over again. + */ + virtual void setRowSetTypes(const int* indexFirst, + const int* indexLast, + const char* senseList, + const double* rhsList, + const double* rangeList); + + /** Set the primal solution variable values + + colsol[getNumCols()] is an array of values for the primal variables. + These values are copied to memory owned by the solver interface + object or the solver. They will be returned as the result of + getColSolution() until changed by another call to setColSolution() or + by a call to any solver routine. Whether the solver makes use of the + solution in any way is solver-dependent. + */ + virtual void setColSolution(const double *colsol) = 0; + + /** Set dual solution variable values + + rowprice[getNumRows()] is an array of values for the dual variables. + These values are copied to memory owned by the solver interface + object or the solver. They will be returned as the result of + getRowPrice() until changed by another call to setRowPrice() or by a + call to any solver routine. Whether the solver makes use of the + solution in any way is solver-dependent. + */ + virtual void setRowPrice(const double * rowprice) = 0; + + /** Fix variables at bound based on reduced cost + + For variables currently at bound, fix the variable at bound if the + reduced cost exceeds the gap. Return the number of variables fixed. + + If justInteger is set to false, the routine will also fix continuous + variables, but the test still assumes a delta of 1.0. + */ + virtual int reducedCostFix(double gap, bool justInteger=true); + //@} + + //------------------------------------------------------------------------- + /**@name Methods to set variable type */ + //@{ + /** Set the index-th variable to be a continuous variable */ + virtual void setContinuous(int index) = 0; + /** Set the index-th variable to be an integer variable */ + virtual void setInteger(int index) = 0; + /** Set the variables listed in indices (which is of length len) to be + continuous variables */ + virtual void setContinuous(const int* indices, int len); + /** Set the variables listed in indices (which is of length len) to be + integer variables */ + virtual void setInteger(const int* indices, int len); + //@} + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + + /*! \brief Data type for name vectors. */ + typedef std::vector<std::string> OsiNameVec ; + + /*! \name Methods for row and column names + + Osi defines three name management disciplines: `auto names' (0), `lazy + names' (1), and `full names' (2). See the description of + #OsiNameDiscipline for details. Changing the name discipline (via + setIntParam()) will not automatically add or remove name information, + but setting the discipline to auto will make existing information + inaccessible until the discipline is reset to lazy or full. + + By definition, a row index of getNumRows() (<i>i.e.</i>, one larger than + the largest valid row index) refers to the objective function. + + OSI users and implementors: While the OSI base class can define an + interface and provide rudimentary support, use of names really depends + on support by the OsiXXX class to ensure that names are managed + correctly. If an OsiXXX class does not support names, it should return + false for calls to getIntParam() or setIntParam() that reference + OsiNameDiscipline. + */ + //@{ + + /*! \brief Generate a standard name of the form Rnnnnnnn or Cnnnnnnn + + Set \p rc to 'r' for a row name, 'c' for a column name. + The `nnnnnnn' part is generated from ndx and will contain 7 digits + by default, padded with zeros if necessary. As a special case, + ndx = getNumRows() is interpreted as a request for the name of the + objective function. OBJECTIVE is returned, truncated to digits+1 + characters to match the row and column names. + */ + virtual std::string dfltRowColName(char rc, + int ndx, unsigned digits = 7) const ; + + /*! \brief Return the name of the objective function */ + + virtual std::string getObjName (unsigned maxLen = static_cast<unsigned>(std::string::npos)) const ; + + /*! \brief Set the name of the objective function */ + + virtual inline void setObjName (std::string name) + { objName_ = name ; } + + /*! \brief Return the name of the row. + + The routine will <i>always</i> return some name, regardless of the name + discipline or the level of support by an OsiXXX derived class. Use + maxLen to limit the length. + */ + virtual std::string getRowName(int rowIndex, + unsigned maxLen = static_cast<unsigned>(std::string::npos)) const ; + + /*! \brief Return a pointer to a vector of row names + + If the name discipline (#OsiNameDiscipline) is auto, the return value + will be a vector of length zero. If the name discipline is lazy, the + vector will contain only names supplied by the client and will be no + larger than needed to hold those names; entries not supplied will be + null strings. In particular, the objective name is <i>not</i> + included in the vector for lazy names. If the name discipline is + full, the vector will have getNumRows() names, either supplied or + generated, plus one additional entry for the objective name. + */ + virtual const OsiNameVec &getRowNames() ; + + /*! \brief Set a row name + + Quietly does nothing if the name discipline (#OsiNameDiscipline) is + auto. Quietly fails if the row index is invalid. + */ + virtual void setRowName(int ndx, std::string name) ; + + /*! \brief Set multiple row names + + The run of len entries starting at srcNames[srcStart] are installed as + row names starting at row index tgtStart. The base class implementation + makes repeated calls to setRowName. + */ + virtual void setRowNames(OsiNameVec &srcNames, + int srcStart, int len, int tgtStart) ; + + /*! \brief Delete len row names starting at index tgtStart + + The specified row names are removed and the remaining row names are + copied down to close the gap. + */ + virtual void deleteRowNames(int tgtStart, int len) ; + + /*! \brief Return the name of the column + + The routine will <i>always</i> return some name, regardless of the name + discipline or the level of support by an OsiXXX derived class. Use + maxLen to limit the length. + */ + virtual std::string getColName(int colIndex, + unsigned maxLen = static_cast<unsigned>(std::string::npos)) const ; + + /*! \brief Return a pointer to a vector of column names + + If the name discipline (#OsiNameDiscipline) is auto, the return value + will be a vector of length zero. If the name discipline is lazy, the + vector will contain only names supplied by the client and will be no + larger than needed to hold those names; entries not supplied will be + null strings. If the name discipline is full, the vector will have + getNumCols() names, either supplied or generated. + */ + virtual const OsiNameVec &getColNames() ; + + /*! \brief Set a column name + + Quietly does nothing if the name discipline (#OsiNameDiscipline) is + auto. Quietly fails if the column index is invalid. + */ + virtual void setColName(int ndx, std::string name) ; + + /*! \brief Set multiple column names + + The run of len entries starting at srcNames[srcStart] are installed as + column names starting at column index tgtStart. The base class + implementation makes repeated calls to setColName. + */ + virtual void setColNames(OsiNameVec &srcNames, + int srcStart, int len, int tgtStart) ; + + /*! \brief Delete len column names starting at index tgtStart + + The specified column names are removed and the remaining column names + are copied down to close the gap. + */ + virtual void deleteColNames(int tgtStart, int len) ; + + + /*! \brief Set row and column names from a CoinMpsIO object. + + Also sets the name of the objective function. If the name discipline + is auto, you get what you asked for. This routine does not use + setRowName or setColName. + */ + void setRowColNames(const CoinMpsIO &mps) ; + + /*! \brief Set row and column names from a CoinModel object. + + If the name discipline is auto, you get what you asked for. + This routine does not use setRowName or setColName. + */ + void setRowColNames(CoinModel &mod) ; + + /*! \brief Set row and column names from a CoinLpIO object. + + Also sets the name of the objective function. If the name discipline is + auto, you get what you asked for. This routine does not use setRowName + or setColName. + */ + void setRowColNames(CoinLpIO &mod) ; + + //@} + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + /**@name Methods to modify the constraint system. + + Note that new columns are added as continuous variables. + */ + //@{ + + /** Add a column (primal variable) to the problem. */ + virtual void addCol(const CoinPackedVectorBase& vec, + const double collb, const double colub, + const double obj) = 0; + + /*! \brief Add a named column (primal variable) to the problem. + + The default implementation adds the column, then changes the name. This + can surely be made more efficient within an OsiXXX class. + */ + virtual void addCol(const CoinPackedVectorBase& vec, + const double collb, const double colub, + const double obj, std::string name) ; + + /** Add a column (primal variable) to the problem. */ + virtual void addCol(int numberElements, + const int* rows, const double* elements, + const double collb, const double colub, + const double obj) ; + + /*! \brief Add a named column (primal variable) to the problem. + + The default implementation adds the column, then changes the name. This + can surely be made more efficient within an OsiXXX class. + */ + virtual void addCol(int numberElements, + const int* rows, const double* elements, + const double collb, const double colub, + const double obj, std::string name) ; + + /** Add a set of columns (primal variables) to the problem. + + The default implementation simply makes repeated calls to + addCol(). + */ + virtual void addCols(const int numcols, + const CoinPackedVectorBase * const * cols, + const double* collb, const double* colub, + const double* obj); + + /** Add a set of columns (primal variables) to the problem. + + The default implementation simply makes repeated calls to + addCol(). + */ + virtual void addCols(const int numcols, const int* columnStarts, + const int* rows, const double* elements, + const double* collb, const double* colub, + const double* obj); + + /// Add columns using a CoinBuild object + void addCols(const CoinBuild & buildObject); + + /** 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 + */ + int addCols(CoinModel & modelObject); + +#if 0 + /** */ + virtual void addCols(const CoinPackedMatrix& matrix, + const double* collb, const double* colub, + const double* obj); +#endif + + /** \brief Remove a set of columns (primal variables) from the + problem. + + The solver interface for a basis-oriented solver will maintain valid + warm start information if all deleted variables are nonbasic. + */ + virtual void deleteCols(const int num, const int * colIndices) = 0; + + /*! \brief Add a row (constraint) to the problem. */ + virtual void addRow(const CoinPackedVectorBase& vec, + const double rowlb, const double rowub) = 0; + + /*! \brief Add a named row (constraint) to the problem. + + The default implementation adds the row, then changes the name. This + can surely be made more efficient within an OsiXXX class. + */ + virtual void addRow(const CoinPackedVectorBase& vec, + const double rowlb, const double rowub, + std::string name) ; + + /*! \brief Add a row (constraint) to the problem. */ + virtual void addRow(const CoinPackedVectorBase& vec, + const char rowsen, const double rowrhs, + const double rowrng) = 0; + + /*! \brief Add a named row (constraint) to the problem. + + The default implementation adds the row, then changes the name. This + can surely be made more efficient within an OsiXXX class. + */ + virtual void addRow(const CoinPackedVectorBase& vec, + const char rowsen, const double rowrhs, + const double rowrng, std::string name) ; + + /*! Add a row (constraint) to the problem. + + Converts to addRow(CoinPackedVectorBase&,const double,const double). + */ + virtual void addRow(int numberElements, + const int *columns, const double *element, + const double rowlb, const double rowub) ; + + /*! Add a set of rows (constraints) to the problem. + + The default implementation simply makes repeated calls to + addRow(). + */ + virtual void addRows(const int numrows, + const CoinPackedVectorBase * const * rows, + const double* rowlb, const double* rowub); + + /** Add a set of rows (constraints) to the problem. + + The default implementation simply makes repeated calls to + addRow(). + */ + virtual void addRows(const int numrows, + const CoinPackedVectorBase * const * rows, + const char* rowsen, const double* rowrhs, + const double* rowrng); + + /** Add a set of rows (constraints) to the problem. + + The default implementation simply makes repeated calls to + addRow(). + */ + virtual void addRows(const int numrows, const int *rowStarts, + const int *columns, const double *element, + const double *rowlb, const double *rowub); + + /// Add rows using a CoinBuild object + void addRows(const CoinBuild &buildObject); + + /*! Add rows from a CoinModel object. + + Returns -1 if the object is in the wrong state (<i>i.e.</i>, has + column-major information), otherwise the number of errors. + + The modelObject is not const as it can be regularized as part of + the build. + */ + int addRows(CoinModel &modelObject); + +#if 0 + /** */ + virtual void addRows(const CoinPackedMatrix& matrix, + const double* rowlb, const double* rowub); + /** */ + virtual void addRows(const CoinPackedMatrix& matrix, + const char* rowsen, const double* rowrhs, + const double* rowrng); +#endif + + /** \brief Delete a set of rows (constraints) from the problem. + + The solver interface for a basis-oriented solver will maintain valid + warm start information if all deleted rows are loose. + */ + virtual void deleteRows(const int num, const int * rowIndices) = 0; + + /** \brief Replace the constraint matrix + + I (JJF) am getting annoyed because I can't just replace a matrix. + The default behavior of this is do nothing so only use where that would + not matter, e.g. strengthening a matrix for MIP. + */ + virtual void replaceMatrixOptional(const CoinPackedMatrix & ) {} + + /** \brief Replace the constraint matrix + + And if it does matter (not used at present) + */ + virtual void replaceMatrix(const CoinPackedMatrix & ) {abort();} + + /** \brief Save a copy of the base model + + If solver wants it can save a copy of "base" (continuous) model here. + */ + virtual void saveBaseModel() {} + + /** \brief Reduce the constraint system to the specified number of + constraints. + + If solver wants it can restore a copy of "base" (continuous) model + here. + + \note + The name is somewhat misleading. Implementors should consider + the opportunity to optimise behaviour in the common case where + \p numberRows is exactly the number of original constraints. Do not, + however, neglect the possibility that \p numberRows does not equal + the number of original constraints. + */ + virtual void restoreBaseModel(int numberRows); + //----------------------------------------------------------------------- + /** Apply a collection of cuts. + + Only cuts which have an <code>effectiveness >= effectivenessLb</code> + are applied. + <ul> + <li> ReturnCode.getNumineffective() -- number of cuts which were + not applied because they had an + <code>effectiveness < effectivenessLb</code> + <li> ReturnCode.getNuminconsistent() -- number of invalid cuts + <li> ReturnCode.getNuminconsistentWrtIntegerModel() -- number of + cuts that are invalid with respect to this integer model + <li> ReturnCode.getNuminfeasible() -- number of cuts that would + make this integer model infeasible + <li> ReturnCode.getNumApplied() -- number of integer cuts which + were applied to the integer model + <li> cs.size() == getNumineffective() + + getNuminconsistent() + + getNuminconsistentWrtIntegerModel() + + getNuminfeasible() + + getNumApplied() + </ul> + */ + virtual ApplyCutsReturnCode applyCuts(const OsiCuts & cs, + double effectivenessLb = 0.0); + + /** Apply a collection of row cuts which are all effective. + applyCuts seems to do one at a time which seems inefficient. + Would be even more efficient to pass an array of pointers. + */ + virtual void applyRowCuts(int numberCuts, const OsiRowCut * cuts); + + /** Apply a collection of row cuts which are all effective. + This is passed in as an array of pointers. + */ + virtual void applyRowCuts(int numberCuts, const OsiRowCut ** cuts); + + /// Deletes branching information before columns deleted + void deleteBranchingInfo(int numberDeleted, const int * which); + + //@} + + //--------------------------------------------------------------------------- + + /**@name Methods for problem input and output */ + //@{ + /*! \brief Load in a problem by copying the arguments. The constraints on + the rows are given by lower and upper bounds. + + If a pointer is 0 then the following values are the default: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>rowub</code>: all rows have upper bound infinity + <li> <code>rowlb</code>: all rows have lower bound -infinity + <li> <code>obj</code>: all variables have 0 objective coefficient + </ul> + + Note that the default values for rowub and rowlb produce the + constraint -infty <= ax <= infty. This is probably not what you want. + */ + virtual void loadProblem (const CoinPackedMatrix& matrix, + const double* collb, const double* colub, + const double* obj, + const double* rowlb, const double* rowub) = 0; + + /*! \brief Load in a problem by assuming ownership of the arguments. + The constraints on the rows are given by lower and upper bounds. + + For default argument values see the matching loadProblem method. + + \warning + The arguments passed to this method will be freed using the + C++ <code>delete</code> and <code>delete[]</code> functions. + */ + virtual void assignProblem (CoinPackedMatrix*& matrix, + double*& collb, double*& colub, double*& obj, + double*& rowlb, double*& rowub) = 0; + + /*! \brief Load in a problem by copying the arguments. + The constraints on the rows are given by sense/rhs/range triplets. + + If a pointer is 0 then the following values are the default: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>obj</code>: all variables have 0 objective coefficient + <li> <code>rowsen</code>: all rows are >= + <li> <code>rowrhs</code>: all right hand sides are 0 + <li> <code>rowrng</code>: 0 for the ranged rows + </ul> + + Note that the default values for rowsen, rowrhs, and rowrng produce the + constraint ax >= 0. + */ + virtual void loadProblem (const CoinPackedMatrix& matrix, + const double* collb, const double* colub, + const double* obj, + const char* rowsen, const double* rowrhs, + const double* rowrng) = 0; + + /*! \brief Load in a problem by assuming ownership of the arguments. + The constraints on the rows are given by sense/rhs/range triplets. + + For default argument values see the matching loadProblem method. + + \warning + The arguments passed to this method will be freed using the + C++ <code>delete</code> and <code>delete[]</code> functions. + */ + virtual void assignProblem (CoinPackedMatrix*& matrix, + double*& collb, double*& colub, double*& obj, + char*& rowsen, double*& rowrhs, + double*& rowrng) = 0; + + /*! \brief Load in a problem by copying the arguments. The constraint + matrix is is specified with standard column-major + column starts / row indices / coefficients vectors. + The constraints on the rows are given by lower and upper bounds. + + The matrix vectors must be gap-free. Note that <code>start</code> must + have <code>numcols+1</code> entries so that the length of the last column + can be calculated as <code>start[numcols]-start[numcols-1]</code>. + + See the previous loadProblem method using rowlb and rowub for default + argument values. + */ + virtual 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) = 0; + + /*! \brief Load in a problem by copying the arguments. The constraint + matrix is is specified with standard column-major + column starts / row indices / coefficients vectors. + The constraints on the rows are given by sense/rhs/range triplets. + + The matrix vectors must be gap-free. Note that <code>start</code> must + have <code>numcols+1</code> entries so that the length of the last column + can be calculated as <code>start[numcols]-start[numcols-1]</code>. + + See the previous loadProblem method using sense/rhs/range for default + argument values. + */ + virtual 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 char* rowsen, const double* rowrhs, + const double* rowrng) = 0; + + /*! \brief Load a model from a CoinModel object. Return the number of + errors encountered. + + The modelObject parameter cannot be const as it may be changed as part + of process. If keepSolution is true will try and keep warmStart. + */ + virtual int loadFromCoinModel (CoinModel & modelObject, + bool keepSolution=false); + + /*! \brief Read a problem in MPS format from the given filename. + + The default implementation uses CoinMpsIO::readMps() to read + the MPS file and returns the number of errors encountered. + */ + virtual int readMps (const char *filename, + const char *extension = "mps") ; + + /*! \brief Read a problem in MPS format from the given full filename. + + This uses CoinMpsIO::readMps() to read the MPS file and returns the + number of errors encountered. It also may return an array of set + information + */ + virtual int readMps (const char *filename, const char*extension, + int & numberSets, CoinSet ** & sets); + + /*! \brief Read a problem in GMPL format from the given filenames. + + The default implementation uses CoinMpsIO::readGMPL(). This capability + is available only if the third-party package Glpk is installed. + */ + virtual int readGMPL (const char *filename, const char *dataname=NULL); + + /*! \brief Write the problem in MPS format to the specified file. + + If objSense is non-zero, a value of -1.0 causes the problem to be + written with a maximization objective; +1.0 forces a minimization + objective. If objSense is zero, the choice is left to the implementation. + */ + virtual void writeMps (const char *filename, + const char *extension = "mps", + double objSense=0.0) const = 0; + + /*! \brief Write the problem in MPS format to the specified file with + more control over the output. + + Row and column names may be null. + formatType is + <ul> + <li> 0 - normal + <li> 1 - extra accuracy + <li> 2 - IEEE hex + </ul> + + Returns non-zero on I/O error + */ + int writeMpsNative (const char *filename, + const char ** rowNames, const char ** columnNames, + int formatType=0,int numberAcross=2, + double objSense=0.0, int numberSOS=0, + const CoinSet * setInfo=NULL) const ; + +/***********************************************************************/ +// Lp files + + /** Write the problem into an Lp file of the given filename with the + specified extension. + Coefficients with value less than epsilon away from an integer value + are written as integers. + Write at most numberAcross monomials on a line. + Write non integer numbers with decimals digits after the decimal point. + + The written problem is always a minimization problem. + If the current problem is a maximization problem, the + intended objective function for the written problem is the current + objective function multiplied by -1. If the current problem is a + minimization problem, the intended objective function for the + written problem is the current objective function. + If objSense < 0, the intended objective function is multiplied by -1 + before writing the problem. It is left unchanged otherwise. + + Write objective function name and constraint names if useRowNames is + true. This version calls writeLpNative(). + */ + virtual void writeLp(const char *filename, + const char *extension = "lp", + double epsilon = 1e-5, + int numberAcross = 10, + int decimals = 5, + double objSense = 0.0, + bool useRowNames = true) const; + + /** Write the problem into the file pointed to by the parameter fp. + Other parameters are similar to + those of writeLp() with first parameter filename. + */ + virtual void writeLp(FILE *fp, + double epsilon = 1e-5, + int numberAcross = 10, + int decimals = 5, + double objSense = 0.0, + bool useRowNames = true) const; + + /** Write the problem into an Lp file. Parameters are similar to + those of writeLp(), but in addition row names and column names + may be given. + + Parameter rowNames may be NULL, in which case default row names + are used. If rowNames is not NULL, it must have exactly one entry + per row in the problem and one additional + entry (rowNames[getNumRows()] with the objective function name. + These getNumRows()+1 entries must be distinct. If this is not the + case, default row names + are used. In addition, format restrictions are imposed on names + (see CoinLpIO::is_invalid_name() for details). + + Similar remarks can be made for the parameter columnNames which + must either be NULL or have exactly getNumCols() distinct entries. + + Write objective function name and constraint names if + useRowNames is true. */ + int writeLpNative(const char *filename, + char const * const * const rowNames, + char const * const * const columnNames, + const double epsilon = 1.0e-5, + const int numberAcross = 10, + const int decimals = 5, + const double objSense = 0.0, + const bool useRowNames = true) const; + + /** Write the problem into the file pointed to by the parameter fp. + Other parameters are similar to + those of writeLpNative() with first parameter filename. + */ + int writeLpNative(FILE *fp, + char const * const * const rowNames, + char const * const * const columnNames, + const double epsilon = 1.0e-5, + const int numberAcross = 10, + const int decimals = 5, + const double objSense = 0.0, + const bool useRowNames = true) const; + + /// Read file in LP format from file with name filename. + /// See class CoinLpIO for description of this format. + virtual int readLp(const char *filename, const double epsilon = 1e-5); + + /// Read file in LP format from the file pointed to by fp. + /// See class CoinLpIO for description of this format. + int readLp(FILE *fp, const double epsilon = 1e-5); + + //@} + + //--------------------------------------------------------------------------- + + /**@name Miscellaneous */ + //@{ + /** Check two models against each other. Return nonzero if different. + Ignore names if that set. + (Note initial version does not check names) + May modify both models by cleaning up + */ + int differentModel(OsiSolverInterface & other, + bool ignoreNames=true); +#ifdef COIN_SNAPSHOT + /// Return a CoinSnapshot + virtual CoinSnapshot * snapshot(bool createArrays=true) const; +#endif +#ifdef COIN_FACTORIZATION_INFO + /// Return number of entries in L part of current factorization + virtual CoinBigIndex getSizeL() const; + /// Return number of entries in U part of current factorization + virtual CoinBigIndex getSizeU() const; +#endif + //@} + + //--------------------------------------------------------------------------- + + /**@name Setting/Accessing application data */ + //@{ + /** Set application data. + + This is a pointer that the application can store into and + retrieve from the solver interface. + This field is available for the application to optionally + define and use. + */ + void setApplicationData (void * appData); + /** Create a clone of an Auxiliary Information object. + The base class just stores an application data pointer + but can be more general. Application data pointer is + designed for one user while this can be extended to cope + with more general extensions. + */ + void setAuxiliaryInfo(OsiAuxInfo * auxiliaryInfo); + + /// Get application data + void * getApplicationData() const; + /// Get pointer to auxiliary info object + OsiAuxInfo * getAuxiliaryInfo() const; + //@} + //--------------------------------------------------------------------------- + + /**@name Message handling + + See the COIN library documentation for additional information about + COIN message facilities. + + */ + //@{ + /** Pass in a message handler + + It is the client's responsibility to destroy a message handler installed + by this routine; it will not be destroyed when the solver interface is + destroyed. + */ + virtual void passInMessageHandler(CoinMessageHandler * handler); + /// Set language + void newLanguage(CoinMessages::Language language); + inline void setLanguage(CoinMessages::Language language) + {newLanguage(language);} + /// Return a pointer to the current message handler + inline CoinMessageHandler * messageHandler() const + {return handler_;} + /// Return the current set of messages + inline CoinMessages messages() + {return messages_;} + /// Return a pointer to the current set of messages + inline CoinMessages * messagesPointer() + {return &messages_;} + /// Return true if default handler + inline bool defaultHandler() const + { return defaultHandler_;} + //@} + //--------------------------------------------------------------------------- + /**@name Methods for dealing with discontinuities other than integers. + + Osi should be able to know about SOS and other types. This is an optional + section where such information can be stored. + + */ + //@{ + /** \brief Identify integer variables and create corresponding objects. + + Record integer variables and create an OsiSimpleInteger object for each + one. All existing OsiSimpleInteger objects will be destroyed. + If justCount then no objects created and we just store numberIntegers_ + */ + + void findIntegers(bool justCount); + /** \brief Identify integer variables and SOS and create corresponding objects. + + Record integer variables and create an OsiSimpleInteger object for each + one. All existing OsiSimpleInteger objects will be destroyed. + If the solver supports SOS then do the same for SOS. + + If justCount then no objects created and we just store numberIntegers_ + Returns number of SOS + */ + + virtual int findIntegersAndSOS(bool justCount); + /// Get the number of objects + inline int numberObjects() const { return numberObjects_;} + /// Set the number of objects + inline void setNumberObjects(int number) + { numberObjects_=number;} + + /// Get the array of objects + inline OsiObject ** objects() const { return object_;} + + /// Get the specified object + const inline OsiObject * object(int which) const { return object_[which];} + /// Get the specified object + inline OsiObject * modifiableObject(int which) const { return object_[which];} + + /// Delete all object information + void deleteObjects(); + + /** Add in object information. + + Objects are cloned; the owner can delete the originals. + */ + void addObjects(int numberObjects, OsiObject ** objects); + /** Use current solution to set bounds so current integer feasible solution will stay feasible. + Only feasible bounds will be used, even if current solution outside bounds. The amount of + such violation will be returned (and if small can be ignored) + */ + double forceFeasible(); + //@} + //--------------------------------------------------------------------------- + + /*! @name Methods related to testing generated cuts + + See the documentation for OsiRowCutDebugger for additional details. + */ + //@{ + /*! \brief Activate the row cut debugger. + + If \p modelName is in the set of known models then all cuts are + checked to see that they do NOT cut off the optimal solution known + to the debugger. + */ + virtual void activateRowCutDebugger (const char *modelName); + + /*! \brief Activate the row cut debugger using a full solution array. + + + Activate the debugger for a model not included in the debugger's + internal database. Cuts will be checked to see that they do NOT + cut off the given solution. + + \p solution must be a full solution vector, but only the integer + variables need to be correct. The debugger will fill in the continuous + variables by solving an lp relaxation with the integer variables + fixed as specified. If the given values for the continuous variables + should be preserved, set \p keepContinuous to true. + */ + virtual void activateRowCutDebugger(const double *solution, + bool enforceOptimality = true); + + /*! \brief Get the row cut debugger provided the solution known to the + debugger is within the feasible region held in the solver. + + If there is a row cut debugger object associated with model AND if + the solution known to the debugger is within the solver's current + feasible region (i.e., the column bounds held in the solver are + compatible with the known solution) then a pointer to the debugger + is returned which may be used to test validity of cuts. + + Otherwise NULL is returned + */ + const OsiRowCutDebugger *getRowCutDebugger() const; + + /*! \brief Get the row cut debugger object + + Return the row cut debugger object if it exists. One common usage of + this method is to obtain a debugger object in order to execute + OsiRowCutDebugger::redoSolution (so that the stored solution is again + compatible with the problem held in the solver). + */ + OsiRowCutDebugger * getRowCutDebuggerAlways() const; + //@} + + /*! \name OsiSimplexInterface + \brief Simplex Interface + + Methods for an advanced interface to a simplex solver. The interface + comprises two groups of methods. Group 1 contains methods for tableau + access. Group 2 contains methods for dictating individual simplex pivots. + */ + //@{ + + /*! \brief Return the simplex implementation level. + + The return codes are: + - 0: the simplex interface is not implemented. + - 1: the Group 1 (tableau access) methods are implemented. + - 2: the Group 2 (pivoting) methods are implemented + + The codes are cumulative - a solver which implements Group 2 also + implements Group 1. + */ + virtual int canDoSimplexInterface() const ; + //@} + + /*! \name OsiSimplex Group 1 + \brief Tableau access methods. + + This group of methods provides access to rows and columns of the basis + inverse and to rows and columns of the tableau. + */ + //@{ + + /*! \brief Prepare the solver for the use of tableau access methods. + + Prepares the solver for the use of the tableau access methods, if + any such preparation is required. + + The \c const attribute is required due to the places this method + may be called (e.g., within CglCutGenerator::generateCuts()). + */ + virtual void enableFactorization() const ; + + /*! \brief Undo the effects of #enableFactorization. */ + virtual void disableFactorization() const ; + + /*! \brief Check if an optimal basis is available. + + Returns true if the problem has been solved to optimality and a + basis is available. This should be used to see if the tableau access + operations are possible and meaningful. + + \note + Implementors please note that this method may be called + before #enableFactorization. + */ + virtual bool basisIsAvailable() const ; + + /// Synonym for #basisIsAvailable + inline bool optimalBasisIsAvailable() const { return basisIsAvailable() ; } + + /*! \brief Retrieve status information for column and row variables. + + This method returns status as integer codes: + <ul> + <li> 0: free + <li> 1: basic + <li> 2: nonbasic at upper bound + <li> 3: nonbasic at lower bound + </ul> + + The #getWarmStart method provides essentially the same functionality + for a simplex-oriented solver, but the implementation details are very + different. + + \note + Logical variables associated with rows are all assumed to have +1 + coefficients, so for a <= constraint the logical will be at lower + bound if the constraint is tight. + + \note + Implementors may choose to implement this method as a wrapper which + converts a CoinWarmStartBasis to the requested representation. + */ + virtual void getBasisStatus(int* cstat, int* rstat) const ; + + /*! \brief Set the status of column and row variables and update + the basis factorization and solution. + + Status information should be coded as documented for #getBasisStatus. + Returns 0 if all goes well, 1 if something goes wrong. + + This method differs from #setWarmStart in the format of the input + and in its immediate effect. Think of it as #setWarmStart immediately + followed by #resolve, but no pivots are allowed. + + \note + Implementors may choose to implement this method as a wrapper that calls + #setWarmStart and #resolve if the no pivot requirement can be satisfied. + */ + virtual int setBasisStatus(const int* cstat, const int* rstat) ; + + /*! \brief Calculate duals and reduced costs for the given objective + coefficients. + + The solver's objective coefficient vector is not changed. + */ + virtual void getReducedGradient(double* columnReducedCosts, + double* duals, const double* c) const ; + + /*! \brief Get a row of the tableau + + If \p slack is not null, it will be loaded with the coefficients for + the artificial (logical) variables (i.e., the row of the basis inverse). + */ + virtual void getBInvARow(int row, double* z, double* slack = NULL) const ; + + /*! \brief Get a row of the basis inverse */ + virtual void getBInvRow(int row, double* z) const ; + + /*! \brief Get a column of the tableau */ + virtual void getBInvACol(int col, double* vec) const ; + + /*! \brief Get a column of the basis inverse */ + virtual void getBInvCol(int col, double* vec) const ; + + /*! \brief Get indices of basic variables + + If the logical (artificial) for row i is basic, the index should be coded + as (#getNumCols + i). + The order of indices must match the order of elements in the vectors + returned by #getBInvACol and #getBInvCol. + */ + virtual void getBasics(int* index) const ; + + //@} + + /*! \name OsiSimplex Group 2 + \brief Pivoting methods + + This group of methods provides for control of individual pivots by a + simplex solver. + */ + //@{ + + /**Enables normal operation of subsequent functions. + This method is supposed to ensure that all typical things (like + reduced costs, etc.) are updated when individual pivots are executed + and can be queried by other methods. says whether will be + doing primal or dual + */ + virtual void enableSimplexInterface(bool doingPrimal) ; + + ///Undo whatever setting changes the above method had to make + virtual void disableSimplexInterface() ; + /** Perform a pivot by substituting a colIn for colOut in the basis. + The status of the leaving variable is given in outStatus. Where + 1 is to upper bound, -1 to lower bound + Return code was undefined - now for OsiClp is 0 for okay, + 1 if inaccuracy forced re-factorization (should be okay) and + -1 for singular factorization + */ + virtual int pivot(int colIn, int colOut, int outStatus) ; + + /** Obtain a result of the primal pivot + Outputs: colOut -- leaving column, outStatus -- its status, + t -- step size, and, if dx!=NULL, *dx -- primal ray direction. + Inputs: colIn -- entering column, sign -- direction of its change (+/-1). + Both for colIn and colOut, artificial variables are index by + the negative of the row index minus 1. + Return code (for now): 0 -- leaving variable found, + -1 -- everything else? + Clearly, more informative set of return values is required + Primal and dual solutions are updated + */ + virtual int primalPivotResult(int colIn, int sign, + int& colOut, int& outStatus, + double& t, CoinPackedVector* dx); + + /** Obtain a result of the dual pivot (similar to the previous method) + Differences: entering variable and a sign of its change are now + the outputs, the leaving variable and its statuts -- the inputs + If dx!=NULL, then *dx contains dual ray + Return code: same + */ + virtual int dualPivotResult(int& colIn, int& sign, + int colOut, int outStatus, + double& t, CoinPackedVector* dx) ; + //@} + + //--------------------------------------------------------------------------- + + ///@name Constructors and destructors + //@{ + /// Default Constructor + OsiSolverInterface(); + + /** Clone + + The result of calling clone(false) is defined to be equivalent to + calling the default constructor OsiSolverInterface(). + */ + virtual OsiSolverInterface * clone(bool copyData = true) const = 0; + + /// Copy constructor + OsiSolverInterface(const OsiSolverInterface &); + + /// Assignment operator + OsiSolverInterface & operator=(const OsiSolverInterface& rhs); + + /// Destructor + virtual ~OsiSolverInterface (); + + /** Reset the solver interface. + + A call to reset() returns the solver interface to the same state as + it would have if it had just been constructed by calling the default + constructor OsiSolverInterface(). + */ + virtual void reset(); + //@} + + //--------------------------------------------------------------------------- + +protected: + ///@name Protected methods + //@{ + /** Apply a row cut (append to the constraint matrix). */ + virtual void applyRowCut( const OsiRowCut & rc ) = 0; + + /** Apply a column cut (adjust the bounds of one or more variables). */ + virtual void applyColCut( const OsiColCut & cc ) = 0; + + /** A quick inlined function to convert from the lb/ub style of + constraint definition to the sense/rhs/range style */ + inline void + convertBoundToSense(const double lower, const double upper, + char& sense, double& right, double& range) const; + /** A quick inlined function to convert from the sense/rhs/range style + of constraint definition to the lb/ub style */ + inline void + convertSenseToBound(const char sense, const double right, + const double range, + double& lower, double& upper) const; + /** A quick inlined function to force a value to be between a minimum and + a maximum value */ + template <class T> inline T + forceIntoRange(const T value, const T lower, const T upper) const { + return value < lower ? lower : (value > upper ? upper : value); + } + /** Set OsiSolverInterface object state for default constructor + + This routine establishes the initial values of data fields in the + OsiSolverInterface object when the object is created using the + default constructor. + */ + void setInitialData(); + //@} + + ///@name Protected member data + //@{ + /*! \brief Pointer to row cut debugger object + + Mutable so that we can update the solution held in the debugger while + maintaining const'ness for the Osi object. + */ + mutable OsiRowCutDebugger * rowCutDebugger_; + // Why not just make useful stuff protected? + /// Message handler + CoinMessageHandler * handler_; + /** Flag to say if the currrent handler is the default handler. + Indicates if the solver interface object is responsible + for destruction of the handler (true) or if the client is + responsible (false). + */ + bool defaultHandler_; + /// Messages + CoinMessages messages_; + /// Number of integers + int numberIntegers_; + /// Total number of objects + int numberObjects_; + + /// Integer and ... information (integer info normally at beginning) + OsiObject ** object_; + /** Column type + 0 - continuous + 1 - binary (may get fixed later) + 2 - general integer (may get fixed later) + */ + mutable char * columnType_; + + //@} + + //--------------------------------------------------------------------------- + +private: + ///@name Private member data + //@{ + /// Pointer to user-defined data structure - and more if user wants + OsiAuxInfo * appDataEtc_; + /// Array of integer parameters + int intParam_[OsiLastIntParam]; + /// Array of double parameters + double dblParam_[OsiLastDblParam]; + /// Array of string parameters + std::string strParam_[OsiLastStrParam]; + /// Array of hint parameters + bool hintParam_[OsiLastHintParam]; + /// Array of hint strengths + OsiHintStrength hintStrength_[OsiLastHintParam]; + /** Warm start information used for hot starts when the default + hot start implementation is used. */ + CoinWarmStart* ws_; + /// Column solution satisfying lower and upper column bounds + std::vector<double> strictColSolution_; + + /// Row names + OsiNameVec rowNames_ ; + /// Column names + OsiNameVec colNames_ ; + /// Objective name + std::string objName_ ; + + //@} +}; + +//############################################################################# +/** A quick inlined function to convert from the lb/ub style of constraint + definition to the sense/rhs/range style */ +inline void +OsiSolverInterface::convertBoundToSense(const double lower, const double upper, + char& sense, double& right, + double& range) const +{ + double inf = getInfinity(); + range = 0.0; + if (lower > -inf) { + if (upper < inf) { + right = upper; + if (upper==lower) { + sense = 'E'; + } else { + sense = 'R'; + range = upper - lower; + } + } else { + sense = 'G'; + right = lower; + } + } else { + if (upper < inf) { + sense = 'L'; + right = upper; + } else { + sense = 'N'; + right = 0.0; + } + } +} + +//----------------------------------------------------------------------------- +/** A quick inlined function to convert from the sense/rhs/range style of + constraint definition to the lb/ub style */ +inline void +OsiSolverInterface::convertSenseToBound(const char sense, const double right, + const double range, + double& lower, double& upper) const +{ + double inf=getInfinity(); + switch (sense) { + case 'E': + lower = upper = right; + break; + case 'L': + lower = -inf; + upper = right; + break; + case 'G': + lower = right; + upper = inf; + break; + case 'R': + lower = right - range; + upper = right; + break; + case 'N': + lower = -inf; + upper = inf; + break; + } +} + +#endif diff --git a/thirdparty/windows/include/coin/OsiSolverParameters.hpp b/thirdparty/windows/include/coin/OsiSolverParameters.hpp new file mode 100644 index 0000000..5f607f5 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiSolverParameters.hpp @@ -0,0 +1,142 @@ +// 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 OsiSolverParameters_H +#define OsiSolverParameters_H + +enum OsiIntParam { + /*! \brief Iteration limit for initial solve and resolve. + + The maximum number of iterations (whatever that means for the given + solver) the solver can execute in the OsiSolverinterface::initialSolve() + and OsiSolverinterface::resolve() methods before terminating. + */ + OsiMaxNumIteration = 0, + /*! \brief Iteration limit for hot start + + The maximum number of iterations (whatever that means for the given + solver) the solver can execute in the + OsiSolverinterface::solveFromHotStart() method before terminating. + */ + OsiMaxNumIterationHotStart, + /*! \brief Handling of row and column names. + + The name discipline specifies how the solver will handle row and column + names: + - 0: Auto names: Names cannot be set by the client. Names of the form + Rnnnnnnn or Cnnnnnnn are generated on demand when a name for a + specific row or column is requested; nnnnnnn is derived from the row + or column index. Requests for a vector of names return a vector with + zero entries. + - 1: Lazy names: Names supplied by the client are retained. Names of the + form Rnnnnnnn or Cnnnnnnn are generated on demand if no name has been + supplied by the client. Requests for a vector of names return a + vector sized to the largest index of a name supplied by the client; + some entries in the vector may be null strings. + - 2: Full names: Names supplied by the client are retained. Names of the + form Rnnnnnnn or Cnnnnnnn are generated on demand if no name has been + supplied by the client. Requests for a vector of names return a + vector sized to match the constraint system, and all entries will + contain either the name specified by the client or a generated name. + */ + OsiNameDiscipline, + /*! \brief End marker. + + Used by OsiSolverInterface to allocate a fixed-sized array to store + integer parameters. + */ + OsiLastIntParam +} ; + +enum OsiDblParam { + /*! \brief Dual objective limit. + + This is to be used as a termination criteria in algorithms where the dual + objective changes monotonically (e.g., dual simplex, volume algorithm). + */ + OsiDualObjectiveLimit = 0, + /*! \brief Primal objective limit. + + This is to be used as a termination criteria in algorithms where the + primal objective changes monotonically (e.g., primal simplex) + */ + OsiPrimalObjectiveLimit, + /*! \brief Dual feasibility tolerance. + + The maximum amount a dual constraint can be violated and still be + considered feasible. + */ + OsiDualTolerance, + /*! \brief Primal feasibility tolerance. + + The maximum amount a primal constraint can be violated and still be + considered feasible. + */ + OsiPrimalTolerance, + /** The value of any constant term in the objective function. */ + OsiObjOffset, + /*! \brief End marker. + + Used by OsiSolverInterface to allocate a fixed-sized array to store + double parameters. + */ + OsiLastDblParam +}; + + +enum OsiStrParam { + /*! \brief The name of the loaded problem. + + This is the string specified on the Name card of an mps file. + */ + OsiProbName = 0, + /*! \brief The name of the solver. + + This parameter is read-only. + */ + OsiSolverName, + /*! \brief End marker. + + Used by OsiSolverInterface to allocate a fixed-sized array to store + string parameters. + */ + OsiLastStrParam +}; + +enum OsiHintParam { + /** Whether to do a presolve in initialSolve */ + OsiDoPresolveInInitial = 0, + /** Whether to use a dual algorithm in initialSolve. + The reverse is to use a primal algorithm */ + OsiDoDualInInitial, + /** Whether to do a presolve in resolve */ + OsiDoPresolveInResolve, + /** Whether to use a dual algorithm in resolve. + The reverse is to use a primal algorithm */ + OsiDoDualInResolve, + /** Whether to scale problem */ + OsiDoScale, + /** Whether to create a non-slack basis (only in initialSolve) */ + OsiDoCrash, + /** Whether to reduce amount of printout, e.g., for branch and cut */ + OsiDoReducePrint, + /** Whether we are in branch and cut - so can modify behavior */ + OsiDoInBranchAndCut, + /** Just a marker, so that OsiSolverInterface can allocate a static sized + array to store parameters. */ + OsiLastHintParam +}; + +enum OsiHintStrength { + /** Ignore hint (default) */ + OsiHintIgnore = 0, + /** This means it is only a hint */ + OsiHintTry, + /** This means do hint if at all possible */ + OsiHintDo, + /** And this means throw an exception if not possible */ + OsiForceDo +}; + +#endif diff --git a/thirdparty/windows/include/coin/OsiSymSolverInterface.hpp b/thirdparty/windows/include/coin/OsiSymSolverInterface.hpp new file mode 100644 index 0000000..46f6514 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiSymSolverInterface.hpp @@ -0,0 +1,806 @@ +/*===========================================================================*/ +/* */ +/* This file is part of the SYMPHONY Branch, Cut, and Price Callable */ +/* Library. */ +/* */ +/* SYMPHONY was jointly developed by Ted Ralphs (tkralphs@lehigh.edu) and */ +/* Laci Ladanyi (ladanyi@us.ibm.com). */ +/* */ +/* (c) Copyright 2004-2006 Ted Ralphs and Lehigh University. */ +/* All Rights Reserved. */ +/* */ +/* The authors of this file are Menal Guzelsoy and Ted Ralphs */ +/* */ +/* This software is licensed under the Eclipse Public License. Please see */ +/* accompanying file for terms. */ +/* */ +/*===========================================================================*/ + +#ifndef OsiSymSolverInterface_hpp +#define OsiSymSolverInterface_hpp + +#include "OsiSolverInterface.hpp" +#include "OsiSymSolverParameters.hpp" +#include "SymWarmStart.hpp" + +#include <string> + +typedef struct SYM_ENVIRONMENT sym_environment; + +//############################################################################# + +/** OSI Solver Interface for SYMPHONY + + Many OsiSolverInterface query methods return a const pointer to the + requested read-only data. If the model data is changed or the solver + is called, these pointers may no longer be valid and should be + refreshed by invoking the member function to obtain an updated copy + of the pointer. + For example: + \code + OsiSolverInterface solverInterfacePtr ; + const double * ruBnds = solverInterfacePtr->getRowUpper(); + solverInterfacePtr->applyCuts(someSetOfCuts); + // ruBnds is no longer a valid pointer and must be refreshed + ruBnds = solverInterfacePtr->getRowUpper(); + \endcode + + Querying a problem that has no data associated with it will result in + zeros for the number of rows and columns, and NULL pointers from + the methods that return vectors. +*/ + +class OsiSymSolverInterface : virtual public OsiSolverInterface { + friend void OsiSymSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir); + +public: + ///@name Solve methods + //@{ + /// Solve initial LP relaxation + virtual void initialSolve(); + + /// Resolve an IP problem modification + virtual void resolve(); + + /// Invoke solver's built-in enumeration algorithm + virtual void branchAndBound(); + + /// Invoke solver's multi-criteria enumeration algorithm + virtual void multiCriteriaBranchAndBound(); + + /// Get a lower bound for the new rhs problem using the warm start tree. + virtual double getLbForNewRhs(int cnt, int *index, + double * value); + /// Get an upper bound for the new rhs problem using the warm start tree. + virtual double getUbForNewRhs(int cnt, int *index, + double * value); +#if 0 + /// Get a lower bound for the new obj problem using the warm start tree. + virtual double getLbForNewObj(int cnt, int *index, + double * value); + /// Get an upper bound for the new obj problem using the warm start tree. +#endif + virtual double getUbForNewObj(int cnt, int *index, + double * value); + + //@} + + //--------------------------------------------------------------------------- + /**@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. + + */ + //@{ + // Set an integer parameter + virtual bool setIntParam(OsiIntParam key, int value); + + // Set SYMPHONY int parameter + virtual bool setSymParam(OsiSymIntParam key, int value); + + // Set SYMPHONY int parameter directly by the C interface parameter name + virtual bool setSymParam(const std::string key, int value); + + + // Set an double parameter + virtual bool setDblParam(OsiDblParam key, double value); + + // Set SYMPHONY double parameter + virtual bool setSymParam(OsiSymDblParam key, double value); + + // Set SYMPHONY double parameter directly by the C interface parameter name + virtual bool setSymParam(const std::string key, double value); + + + + // Set a string parameter + virtual bool setStrParam(OsiStrParam key, const std::string & value); + + // Set SYMPHONY string parameter + virtual bool setSymParam(OsiSymStrParam key, const std::string & value); + + // Set SYMPHONY string parameter directly by the C interface parameter name + virtual bool setSymParam(const std::string key, const std::string value); + + + + // Get an integer parameter + virtual bool getIntParam(OsiIntParam key, int& value) const; + + // Get SYMPHONY int parameter + virtual bool getSymParam(OsiSymIntParam key, int& value) const; + + // Get SYMPHONY int parameter directly by the C interface parameter name + virtual bool getSymParam(const std::string key, int& value) const; + + + // Get an double parameter + virtual bool getDblParam(OsiDblParam key, double& value) const; + + // Get SYMPHONY double parameter + virtual bool getSymParam(OsiSymDblParam key, double& value) const; + + // Get SYMPHONY double parameter directly by the C interface parameter name + virtual bool getSymParam(const std::string key, double& value) const; + + + + // Get a string parameter + virtual bool getStrParam(OsiStrParam key, std::string& value) const; + + // Get SYMPHONY string parameter + virtual bool getSymParam(OsiSymStrParam key, std::string& value) const; + + // Get SYMPHONY string parameter directly by the C interface parameter name + virtual bool getSymParam(const std::string key, std::string& value) const; + + //@} + + //--------------------------------------------------------------------------- + ///@name Methods returning info on how the solution process terminated + //@{ + /// Are there numerical difficulties? + virtual bool isAbandoned() const; + + /// Is optimality proven? + virtual bool isProvenOptimal() const; + + /// Is primal infeasiblity proven? + virtual bool isProvenPrimalInfeasible() const; + + /// Is dual infeasiblity proven? + virtual bool isProvenDualInfeasible() const { + throw CoinError("Error: Function not implemented", + "isProvenDualInfeasible", "OsiSymSolverInterface"); + } + /// Is the given primal objective limit reached? + //virtual bool isPrimalObjectiveLimitReached() const; + + /// Is the given dual objective limit reached? + //virtual bool isDualObjectiveLimitReached() const{ + // throw CoinError("Error: Function not implemented", + // "isDualObjectiveLimitReached", "OsiSymSolverInterface"); + //} + /// Iteration limit reached? + virtual bool isIterationLimitReached() const; + + /// Time limit reached? + virtual bool isTimeLimitReached() const; + + /// Target gap achieved? + virtual bool isTargetGapReached() const; + + //@} + + //--------------------------------------------------------------------------- + /**@name Warm start methods */ + //@{ + /*! \brief Get an empty warm start object + + This routine returns an empty warm start object. Its purpose is + to provide a way to give a client a warm start object of the + appropriate type, which can resized and modified as desired. + */ + + virtual CoinWarmStart *getEmptyWarmStart () const{ + throw CoinError("Error: Function not implemented", + "getEmptyWarmStart", "OsiSymSolverInterface"); + } + + /** Get warm start information. + + If there is no valid solution, an empty warm start object (0 rows, 0 + columns) wil be returned. + */ + + /* + virtual CoinWarmStart* getWarmStart(bool keepTreeInSymEnv = false) const; + */ + + virtual CoinWarmStart* getWarmStart() const; + + /** Set warm start information. + + Return true/false depending on whether the warm start information was + accepted or not. */ + virtual bool setWarmStart(const CoinWarmStart* warmstart); + //@} + + //--------------------------------------------------------------------------- + /**@name Problem query methods + + Querying a problem that has no data associated with it will result in + zeros for the number of rows and columns, and NULL pointers from + the methods that return vectors. + + Const pointers returned from any data-query method are valid as + long as the data is unchanged and the solver is not called. + */ + //@{ + /// Get pointer to SYMPHONY environment (eventually we won't need this) + sym_environment *getSymphonyEnvironment() const {return env_;} + + /// Get number of columns + virtual int getNumCols() const; + + /// Get number of rows + virtual int getNumRows() const; + + /// Get number of nonzero elements + virtual int getNumElements() const; + + /// Get pointer to array[getNumCols()] of column lower bounds + virtual const double * getColLower() const; + + /// Get pointer to array[getNumCols()] of column upper bounds + virtual const double * getColUpper() const; + + /** Get pointer to array[getNumRows()] of row constraint senses. + <ul> + <li>'L': <= constraint + <li>'E': = constraint + <li>'G': >= constraint + <li>'R': ranged constraint + <li>'N': free constraint + </ul> + */ + virtual const char * getRowSense() const; + + /** Get pointer to array[getNumRows()] of row right-hand sides + <ul> + <li> if getRowSense()[i] == 'L' then + getRightHandSide()[i] == getRowUpper()[i] + <li> if getRowSense()[i] == 'G' then + getRightHandSide()[i] == getRowLower()[i] + <li> if getRowSense()[i] == 'R' then + getRightHandSide()[i] == getRowUpper()[i] + <li> if getRowSense()[i] == 'N' then + getRightHandSide()[i] == 0.0 + </ul> + */ + virtual const double * getRightHandSide() const; + + /** Get pointer to array[getNumRows()] of row ranges. + <ul> + <li> if getRowSense()[i] == 'R' then + getRowRange()[i] == getRowUpper()[i] - getRowLower()[i] + <li> if getRowSense()[i] != 'R' then + getRowRange()[i] is 0.0 + </ul> + */ + virtual const double * getRowRange() const; + + /// Get pointer to array[getNumRows()] of row lower bounds + virtual const double * getRowLower() const; + + /// Get pointer to array[getNumRows()] of row upper bounds + virtual const double * getRowUpper() const; + + /// Get pointer to array[getNumCols()] of objective function coefficients + virtual const double * getObjCoefficients() const; + + /** Get pointer to array[getNumCols()] of second + objective function coefficients if loaded before. + */ + virtual const double * getObj2Coefficients() const; + + /// Get objective function sense (1 for min (default), -1 for max) + virtual double getObjSense() const; + + /// Return true if variable is continuous + virtual bool isContinuous(int colIndex) const; + + /// Return true if variable is binary + virtual bool isBinary(int colIndex) const; + + /** Return true if column is integer. + Note: This function returns true if the the column + is binary or a general integer. + */ + virtual bool isInteger(int colIndex) const; + + /// Return true if variable is general integer + virtual bool isIntegerNonBinary(int colIndex) const; + + /// Return true if variable is binary and not fixed at either bound + virtual bool isFreeBinary(int colIndex) const; + + /// Get pointer to row-wise copy of matrix + virtual const CoinPackedMatrix * getMatrixByRow() const; + + /// Get pointer to column-wise copy of matrix + virtual const CoinPackedMatrix * getMatrixByCol() const; + + /// Get solver's value for infinity + virtual double getInfinity() const; + + //@} + + /**@name Solution query methods */ + //@{ + /// Get pointer to array[getNumCols()] of primal variable values + virtual const double * getColSolution() const; + + /// Get pointer to array[getNumRows()] of dual variable values + virtual const double * getRowPrice() const; + + /// Get a pointer to array[getNumCols()] of reduced costs + virtual const double * getReducedCost() const; + + /** Get pointer to array[getNumRows()] of row activity levels (constraint + matrix times the solution vector). */ + virtual const double * getRowActivity() const; + + /// Get objective function value + virtual double getObjValue() const; + + /// Get the current upper/lower bound + virtual double getPrimalBound() const; + + /** Get the number of iterations it took to solve the problem (whatever + ``iteration'' means to the solver). */ + virtual int getIterationCount() const; + + /** Get as many dual rays as the solver can provide. In case of proven + primal infeasibility there should be at least one. + + \note + Implementors of solver interfaces note that + the double pointers in the vector should point to arrays of length + getNumRows() and they should be allocated via new[]. + + \note + Clients of solver interfaces note that + it is the client's responsibility to free the double pointers in the + vector using delete[]. + */ + virtual std::vector<double*> getDualRays(int maxNumRays, + bool fullRay = false) const{ + throw CoinError("Error: Function not implemented", + "getDualRays", "OsiSymSolverInterface"); + } + /** Get as many primal rays as the solver can provide. (In case of proven + dual infeasibility there should be at least one.) + + <strong>NOTE for implementers of solver interfaces:</strong> <br> + The double pointers in the vector should point to arrays of length + getNumCols() and they should be allocated via new[]. <br> + + <strong>NOTE for users of solver interfaces:</strong> <br> + It is the user's responsibility to free the double pointers in the + vector using delete[]. + */ + virtual std::vector<double*> getPrimalRays(int maxNumRays) const{ + throw CoinError("Error: Function not implemented", + "getPrimalRays", "OsiSymSolverInterface"); + } + + //@} + + //------------------------------------------------------------------------- + /**@name Methods to modify the objective, bounds, and solution + + For functions which take a set of indices as parameters + (\c setObjCoeffSet(), \c setColSetBounds(), \c setRowSetBounds(), + \c setRowSetTypes()), the parameters follow the C++ STL iterator + convention: \c indexFirst points to the first index in the + set, and \c indexLast points to a position one past the last index + in the set. + + */ + //@{ + /** Set an objective function coefficient */ + virtual void setObjCoeff( int elementIndex, double elementValue ); + + /** Set an objective function coefficient for the second objective */ + virtual void setObj2Coeff( int elementIndex, double elementValue ); + + using OsiSolverInterface::setColLower ; + /** Set a single column lower bound. + Use -getInfinity() for -infinity. */ + virtual void setColLower( int elementIndex, double elementValue ); + + using OsiSolverInterface::setColUpper ; + /** Set a single column upper bound. + Use getInfinity() for infinity. */ + virtual void setColUpper( int elementIndex, double elementValue ); + + /** Set a single row lower bound. + Use -getInfinity() for -infinity. */ + virtual void setRowLower( int elementIndex, double elementValue ); + + /** Set a single row upper bound. + Use getInfinity() for infinity. */ + virtual void setRowUpper( int elementIndex, double elementValue ); + + /** Set the type of a single row */ + virtual void setRowType(int index, char sense, double rightHandSide, + double range); + + /// Set the objective function sense. + /// (1 for min (default), -1 for max) + virtual void setObjSense(double s); + + /** Set the primal solution variable values + + colsol[getNumCols()] is an array of values for the primal variables. + These values are copied to memory owned by the solver interface object + or the solver. They will be returned as the result of getColSolution() + until changed by another call to setColSolution() or by a call to any + solver routine. Whether the solver makes use of the solution in any + way is solver-dependent. + */ + virtual void setColSolution(const double *colsol); + + /** Set the a priori upper/lower bound */ + + virtual void setPrimalBound(const double bound); + + /** Set dual solution variable values + + rowprice[getNumRows()] is an array of values for the dual + variables. These values are copied to memory owned by the solver + interface object or the solver. They will be returned as the result of + getRowPrice() until changed by another call to setRowPrice() or by a + call to any solver routine. Whether the solver makes use of the + solution in any way is solver-dependent. + */ + + virtual void setRowPrice(const double * rowprice); + + //@} + + //------------------------------------------------------------------------- + /**@name Methods to set variable type */ + //@{ + + using OsiSolverInterface::setContinuous ; + /** Set the index-th variable to be a continuous variable */ + virtual void setContinuous(int index); + + using OsiSolverInterface::setInteger ; + /** Set the index-th variable to be an integer variable */ + virtual void setInteger(int index); + + + using OsiSolverInterface::setColName ; + virtual void setColName(char **colname); + + //@} + //------------------------------------------------------------------------- + + //------------------------------------------------------------------------- + /**@name Methods to expand a problem. + + Note that new columns are added as continuous variables. + + */ + //@{ + + using OsiSolverInterface::addCol ; + /** Add a column (primal variable) to the problem. */ + virtual void addCol(const CoinPackedVectorBase& vec, + const double collb, const double colub, + const double obj); + + /** Remove a set of columns (primal variables) from the problem. */ + virtual void deleteCols(const int num, const int * colIndices); + + using OsiSolverInterface::addRow ; + /** Add a row (constraint) to the problem. */ + virtual void addRow(const CoinPackedVectorBase& vec, + const double rowlb, const double rowub); + /** */ + virtual void addRow(const CoinPackedVectorBase& vec, + const char rowsen, const double rowrhs, + const double rowrng); + + /** Delete a set of rows (constraints) from the problem. */ + virtual void deleteRows(const int num, const int * rowIndices); + + //@} + + //--------------------------------------------------------------------------- + + /**@name Methods to input a problem */ + //@{ + + virtual void loadProblem(); + + /** Load in an problem by copying the arguments (the constraints on the + rows are given by lower and upper bounds). If a pointer is 0 then the + following values are the default: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>rowub</code>: all rows have upper bound infinity + <li> <code>rowlb</code>: all rows have lower bound -infinity + <li> <code>obj</code>: all variables have 0 objective coefficient + </ul> + */ + virtual void loadProblem(const CoinPackedMatrix& matrix, + const double* collb, const double* colub, + const double* obj, + const double* rowlb, const double* rowub); + + /** Load in an problem by assuming ownership of the arguments (the + constraints on the rows are given by lower and upper bounds). + For default values see the previous method. + + \warning + The arguments passed to this method will be + freed using the C++ <code>delete</code> and <code>delete[]</code> + functions. + */ + virtual void assignProblem(CoinPackedMatrix*& matrix, + double*& collb, double*& colub, double*& obj, + double*& rowlb, double*& rowub); + + /** Load in an problem by copying the arguments (the constraints on the + rows are given by sense/rhs/range triplets). If a pointer is 0 then the + following values are the default: + <ul> + <li> <code>colub</code>: all columns have upper bound infinity + <li> <code>collb</code>: all columns have lower bound 0 + <li> <code>obj</code>: all variables have 0 objective coefficient + <li> <code>rowsen</code>: all rows are >= + <li> <code>rowrhs</code>: all right hand sides are 0 + <li> <code>rowrng</code>: 0 for the ranged rows + </ul> + */ + virtual void loadProblem(const CoinPackedMatrix& matrix, + const double* collb, const double* colub, + const double* obj, + const char* rowsen, const double* rowrhs, + const double* rowrng); + + /** Load in an problem by assuming ownership of the arguments (the + constraints on the rows are given by sense/rhs/range triplets). For + default values see the previous method. + + \warning + The arguments passed to this method will be + freed using the C++ <code>delete</code> and <code>delete[]</code> + functions. + */ + virtual void assignProblem(CoinPackedMatrix*& matrix, + double*& collb, double*& colub, double*& obj, + char*& rowsen, double*& rowrhs, + double*& rowrng); + + /** Just like the other loadProblem() methods except that the matrix is + given in a standard column major ordered format (without gaps). */ + virtual 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); + + /** Just like the other loadProblem() methods except that the matrix is + given in a standard column major ordered format (without gaps). */ + virtual 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 char* rowsen, const double* rowrhs, + const double* rowrng); + + /** Write the problem in MPS format to the specified file. + + If objSense is non-zero, a value of -1.0 causes the problem to be + written with a maximization objective; +1.0 forces a minimization + objective. If objSense is zero, the choice is left to implementation. + */ + virtual void writeMps(const char *filename, + const char *extension = "mps", + double objSense=0.0) const; + + void parseCommandLine(int argc, char **argv); + + using OsiSolverInterface::readMps ; + virtual int readMps(const char * infile, const char *extension = "mps"); + + virtual int readGMPL(const char * modelFile, const char * dataFile=NULL); + + void findInitialBounds(); + + int createPermanentCutPools(); + + //@} + + //--------------------------------------------------------------------------- + + enum keepCachedFlag { + /// discard all cached data (default) + KEEPCACHED_NONE = 0, + /// column information: objective values, lower and upper bounds, variable types + KEEPCACHED_COLUMN = 1, + /// row information: right hand sides, ranges and senses, lower and upper bounds for row + KEEPCACHED_ROW = 2, + /// problem matrix: matrix ordered by column and by row + KEEPCACHED_MATRIX = 4, + /// LP solution: primal and dual solution, reduced costs, row activities + KEEPCACHED_RESULTS = 8, + /// only discard cached LP solution + KEEPCACHED_PROBLEM = KEEPCACHED_COLUMN | KEEPCACHED_ROW | KEEPCACHED_MATRIX, + /// keep all cached data (similar to getMutableLpPtr()) + KEEPCACHED_ALL = KEEPCACHED_PROBLEM | KEEPCACHED_RESULTS, + /// free only cached column and LP solution information + FREECACHED_COLUMN = KEEPCACHED_PROBLEM & ~KEEPCACHED_COLUMN, + /// free only cached row and LP solution information + FREECACHED_ROW = KEEPCACHED_PROBLEM & ~KEEPCACHED_ROW, + /// free only cached matrix and LP solution information + FREECACHED_MATRIX = KEEPCACHED_PROBLEM & ~KEEPCACHED_MATRIX, + /// free only cached LP solution information + FREECACHED_RESULTS = KEEPCACHED_ALL & ~KEEPCACHED_RESULTS + }; + + ///@name Constructors and destructors + //@{ + /// Default Constructor + OsiSymSolverInterface(); + + /** Clone + + The result of calling clone(false) is defined to be equivalent to + calling the default constructor OsiSolverInterface(). + */ + virtual OsiSolverInterface * clone(bool copyData = true) const; + + /// Copy constructor + OsiSymSolverInterface(const OsiSymSolverInterface &); + + /// Assignment operator + OsiSymSolverInterface & operator=(const OsiSymSolverInterface& rhs); + + /// Destructor + virtual ~OsiSymSolverInterface (); + + /** Reset the solver interface. + + A call to reset() returns the solver interface to the same state as + it would have if it had just been constructed by calling the default + constructor OsiSolverInterface(). + */ + virtual void reset(); + //@} + + //--------------------------------------------------------------------------- + +protected: + ///@name Protected methods + //@{ + /** Apply a row cut (append to the constraint matrix). */ + virtual void applyRowCut( const OsiRowCut & rc ); + + /** Apply a column cut (adjust the bounds of one or more variables). */ + virtual void applyColCut( const OsiColCut & cc ); + + /** Set OsiSolverInterface object state for default constructor + + This routine establishes the initial values of data fields in the + OsiSolverInterface object when the object is created using the + default constructor. + */ + + void setInitialData(); + //@} + +private: + + /// The real work of the constructor + void gutsOfConstructor(); + + /// The real work of the destructor + void gutsOfDestructor(); + + /// free cached column rim vectors + void freeCachedColRim(); + + /// free cached row rim vectors + void freeCachedRowRim(); + + /// free cached result vectors + void freeCachedResults(); + + /// free cached matrices + void freeCachedMatrix(); + + /// free all cached data (except specified entries, see getLpPtr()) + void freeCachedData( int keepCached = KEEPCACHED_NONE ); + + /// free all allocated memory + void freeAllMemory(); + + /**@name Private member data */ + //@{ + /// The pointer to the SYMPHONY problem environment + sym_environment *env_; + //@} + + /// Pointer to objective vector + mutable double *obj_; + + /// Pointer to second objective vector to be used in bicriteria solver + mutable double *obj2_; + + /// Pointer to dense vector of variable lower bounds + mutable double *collower_; + + /// Pointer to dense vector of variable lower bounds + mutable double *colupper_; + + /// Pointer to dense vector of variable lower bounds + mutable double *colredcost_; + + /// Pointer to dense vector of row sense indicators + mutable char *rowsense_; + + /// Pointer to dense vector of row right-hand side values + mutable double *rhs_; + + /** Pointer to dense vector of slack upper bounds for range constraints + (undefined for non-range rows) + */ + mutable double *rowrange_; + + /// Pointer to dense vector of row lower bounds + mutable double *rowlower_; + + /// Pointer to dense vector of row upper bounds + mutable double *rowupper_; + + /// Pointer to dense vector of row prices + mutable double *rowprice_; + + /// Pointer to primal solution vector + mutable double *colsol_; + + /// Pointer to row activity (slack) vector + mutable double *rowact_; + + /// Pointer to row-wise copy of problem matrix coefficients. + mutable CoinPackedMatrix *matrixByRow_; + + /// Pointer to row-wise copy of problem matrix coefficients. + mutable CoinPackedMatrix *matrixByCol_; + +}; + +//############################################################################# +/** A function that tests the methods in the OsiSymSolverInterface class. */ +void OsiSymSolverInterfaceUnitTest(const std::string & mpsDir, const std::string & netlibDir); + +#endif diff --git a/thirdparty/windows/include/coin/OsiSymSolverParameters.hpp b/thirdparty/windows/include/coin/OsiSymSolverParameters.hpp new file mode 100644 index 0000000..041acce --- /dev/null +++ b/thirdparty/windows/include/coin/OsiSymSolverParameters.hpp @@ -0,0 +1,64 @@ +/*===========================================================================*/ +/* */ +/* This file is part of the SYMPHONY Branch, Cut, and Price Callable */ +/* Library. */ +/* */ +/* SYMPHONY was jointly developed by Ted Ralphs (tkralphs@lehigh.edu) and */ +/* Laci Ladanyi (ladanyi@us.ibm.com). */ +/* */ +/* (c) Copyright 2004-2006 Ted Ralphs and Lehigh University. */ +/* All Rights Reserved. */ +/* */ +/* The authors of this file are Menal Guzelsoy and Ted Ralphs */ +/* */ +/* This software is licensed under the Eclipse Public License. Please see */ +/* accompanying file for terms. */ +/* */ +/*===========================================================================*/ + +#ifndef OsiSymSolverParameters_hpp +#define OsiSymSolverParameters_hpp + +enum OsiSymIntParam { + /** This controls the level of output */ + OsiSymMaxActiveNodes, + OsiSymVerbosity, + OsiSymNodeLimit, + OsiSymFindFirstFeasible, + OsiSymSearchStrategy, + OsiSymUsePermanentCutPools, + OsiSymKeepWarmStart, + OsiSymDoReducedCostFixing, + OsiSymMCFindSupportedSolutions, + OsiSymSensitivityAnalysis, + OsiSymRandomSeed, + OsiSymDivingStrategy, + OsiSymDivingK, + OsiSymDivingThreshold, + OsiSymTrimWarmTree, + OsiSymGenerateCglGomoryCuts, + OsiSymGenerateCglKnapsackCuts, + OsiSymGenerateCglOddHoleCuts, + OsiSymGenerateCglProbingCuts, + OsiSymGenerateCglFlowAndCoverCuts, + OsiSymGenerateCglRoundingCuts, + OsiSymGenerateCglLiftAndProjectCuts, + OsiSymGenerateCglCliqueCuts +}; + +enum OsiSymDblParam { + /** The granularity is the actual minimum difference in objective function + value for two solutions that actually have do different objective + function values. For integer programs with integral objective function + coefficients, this would be 1, for instance. */ + OsiSymGranularity, + OsiSymTimeLimit, + OsiSymGapLimit, + OsiSymUpperBound, + OsiSymLowerBound +}; + +enum OsiSymStrParam { +}; + +#endif diff --git a/thirdparty/windows/include/coin/OsiUnitTests.hpp b/thirdparty/windows/include/coin/OsiUnitTests.hpp new file mode 100644 index 0000000..fbb4fc1 --- /dev/null +++ b/thirdparty/windows/include/coin/OsiUnitTests.hpp @@ -0,0 +1,374 @@ +// Copyright (C) 2010 +// All Rights Reserved. +// This code is licensed under the terms of the Eclipse Public License (EPL). + +/*! \file OsiUnitTests.hpp + + Utility methods for OSI unit tests. +*/ + +#ifndef OSISOLVERINTERFACETEST_HPP_ +#define OSISOLVERINTERFACETEST_HPP_ + +#include <cstdio> +#include <cstdlib> +#include <iostream> +#include <string> +#include <sstream> +#include <vector> +#include <list> +#include <map> + +class OsiSolverInterface; +class CoinPackedVectorBase; + +/** A function that tests that a lot of problems given in MPS files (mostly the NETLIB problems) solve properly with all the specified solvers. + * + * The routine creates a vector of NetLib problems (problem name, objective, + * various other characteristics), and a vector of solvers to be tested. + * + * Each solver is run on each problem. The run is deemed successful if the + * solver reports the correct problem size after loading and returns the + * correct objective value after optimization. + + * If multiple solvers are available, the results are compared pairwise against + * the results reported by adjacent solvers in the solver vector. Due to + * limitations of the volume solver, it must be the last solver in vecEmptySiP. + */ +void OsiSolverInterfaceMpsUnitTest + (const std::vector<OsiSolverInterface*> & vecEmptySiP, + const std::string& mpsDir); + +/** A function that tests the methods in the OsiSolverInterface class. + * Some time ago, if this method is compiled with optimization, + * the compilation took 10-15 minutes and the machine pages (has 256M core memory!)... + */ +void OsiSolverInterfaceCommonUnitTest + (const OsiSolverInterface* emptySi, + const std::string& mpsDir, + const std::string& netlibDir); + +/** A function that tests the methods in the OsiColCut class. */ +void OsiColCutUnitTest + (const OsiSolverInterface * baseSiP, + const std::string & mpsDir); + +/** A function that tests the methods in the OsiRowCut class. */ +void OsiRowCutUnitTest + (const OsiSolverInterface * baseSiP, + const std::string & mpsDir); + +/** A function that tests the methods in the OsiRowCutDebugger class. */ +void OsiRowCutDebuggerUnitTest + (const OsiSolverInterface * siP, + const std::string & mpsDir); + +/** A function that tests the methods in the OsiCuts class. */ +void OsiCutsUnitTest(); + +/// A namespace so we can define a few `global' variables to use during tests. +namespace OsiUnitTest { + +class TestOutcomes; + +/*! \brief Verbosity level of unit tests + + 0 (default) for minimal output; larger numbers produce more output +*/ +extern unsigned int verbosity; + +/*! \brief Behaviour on failing a test + + - 0 (= default) continue + - 1 press any key to continue + - 2 stop with abort() +*/ +extern unsigned int haltonerror; + +/*! \brief Test outcomes + + A global TestOutcomes object to store test outcomes during the run of the unit test + for an OSI. + */ +extern TestOutcomes outcomes; + +/*! \brief Print an error message + + Formatted as "XxxSolverInterface testing issue: message" where Xxx is the string + provided as \p solverName. + + Flushes std::cout before printing to std::cerr. +*/ +void failureMessage(const std::string &solverName, + const std::string &message) ; +/// \overload +void failureMessage(const OsiSolverInterface &si, + const std::string &message) ; + +/*! \brief Print an error message, specifying the test name and condition + + Formatted as "XxxSolverInterface testing issue: testname failed: testcond" where + Xxx is the OsiStrParam::OsiSolverName parameter of the \p si. + Flushes std::cout before printing to std::cerr. +*/ +void failureMessage(const std::string &solverName, + const std::string &testname, const std::string &testcond) ; + +/// \overload +void failureMessage(const OsiSolverInterface &si, + const std::string &testname, const std::string &testcond) ; + +/*! \brief Print a message. + + Prints the message as given. Flushes std::cout before printing to std::cerr. +*/ +void testingMessage(const char *const msg) ; + +/*! \brief Utility method to check equality + + Tests for equality using CoinRelFltEq with tolerance \p tol. Understands the + notion of solver infinity and obtains the value for infinity from the solver + interfaces supplied as parameters. +*/ +bool equivalentVectors(const OsiSolverInterface * si1, + const OsiSolverInterface * si2, + double tol, const double * v1, const double * v2, int size) ; + +/*! \brief Compare two problems for equality + + Compares the problems held in the two solvers: constraint matrix, row and column + bounds, column type, and objective. Rows are checked using upper and lower bounds + and using sense, bound, and range. +*/ +bool compareProblems(OsiSolverInterface *osi1, OsiSolverInterface *osi2) ; + +/*! \brief Compare a packed vector with an expanded vector + + Checks that all values present in the packed vector are present in the full vector + and checks that there are no extra entries in the full vector. Uses CoinRelFltEq + with the default tolerance. +*/ +bool isEquivalent(const CoinPackedVectorBase &pv, int n, const double *fv) ; + +/*! \brief Process command line parameters. + + An unrecognised keyword which is not in the \p ignorekeywords map will trigger the + help message and a return value of false. For each keyword in \p ignorekeywords, you + can specify the number of following parameters that should be ignored. + + This should be replaced with the one of the standard CoinUtils parameter mechanisms. + */ +bool processParameters (int argc, const char **argv, + std::map<std::string,std::string>& parms, + const std::map<std::string,int>& ignorekeywords = std::map<std::string,int>()); + +/// A single test outcome record. +class TestOutcome { + public: + /// Test result + typedef enum { + NOTE = 0, + PASSED = 1, + WARNING = 2, + ERROR = 3, + LAST = 4 + } SeverityLevel; + /// Print strings for SeverityLevel + static std::string SeverityLevelName[LAST]; + /// Name of component under test + std::string component; + /// Name of test + std::string testname; + /// Condition being tested + std::string testcond; + /// Test result + SeverityLevel severity; + /// Set to true if problem is expected + bool expected; + /// Name of code file where test executed + std::string filename; + /// Line number in code file where test executed + int linenumber; + /// Standard constructor + TestOutcome(const std::string& comp, const std::string& tst, + const char* cond, SeverityLevel sev, + const char* file, int line, bool exp = false) + : component(comp),testname(tst),testcond(cond),severity(sev), + expected(exp),filename(file),linenumber(line) + { } + /// Print the test outcome + void print() const; +}; + +/// Utility class to maintain a list of test outcomes. +class TestOutcomes : public std::list<TestOutcome> { + public: + /// Add an outcome to the list + void add(std::string comp, std::string tst, const char* cond, + TestOutcome::SeverityLevel sev, const char* file, int line, + bool exp = false) + { push_back(TestOutcome(comp,tst,cond,sev,file,line,exp)); } + + /*! \brief Add an outcome to the list + + Get the component name from the solver interface. + */ + void add(const OsiSolverInterface& si, std::string tst, const char* cond, + TestOutcome::SeverityLevel sev, const char* file, int line, + bool exp = false); + /// Print the list of outcomes + void print() const; + /*! \brief Count total and expected outcomes at given severity level + + Given a severity level, walk the list of outcomes and count the total number + of outcomes at this severity level and the number expected. + */ + void getCountBySeverity(TestOutcome::SeverityLevel sev, + int& total, int& expected) const; +}; + +/// Convert parameter to a string (stringification) +#define OSIUNITTEST_QUOTEME_(x) #x +/// Convert to string with one level of expansion of the parameter +#define OSIUNITTEST_QUOTEME(x) OSIUNITTEST_QUOTEME_(x) + +template <typename Component> +bool OsiUnitTestAssertSeverityExpected( + bool condition, const char * condition_str, const char *filename, + int line, const Component& component, const std::string& testname, + TestOutcome::SeverityLevel severity, bool expected) +{ + if (condition) { + OsiUnitTest::outcomes.add(component, testname, condition_str, + OsiUnitTest::TestOutcome::PASSED, filename, line, false); + if (OsiUnitTest::verbosity >= 2) { + std::ostringstream successmsg; + successmsg << __FILE__ << ":" << __LINE__ << ": " << testname + << " (condition \'" << condition_str << "\') passed.\n"; + OsiUnitTest::testingMessage(successmsg.str().c_str()); + } + return true; + } + OsiUnitTest::outcomes.add(component, testname, condition_str, + severity, filename, line, expected); + OsiUnitTest::failureMessage(component, testname, condition_str); + switch (OsiUnitTest::haltonerror) { + case 2: + { if (severity >= OsiUnitTest::TestOutcome::ERROR ) std::abort(); break; } + case 1: + { std::cout << std::endl << "press any key to continue..." << std::endl; + std::getchar(); + break ; } + default: ; + } + return false; +} + +/// Add a test outcome to the list held in OsiUnitTest::outcomes +#define OSIUNITTEST_ADD_OUTCOME(component,testname,testcondition,severity,expected) \ + OsiUnitTest::outcomes.add(component,testname,testcondition,severity,\ + __FILE__,__LINE__,expected) +/*! \brief Test for a condition and record the result + + Test \p condition and record the result in OsiUnitTest::outcomes. + If it succeeds, record the result as OsiUnitTest::TestOutcome::PASSED and print + a message for OsiUnitTest::verbosity >= 2. + If it fails, record the test as failed with \p severity and \p expected and + react as specified by OsiUnitTest::haltonerror. + + \p failurecode is executed when failure is not fatal. +*/ +#define OSIUNITTEST_ASSERT_SEVERITY_EXPECTED(condition,failurecode,component,\ + testname, severity, expected) \ +{ \ + if (!OsiUnitTestAssertSeverityExpected(condition, #condition, \ + __FILE__, __LINE__, component, testname, severity, expected)) { \ + failurecode; \ + } \ +} + +/*! \brief Perform a test with severity OsiUnitTest::TestOutcome::ERROR, failure not + expected. +*/ +#define OSIUNITTEST_ASSERT_ERROR(condition, failurecode, component, testname) \ + OSIUNITTEST_ASSERT_SEVERITY_EXPECTED(condition,failurecode,component,testname,\ + OsiUnitTest::TestOutcome::ERROR,false) + +/*! \brief Perform a test with severity OsiUnitTest::TestOutcome::WARNING, failure + not expected. +*/ +#define OSIUNITTEST_ASSERT_WARNING(condition, failurecode, component, testname) \ + OSIUNITTEST_ASSERT_SEVERITY_EXPECTED(condition,failurecode,component,testname,\ + OsiUnitTest::TestOutcome::WARNING,false) + +/*! \brief Perform a test surrounded by a try/catch block + + \p trycode is executed in a try/catch block; if there's no throw the test is deemed + to have succeeded and is recorded in OsiUnitTest::outcomes with status + OsiUnitTest::TestOutcome::PASSED. If the \p trycode throws a CoinError, the failure + is recorded with status \p severity and \p expected and the value of + OsiUnitTest::haltonerror is consulted. If the failure is not fatal, \p catchcode is + executed. If any other error is thrown, the failure is recorded as for a CoinError + and \p catchcode is executed (haltonerror is not consulted). +*/ +#define OSIUNITTEST_CATCH_SEVERITY_EXPECTED(trycode, catchcode, component, testname,\ + severity, expected) \ +{ \ + try { \ + trycode; \ + OSIUNITTEST_ADD_OUTCOME(component,testname,#trycode " did not throw exception",\ + OsiUnitTest::TestOutcome::PASSED,false); \ + if (OsiUnitTest::verbosity >= 2) { \ + std::string successmsg( __FILE__ ":" OSIUNITTEST_QUOTEME(__LINE__) ": "); \ + successmsg = successmsg + testname; \ + successmsg = successmsg + " (code \'" #trycode "\') did not throw exception"; \ + successmsg = successmsg + ".\n" ; \ + OsiUnitTest::testingMessage(successmsg.c_str()); \ + } \ + } catch (CoinError& e) { \ + std::stringstream errmsg; \ + errmsg << #trycode " threw CoinError: " << e.message(); \ + if (e.className().length() > 0) \ + errmsg << " in " << e.className(); \ + if (e.methodName().length() > 0) \ + errmsg << " in " << e.methodName(); \ + if (e.lineNumber() >= 0) \ + errmsg << " at " << e.fileName() << ":" << e.lineNumber(); \ + OSIUNITTEST_ADD_OUTCOME(component,testname,errmsg.str().c_str(),\ + severity,expected); \ + OsiUnitTest::failureMessage(component,testname,errmsg.str().c_str()); \ + switch(OsiUnitTest::haltonerror) { \ + case 2: \ + { if (severity >= OsiUnitTest::TestOutcome::ERROR) abort(); break; } \ + case 1: \ + { std::cout << std::endl << "press any key to continue..." << std::endl; \ + getchar(); \ + break ; } \ + default: ; \ + } \ + catchcode; \ + } catch (...) { \ + std::string errmsg; \ + errmsg = #trycode; \ + errmsg = errmsg + " threw unknown exception"; \ + OSIUNITTEST_ADD_OUTCOME(component,testname,errmsg.c_str(),severity,false); \ + OsiUnitTest::failureMessage(component,testname,errmsg.c_str()); \ + catchcode; \ + } \ +} + +/*! \brief Perform a try/catch test with severity OsiUnitTest::TestOutcome::ERROR, + failure not expected. +*/ +#define OSIUNITTEST_CATCH_ERROR(trycode, catchcode, component, testname) \ + OSIUNITTEST_CATCH_SEVERITY_EXPECTED(trycode, catchcode, component, testname, OsiUnitTest::TestOutcome::ERROR, false) + +/*! \brief Perform a try/catch test with severity OsiUnitTest::TestOutcome::WARNING, + failure not expected. +*/ +#define OSIUNITTEST_CATCH_WARNING(trycode, catchcode, component, testname) \ + OSIUNITTEST_CATCH_SEVERITY_EXPECTED(trycode, catchcode, component, testname, OsiUnitTest::TestOutcome::WARNING, false) + +} // end namespace OsiUnitTest + +#endif /*OSISOLVERINTERFACETEST_HPP_*/ diff --git a/thirdparty/windows/include/coin/SymConfig.h b/thirdparty/windows/include/coin/SymConfig.h new file mode 100644 index 0000000..dcd9a3c --- /dev/null +++ b/thirdparty/windows/include/coin/SymConfig.h @@ -0,0 +1,19 @@ +/* include/config_sym.h. Generated by configure. */ +/* include/config_sym.h.in. */ + +#ifndef __CONFIG_SYM_H__ +#define __CONFIG_SYM_H__ + +/* Version number of project */ +#define SYMPHONY_VERSION "5.6.14" + +/* Major Version number of project */ +#define SYMPHONY_VERSION_MAJOR 5 + +/* Minor Version number of project */ +#define SYMPHONY_VERSION_MINOR 6 + +/* Release Version number of project */ +#define SYMPHONY_VERSION_RELEASE 14 + +#endif diff --git a/thirdparty/windows/include/coin/SymWarmStart.hpp b/thirdparty/windows/include/coin/SymWarmStart.hpp new file mode 100644 index 0000000..74089d1 --- /dev/null +++ b/thirdparty/windows/include/coin/SymWarmStart.hpp @@ -0,0 +1,72 @@ +/*===========================================================================*/ +/* */ +/* This file is part of the SYMPHONY Branch, Cut, and Price Callable */ +/* Library. */ +/* */ +/* SYMPHONY was jointly developed by Ted Ralphs (tkralphs@lehigh.edu) and */ +/* Laci Ladanyi (ladanyi@us.ibm.com). */ +/* */ +/* (c) Copyright 2004-2006 Ted Ralphs and Lehigh University. */ +/* All Rights Reserved. */ +/* */ +/* The authors of this file are Menal Guzelsoy and Ted Ralphs */ +/* */ +/* This software is licensed under the Eclipse Public License. Please see */ +/* accompanying file for terms. */ +/* */ +/*===========================================================================*/ + +#ifndef SymWarmStart_H +#define SymWarmStart_H + +#include "CoinWarmStart.hpp" + +typedef struct WARM_START_DESC warm_start_desc; + +//############################################################################# + +class SymWarmStart : public CoinWarmStart +{ + +public: + + /* Default constructor. Will do nothing! */ + SymWarmStart(){} + + /* Initialize the warmStart_ using the given warm start. If dominate + WarmStart is set, then, SymWarmStart will take the control of the + given description, otherwise, will copy everything. + */ + SymWarmStart(warm_start_desc * ws); + + /*Get the warmStart info from a file*/ + SymWarmStart(char *f); + + /* Copy constructor */ + SymWarmStart(const SymWarmStart & symWS); + + /* Destructor */ + virtual ~SymWarmStart(); + + /* Clone the warmstart */ + virtual CoinWarmStart * clone() const; + + /* Get the pointer to the loaded warmStart_ */ + virtual warm_start_desc * getCopyOfWarmStartDesc(); + + /* Move the pointer to the rootnode of the warmStart to another + node which will change the underlying tree + */ + // virtual void setRoot(bc_node *root) {} //FIX_ME! Ask Prof. Ralphs. + + /* Write the current warm start info to a file */ + virtual int writeToFile(char * f); + +private: + + /* Private warm start desc. to keep everything */ + warm_start_desc *warmStart_; + +}; + +#endif diff --git a/thirdparty/windows/include/coin/config_ipopt.h b/thirdparty/windows/include/coin/config_ipopt.h new file mode 100644 index 0000000..5de76c8 --- /dev/null +++ b/thirdparty/windows/include/coin/config_ipopt.h @@ -0,0 +1,218 @@ +/* inc/config_ipopt.h. Generated by configure. */ +/* inc/config_ipopt.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if the inexact linear solver option is included */ +/* #undef BUILD_INEXACT */ + +/* If defined, the Ampl Solver Library is available. */ +#define COIN_HAS_ASL 1 + +/* If defined, the BLAS Library is available. */ +#define COIN_HAS_BLAS 1 + +/* Define to 1 if the Ipopt package is used */ +#define COIN_HAS_IPOPT 1 + +/* If defined, the LAPACK Library is available. */ +#define COIN_HAS_LAPACK 1 + +/* If defined, the METIS library is available. */ +/* #undef COIN_HAS_METIS */ + +/* If defined, the MUMPS Library is available. */ +#define COIN_HAS_MUMPS 1 + +/* Define to the debug sanity check level (0 is no test) */ +#define COIN_IPOPT_CHECKLEVEL 0 + +/* Define to the debug verbosity level (0 is no output) */ +#define COIN_IPOPT_VERBOSITY 0 + +/* Define to dummy `main' function (if any) required to link to the Fortran + libraries. */ +/* #undef F77_DUMMY_MAIN */ + +/* Define to a macro mangling the given C identifier (in lower and upper + case), which must not contain underscores, for linking with Fortran. */ +#define F77_FUNC(name,NAME) name ## _ + +/* As F77_FUNC, but for C identifiers containing underscores. */ +#define F77_FUNC_(name,NAME) name ## __ + +/* Define if F77 and FC dummy `main' functions are identical. */ +/* #undef FC_DUMMY_MAIN_EQ_F77 */ + +/* Define to the C type corresponding to Fortran INTEGER */ +#define FORTRAN_INTEGER_TYPE int + +/* Define to 1 if you have the <assert.h> header file. */ +/* #undef HAVE_ASSERT_H */ + +/* Define to 1 if you have the <cassert> header file. */ +#define HAVE_CASSERT 1 + +/* Define to 1 if you have the <cctype> header file. */ +#define HAVE_CCTYPE 1 + +/* Define to 1 if you have the <cfloat> header file. */ +#define HAVE_CFLOAT 1 + +/* Define to 1 if you have the <cieeefp> header file. */ +/* #undef HAVE_CIEEEFP */ + +/* Define to 1 if you have the <cmath> header file. */ +#define HAVE_CMATH 1 + +/* Define to 1 if you have the <cstdarg> header file. */ +#define HAVE_CSTDARG 1 + +/* Define to 1 if you have the <cstdio> header file. */ +#define HAVE_CSTDIO 1 + +/* Define to 1 if you have the <cstdlib> header file. */ +#define HAVE_CSTDLIB 1 + +/* Define to 1 if you have the <cstring> header file. */ +#define HAVE_CSTRING 1 + +/* Define to 1 if you have the <ctime> header file. */ +#define HAVE_CTIME 1 + +/* Define to 1 if you have the <ctype.h> header file. */ +/* #undef HAVE_CTYPE_H */ + +/* Define to 1 if you have the <dlfcn.h> header file. */ +/* #undef HAVE_DLFCN_H */ + +/* Define to 1 if function drand48 is available */ +/* #undef HAVE_DRAND48 */ + +/* Define to 1 if you have the <float.h> header file. */ +/* #undef HAVE_FLOAT_H */ + +/* Define to 1 if you have the <ieeefp.h> header file. */ +/* #undef HAVE_IEEEFP_H */ + +/* Define to 1 if you have the <inttypes.h> header file. */ +/* #undef HAVE_INTTYPES_H */ + +/* Define to 1 if the linear solver loader should be compiled to allow dynamic + loading of shared libaries with linear solvers */ +#define HAVE_LINEARSOLVERLOADER 1 + +/* Define to 1 if MA27 is available */ +/* #undef HAVE_MA27 */ + +/* Define to 1 if MA28 is available */ +/* #undef HAVE_MA28 */ + +/* Define to 1 if MA57 is available */ +/* #undef HAVE_MA57 */ + +/* Define to 1 if you have the <math.h> header file. */ +/* #undef HAVE_MATH_H */ + +/* Define to 1 if MC19 is available */ +/* #undef HAVE_MC19 */ + +/* Define to 1 if you have the <memory.h> header file. */ +#define HAVE_MEMORY_H 1 + +/* Define to 1 if Pardiso is available */ +/* #undef HAVE_PARDISO */ + +/* Define to 1 if you are using at least a 4.0 version of Pardiso */ +/* #undef HAVE_PARDISO_NEWINTERFACE */ + +/* Define to 1 if you are using the parallel version of Pardiso */ +/* #undef HAVE_PARDISO_PARALLEL */ + +/* Define to 1 if function rand is available */ +#define HAVE_RAND 1 + +/* Define to 1 if you have the `snprintf' function. */ +/* #undef HAVE_SNPRINTF */ + +/* Define to 1 if you have the <stdarg.h> header file. */ +/* #undef HAVE_STDARG_H */ + +/* Define to 1 if you have the <stdint.h> header file. */ +/* #undef HAVE_STDINT_H */ + +/* Define to 1 if you have the <stdio.h> header file. */ +/* #undef HAVE_STDIO_H */ + +/* Define to 1 if you have the <stdlib.h> header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if function std::rand is available */ +#define HAVE_STD__RAND 1 + +/* Define to 1 if you have the <strings.h> header file. */ +/* #undef HAVE_STRINGS_H */ + +/* Define to 1 if you have the <string.h> header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the <sys/stat.h> header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the <sys/types.h> header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the <time.h> header file. */ +/* #undef HAVE_TIME_H */ + +/* Define to 1 if you have the <unistd.h> header file. */ +/* #undef HAVE_UNISTD_H */ + +/* Define to 1 if va_copy is avaliable */ +/* #undef HAVE_VA_COPY */ + +/* Define to 1 if you have the `vsnprintf' function. */ +#define HAVE_VSNPRINTF 1 + +/* Define to 1 if you have the <windows.h> header file. */ +#define HAVE_WINDOWS_H 1 + +/* Define to 1 if WSMP is available */ +/* #undef HAVE_WSMP */ + +/* Define to 1 if you have the `_snprintf' function. */ +#define HAVE__SNPRINTF 1 + +/* Define to 1 if you have the `_vsnprintf' function. */ +/* #undef HAVE__VSNPRINTF */ + +/* Define to be the name of C-function for NaNInf check */ +#define MY_C_FINITE _finite + +/* Name of package */ +#define PACKAGE "ipopt" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "http://projects.coin-or.org/Ipopt/newticket" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "Ipopt" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "Ipopt 3.8.0" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "ipopt" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "3.8.0" + +/* Set to extension for shared libraries in quotes. */ +#define SHAREDLIBEXT "dll" + +/* The size of a `int *', as computed by sizeof. */ +#define SIZEOF_INT_P 4 + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Version number of package */ +#define VERSION "3.8.0" diff --git a/thirdparty/windows/include/coin/symphony.h b/thirdparty/windows/include/coin/symphony.h new file mode 100644 index 0000000..9106e82 --- /dev/null +++ b/thirdparty/windows/include/coin/symphony.h @@ -0,0 +1,328 @@ +/*===========================================================================*/ +/* */ +/* This file is part of the SYMPHONY MILP Solver Framework. */ +/* */ +/* SYMPHONY was jointly developed by Ted Ralphs (ted@lehigh.edu) and */ +/* Laci Ladanyi (ladanyi@us.ibm.com). */ +/* */ +/* (c) Copyright 2005-2015 Ted Ralphs. All Rights Reserved. */ +/* */ +/* This software is licensed under the Eclipse Public License. Please see */ +/* accompanying file for terms. */ +/* */ +/*===========================================================================*/ + +#ifndef _SYM_API_H +#define _SYM_API_H + +#define COMPILING_FOR_MASTER + +#ifdef PROTO +#undef PROTO +#endif +#define PROTO(x) x + +/***************************************************************************** + ***************************************************************************** + ************* ********** + ************* Return Values ********** + ************* ********** + ***************************************************************************** + *****************************************************************************/ + +/*----------------------- Global return codes -------------------------------*/ +#define FUNCTION_TERMINATED_NORMALLY 0 +#define FUNCTION_TERMINATED_ABNORMALLY -1 +#define ERROR__USER -100 + +/*-------------- Return codes for sym_parse_comand_line() -------------------*/ +#define ERROR__OPENING_PARAM_FILE -110 +#define ERROR__PARSING_PARAM_FILE -111 + +/*----------------- Return codes for sym_load_problem() ---------------------*/ +#define ERROR__READING_GMPL_FILE -120 +#define ERROR__READING_WARM_START_FILE -121 +#define ERROR__READING_MPS_FILE -122 +#define ERROR__READING_LP_FILE -123 + +/*-------------------- Return codes for sym_solve() -------------------------*/ +#define TM_NO_PROBLEM 225 +#define TM_NO_SOLUTION 226 +#define TM_OPTIMAL_SOLUTION_FOUND 227 +#define TM_TIME_LIMIT_EXCEEDED 228 +#define TM_NODE_LIMIT_EXCEEDED 229 +#define TM_ITERATION_LIMIT_EXCEEDED 230 +#define TM_TARGET_GAP_ACHIEVED 231 +#define TM_FOUND_FIRST_FEASIBLE 232 +#define TM_FINISHED 233 +#define TM_UNFINISHED 234 +#define TM_FEASIBLE_SOLUTION_FOUND 235 +#define TM_SIGNAL_CAUGHT 236 +#define TM_UNBOUNDED 237 +#define PREP_OPTIMAL_SOLUTION_FOUND 238 +#define PREP_NO_SOLUTION 239 +#define TM_ERROR__NO_BRANCHING_CANDIDATE -250 +#define TM_ERROR__ILLEGAL_RETURN_CODE -251 +#define TM_ERROR__NUMERICAL_INSTABILITY -252 +#define TM_ERROR__COMM_ERROR -253 +#define TM_ERROR__USER -275 +#define PREP_ERROR -276 + +/***************************************************************************** + ***************************************************************************** + ************* ********** + ************* General Constants ********** + ************* ********** + ***************************************************************************** + *****************************************************************************/ + +#ifndef TRUE +#define TRUE 1 +#endif +#ifndef FALSE +#define FALSE 0 +#endif + +#ifndef ANYONE +#define ANYONE -1 +#endif +#ifndef ANYTHING +#define ANYTHING -1 +#endif + +#define DSIZE sizeof(double) +#define ISIZE sizeof(int) +#define CSIZE sizeof(char) + +#ifndef BITSPERBYTE +#define BITSPERBYTE 8 +#endif +#ifndef BITS +#define BITS(type) (BITSPERBYTE * (int)sizeof (type)) +#endif + +#ifdef HIBITI +#undef HIBITI +#endif +#define HIBITI (1U << (BITS(int) - 1)) +#ifdef MAXINT +#undef MAXINT +#endif +#define MAXINT ((int)(~(HIBITI))) +#ifdef MAXDOUBLE +#undef MAXDOUBLE +#endif +#define MAXDOUBLE 1.79769313486231570e+308 + +#define SYM_INFINITY 1e20 + +#define BIG_DBL 1e40 + +#define SYM_MINIMIZE 0 +#define SYM_MAXIMIZE 1 + +#define MAX_NAME_SIZE 255 + +/*--------------------- return values for user-written functions ------------*/ +#define USER_ERROR -5 +#define USER_SUCCESS -4 +#define USER_NO_PP -3 +#define USER_AND_PP -2 +#define USER_DEFAULT -1 + +/*------------ search order options for multi-criteria problems -------------*/ +#define MC_FIFO 0 +#define MC_LIFO 1 + +/*------------ warm_starting options for multi-criteria problems -------------*/ +#define MC_WS_UTOPIA_FIRST 0 +#define MC_WS_UTOPIA_BOTH_FIXED 1 +#define MC_WS_UTOPIA_BOTH 2 +#define MC_WS_BEST_CLOSE 3 + +/*------------------------ compare_candidates -------------------------------*/ +#define BIGGEST_DIFFERENCE_OBJ 0 +#define LOWEST_LOW_OBJ 1 +#define HIGHEST_LOW_OBJ 2 +#define LOWEST_HIGH_OBJ 3 +#define HIGHEST_HIGH_OBJ 4 +#define HIGH_LOW_COMBINATION 9 + +/*--------------------------- select_child ----------------------------------*/ +#define PREFER_LOWER_OBJ_VALUE 0 +#define PREFER_HIGHER_OBJ_VALUE 1 + +/*-------------------- generate_cuts_in_lp defaults -------------------------*/ +#define GENERATE_CGL_CUTS 20 +#define DO_NOT_GENERATE_CGL_CUTS 21 + +/*-------------------- xxx_cuts_generation_levels ---------------------------*/ +#define DO_NOT_GENERATE -1 +#define GENERATE_DEFAULT 0 +#define GENERATE_IF_IN_ROOT 1 +#define GENERATE_ONLY_IN_ROOT 2 +#define GENERATE_ALWAYS 3 +#define GENERATE_PERIODICALLY 4 + +/*------------------------- node selection rules ----------------------------*/ +#define LOWEST_LP_FIRST 0 +#define HIGHEST_LP_FIRST 1 +#define BREADTH_FIRST_SEARCH 2 +#define DEPTH_FIRST_SEARCH 3 +#define BEST_FIRST_SEARCH 4 +#define DEPTH_FIRST_THEN_BEST_FIRST 5 + +/*-------------------------- diving_strategy --------------------------------*/ +#define BEST_ESTIMATE 0 +#define COMP_BEST_K 1 +#define COMP_BEST_K_GAP 2 + +/*--------------- parameter values for feasibility pump heuristic -----------*/ +#define SYM_FEAS_PUMP_DEFAULT 1 /* use fp using the default rules */ +#define SYM_FEAS_PUMP_REPEATED 2 /* use fp till the end of solve */ +#define SYM_FEAS_PUMP_TILL_SOL 3 /* use fp till a solution is found */ +#define SYM_FEAS_PUMP_DISABLE -1 /* dont use fp */ + +typedef struct MIPDESC MIPdesc; +typedef struct WARM_START_DESC warm_start_desc; +typedef struct SYM_ENVIRONMENT sym_environment; + +/*===========================================================================*/ +/*===================== Interface functions (master.c) ======================*/ +/*===========================================================================*/ + +void sym_version PROTO((void)); +sym_environment *sym_open_environment PROTO((void)); +int sym_close_environment PROTO((sym_environment *env)); +int sym_reset_environment PROTO((sym_environment *env)); +int sym_set_defaults PROTO((sym_environment *env)); +int sym_parse_command_line PROTO((sym_environment *env, int argc, + char **argv)); +int sym_set_user_data PROTO((sym_environment *env, void *user)); +int sym_get_user_data PROTO((sym_environment *env, void **user)); +int sym_read_mps PROTO((sym_environment *env, char *infile)); +int sym_read_lp PROTO((sym_environment *env, char *infile)); +int sym_read_gmpl PROTO((sym_environment *env, char *modelfile, + char *datafile)); +int sym_write_mps PROTO((sym_environment *env, char *infile)); +int sym_write_lp PROTO((sym_environment *env, char *infile)); + +int sym_load_problem PROTO((sym_environment *env)); +int sym_find_initial_bounds PROTO((sym_environment *env)); + +int sym_solve PROTO((sym_environment *env)); +int sym_warm_solve PROTO((sym_environment *env)); +int sym_mc_solve PROTO((sym_environment *env)); + +int sym_create_permanent_cut_pools PROTO((sym_environment *env, int *cp_num)); +int sym_explicit_load_problem PROTO((sym_environment *env, int numcols, + int numrows, int *start, int *index, + double *value, double *collb, + double *colub, char *is_int, double *obj, + double *obj2, char *rowsen, + double *rowrhs, double *rowrng, + char make_copy)); + +int sym_is_abandoned PROTO((sym_environment *env)); +int sym_is_proven_optimal PROTO((sym_environment *env)); +int sym_is_proven_primal_infeasible PROTO((sym_environment *env)); +int sym_is_iteration_limit_reached PROTO((sym_environment *env)); +int sym_is_time_limit_reached PROTO((sym_environment *env)); +int sym_is_target_gap_achieved PROTO((sym_environment *env)); + +int sym_get_status PROTO((sym_environment *env)); +int sym_get_num_cols PROTO((sym_environment *env, int *numcols)); +int sym_get_num_rows PROTO((sym_environment *env, int *numrows)); +int sym_get_num_elements PROTO((sym_environment *env, int *numelems)); +int sym_get_col_lower PROTO((sym_environment *env, double *collb)); +int sym_get_col_upper PROTO((sym_environment *env, double *colub)); +int sym_get_row_sense PROTO((sym_environment *env, char *rowsen)); +int sym_get_rhs PROTO((sym_environment *env, double *rowrhs)); +int sym_get_matrix PROTO((sym_environment *env, int *nz, int *matbeg, + int *matind, double *matval)); +int sym_get_row_range PROTO((sym_environment *env, double *rowrng)); +int sym_get_row_lower PROTO((sym_environment *env, double *rowlb)); +int sym_get_row_upper PROTO((sym_environment *env, double *rowub)); +int sym_get_obj_coeff PROTO((sym_environment *env, double *obj)); +int sym_get_obj2_coeff PROTO((sym_environment *env, double *obj2)); +int sym_get_obj_sense PROTO((sym_environment *env, int *sense)); + +int sym_is_continuous PROTO((sym_environment *env, int index, int *value)); +int sym_is_binary PROTO((sym_environment *env, int index, int *value)); +int sym_is_integer PROTO((sym_environment *env, int index, char *value)); + +double sym_get_infinity PROTO(()); + +int sym_get_col_solution PROTO((sym_environment *env, double *colsol)); +int sym_get_sp_size PROTO((sym_environment *env, int *size)); +int sym_get_sp_solution PROTO((sym_environment *env, int index, + double *colsol, double *objval)); +int sym_get_row_activity PROTO((sym_environment *env, double *rowact)); +int sym_get_obj_val PROTO((sym_environment *env, double *objval)); +int sym_get_primal_bound PROTO((sym_environment *env, double *ub)); +int sym_get_iteration_count PROTO((sym_environment *env, int *numnodes)); + +int sym_set_obj_coeff PROTO((sym_environment *env, int index, double value)); +int sym_set_obj2_coeff PROTO((sym_environment *env, int index, double value)); +int sym_set_col_lower PROTO((sym_environment *env, int index, double value)); +int sym_set_col_upper PROTO((sym_environment *env, int index, double value)); +int sym_set_row_lower PROTO((sym_environment *env, int index, double value)); +int sym_set_row_upper PROTO((sym_environment *env, int index, double value)); +int sym_set_row_type PROTO((sym_environment *env, int index, char rowsense, + double rowrhs, double rowrng)); +int sym_set_obj_sense PROTO((sym_environment *env, int sense)); +int sym_set_col_solution PROTO((sym_environment *env, double * colsol)); +int sym_set_primal_bound PROTO((sym_environment *env, double bound)); +int sym_set_continuous PROTO((sym_environment *env, int index)); +int sym_set_integer PROTO((sym_environment *env, int index)); +int sym_set_col_names PROTO((sym_environment *env, char **colname)); +int sym_add_col PROTO((sym_environment *env, int numelems, int *indices, + double *elements, double collb, double colub, + double obj, char is_int, char *name)); +int sym_add_row PROTO((sym_environment *env, int numelems, int *indices, + double *elements, char rowsen, double rowrhs, + double rowrng)); +int sym_delete_cols PROTO((sym_environment *env, int num, int * indices)); +int sym_delete_rows PROTO((sym_environment *env, int num, int * indices)); + +int sym_write_warm_start_desc PROTO((warm_start_desc *ws, char *file)); +warm_start_desc *sym_read_warm_start PROTO((char *file)); + +void sym_delete_warm_start PROTO((warm_start_desc *ws)); +warm_start_desc *sym_get_warm_start PROTO((sym_environment *env, + int copy_warm_start)); + +int sym_set_warm_start PROTO((sym_environment *env, warm_start_desc *ws)); + +int sym_set_int_param PROTO((sym_environment *env, const char *key, int value)); +int sym_set_dbl_param PROTO((sym_environment *env, const char *key, double value)); +int sym_set_str_param PROTO((sym_environment *env, const char *key, const char *value)); + +int sym_get_int_param PROTO((sym_environment *env, const char *key, int *value)); +int sym_get_dbl_param PROTO((sym_environment *env, const char *key, double *value)); +int sym_get_str_param PROTO((sym_environment *env, const char *key, char **value)); + +int sym_get_lb_for_new_rhs PROTO((sym_environment *env, int cnt, + int *new_rhs_ind, double *new_rhs_val, + double *lb_for_new_rhs)); +int sym_get_ub_for_new_rhs PROTO((sym_environment *env, int cnt, + int *new_rhs_ind, double *new_rhs_val, + double *ub_for_new_rhs)); +#if 0 +int sym_get_lb_for_new_obj PROTO((sym_environment *env, int cnt, + int *new_obj_ind, double *new_obj_val, + double *lb_for_new_obj)); +#endif +int sym_get_ub_for_new_obj PROTO((sym_environment *env, int cnt, + int *new_obj_ind, double *new_obj_val, + double *ub_for_new_obj)); + +warm_start_desc *sym_create_copy_warm_start PROTO((warm_start_desc * ws)); +MIPdesc *sym_create_copy_mip_desc PROTO((sym_environment *env)); +MIPdesc *sym_get_presolved_mip_desc PROTO((sym_environment *env)); +sym_environment * sym_create_copy_environment PROTO((sym_environment *env)); + +int sym_test PROTO((sym_environment *env, int argc, char **argv, + int *test_status)); + +#endif diff --git a/thirdparty/windows/lib/x64/IpOpt-vc10.dll b/thirdparty/windows/lib/x64/IpOpt-vc10.dll Binary files differnew file mode 100644 index 0000000..410a173 --- /dev/null +++ b/thirdparty/windows/lib/x64/IpOpt-vc10.dll diff --git a/thirdparty/windows/lib/x64/IpOpt-vc10.lib b/thirdparty/windows/lib/x64/IpOpt-vc10.lib Binary files differnew file mode 100644 index 0000000..7063d30 --- /dev/null +++ b/thirdparty/windows/lib/x64/IpOpt-vc10.lib diff --git a/thirdparty/windows/lib/x64/IpOptFSS.dll b/thirdparty/windows/lib/x64/IpOptFSS.dll Binary files differnew file mode 100644 index 0000000..9744782 --- /dev/null +++ b/thirdparty/windows/lib/x64/IpOptFSS.dll diff --git a/thirdparty/windows/lib/x64/IpOptFSS.lib b/thirdparty/windows/lib/x64/IpOptFSS.lib Binary files differnew file mode 100644 index 0000000..77a9218 --- /dev/null +++ b/thirdparty/windows/lib/x64/IpOptFSS.lib diff --git a/thirdparty/windows/lib/x64/Ipopt-vc8.dll b/thirdparty/windows/lib/x64/Ipopt-vc8.dll Binary files differnew file mode 100644 index 0000000..5d2e1b9 --- /dev/null +++ b/thirdparty/windows/lib/x64/Ipopt-vc8.dll diff --git a/thirdparty/windows/lib/x64/Ipopt-vc8.lib b/thirdparty/windows/lib/x64/Ipopt-vc8.lib Binary files differnew file mode 100644 index 0000000..30462b8 --- /dev/null +++ b/thirdparty/windows/lib/x64/Ipopt-vc8.lib diff --git a/thirdparty/windows/lib/x64/libCgl.lib b/thirdparty/windows/lib/x64/libCgl.lib Binary files differnew file mode 100644 index 0000000..97b94c0 --- /dev/null +++ b/thirdparty/windows/lib/x64/libCgl.lib diff --git a/thirdparty/windows/lib/x64/libClp.lib b/thirdparty/windows/lib/x64/libClp.lib Binary files differnew file mode 100644 index 0000000..44cf0d5 --- /dev/null +++ b/thirdparty/windows/lib/x64/libClp.lib diff --git a/thirdparty/windows/lib/x64/libCoinUtils.lib b/thirdparty/windows/lib/x64/libCoinUtils.lib Binary files differnew file mode 100644 index 0000000..fcfb0f5 --- /dev/null +++ b/thirdparty/windows/lib/x64/libCoinUtils.lib diff --git a/thirdparty/windows/lib/x64/libOsi.lib b/thirdparty/windows/lib/x64/libOsi.lib Binary files differnew file mode 100644 index 0000000..d020104 --- /dev/null +++ b/thirdparty/windows/lib/x64/libOsi.lib diff --git a/thirdparty/windows/lib/x64/libOsiClp.lib b/thirdparty/windows/lib/x64/libOsiClp.lib Binary files differnew file mode 100644 index 0000000..8251609 --- /dev/null +++ b/thirdparty/windows/lib/x64/libOsiClp.lib diff --git a/thirdparty/windows/lib/x64/libSymphony.lib b/thirdparty/windows/lib/x64/libSymphony.lib Binary files differnew file mode 100644 index 0000000..73906e8 --- /dev/null +++ b/thirdparty/windows/lib/x64/libSymphony.lib diff --git a/thirdparty/windows/lib/x64/libiomp5md.dll b/thirdparty/windows/lib/x64/libiomp5md.dll Binary files differnew file mode 100644 index 0000000..2802cec --- /dev/null +++ b/thirdparty/windows/lib/x64/libiomp5md.dll diff --git a/thirdparty/windows/lib/x64/msvcp100.dll b/thirdparty/windows/lib/x64/msvcp100.dll Binary files differnew file mode 100644 index 0000000..6f0cdf1 --- /dev/null +++ b/thirdparty/windows/lib/x64/msvcp100.dll diff --git a/thirdparty/windows/lib/x64/msvcr100.dll b/thirdparty/windows/lib/x64/msvcr100.dll Binary files differnew file mode 100644 index 0000000..b1c3a5e --- /dev/null +++ b/thirdparty/windows/lib/x64/msvcr100.dll diff --git a/thirdparty/windows/lib/x86/IpOpt-vc10.dll b/thirdparty/windows/lib/x86/IpOpt-vc10.dll Binary files differnew file mode 100644 index 0000000..8c02f76 --- /dev/null +++ b/thirdparty/windows/lib/x86/IpOpt-vc10.dll diff --git a/thirdparty/windows/lib/x86/IpOpt-vc10.lib b/thirdparty/windows/lib/x86/IpOpt-vc10.lib Binary files differnew file mode 100644 index 0000000..27b04c1 --- /dev/null +++ b/thirdparty/windows/lib/x86/IpOpt-vc10.lib diff --git a/thirdparty/windows/lib/x86/IpOptFSS.dll b/thirdparty/windows/lib/x86/IpOptFSS.dll Binary files differnew file mode 100644 index 0000000..8b9fe4c --- /dev/null +++ b/thirdparty/windows/lib/x86/IpOptFSS.dll diff --git a/thirdparty/windows/lib/x86/IpOptFSS.lib b/thirdparty/windows/lib/x86/IpOptFSS.lib Binary files differnew file mode 100644 index 0000000..6821362 --- /dev/null +++ b/thirdparty/windows/lib/x86/IpOptFSS.lib diff --git a/thirdparty/windows/lib/x86/Ipopt-vc8.dll b/thirdparty/windows/lib/x86/Ipopt-vc8.dll Binary files differnew file mode 100644 index 0000000..22269fa --- /dev/null +++ b/thirdparty/windows/lib/x86/Ipopt-vc8.dll diff --git a/thirdparty/windows/lib/x86/Ipopt-vc8.lib b/thirdparty/windows/lib/x86/Ipopt-vc8.lib Binary files differnew file mode 100644 index 0000000..4d66573 --- /dev/null +++ b/thirdparty/windows/lib/x86/Ipopt-vc8.lib diff --git a/thirdparty/windows/lib/x86/libCgl.lib b/thirdparty/windows/lib/x86/libCgl.lib Binary files differnew file mode 100644 index 0000000..82509c4 --- /dev/null +++ b/thirdparty/windows/lib/x86/libCgl.lib diff --git a/thirdparty/windows/lib/x86/libClp.lib b/thirdparty/windows/lib/x86/libClp.lib Binary files differnew file mode 100644 index 0000000..0ef9c10 --- /dev/null +++ b/thirdparty/windows/lib/x86/libClp.lib diff --git a/thirdparty/windows/lib/x86/libCoinUtils.lib b/thirdparty/windows/lib/x86/libCoinUtils.lib Binary files differnew file mode 100644 index 0000000..7605cff --- /dev/null +++ b/thirdparty/windows/lib/x86/libCoinUtils.lib diff --git a/thirdparty/windows/lib/x86/libOsi.lib b/thirdparty/windows/lib/x86/libOsi.lib Binary files differnew file mode 100644 index 0000000..847f19b --- /dev/null +++ b/thirdparty/windows/lib/x86/libOsi.lib diff --git a/thirdparty/windows/lib/x86/libOsiClp.lib b/thirdparty/windows/lib/x86/libOsiClp.lib Binary files differnew file mode 100644 index 0000000..41cfbea --- /dev/null +++ b/thirdparty/windows/lib/x86/libOsiClp.lib diff --git a/thirdparty/windows/lib/x86/libSymphony.lib b/thirdparty/windows/lib/x86/libSymphony.lib Binary files differnew file mode 100644 index 0000000..ba1fa35 --- /dev/null +++ b/thirdparty/windows/lib/x86/libSymphony.lib diff --git a/thirdparty/windows/lib/x86/libiomp5md.dll b/thirdparty/windows/lib/x86/libiomp5md.dll Binary files differnew file mode 100644 index 0000000..f4d5925 --- /dev/null +++ b/thirdparty/windows/lib/x86/libiomp5md.dll diff --git a/thirdparty/windows/lib/x86/msvcp100.dll b/thirdparty/windows/lib/x86/msvcp100.dll Binary files differnew file mode 100644 index 0000000..8502dfa --- /dev/null +++ b/thirdparty/windows/lib/x86/msvcp100.dll diff --git a/thirdparty/windows/lib/x86/msvcr100.dll b/thirdparty/windows/lib/x86/msvcr100.dll Binary files differnew file mode 100644 index 0000000..3e82b1a --- /dev/null +++ b/thirdparty/windows/lib/x86/msvcr100.dll |