Changeset 1928


Ignore:
Timestamp:
Apr 6, 2013 8:54:16 AM (6 years ago)
Author:
stefan
Message:

revert r1925 (so we can merge r1926) and sync with rev 1927

Location:
stable/1.15/Clp
Files:
24 edited

Legend:

Unmodified
Added
Removed
  • stable/1.15/Clp

  • stable/1.15/Clp/src

  • stable/1.15/Clp/src/CbcOrClpParam.cpp

    r1910 r1928  
    1313
    1414#ifdef COIN_HAS_CBC
     15#if CBC_VERSION_MAJOR==2
     16#if CBC_VERSION_MINOR>9
     17#define CBC_AFTER_2_9
     18#endif
     19#else
     20#define CBC_AFTER_2_9
     21#endif
    1522#ifdef COIN_HAS_CLP
    1623#include "OsiClpSolverInterface.hpp"
     
    15651572See Rounding for meaning of on,both,before"
    15661573     );
     1574#ifdef CBC_AFTER_2_9
     1575      parameters[numberParameters++] =
     1576          CbcOrClpParam("constraint!fromCutoff", "Whether to use cutoff as constraint",
     1577                        "off", CBC_PARAM_STR_CUTOFF_CONSTRAINT);
     1578     parameters[numberParameters-1].append("on");
     1579     parameters[numberParameters-1].setLonghelp
     1580     (
     1581          "This adds the objective as a constraint with best solution as RHS"
     1582     );
     1583#endif
    15671584     parameters[numberParameters++] =
    15681585          CbcOrClpParam("cost!Strategy", "How to use costs as priorities",
     
    15731590     parameters[numberParameters-1].append("01l!ast?");
    15741591     parameters[numberParameters-1].append("length!?");
     1592     parameters[numberParameters-1].append("singletons");
     1593     parameters[numberParameters-1].append("nonzero");
    15751594     parameters[numberParameters-1].setLonghelp
    15761595     (
     
    18171836     (
    18181837          "If >2 && <8 then modify diving options - \
    1819          \t3 only at root and if no solution,  \
    1820          \t4 only at root and if this heuristic has not got solution, \
    1821          \t5 only at depth <4, \
    1822          \t6 decay, \
    1823          \t7 run up to 2 times if solution found 4 otherwise."
     1838         \n\t3 only at root and if no solution,  \
     1839         \n\t4 only at root and if this heuristic has not got solution, \
     1840         \n\t5 only at depth <4, \
     1841         \n\t6 decay, \
     1842         \n\t7 run up to 2 times if solution found 4 otherwise."
    18241843     );
    18251844     parameters[numberParameters-1].setIntValue(-1);
     
    20012020     (
    20022021      "Strategy for extra strong branching \n\
    2003 \t0 - normal\n\
    2004 \twhen to do all fractional\n\
    2005 \t1 - root node\n\
    2006 \t2 - depth less than modifier\n\
    2007 \t4 - if objective == best possible\n\
    2008 \t6 - as 2+4\n\
    2009 \twhen to do all including satisfied\n\
    2010 \t10 - root node etc.\n\
    2011 \tIf >=100 then do when depth <= strategy/100 (otherwise 5)"
     2022\n\t0 - normal\n\
     2023\n\twhen to do all fractional\n\
     2024\n\t1 - root node\n\
     2025\n\t2 - depth less than modifier\n\
     2026\n\t4 - if objective == best possible\n\
     2027\n\t6 - as 2+4\n\
     2028\n\twhen to do all including satisfied\n\
     2029\n\t10 - root node etc.\n\
     2030\n\tIf >=100 then do when depth <= strategy/100 (otherwise 5)"
    20122031     );
    20132032     parameters[numberParameters-1].setIntValue(0);
     
    20462065means use until a solution is found.  The next two digits say what sort \
    20472066of dual information to use.  After that it goes back to powers of 2 so -\n\
    2048 \t1000 - switches on experimental hotstart\n\
    2049 \t2,4,6000 - switches on experimental methods of stopping cuts\n\
    2050 \t8000 - increase minimum drop gradually\n\
    2051 \t16000 - switches on alternate gomory criterion"
     2067\n\t1000 - switches on experimental hotstart\n\
     2068\n\t2,4,6000 - switches on experimental methods of stopping cuts\n\
     2069\n\t8000 - increase minimum drop gradually\n\
     2070\n\t16000 - switches on alternate gomory criterion"
     2071     );
     2072     parameters[numberParameters++] =
     2073       CbcOrClpParam("extraV!ariables", "Allow creation of extra integer variables",
     2074                     -COIN_INT_MAX, COIN_INT_MAX, CBC_PARAM_INT_EXTRA_VARIABLES, 0);
     2075     parameters[numberParameters-1].setIntValue(0);
     2076     parameters[numberParameters-1].setLonghelp
     2077     (
     2078          "This switches on creation of extra integer variables \
     2079to gather all variables with same cost."
    20522080     );
    20532081#endif
     
    21412169     parameters[numberParameters-1].append("deltastrong");
    21422170#endif
    2143      parameters[numberParameters++] =
    2144           CbcOrClpParam("gsolu!tion", "Puts glpk solution to file",
    2145                         CLP_PARAM_ACTION_GMPL_SOLUTION);
    2146      parameters[numberParameters-1].setLonghelp
    2147      (
    2148           "Will write a glpk solution file to the given file name.  It will use the default\
    2149  directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
    2150  is initialized to 'stdout' (this defaults to ordinary solution if stdout). \
    2151 If problem created from gmpl model - will do any reports."
    2152      );
    2153 #ifdef COIN_HAS_CBC
     2171#ifdef COIN_HAS_CBC
     2172      parameters[numberParameters++] =
     2173          CbcOrClpParam("GMI!Cuts", "Whether to use alternative Gomory cuts",
     2174                        "off", CBC_PARAM_STR_GMICUTS);
     2175     parameters[numberParameters-1].append("on");
     2176     parameters[numberParameters-1].append("root");
     2177     parameters[numberParameters-1].append("ifmove");
     2178     parameters[numberParameters-1].append("forceOn");
     2179     parameters[numberParameters-1].append("endonly");
     2180     parameters[numberParameters-1].append("long");
     2181     parameters[numberParameters-1].append("longroot");
     2182     parameters[numberParameters-1].append("longifmove");
     2183     parameters[numberParameters-1].append("forceLongOn");
     2184     parameters[numberParameters-1].append("longendonly");
     2185     parameters[numberParameters-1].setLonghelp
     2186     (
     2187          "This switches on an alternative Gomory cut generator (either at root or in entire tree) \
     2188This version is by Giacomo Nannicini and may be more robust \
     2189See branchAndCut for information on options."
     2190     );
     2191     parameters[numberParameters++] =
     2192          CbcOrClpParam("GMI!Cuts", "Whether to use alternative Gomory cuts",
     2193                        "off", CBC_PARAM_STR_GMICUTS);
     2194     parameters[numberParameters-1].append("on");
     2195     parameters[numberParameters-1].append("root");
     2196     parameters[numberParameters-1].append("ifmove");
     2197     parameters[numberParameters-1].append("forceOn");
     2198     parameters[numberParameters-1].append("endonly");
     2199     parameters[numberParameters-1].append("long");
     2200     parameters[numberParameters-1].append("longroot");
     2201     parameters[numberParameters-1].append("longifmove");
     2202     parameters[numberParameters-1].append("forceLongOn");
     2203     parameters[numberParameters-1].append("longendonly");
     2204     parameters[numberParameters-1].setLonghelp
     2205     (
     2206          "This switches on an alternative Gomory cut generator (either at root or in entire tree) \
     2207This version is by Giacomo Nannicini and may be more robust \
     2208See branchAndCut for information on options."
     2209     );
    21542210     parameters[numberParameters++] =
    21552211          CbcOrClpParam("gomory!Cuts", "Whether to use Gomory cuts",
     
    21842240See Rounding for meaning of on,both,before"
    21852241     );
     2242#endif
     2243     parameters[numberParameters++] =
     2244          CbcOrClpParam("gsolu!tion", "Puts glpk solution to file",
     2245                        CLP_PARAM_ACTION_GMPL_SOLUTION);
     2246     parameters[numberParameters-1].setLonghelp
     2247     (
     2248          "Will write a glpk solution file to the given file name.  It will use the default\
     2249 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
     2250 is initialized to 'stdout' (this defaults to ordinary solution if stdout). \
     2251If problem created from gmpl model - will do any reports."
     2252     );
     2253#ifdef COIN_HAS_CBC
    21862254     parameters[numberParameters++] =
    21872255          CbcOrClpParam("heur!isticsOnOff", "Switches most heuristics on or off",
     
    23372405The length options for gomory cuts are used."
    23382406     );
     2407#ifdef CBC_AFTER_2_9
     2408      parameters[numberParameters++] =
     2409          CbcOrClpParam("latwomir!Cuts", "Whether to use Lagrangean TwoMir cuts",
     2410                        "off", CBC_PARAM_STR_LATWOMIRCUTS);
     2411     parameters[numberParameters-1].append("endonlyroot");
     2412     parameters[numberParameters-1].append("endcleanroot");
     2413     parameters[numberParameters-1].append("endbothroot");
     2414     parameters[numberParameters-1].append("endonly");
     2415     parameters[numberParameters-1].append("endclean");
     2416     parameters[numberParameters-1].append("endboth");
     2417     parameters[numberParameters-1].append("onlyaswell");
     2418     parameters[numberParameters-1].append("cleanaswell");
     2419     parameters[numberParameters-1].append("bothaswell");
     2420     parameters[numberParameters-1].append("onlyinstead");
     2421     parameters[numberParameters-1].append("cleaninstead");
     2422     parameters[numberParameters-1].append("bothinstead");
     2423     parameters[numberParameters-1].setLonghelp
     2424     (
     2425          "This is a lagrangean relaxation for TwoMir cuts.  See \
     2426lagomoryCuts for description of options."
     2427     );
     2428#endif
    23392429     parameters[numberParameters++] =
    23402430          CbcOrClpParam("lift!AndProjectCuts", "Whether to use Lift and Project cuts",
     
    23462436     parameters[numberParameters-1].setLonghelp
    23472437     (
    2348           "Lift and project cuts - may be expensive to compute. \
     2438          "Lift and project cuts. \
     2439May be slow \
    23492440See branchAndCut for information on options."
    23502441     );
     
    23642455     parameters[numberParameters++] =
    23652456          CbcOrClpParam("log!Level", "Level of detail in Solver output",
    2366                         -1, 63, CLP_PARAM_INT_SOLVERLOGLEVEL);
     2457                        -1, 999999, CLP_PARAM_INT_SOLVERLOGLEVEL);
    23672458#else
    23682459     parameters[numberParameters++] =
     
    24102501          CbcOrClpParam("maxN!odes", "Maximum number of nodes to do",
    24112502                        -1, 2147483647, CBC_PARAM_INT_MAXNODES);
    2412      parameters[numberParameters-1].setLonghelp
     2503     parameters[numberParameters-1].setLonghelp 
    24132504     (
    24142505          "This is a repeatable way to limit search.  Normally using time is easier \
     
    25442635          "Do (in parallel if threads enabled) the root phase this number of times \
    25452636 and collect all solutions and cuts generated.  The actual format is aabbcc \
    2546 where aa is non-zero to say just do heuristics - no cuts, if bb is non zero \
     2637where aa is number of extra passes, if bb is non zero \
    25472638then it is number of threads to use (otherwise uses threads setting) and \
    25482639cc is number of times to do root phase.  Yet another one from the Italian idea factory \
    25492640(This time - Andrea Lodi , Matteo Fischetti , Michele Monaci , Domenico Salvagnin , \
    2550 and Andrea Tramontani)"
     2641and Andrea Tramontani). \
     2642The solvers do not interact with each other.  However if extra passes are specified \
     2643then cuts are collected and used in later passes - so there is interaction there."
    25512644     );
    25522645     parameters[numberParameters++] =
     
    31043197     parameters[numberParameters-1].setLonghelp
    31053198     (
     3199          "This switches on reduce and split  cuts (either at root or in entire tree). \
     3200May be slow \
     3201See branchAndCut for information on options."
     3202     );
     3203      parameters[numberParameters++] =
     3204          CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
     3205                        "off", CBC_PARAM_STR_REDSPLIT2CUTS);
     3206     parameters[numberParameters-1].append("on");
     3207     parameters[numberParameters-1].append("root");
     3208     parameters[numberParameters-1].append("longOn");
     3209     parameters[numberParameters-1].append("longRoot");
     3210     parameters[numberParameters-1].setLonghelp
     3211     (
    31063212          "This switches on reduce and split  cuts (either at root or in entire tree) \
     3213This version is by Giacomo Nannicini based on Francois Margot's version \
     3214Standard setting only uses rows in tableau <=256, long uses all \
     3215May be slow \
     3216See branchAndCut for information on options."
     3217     );
     3218     parameters[numberParameters++] =
     3219          CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
     3220                        "off", CBC_PARAM_STR_REDSPLIT2CUTS);
     3221     parameters[numberParameters-1].append("on");
     3222     parameters[numberParameters-1].append("root");
     3223     parameters[numberParameters-1].append("longOn");
     3224     parameters[numberParameters-1].append("longRoot");
     3225     parameters[numberParameters-1].setLonghelp
     3226     (
     3227          "This switches on reduce and split  cuts (either at root or in entire tree) \
     3228This version is by Giacomo Nannicini based on Francois Margot's version \
     3229Standard setting only uses rows in tableau <=256, long uses all \
    31073230See branchAndCut for information on options."
    31083231     );
     
    32543377          "If passed to solver fom ampl, then ampl will wait so that you can copy .nl file for debug."
    32553378     );
     3379#ifdef COIN_HAS_CBC
     3380#ifdef CBC_AFTER_2_9
     3381     parameters[numberParameters++] =
     3382          CbcOrClpParam("slow!cutpasses", "Maximum number of tries for slower cuts",
     3383                        -1, COIN_INT_MAX, CBC_PARAM_INT_MAX_SLOW_CUTS);
     3384     parameters[numberParameters-1].setLonghelp
     3385     (
     3386          "Some cut generators are fairly slow - this limits the number of times they are tried."
     3387     );
     3388     parameters[numberParameters-1].setIntValue(10);
     3389#endif
     3390#endif
    32563391#ifdef COIN_HAS_CLP
    32573392     parameters[numberParameters++] =
  • stable/1.15/Clp/src/CbcOrClpParam.hpp

    r1906 r1928  
    140140     CBC_PARAM_INT_MULTIPLEROOTS,
    141141     CBC_PARAM_INT_STRONG_STRATEGY,
     142     CBC_PARAM_INT_EXTRA_VARIABLES,
     143     CBC_PARAM_INT_MAX_SLOW_CUTS,
    142144
    143145     CLP_PARAM_STR_DIRECTION = 201,
     
    210212     CBC_PARAM_STR_VND,
    211213     CBC_PARAM_STR_LAGOMORYCUTS,
     214     CBC_PARAM_STR_LATWOMIRCUTS,
     215     CBC_PARAM_STR_REDSPLIT2CUTS,
     216     CBC_PARAM_STR_GMICUTS,
     217     CBC_PARAM_STR_CUTOFF_CONSTRAINT,
    212218
    213219     CLP_PARAM_ACTION_DIRECTORY = 301,
  • stable/1.15/Clp/src/ClpMain.cpp

    r1910 r1928  
    915915                                   try {
    916916                                        status = model2->initialSolve(solveOptions);
     917#ifndef NDEBUG
     918                                        // if infeasible check ray
     919                                        if (model2->status()==1) {
     920                                          int debugMode=0;
     921                                          ClpSimplex * simplex = model2;
     922                                          if(simplex->ray()) {
     923                                            // make sure we use non-scaled versions
     924                                            ClpPackedMatrix * saveMatrix = simplex->swapScaledMatrix(NULL);
     925                                            double * saveScale = simplex->swapRowScale(NULL);
     926                                            // could use existing arrays
     927                                            int numberRows=simplex->numberRows();
     928                                            int numberColumns=simplex->numberColumns();
     929                                            double * farkas = new double [2*numberColumns+numberRows];
     930                                            double * bound = farkas + numberColumns;
     931                                            double * effectiveRhs = bound + numberColumns;
     932                                            // get ray as user would
     933                                            double * ray = simplex->infeasibilityRay();
     934                                            // get farkas row
     935                                            memset(farkas,0,(2*numberColumns+numberRows)*sizeof(double));
     936                                            simplex->transposeTimes(-1.0,ray,farkas);
     937                                            // Put nonzero bounds in bound
     938                                            const double * columnLower = simplex->columnLower();
     939                                            const double * columnUpper = simplex->columnUpper();
     940                                            int numberBad=0;
     941                                            for (int i=0;i<numberColumns;i++) {
     942                                              double value = farkas[i];
     943                                              double boundValue=0.0;
     944                                              if (simplex->getStatus(i)==ClpSimplex::basic) {
     945                                                // treat as zero if small
     946                                                if (fabs(value)<1.0e-8) {
     947                                                  value=0.0;
     948                                                  farkas[i]=0.0;
     949                                                }
     950                                                if (value) {
     951                                                  //printf("basic %d direction %d farkas %g\n",
     952                                                  //       i,simplex->directionOut(),value);
     953                                                  if (value<0.0)
     954                                                    boundValue=columnLower[i];
     955                                                  else
     956                                                    boundValue=columnUpper[i];
     957                                                }
     958                                              } else if (fabs(value)>1.0e-10) {
     959                                                if (value<0.0)
     960                                                  boundValue=columnLower[i];
     961                                                else
     962                                                  boundValue=columnUpper[i];
     963                                              }
     964                                              bound[i]=boundValue;
     965                                              if (fabs(boundValue)>1.0e10)
     966                                                numberBad++;
     967                                            }
     968                                            const double * rowLower = simplex->rowLower();
     969                                            const double * rowUpper = simplex->rowUpper();
     970                                            //int pivotRow = simplex->spareIntArray_[3];
     971                                            //bool badPivot=pivotRow<0;
     972                                            for (int i=0;i<numberRows;i++) {
     973                                              double value = ray[i];
     974                                              double rhsValue=0.0;
     975                                              if (simplex->getRowStatus(i)==ClpSimplex::basic) {
     976                                                // treat as zero if small
     977                                                if (fabs(value)<1.0e-8) {
     978                                                  value=0.0;
     979                                                  ray[i]=0.0;
     980                                                }
     981                                                if (value) {
     982                                                  //printf("row basic %d direction %d ray %g\n",
     983                                                  //       i,simplex->directionOut(),value);
     984                                                  if (value<0.0)
     985                                                    rhsValue=rowLower[i];
     986                                                  else
     987                                                    rhsValue=rowUpper[i];
     988                                                }
     989                                              } else if (fabs(value)>1.0e-10) {
     990                                                if (value<0.0)
     991                                                  rhsValue=rowLower[i];
     992                                                else
     993                                                  rhsValue=rowUpper[i];
     994                                              }
     995                                              effectiveRhs[i]=rhsValue;
     996                                              if (fabs(effectiveRhs[i])>1.0e10)
     997                                                printf("Large rhs row %d %g\n",
     998                                                       i,effectiveRhs[i]);
     999                                            }
     1000                                            simplex->times(-1.0,bound,effectiveRhs);
     1001                                            double bSum=0.0;
     1002                                            for (int i=0;i<numberRows;i++) {
     1003                                              bSum += effectiveRhs[i]*ray[i];
     1004                                              if (fabs(effectiveRhs[i])>1.0e10)
     1005                                                printf("Large rhs row %d %g after\n",
     1006                                                       i,effectiveRhs[i]);
     1007                                            }
     1008                                            if (numberBad||bSum>1.0e-6) {
     1009                                              printf("Bad infeasibility ray %g  - %d bad\n",
     1010                                                     bSum,numberBad);
     1011                                            } else {
     1012                                              //printf("Good ray - infeasibility %g\n",
     1013                                              //     -bSum);
     1014                                            }
     1015                                            delete [] ray;
     1016                                            delete [] farkas;
     1017                                            simplex->swapRowScale(saveScale);
     1018                                            simplex->swapScaledMatrix(saveMatrix);
     1019                                          } else {
     1020                                            //printf("No dual ray\n");
     1021                                          }
     1022                                        }
     1023#endif
    9171024                                   } catch (CoinError e) {
    9181025                                        e.print();
     
    26872794                    if (columnUpper[iColumn] > columnLower[iColumn]) {
    26882795                         numberIntegers++;
    2689                          if (columnUpper[iColumn] == 0.0 && columnLower[iColumn] == 1)
     2796                         if (columnLower[iColumn] == 0.0 && columnUpper[iColumn] == 1)
    26902797                              numberBinary++;
    26912798                    }
    26922799               }
    26932800          }
     2801          printf("Original problem has %d integers (%d of which binary)\n",
     2802                 numberIntegers,numberBinary);
    26942803     }
    26952804     numberColumns = model->numberColumns();
     
    27002809     const double * rowUpper = model->rowUpper();
    27012810     const double * objective = model->objective();
     2811     if (model->integerInformation()) {
     2812       const char * integerInformation  = model->integerInformation();
     2813       int numberIntegers = 0;
     2814       int numberBinary = 0;
     2815       double * obj = new double [numberColumns];
     2816       int * which = new int [numberColumns];
     2817       for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     2818         if (columnUpper[iColumn] > columnLower[iColumn]) {
     2819           if (integerInformation[iColumn]) {
     2820             numberIntegers++;
     2821             if (columnLower[iColumn] == 0.0 && columnUpper[iColumn] == 1)
     2822               numberBinary++;
     2823           }
     2824         }
     2825       }
     2826       if(numberColumns != originalModel->numberColumns())
     2827         printf("Presolved problem has %d integers (%d of which binary)\n",
     2828                numberIntegers,numberBinary);
     2829       for (int ifInt=0;ifInt<2;ifInt++) {
     2830         for (int ifAbs=0;ifAbs<2;ifAbs++) {
     2831           int numberSort=0;
     2832           int numberZero=0;
     2833           int numberDifferentObj=0;
     2834           for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     2835             if (columnUpper[iColumn] > columnLower[iColumn]) {
     2836               if (!ifInt||integerInformation[iColumn]) {
     2837                 obj[numberSort]=(ifAbs) ? fabs(objective[iColumn]) :
     2838                   objective[iColumn];
     2839                 which[numberSort++]=iColumn;
     2840                 if (!objective[iColumn])
     2841                   numberZero++;
     2842               }
     2843             }
     2844           }
     2845           CoinSort_2(obj,obj+numberSort,which);
     2846           double last=obj[0];
     2847           for (int jColumn = 1; jColumn < numberSort; jColumn++) {
     2848             if (fabs(obj[jColumn]-last)>1.0e-12) {
     2849               numberDifferentObj++;
     2850               last=obj[jColumn];
     2851             }
     2852           }
     2853           numberDifferentObj++;
     2854           printf("==== ");
     2855           if (ifInt)
     2856             printf("for integers ");
     2857           if (!ifAbs)
     2858             printf("%d zero objective ",numberZero);
     2859           else
     2860             printf("absolute objective values ");
     2861           printf("%d different\n",numberDifferentObj);
     2862           bool saveModel=false;
     2863           int target=model->logLevel();
     2864           if (target>10000) {
     2865             if (ifInt&&!ifAbs)
     2866               saveModel=true;
     2867             target-=10000;
     2868           }
     2869
     2870           if (target<=100)
     2871             target=12;
     2872           else
     2873             target-=100;
     2874           if (numberDifferentObj<target) {
     2875             int iLast=0;
     2876             double last=obj[0];
     2877             for (int jColumn = 1; jColumn < numberSort; jColumn++) {
     2878               if (fabs(obj[jColumn]-last)>1.0e-12) {
     2879                 printf("%d variables have objective of %g\n",
     2880                        jColumn-iLast,last);
     2881                 iLast=jColumn;
     2882                 last=obj[jColumn];
     2883               }
     2884             }
     2885             printf("%d variables have objective of %g\n",
     2886                    numberSort-iLast,last);
     2887             if (saveModel) {
     2888               int spaceNeeded=numberSort+numberDifferentObj;
     2889               int * columnAdd = new int[spaceNeeded+numberDifferentObj+1];
     2890               double * elementAdd = new double[spaceNeeded];
     2891               int * rowAdd = new int[2*numberDifferentObj+1];
     2892               int * newIsInteger = rowAdd+numberDifferentObj+1;
     2893               double * objectiveNew = new double[3*numberDifferentObj];
     2894               double * lowerNew = objectiveNew+numberDifferentObj;
     2895               double * upperNew = lowerNew+numberDifferentObj;
     2896               memset(columnAdd+spaceNeeded,0,
     2897                      (numberDifferentObj+1)*sizeof(int));
     2898               ClpSimplex tempModel=*model;
     2899               int iLast=0;
     2900               double last=obj[0];
     2901               numberDifferentObj=0;
     2902               int numberElements=0;
     2903               rowAdd[0]=0;
     2904               double * objective = tempModel.objective();
     2905               for (int jColumn = 1; jColumn < numberSort+1; jColumn++) {
     2906                 if (jColumn==numberSort||fabs(obj[jColumn]-last)>1.0e-12) {
     2907                   // not if just one
     2908                   if (jColumn-iLast>1) {
     2909                     bool allInteger=integerInformation!=NULL;
     2910                     int iColumn=which[iLast];
     2911                     objectiveNew[numberDifferentObj]=objective[iColumn];
     2912                     double lower=0.0;
     2913                     double upper=0.0;
     2914                     for (int kColumn=iLast;kColumn<jColumn;kColumn++) {
     2915                       iColumn=which[kColumn];
     2916                       objective[iColumn]=0.0;
     2917                       double lowerValue=columnLower[iColumn];
     2918                       double upperValue=columnUpper[iColumn];
     2919                       double elementValue=-1.0;
     2920                       if (objectiveNew[numberDifferentObj]*objective[iColumn]<0.0) {
     2921                         lowerValue=-columnUpper[iColumn];
     2922                         upperValue=-columnLower[iColumn];
     2923                         elementValue=1.0;
     2924                       }
     2925                       columnAdd[numberElements]=iColumn;
     2926                       elementAdd[numberElements++]=elementValue;
     2927                       if (integerInformation&&!integerInformation[iColumn])
     2928                         allInteger=false;
     2929                       if (lower!=-COIN_DBL_MAX) {
     2930                         if (lowerValue!=-COIN_DBL_MAX)
     2931                           lower += lowerValue;
     2932                         else
     2933                           lower=-COIN_DBL_MAX;
     2934                       }
     2935                       if (upper!=COIN_DBL_MAX) {
     2936                         if (upperValue!=COIN_DBL_MAX)
     2937                           upper += upperValue;
     2938                         else
     2939                           upper=COIN_DBL_MAX;
     2940                       }
     2941                     }
     2942                     columnAdd[numberElements]=numberColumns+numberDifferentObj;
     2943                     elementAdd[numberElements++]=1.0;
     2944                     newIsInteger[numberDifferentObj]= (allInteger) ? 1 : 0;
     2945                     lowerNew[numberDifferentObj]=lower;
     2946                     upperNew[numberDifferentObj]=upper;
     2947                     numberDifferentObj++;
     2948                     rowAdd[numberDifferentObj]=numberElements;
     2949                   }
     2950                   iLast=jColumn;
     2951                   last=obj[jColumn];
     2952                 }
     2953               }
     2954               // add columns
     2955               tempModel.addColumns(numberDifferentObj, lowerNew, upperNew,
     2956                                    objectiveNew,
     2957                                    columnAdd+spaceNeeded, NULL, NULL);
     2958               // add constraints and make integer if all integer in group
     2959               for (int iObj=0; iObj < numberDifferentObj; iObj++) {
     2960                 lowerNew[iObj]=0.0;
     2961                 upperNew[iObj]=0.0;
     2962                 if (newIsInteger[iObj])
     2963                   tempModel.setInteger(numberColumns+iObj);
     2964               }
     2965               tempModel.addRows(numberDifferentObj, lowerNew, upperNew,
     2966                                 rowAdd,columnAdd,elementAdd);
     2967               delete [] columnAdd;
     2968               delete [] elementAdd;
     2969               delete [] rowAdd;
     2970               delete [] objectiveNew;
     2971               // save
     2972               std::string tempName = model->problemName();
     2973               if (ifInt)
     2974                 tempName += "_int";
     2975               if (ifAbs)
     2976                 tempName += "_abs";
     2977               tempName += ".mps";
     2978               tempModel.writeMps(tempName.c_str());
     2979             }
     2980           }
     2981         }
     2982       }
     2983       delete [] which;
     2984       delete [] obj;
     2985       printf("===== end objective counts\n");
     2986     }
    27022987     CoinPackedMatrix * matrix = model->matrix();
    27032988     CoinBigIndex numberElements = matrix->getNumElements();
  • stable/1.15/Clp/src/ClpMessage.cpp

    r1878 r1928  
    4545     {CLP_POSSIBLELOOP, 23, 2, "Possible loop - %d matches (%x) after %d checks"},
    4646     {CLP_SMALLELEMENTS, 24, 1, "Matrix will be packed to eliminate %d small elements"},
     47     {CLP_DUPLICATEELEMENTS, 26, 1, "Matrix will be packed to eliminate %d duplicate elements"},
    4748     {CLP_SIMPLEX_HOUSE1, 101, 32, "dirOut %d, dirIn %d, theta %g, out %g, dj %g, alpha %g"},
    4849     {CLP_SIMPLEX_HOUSE2, 102, 4, "%d %g In: %c%d Out: %c%d%? dj ratio %g distance %g%? dj %g distance %g"},
     
    6162     {CLP_BAD_MATRIX, 6003, 1, "Matrix has %d large values, first at column %d, row %d is %g"},
    6263     {CLP_LOOP, 6004, 1, "Can't get out of loop - stopping"},
    63      {CLP_DUPLICATEELEMENTS, 26, 1, "Matrix will be packed to eliminate %d duplicate elements"},
    6464     {CLP_IMPORT_RESULT, 27, 1, "Model was imported from %s in %g seconds"},
    6565     {CLP_IMPORT_ERRORS, 3001, 1, " There were %d errors when importing model from %s"},
  • stable/1.15/Clp/src/ClpMessage.hpp

    r1817 r1928  
    104104     CLP_PARAMETRICS_STATS,
    105105     CLP_PARAMETRICS_STATS2,
    106      CLP_GENERAL,
    107      CLP_GENERAL2,
    108      CLP_GENERAL_WARNING,
    109106#ifndef NO_FATHOM_PRINT
    110107     CLP_FATHOM_STATUS,
     
    112109     CLP_FATHOM_FINISH,
    113110#endif
     111     CLP_GENERAL,
     112     CLP_GENERAL2,
     113     CLP_GENERAL_WARNING,
    114114     CLP_DUMMY_END
    115115};
  • stable/1.15/Clp/src/ClpModel.cpp

    r1895 r1928  
    123123     intParam_[ClpMaxNumIteration] = 2147483647;
    124124     intParam_[ClpMaxNumIterationHotStart] = 9999999;
    125      intParam_[ClpNameDiscipline] = 0;
     125     intParam_[ClpNameDiscipline] = 1;
    126126
    127127     dblParam_[ClpDualObjectiveLimit] = COIN_DBL_MAX;
     
    27552755// Infeasibility/unbounded ray (NULL returned if none/wrong)
    27562756double *
    2757 ClpModel::infeasibilityRay() const
     2757ClpModel::infeasibilityRay(bool fullRay) const
    27582758{
    27592759     double * array = NULL;
    27602760     if (problemStatus_ == 1 && ray_) {
    2761           array = ClpCopyOfArray(ray_, numberRows_);
    2762 #ifndef CLP_NO_SWAP_SIGN
    2763           // swap signs to be consistent with norm
    2764           for (int i = 0; i < numberRows_; i++)
    2765                array[i] = -array[i];
    2766 #endif
    2767 #if 0
    2768           // clean up
    2769           double largest = 1.0e-30;
    2770           double smallest = COIN_DBL_MAX;
    2771           int i;
    2772           for (i = 0; i < numberRows_; i++) {
    2773                double value = fabs(array[i]);
    2774                smallest = CoinMin(smallest, value);
    2775                largest = CoinMax(largest, value);
    2776           }
    2777 #endif
     2761       if (!fullRay) {
     2762         array = ClpCopyOfArray(ray_, numberRows_);
     2763       } else {
     2764         array = new double [numberRows_+numberColumns_];
     2765         memcpy(array,ray_,numberRows_*sizeof(double));
     2766         memset(array+numberRows_,0,numberColumns_*sizeof(double));
     2767         transposeTimes(-1.0,array,array+numberRows_);
     2768       }
    27782769     }
    27792770     return array;
     
    28502841     defaultHandler_ = oldDefault;
    28512842     handler_ = oldHandler;
     2843}
     2844// Overrides message handler with a default one
     2845void
     2846ClpModel::setDefaultMessageHandler()
     2847{
     2848     int logLevel = handler_->logLevel();
     2849     if (defaultHandler_)
     2850          delete handler_;
     2851     defaultHandler_ = true;
     2852     handler_ = new CoinMessageHandler();
     2853     handler_->setLogLevel(logLevel);
    28522854}
    28532855// Set language
     
    40644066               coinModel->setColumnIsInteger(i, true);
    40654067     }
    4066      // do names
     4068     // do names - clear out
     4069     coinModel->zapRowNames();
     4070     coinModel->zapColumnNames();
    40674071     for (i = 0; i < numberRows_; i++) {
    40684072          char temp[30];
  • stable/1.15/Clp/src/ClpModel.hpp

    r1901 r1928  
    616616          return inverseColumnScale_;
    617617     }
     618     inline double * swapRowScale(double * newScale) {
     619          double * oldScale = rowScale_;
     620          rowScale_ = newScale;
     621          return oldScale;
     622     }
    618623     void setRowScale(double * scale) ;
    619624     void setColumnScale(double * scale);
     
    723728          scaledMatrix_ = scaledMatrix;
    724729     }
     730     /// Swaps pointer to scaled ClpPackedMatrix
     731     inline ClpPackedMatrix * swapScaledMatrix(ClpPackedMatrix * scaledMatrix) {
     732          ClpPackedMatrix * oldMatrix = scaledMatrix_;
     733          scaledMatrix_ = scaledMatrix;
     734          return oldMatrix;
     735     }
    725736     /** Replace Clp Matrix (current is not deleted unless told to
    726737         and new is used)
     
    754765     /** Infeasibility/unbounded ray (NULL returned if none/wrong)
    755766         Up to user to use delete [] on these arrays.  */
    756      double * infeasibilityRay() const;
     767     double * infeasibilityRay(bool fullRay=false) const;
    757768     double * unboundedRay() const;
     769     /// For advanced users - no need to delete - sign not changed
     770     inline double * ray() const
     771     { return ray_;}
    758772     /// just test if infeasibility or unbounded Ray exists
    759773     inline bool rayExists() const {
     
    826840          newLanguage(language);
    827841     }
     842     /// Overrides message handler with a default one
     843     void setDefaultMessageHandler();
    828844     /// Return handler
    829845     inline CoinMessageHandler * messageHandler() const       {
  • stable/1.15/Clp/src/ClpPackedMatrix.cpp

    r1878 r1928  
    2525#include "mkl_spblas.h"
    2626#endif
    27 
     27//#define DO_CHECK_FLAGS 1
    2828//=============================================================================
    2929#ifdef COIN_PREFETCH
     
    6969     : ClpMatrixBase(rhs)
    7070{
     71#ifdef DO_CHECK_FLAGS
     72     rhs.checkFlags(0);
     73#endif
    7174#ifndef COIN_SPARSE_MATRIX
    7275     // Guaranteed no gaps or small elements
     
    98101          columnCopy_ = NULL;
    99102     }
     103#ifdef DO_CHECK_FLAGS
     104     checkFlags(0);
     105#endif
    100106}
    101107//-------------------------------------------------------------------
     
    111117     columnCopy_ = NULL;
    112118     setType(1);
     119#ifdef DO_CHECK_FLAGS
     120     checkFlags(0);
     121#endif
    113122
    114123}
     
    128137     columnCopy_ = NULL;
    129138     setType(1);
     139#ifdef DO_CHECK_FLAGS
     140     checkFlags(0);
     141#endif
    130142
    131143}
     
    173185               columnCopy_ = NULL;
    174186          }
     187#ifdef DO_CHECK_FLAGS
     188          checkFlags(0);
     189#endif
    175190     }
    176191     return *this;
     
    191206     assert (matrix_->isColOrdered() == rhs->matrix_->isColOrdered());
    192207     matrix_->copyReuseArrays(*rhs->matrix_);
     208#ifdef DO_CHECK_FLAGS
     209     checkFlags(0);
     210#endif
    193211}
    194212/* Subset clone (without gaps).  Duplicates are allowed
     
    216234     flags_ = rhs.flags_&(~0x02) ; // no gaps
    217235     columnCopy_ = NULL;
     236#ifdef DO_CHECK_FLAGS
     237     checkFlags(0);
     238#endif
    218239}
    219240ClpPackedMatrix::ClpPackedMatrix (
     
    230251     columnCopy_ = NULL;
    231252     setType(1);
     253#ifdef DO_CHECK_FLAGS
     254     checkFlags(0);
     255#endif
    232256}
    233257
     
    244268     copy->numberActiveColumns_ = copy->matrix_->getNumCols();
    245269     copy->flags_ = flags_&(~0x02) ; // no gaps
     270#ifdef DO_CHECK_FLAGS
     271     checkFlags(0);
     272#endif
    246273     return copy;
    247274}
     
    34083435          // if scalingMethod 3 then may change
    34093436          bool extraDetails = (model->logLevel() > 2);
     3437#if 0
     3438          for (iColumn = 0; iColumn < numberColumns; iColumn++) {
     3439            if (columnUpper[iColumn] >
     3440                columnLower[iColumn] + 1.0e-12 && columnLength[iColumn])
     3441              assert(usefulColumn[iColumn]!=0);
     3442            else
     3443              assert(usefulColumn[iColumn]==0);
     3444          }
     3445#endif
    34103446          while (!finished) {
    34113447               int numberPass = 3;
     
    36543690                         //overallSmallest = CoinMin(overallSmallest,smallest*columnScale[iColumn]);
    36553691                    } else {
    3656                          assert(columnScale[iColumn] == 1.0);
     3692                      assert(columnScale[iColumn] == 1.0);
    36573693                         //columnScale[iColumn]=1.0;
    36583694                    }
     
    38773913          }
    38783914     }
     3915#ifdef DO_CHECK_FLAGS
     3916     checkFlags(0);
     3917#endif
    38793918}
    38803919/* Unpacks a column into an CoinIndexedvector
     
    40524091#else
    40534092               checkGaps();
     4093#ifdef DO_CHECK_FLAGS
     4094               checkFlags(0);
     4095#endif
    40544096#endif
    40554097#ifdef COIN_DEVELOP
     
    46444686     flags_ &= ~(4 + 8);
    46454687     checkGaps();
     4688#ifdef DO_CHECK_FLAGS
     4689     checkFlags(0);
     4690#endif
    46464691}
    46474692// makes sure active columns correct
     
    46674712     }
    46684713     delete rowCopy;
     4714#endif
     4715     checkGaps();
     4716#ifdef DO_CHECK_FLAGS
     4717     checkFlags(0);
    46694718#endif
    46704719     return 0;
     
    47764825     // may now have gaps
    47774826     checkGaps();
     4827#ifdef DO_CHECK_FLAGS
     4828     checkFlags(0);
     4829#endif
    47784830     matrix_->setExtraGap(0.0);
    47794831}
     
    47884840     // may now have gaps
    47894841     checkGaps();
     4842#ifdef DO_CHECK_FLAGS
     4843     checkFlags(0);
     4844#endif
    47904845     matrix_->setExtraGap(0.0);
    47914846}
     
    48074862     // may now have gaps
    48084863     checkGaps();
     4864#ifdef DO_CHECK_FLAGS
     4865     checkFlags(0);
     4866#endif
    48094867     clearCopies();
    48104868}
     
    48194877{
    48204878     matrix_->setDimensions(numrows, numcols);
     4879#ifdef DO_CHECK_FLAGS
     4880     checkFlags(0);
     4881#endif
    48214882}
    48224883/* Append a set of rows/columns to the end of the matrix. Returns number of errors
  • stable/1.15/Clp/src/ClpPredictorCorrector.cpp

    r1726 r1928  
    211211     int saveIteration2 = -1;
    212212     bool sloppyOptimal = false;
     213     // this just to be used to exit
     214     bool sloppyOptimal2 = false;
    213215     CoinWorkDouble * savePi = NULL;
    214216     CoinWorkDouble * savePrimal = NULL;
     
    359361                         CoinMemcpyN(solution_, numberTotal, savePrimal2);
    360362                    }
    361                     if (sloppyOptimal) {
     363                    if (sloppyOptimal2) {
    362364                         // vaguely optimal
    363365                         if (maximumBoundInfeasibility_ > 1.0e-2 ||
     
    401403               }
    402404          }
     405          // See if we should be thinking about exit if diverging
     406          double relativeMultiplier = 1.0 + fabs(primalObjective_) + fabs(dualObjective_);
     407          // Quadratic coding is rubbish so be more forgiving?
     408          if (quadraticObj)
     409            relativeMultiplier *= 5.0;
     410          if (gapO < 1.0e-5 + 1.0e-9 * relativeMultiplier
     411              || complementarityGap_ < 0.1 + 1.0e-9 * relativeMultiplier)
     412              sloppyOptimal2 = true;
    403413          if ((gapO < 1.0e-6 || (gapO < 1.0e-4 && complementarityGap_ < 0.1)) && !sloppyOptimal) {
    404414               sloppyOptimal = true;
     415               sloppyOptimal2 = true;
    405416               handler_->message(CLP_BARRIER_CLOSE_TO_OPTIMAL, messages_)
    406417                         << numberIterations_ << static_cast<double>(complementarityGap_)
     
    415426                         << static_cast<double>(complementarityGap_) << "increasing"
    416427                         << CoinMessageEol;
    417                if (saveIteration >= 0 && sloppyOptimal) {
     428               if (saveIteration >= 0 && sloppyOptimal2) {
    418429                    handler_->message(CLP_BARRIER_EXIT2, messages_)
    419430                              << saveIteration
  • stable/1.15/Clp/src/ClpPresolve.cpp

    r1925 r1928  
    871871#define possibleSkip
    872872#endif
     873#define SOME_PRESOLVE_DETAIL
     874#ifndef SOME_PRESOLVE_DETAIL
     875#define printProgress(x,y) {}
     876#else
     877#define printProgress(x,y) {if ((presolveActions_ & 0x80000000) != 0)   \
     878      printf("%c loop %d %d empty rows, %d empty columns\n",x,y,prob->countEmptyRows(), \
     879           prob->countEmptyCols());}
     880#endif
    873881// This is the presolve loop.
    874882// It is a separate virtual function so that it can be easily
     
    905913#endif
    906914     prob->status_ = 0; // say feasible
     915     printProgress('A',0);
    907916     paction_ = make_fixed(prob, paction_);
    908917     paction_ = testRedundant(prob,paction_) ;
     918     printProgress('B',0);
    909919     // if integers then switch off dual stuff
    910920     // later just do individually
     
    974984               possibleSkip;
    975985               paction_ = dupcol_action::presolve(prob, paction_);
     986               printProgress('C',0);
    976987          }
    977988#ifdef ABC_INHERIT
     
    983994          if (duprow) {
    984995            possibleSkip;
    985             //int nTightened=tightenDoubletons2(prob);
    986             //if (nTightened)
    987             // PRESOLVE_DETAIL_PRINT(printf("%d doubletons tightened\n",
    988             //              nTightened));
     996            if (doTwoxTwo()) {
     997              int nTightened=tightenDoubletons2(prob);
     998              if (nTightened)
     999                PRESOLVE_DETAIL_PRINT(printf("%d doubletons tightened\n",
     1000                                             nTightened));
     1001            }
    9891002            paction_ = duprow_action::presolve(prob, paction_);
     1003            printProgress('D',0);
    9901004          }
    9911005          if (doGubrow()) {
    9921006            possibleSkip;
    9931007               paction_ = gubrow_action::presolve(prob, paction_);
     1008               printProgress('E',0);
    9941009          }
    9951010
    9961011          if ((presolveActions_ & 16384) != 0)
    9971012               prob->setPresolveOptions(prob->presolveOptions() | 16384);
     1013          // For inaccurate data in implied free
     1014          if ((presolveActions_ & 1024) != 0)
     1015               prob->setPresolveOptions(prob->presolveOptions() | 0x20000);
    9981016          // Check number rows dropped
    9991017          int lastDropped = 0;
     
    10151033               // See if we want statistics
    10161034               if ((presolveActions_ & 0x80000000) != 0)
    1017                     printf("Starting major pass %d after %g seconds\n", iLoop + 1, CoinCpuTime() - prob->startTime_);
     1035                 printf("Starting major pass %d after %g seconds with %d rows, %d columns\n", iLoop + 1, CoinCpuTime() - prob->startTime_,
     1036                        nrows_-prob->countEmptyRows(),
     1037                        ncols_-prob->countEmptyCols());
    10181038#ifdef PRESOLVE_SUMMARY
    10191039               printf("Starting major pass %d\n", iLoop + 1);
     
    10511071                                         notFinished);
    10521072                         }
     1073                         printProgress('F',iLoop+1);
    10531074                         if (prob->status_)
    10541075                              break;
     
    10601081                         if (prob->status_)
    10611082                              break;
     1083                         printProgress('G',iLoop+1);
    10621084                    }
    10631085
     
    10671089                         if (prob->status_)
    10681090                              break;
     1091                         printProgress('H',iLoop+1);
    10691092                    }
    10701093                    if (tripleton) {
     
    10731096                         if (prob->status_)
    10741097                              break;
     1098                         printProgress('I',iLoop+1);
    10751099                    }
    10761100
     
    10801104                         if (prob->status_)
    10811105                              break;
     1106                         printProgress('J',iLoop+1);
    10821107                    }
    10831108#ifndef NO_FORCING
     
    10871112                         if (prob->status_)
    10881113                              break;
     1114                         printProgress('K',iLoop+1);
    10891115                    }
    10901116#endif
     
    10951121                         if (prob->status_)
    10961122                              break;
     1123                         printProgress('L',iLoop+1);
    10971124                    }
    10981125
     
    11991226                         if (prob->status_)
    12001227                              break;
     1228                         printProgress('M',iLoop+1);
    12011229                         const CoinPresolveAction * const paction2 = paction_;
    12021230                         if (ifree) {
     
    12141242                              if (prob->status_)
    12151243                                   break;
     1244                              printProgress('N',iLoop+1);
    12161245                         }
    12171246                         if (paction_ == paction2)
     
    12311260                    if (prob->status_)
    12321261                         break;
     1262                    printProgress('O',iLoop+1);
    12331263               }
    12341264#if     PRESOLVE_DEBUG
     
    12431273                    if (prob->status_)
    12441274                         break;
     1275                    printProgress('P',iLoop+1);
    12451276               }
    12461277#if     PRESOLVE_DEBUG
     
    12531284                    if (prob->status_)
    12541285                         break;
     1286                    printProgress('Q',iLoop+1);
    12551287               }
    12561288               // Marginally slower on netlib if this call is enabled.
     
    12901322                         stopLoop = true;
    12911323                    }
     1324                    printProgress('R',iLoop+1);
    12921325               }
    12931326#if     PRESOLVE_DEBUG
  • stable/1.15/Clp/src/ClpPresolve.hpp

    r1878 r1928  
    170170     /// Whether we want to do twoxtwo part of presolve
    171171     inline bool doTwoxTwo() const {
    172           return (presolveActions_ & 2048) == 0;
     172          return (presolveActions_ & 2048) != 0;
    173173     }
    174174     inline void setDoTwoxtwo(bool doTwoxTwo) {
    175           if (doTwoxTwo) presolveActions_  &= ~2048;
     175          if (!doTwoxTwo) presolveActions_  &= ~2048;
    176176          else presolveActions_ |= 2048;
    177177     }
  • stable/1.15/Clp/src/ClpSimplex.cpp

    r1878 r1928  
    598598                    && (badInfeasibility > CoinMax(incomingInfeasibility_, allowedInfeasibility_) ||
    599599                        useError > 1.0e-3)) {
     600               if (algorithm_>1) {
     601                 // nonlinear
     602                 //printf("Original largest infeas %g, now %g, primalError %g\n",
     603                 //     oldValue,nonLinearCost_->largestInfeasibility(),
     604                 //     largestPrimalError_);
     605                 //printf("going to all slack\n");
     606                 allSlackBasis(true);
     607                 CoinIotaN(pivotVariable_, numberRows_, numberColumns_);
     608                 return 1;
     609               }
    600610               //printf("Original largest infeas %g, now %g, primalError %g\n",
    601611               //     oldValue,nonLinearCost_->largestInfeasibility(),
     
    17391749     //}
    17401750     //}
    1741 #    ifndef _MSC_VER
     1751#    if 0 //ndef _MSC_VER
    17421752         // The local static var k is a problem when trying to build a DLL. Since this is
    17431753         // just for debugging (likely done on *nix), just hide it from Windows
     
    44244434               }
    44254435          }
    4426           if (problemStatus_ == 2) {
     4436          if (problemStatus_ == 2 && ray_) {
    44274437               for (i = 0; i < numberColumns; i++) {
    44284438                    ray_[i] *= columnScale_[i];
     
    53995409               && sumDualInfeasibilities_ < 1000.0 * dualTolerance_ && perturbation_ >= 100)
    54005410          problemStatus_ = 0; // ignore
     5411     if (problemStatus_==1&&((specialOptions_&(1024 | 4096)) == 0 || (specialOptions_ & 32) != 0)
     5412         &&numberFake_) {
     5413       problemStatus_ = 10; // clean up in primal as fake bounds
     5414     }
    54015415     if (problemStatus_ == 10) {
    54025416          //printf("Cleaning up with primal\n");
     
    80328046     // for now assume primal is feasible (or in dual)
    80338047     dualOut_ = dj_[sequenceOut_];
    8034      assert(fabs(dualOut_) < 1.0e-6);
     8048     assert(fabs(dualOut_) < 1.0e-5);
    80358049     bool roundAgain = true;
    80368050     int returnCode = 0;
     
    80898103          // see where something went to
    80908104#ifndef NDEBUG
    8091           CoinRelFltEq eq(1.0e-9);
     8105          CoinRelFltEq eq(1.0e-7);
    80928106#endif
    80938107          if (sequenceOut_ < 0) {
     
    87008714     otherModel.directionOut_ = directionOut_;
    87018715     otherModel.pivotRow_ = pivotRow_;
     8716     otherModel.algorithm_ = algorithm_;
    87028717     otherModel.sumDualInfeasibilities_ = sumDualInfeasibilities_;
    87038718     otherModel.numberDualInfeasibilities_ = numberDualInfeasibilities_;
     
    98589873                      sumDualInfeasibilities_ += fabs(dualValue) - dualTolerance_;
    98599874                         numberDualInfeasibilities_ ++;
     9875                         if (fabs(dualValue) > 1000.0 * dualTolerance)
     9876                           setColumnStatus(iColumn,superBasic);
    98609877                    }
    98619878                    break;
     
    1005010067     objectiveValue -= dblParam_[ClpObjOffset];
    1005110068     return objectiveValue;
     10069}
     10070// Infeasibility/unbounded ray (NULL returned if none/wrong)
     10071double *
     10072ClpSimplex::infeasibilityRay(bool fullRay) const
     10073{
     10074     double * array = NULL;
     10075     if (problemStatus_ == 1 && ray_) {
     10076       if (!fullRay) {
     10077         array = ClpCopyOfArray(ray_, numberRows_);
     10078       } else {
     10079         array = new double [numberRows_+numberColumns_];
     10080         memcpy(array,ray_,numberRows_*sizeof(double));
     10081         memset(array+numberRows_,0,numberColumns_*sizeof(double));
     10082         transposeTimes(-1.0,array,array+numberRows_);
     10083       }
     10084#ifdef PRINT_RAY_METHOD
     10085       printf("Infeasibility ray obtained by algorithm %s - direction out %d\n",algorithm_>0 ?
     10086              "primal" : "dual",directionOut_);
     10087#endif
     10088     }
     10089     return array;
    1005210090}
    1005310091// If user left factorization frequency then compute
     
    1151011548     //abort();
    1151111549#endif
     11550     // make sure clean
     11551     whatsChanged_=0;
    1151211552     dual(0, 7);
    1151311553#if 0
     
    1188711927{
    1188811928     ClpModel::resize(newNumberRows, newNumberColumns);
     11929     delete [] perturbationArray_;
     11930     perturbationArray_ = NULL;
     11931     maximumPerturbationSize_=0;
    1188911932     if (saveStatus_) {
    1189011933          // delete arrays
     
    1195211995     fprintf(fp, "%d  clpModel->setPerturbation(save_perturbation);\n", iValue1 == iValue2 ? 7 : 6);
    1195311996}
     11997// Copy across enabled stuff from one solver to another
     11998void
     11999ClpSimplex::copyEnabledStuff(const ClpSimplex * rhs)
     12000{
     12001  solveType_=rhs->solveType_;
     12002  if (rhs->solution_) {
     12003    int numberTotal = numberRows_+numberColumns_;
     12004    assert (!solution_);
     12005    solution_ = CoinCopyOfArray(rhs->solution_,numberTotal);
     12006    lower_ = CoinCopyOfArray(rhs->lower_,numberTotal);
     12007    upper_ = CoinCopyOfArray(rhs->upper_,numberTotal);
     12008    dj_ = CoinCopyOfArray(rhs->dj_,numberTotal);
     12009    cost_ = CoinCopyOfArray(rhs->cost_,2*numberTotal);
     12010    reducedCostWork_ = dj_;
     12011    rowReducedCost_ = dj_ + numberColumns_;
     12012    columnActivityWork_ = solution_;
     12013    rowActivityWork_ = solution_ + numberColumns_;
     12014    objectiveWork_ = cost_;
     12015    rowObjectiveWork_ = cost_ + numberColumns_;
     12016    rowLowerWork_ = lower_ + numberColumns_;
     12017    columnLowerWork_ = lower_;
     12018    rowUpperWork_ = upper_ + numberColumns_;
     12019    columnUpperWork_ = upper_;
     12020  }
     12021  if (rhs->factorization_) {
     12022    delete factorization_;
     12023    factorization_ = new ClpFactorization(*rhs->factorization_);
     12024    delete [] pivotVariable_;
     12025    pivotVariable_ = CoinCopyOfArray(rhs->pivotVariable_,numberRows_);
     12026  }
     12027  for (int i = 0; i < 6; i++) {
     12028    if (rhs->rowArray_[i])
     12029      rowArray_[i] = new CoinIndexedVector(*rhs->rowArray_[i]);
     12030    if (rhs->columnArray_[i])
     12031      columnArray_[i] = new CoinIndexedVector(*rhs->columnArray_[i]);
     12032  }
     12033  if (rhs->nonLinearCost_)
     12034    nonLinearCost_=new ClpNonLinearCost(*rhs->nonLinearCost_);
     12035  if (rhs->dualRowPivot_)
     12036    dualRowPivot_ = rhs->dualRowPivot_->clone();
     12037  if (rhs->primalColumnPivot_)
     12038    primalColumnPivot_ = rhs->primalColumnPivot_->clone();
     12039}
  • stable/1.15/Clp/src/ClpSimplex.hpp

    r1922 r1928  
    565565     /// If user left factorization frequency then compute
    566566     void defaultFactorizationFrequency();
     567     /// Copy across enabled stuff from one solver to another
     568     void copyEnabledStuff(const ClpSimplex * rhs);
    567569     //@}
    568570
     
    13001302     /// Compute minimization objective value from internal solution without perturbation
    13011303     double computeInternalObjectiveValue();
     1304     /** Infeasibility/unbounded ray (NULL returned if none/wrong)
     1305         Up to user to use delete [] on these arrays.  */
     1306     double * infeasibilityRay(bool fullRay=false) const;
    13021307     /** Number of extra rows.  These are ones which will be dynamically created
    13031308         each iteration.  This is for GUB but may have other uses.
  • stable/1.15/Clp/src/ClpSimplexDual.cpp

    r1922 r1928  
    15941594                    solution_[sequenceOut_] = valueOut_;
    15951595                    int whatNext = housekeeping(objectiveChange);
     1596#if 0
     1597                    for (int i=0;i<numberRows_+numberColumns_;i++) {
     1598                      if (getStatus(i)==atLowerBound) {
     1599                        assert (dj_[i]>-1.0e-5);
     1600                        assert (solution_[i]<=lower_[i]+1.0e-5);
     1601                      } else if (getStatus(i)==atUpperBound) {
     1602                        assert (dj_[i]<1.0e-5);
     1603                        assert (solution_[i]>=upper_[i]-1.0e-5);
     1604                      }
     1605                    }
     1606#endif
    15961607#ifdef CLP_REPORT_PROGRESS
    15971608                    if (ixxxxxx > ixxyyyy - 5) {
     
    17421753#endif
    17431754                    // no incoming column is valid
     1755                    spareIntArray_[3]=pivotRow_;
    17441756                    pivotRow_ = -1;
    17451757#ifdef CLP_DEBUG
     
    17531765                         if ((specialOptions_&(1024 | 4096)) == 0 || (specialOptions_ & 32) != 0) {
    17541766                              // create ray anyway
     1767#ifdef PRINT_RAY_METHOD
     1768                           printf("Dual creating infeasibility ray direction out %d - pivRow %d seqOut %d lower %g,val %g,upper %g\n",
     1769                                  directionOut_,spareIntArray_[3],sequenceOut_,lowerOut_,valueOut_,upperOut_);
     1770#endif
    17551771                              ray_ = new double [ numberRows_];
    17561772                              rowArray_[0]->expand(); // in case packed
    1757                               CoinMemcpyN(rowArray_[0]->denseVector(), numberRows_, ray_);
     1773                              const double * array = rowArray_[0]->denseVector();
     1774                              for (int i=0;i<numberRows_;i++)
     1775                                ray_[i] = array[i];
    17581776                         } else {
    17591777                              ray_ = NULL;
     
    74537471               if (fakeStatus != ClpSimplexDual::noFake) {
    74547472                    Status status = getStatus(iSequence);
    7455                     if (status == basic) {
     7473                    if (status == basic || status == isFixed) {
    74567474                         setFakeBound(iSequence, ClpSimplexDual::noFake);
    74577475                         continue;
     
    74687486                              solution_[iSequence] = upper_[iSequence];
    74697487                         } else {
     7488                              printf("Unknown status %d for variable %d in %s line %d\n",
     7489                                  status,iSequence,__FILE__,__LINE__);
    74707490                              abort();
    74717491                         }
     
    74777497                              solution_[iSequence] = upperValue;
    74787498                         } else {
     7499                              printf("Unknown status %d for variable %d in %s line %d\n",
     7500                                  status,iSequence,__FILE__,__LINE__);
    74797501                              abort();
    74807502                         }
     
    74927514                              upper_[iSequence] = value + 0.5 * dualBound_;
    74937515                         } else {
     7516                              printf("Unknown status %d for variable %d in %s line %d\n",
     7517                                  status,iSequence,__FILE__,__LINE__);
    74947518                              abort();
    74957519                         }
  • stable/1.15/Clp/src/ClpSimplexNonlinear.cpp

    r1665 r1928  
    169169          infeasibilityCost_ = 0.0;
    170170          createRim(1 + 4);
     171          delete nonLinearCost_;
     172          nonLinearCost_ = new ClpNonLinearCost(this);
    171173          nonLinearCost_->checkInfeasibilities(0.0);
    172174          sumPrimalInfeasibilities_ = nonLinearCost_->sumInfeasibilities();
     
    19131915                    printf("current obj %g thetaObj %g, predictedObj %g\n", currentObj, thetaObj, predictedObj);
    19141916#endif
     1917               objTheta2=CoinMin(objTheta2,1.0e29);
    19151918#if MINTYPE==1
    19161919               if (conjugate) {
  • stable/1.15/Clp/src/ClpSimplexPrimal.cpp

    r1878 r1928  
    557557     if (valuesOption > 1)
    558558          superBasicType = 3;
     559     // delete any rays
     560     delete [] ray_;
     561     ray_ = NULL;
    559562     // status stays at -1 while iterating, >=0 finished, -2 to invert
    560563     // status -3 to go to top without an invert
     
    12951298                              delete [] ray_;
    12961299                              ray_ = new double [numberRows_];
    1297                               CoinMemcpyN(dual_, numberRows_, ray_);
     1300                              // swap sign
     1301                              for (int i=0;i<numberRows_;i++)
     1302                                ray_[i] = -dual_[i];
     1303#ifdef PRINT_RAY_METHOD
     1304                              printf("Primal creating infeasibility ray\n");
     1305#endif
    12981306                              // and get feasible duals
    12991307                              infeasibilityCost_ = 0.0;
     
    31343142                    }
    31353143 #endif
    3136                     if (!factorization_->pivots() && acceptablePivot_ <= 1.0e-8) {
     3144                    if (!factorization_->pivots() && acceptablePivot_ <= 1.0e-8 ) {
    31373145                         returnCode = 2; //say looks unbounded
    31383146                         // do ray
    3139                          primalRay(rowArray_[1]);
     3147                         if (!nonLinearCost_->sumInfeasibilities())
     3148                           primalRay(rowArray_[1]);
    31403149                    } else if (solveType_ == 2 && (moreSpecialOptions_ & 512) == 0) {
    31413150                         // refactorize
  • stable/1.15/Clp/src/ClpSolve.cpp

    r1881 r1928  
    31033103          if (finalStatus != 3 && rcode < 0 && (finalStatus || oldStatus == -1)) {
    31043104               int savePerturbation = perturbation();
    3105                if (!finalStatus || (moreSpecialOptions_ & 2) == 0) {
     3105               if (!finalStatus || (moreSpecialOptions_ & 2) == 0 ||
     3106                   fabs(sumDualInfeasibilities_)+
     3107                   fabs(sumPrimalInfeasibilities_)<1.0e-3) {
    31063108                    if (finalStatus == 2) {
    31073109                         // unbounded - get feasible first
  • stable/1.15/Clp/src/ClpSolve.hpp

    r1910 r1928  
    199199          if (doSingleton_) independentOptions_[1]  &= ~512;
    200200          else independentOptions_[1] |= 512;
     201     }
     202     /// Whether we want to kill small substitutions
     203     inline bool doKillSmall() const {
     204          return (independentOptions_[1] & 1024) == 0;
     205     }
     206     inline void setDoKillSmall(bool doKill) {
     207          if (doKill) independentOptions_[1]  &= ~1024;
     208          else independentOptions_[1] |= 1024;
    201209     }
    202210     /// Set whole group
  • stable/1.15/Clp/src/Clp_C_Interface.cpp

    r1902 r1928  
    649649          array = static_cast<double*>(malloc(numberRows*sizeof(double)));
    650650          memcpy(array,ray,numberRows*sizeof(double));
    651 #ifndef CLP_NO_SWAP_SIGN
    652           // swap signs to be consistent with norm
    653           for (int i = 0; i < numberRows; i++)
    654                array[i] = -array[i];
     651#ifdef PRINT_RAY_METHOD
     652          printf("Infeasibility ray obtained by algorithm %s\n",model->model_->algorithm()>0 ?
     653              "primal" : "dual");
    655654#endif
    656655     }
  • stable/1.15/Clp/src/OsiClp

  • stable/1.15/Clp/src/OsiClp/OsiClpSolverInterface.cpp

    r1887 r1928  
    133133  int saveMessageLevel2 = messageLevel;
    134134  // Set message handler
    135   solver->passInMessageHandler(handler_);
     135  if (!defaultHandler_)
     136    solver->passInMessageHandler(handler_);
    136137  // But keep log level
    137138  solver->messageHandler()->setLogLevel(saveMessageLevel);
     
    778779  }
    779780  modelPtr_->whatsChanged_ |= 0x30000;
     781#if 0
     782  // delete scaled matrix and rowcopy for safety
     783  delete modelPtr_->scaledMatrix_;
     784  modelPtr_->scaledMatrix_=NULL;
     785  delete modelPtr_->rowCopy_;
     786  modelPtr_->rowCopy_=NULL;
     787#endif
    780788  //std::cout<<time1<<" seconds - total "<<totalTime<<std::endl;
    781789  delete pinfo;
     
    919927  int messageLevel=messageHandler()->logLevel();
    920928  bool oldDefault;
    921   CoinMessageHandler * saveHandler = modelPtr_->pushMessageHandler(handler_,oldDefault);
     929  CoinMessageHandler * saveHandler = NULL;
     930  if (!defaultHandler_)
     931    saveHandler = modelPtr_->pushMessageHandler(handler_,oldDefault);
    922932  //printf("basis before dual\n");
    923933  //basis_.print();
     
    12571267  //printf("basis after dual\n");
    12581268  //basis_.print();
    1259   modelPtr_->popMessageHandler(saveHandler,oldDefault);
     1269  if (!defaultHandler_)
     1270    modelPtr_->popMessageHandler(saveHandler,oldDefault);
    12601271  modelPtr_->messageHandler()->setLogLevel(saveMessageLevel);
    12611272  if (saveSolveType==2) {
     
    20392050      //small->setLogLevel(0);
    20402051      // Could be infeasible if forced one way (and other way stopped on iterations)
    2041       if (small->status()==1) {
     2052      // could also be stopped on iterations
     2053      if (small->status()) {
    20422054#ifndef KEEP_SMALL
    20432055        if (small!=modelPtr_)
     
    23542366    double saveObjectiveValue = arrayD[0];
    23552367    double * saveSolution = arrayD+1;
     2368    // double check arrays exist (? for nonlinear)
     2369    //if (!smallModel_->solutionRegion())
     2370    //smallModel_->createRim(63);
    23562371    int numberRows2 = smallModel_->numberRows();
    23572372    int numberColumns2 = smallModel_->numberColumns();
     
    29002915                                                        bool fullRay) const
    29012916{
    2902   if (fullRay == true) {
    2903     throw CoinError("Full dual rays not yet implemented.","getDualRays",
    2904                     "OsiClpSolverInterface");
    2905   }
    2906   return std::vector<double*>(1, modelPtr_->infeasibilityRay());
     2917  return std::vector<double*>(1, modelPtr_->infeasibilityRay(fullRay));
    29072918}
    29082919//------------------------------------------------------------------
     
    34783489  modelPtr_->scaledMatrix_=NULL;
    34793490  if (saveRowCopy) {
    3480 #if 1
    34813491    matrixByRow_=saveRowCopy;
    34823492    matrixByRow_->deleteRows(num,rowIndices);
    3483     assert (matrixByRow_->getNumElements()==modelPtr_->clpMatrix()->getNumElements());
    3484 #else
    3485     delete saveRowCopy;
    3486 #endif
     3493    if (matrixByRow_->getNumElements()!=modelPtr_->clpMatrix()->getNumElements()) {
     3494      delete matrixByRow_; // odd type matrix
     3495      matrixByRow_=NULL;
     3496    }
    34873497  }
    34883498  lastAlgorithm_ = saveAlgorithm;
     
    42784288  }
    42794289  starts[numberCuts]=size;
    4280   if (!modelPtr_->clpMatrix())
     4290 if (!modelPtr_->clpMatrix())
    42814291    modelPtr_->createEmptyMatrix();
    42824292  //modelPtr_->matrix()->appendRows(numberCuts,rows);
    42834293  modelPtr_->clpMatrix()->appendMatrix(numberCuts,0,starts,indices,elements);
    42844294  modelPtr_->setNewRowCopy(NULL);
     4295  modelPtr_->setClpScaledMatrix(NULL);
    42854296  freeCachedResults1();
    42864297  redoScaleFactors( numberCuts,starts, indices, elements);
     
    42894300    matrixByRow_=saveRowCopy;
    42904301    matrixByRow_->appendRows(numberCuts,starts,indices,elements,0);
    4291     assert (matrixByRow_->getNumElements()==modelPtr_->clpMatrix()->getNumElements());
     4302    if (matrixByRow_->getNumElements()!=modelPtr_->clpMatrix()->getNumElements()) {
     4303      delete matrixByRow_; // odd type matrix
     4304      matrixByRow_=NULL;
     4305    }
    42924306#else
    42934307    delete saveRowCopy;
     
    53345348OsiClpSolverInterface::getRowName(int rowIndex, unsigned int /*maxLen*/) const
    53355349{
    5336         if (rowIndex == getNumRows())
    5337                 return getObjName();
    5338   return modelPtr_->getRowName(rowIndex);
     5350  if (rowIndex == getNumRows())
     5351    return getObjName();
     5352  int useNames;
     5353  getIntParam (OsiNameDiscipline,useNames);
     5354  if (useNames)
     5355    return modelPtr_->getRowName(rowIndex);
     5356  else
     5357    return dfltRowColName('r',rowIndex);
    53395358}
    53405359   
     
    53575376OsiClpSolverInterface::getColName(int colIndex, unsigned int /*maxLen*/) const
    53585377{
    5359   return modelPtr_->getColumnName(colIndex);
     5378  int useNames;
     5379  getIntParam (OsiNameDiscipline,useNames);
     5380  if (useNames)
     5381    return modelPtr_->getColumnName(colIndex);
     5382  else
     5383    return dfltRowColName('c',colIndex);
    53605384}
    53615385   
     
    55015525  delete modelPtr_->scaledMatrix_;
    55025526  modelPtr_->scaledMatrix_=NULL;
     5527  // make sure using standard factorization
     5528  modelPtr_->factorization()->forceOtherFactorization(4);
    55035529#ifdef NDEBUG
    55045530  modelPtr_->startup(0);
     
    67066732          delete [] modelPtr_->ray_;
    67076733          modelPtr_->ray_=NULL;
     6734          if (problemStatus==1&&small->ray_) {
     6735            // get ray to full problem
     6736            int numberRows = modelPtr_->numberRows();
     6737            int numberRows2 = small->numberRows();
     6738            double * ray = new double [numberRows];
     6739            memset(ray,0,numberRows*sizeof(double));
     6740            for (int i = 0; i < numberRows2; i++) {
     6741              int iRow = whichRow[i];
     6742              ray[iRow] = small->ray_[i];
     6743            }
     6744            // Column copy of matrix
     6745            const double * element = getMatrixByCol()->getElements();
     6746            const int * row = getMatrixByCol()->getIndices();
     6747            const CoinBigIndex * columnStart = getMatrixByCol()->getVectorStarts();
     6748            const int * columnLength = getMatrixByCol()->getVectorLengths();
     6749            // translate
     6750            //pivotRow=whichRow[pivotRow];
     6751            //modelPtr_->spareIntArray_[3]=pivotRow;
     6752            int pivotRow=-1;
     6753            for (int jRow = nBound; jRow < 2 * numberRows; jRow++) {
     6754              int iRow = whichRow[jRow];
     6755              int iColumn = whichRow[jRow+numberRows];
     6756              if (modelPtr_->getColumnStatus(iColumn) == ClpSimplex::basic) {
     6757                double value = 0.0;
     6758                double sum = 0.0;
     6759                for (CoinBigIndex j = columnStart[iColumn];
     6760                     j < columnStart[iColumn] + columnLength[iColumn]; j++) {
     6761                  if (iRow == row[j]) {
     6762                    value = element[j];
     6763                  } else {
     6764                    sum += ray[row[j]]*element[j];
     6765                  }
     6766                }
     6767                if (iRow!=pivotRow) {
     6768                  ray[iRow] = -sum / value;
     6769                } else {
     6770                  printf("what now - direction %d wanted %g sum %g value %g\n",
     6771                         small->directionOut_,ray[iRow],
     6772                         sum,value);
     6773                }
     6774              }
     6775            }
     6776            for (int i=0;i<modelPtr_->numberColumns_;i++) {
     6777              if (modelPtr_->getStatus(i)!=ClpSimplex::basic&&
     6778                  modelPtr_->columnLower_[i]==modelPtr_->columnUpper_[i])
     6779                modelPtr_->setStatus(i,ClpSimplex::isFixed);
     6780            }
     6781            modelPtr_->ray_=ray;
     6782            modelPtr_->directionOut_=small->directionOut_;
     6783          }
    67086784        }
    67096785      }
  • stable/1.15/Clp/src/OsiClp/OsiClpSolverInterface.hpp

    r1828 r1928  
    177177  */
    178178  virtual void enableSimplexInterface(bool doingPrimal);
     179  /// Copy across enabled stuff from one solver to another
     180  void copyEnabledSuff(OsiClpSolverInterface & rhs);
    179181 
    180182  /*! \brief Undo setting changes made by #enableSimplexInterface */
    181183  virtual void disableSimplexInterface();
     184  /// Copy across enabled stuff from one solver to another
     185  void copyEnabledStuff(ClpSimplex & rhs);
    182186
    183187  /** Perform a pivot by substituting a colIn for colOut in the basis.
Note: See TracChangeset for help on using the changeset viewer.