Changeset 1924 for trunk


Ignore:
Timestamp:
Mar 19, 2013 9:01:05 AM (7 years ago)
Author:
forrest
Message:

changes for miqp, parameters and presolve

Location:
trunk/Clp/src
Files:
15 edited

Legend:

Unmodified
Added
Removed
  • trunk/Clp/src/CbcOrClpParam.cpp

    r1910 r1924  
    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     );
    21542191     parameters[numberParameters++] =
    21552192          CbcOrClpParam("gomory!Cuts", "Whether to use Gomory cuts",
     
    21842221See Rounding for meaning of on,both,before"
    21852222     );
     2223#endif
     2224     parameters[numberParameters++] =
     2225          CbcOrClpParam("gsolu!tion", "Puts glpk solution to file",
     2226                        CLP_PARAM_ACTION_GMPL_SOLUTION);
     2227     parameters[numberParameters-1].setLonghelp
     2228     (
     2229          "Will write a glpk solution file to the given file name.  It will use the default\
     2230 directory given by 'directory'.  A name of '$' will use the previous value for the name.  This\
     2231 is initialized to 'stdout' (this defaults to ordinary solution if stdout). \
     2232If problem created from gmpl model - will do any reports."
     2233     );
     2234#ifdef COIN_HAS_CBC
    21862235     parameters[numberParameters++] =
    21872236          CbcOrClpParam("heur!isticsOnOff", "Switches most heuristics on or off",
     
    23372386The length options for gomory cuts are used."
    23382387     );
     2388#ifdef CBC_AFTER_2_9
     2389      parameters[numberParameters++] =
     2390          CbcOrClpParam("latwomir!Cuts", "Whether to use Lagrangean TwoMir cuts",
     2391                        "off", CBC_PARAM_STR_LATWOMIRCUTS);
     2392     parameters[numberParameters-1].append("endonlyroot");
     2393     parameters[numberParameters-1].append("endcleanroot");
     2394     parameters[numberParameters-1].append("endbothroot");
     2395     parameters[numberParameters-1].append("endonly");
     2396     parameters[numberParameters-1].append("endclean");
     2397     parameters[numberParameters-1].append("endboth");
     2398     parameters[numberParameters-1].append("onlyaswell");
     2399     parameters[numberParameters-1].append("cleanaswell");
     2400     parameters[numberParameters-1].append("bothaswell");
     2401     parameters[numberParameters-1].append("onlyinstead");
     2402     parameters[numberParameters-1].append("cleaninstead");
     2403     parameters[numberParameters-1].append("bothinstead");
     2404     parameters[numberParameters-1].setLonghelp
     2405     (
     2406          "This is a lagrangean relaxation for TwoMir cuts.  See \
     2407lagomoryCuts for description of options."
     2408     );
     2409#endif
    23392410     parameters[numberParameters++] =
    23402411          CbcOrClpParam("lift!AndProjectCuts", "Whether to use Lift and Project cuts",
     
    23462417     parameters[numberParameters-1].setLonghelp
    23472418     (
    2348           "Lift and project cuts - may be expensive to compute. \
     2419          "Lift and project cuts. \
     2420May be slow \
    23492421See branchAndCut for information on options."
    23502422     );
     
    23642436     parameters[numberParameters++] =
    23652437          CbcOrClpParam("log!Level", "Level of detail in Solver output",
    2366                         -1, 63, CLP_PARAM_INT_SOLVERLOGLEVEL);
     2438                        -1, 999999, CLP_PARAM_INT_SOLVERLOGLEVEL);
    23672439#else
    23682440     parameters[numberParameters++] =
     
    25442616          "Do (in parallel if threads enabled) the root phase this number of times \
    25452617 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 \
     2618where aa is number of extra passes, if bb is non zero \
    25472619then it is number of threads to use (otherwise uses threads setting) and \
    25482620cc is number of times to do root phase.  Yet another one from the Italian idea factory \
    25492621(This time - Andrea Lodi , Matteo Fischetti , Michele Monaci , Domenico Salvagnin , \
    2550 and Andrea Tramontani)"
     2622+and Andrea Tramontani). \
     2623+The solvers do not interact with each other.  However if extra passes are specified \
     2624+then cuts are collected and used in later passes - so there is interaction there."
    25512625     );
    25522626     parameters[numberParameters++] =
     
    31043178     parameters[numberParameters-1].setLonghelp
    31053179     (
     3180          "This switches on reduce and split  cuts (either at root or in entire tree). \
     3181May be slow \
     3182See branchAndCut for information on options."
     3183     );
     3184      parameters[numberParameters++] =
     3185          CbcOrClpParam("reduce2!AndSplitCuts", "Whether to use Reduce-and-Split cuts - style 2",
     3186                        "off", CBC_PARAM_STR_REDSPLIT2CUTS);
     3187     parameters[numberParameters-1].append("on");
     3188     parameters[numberParameters-1].append("root");
     3189     parameters[numberParameters-1].append("longOn");
     3190     parameters[numberParameters-1].append("longRoot");
     3191     parameters[numberParameters-1].setLonghelp
     3192     (
    31063193          "This switches on reduce and split  cuts (either at root or in entire tree) \
     3194This version is by Giacomo Nannicini based on Francois Margot's version \
     3195Standard setting only uses rows in tableau <=256, long uses all \
     3196May be slow \
    31073197See branchAndCut for information on options."
    31083198     );
     
    32543344          "If passed to solver fom ampl, then ampl will wait so that you can copy .nl file for debug."
    32553345     );
     3346#ifdef COIN_HAS_CBC
     3347#ifdef CBC_AFTER_2_9
     3348     parameters[numberParameters++] =
     3349          CbcOrClpParam("slow!cutpasses", "Maximum number of tries for slower cuts",
     3350                        -1, COIN_INT_MAX, CBC_PARAM_INT_MAX_SLOW_CUTS);
     3351     parameters[numberParameters-1].setLonghelp
     3352     (
     3353          "Some cut generators are fairly slow - this limits the number of times they are tried."
     3354     );
     3355     parameters[numberParameters-1].setIntValue(10);
     3356#endif
     3357#endif
    32563358#ifdef COIN_HAS_CLP
    32573359     parameters[numberParameters++] =
  • trunk/Clp/src/CbcOrClpParam.hpp

    r1906 r1924  
    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,
  • trunk/Clp/src/ClpMain.cpp

    r1910 r1924  
    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                                             double * ray = simplex->ray();
     933                                            // get farkas row
     934                                            memset(farkas,0,(2*numberColumns+numberRows)*sizeof(double));
     935                                            simplex->transposeTimes(-1.0,ray,farkas);
     936                                            // Put nonzero bounds in bound
     937                                            const double * columnLower = simplex->columnLower();
     938                                            const double * columnUpper = simplex->columnUpper();
     939                                            int numberBad=0;
     940                                            for (int i=0;i<numberColumns;i++) {
     941                                              double value = farkas[i];
     942                                              double boundValue=0.0;
     943                                              if (simplex->getStatus(i)==ClpSimplex::basic) {
     944                                                // treat as zero if small
     945                                                if (fabs(value)<1.0e-8) {
     946                                                  value=0.0;
     947                                                  farkas[i]=0.0;
     948                                                }
     949                                                if (value) {
     950                                                  //printf("basic %d direction %d farkas %g\n",
     951                                                  //       i,simplex->directionOut(),value);
     952                                                  if (value<0.0)
     953                                                    boundValue=columnLower[i];
     954                                                  else
     955                                                    boundValue=columnUpper[i];
     956                                                }
     957                                              } else if (fabs(value)>1.0e-10) {
     958                                                if (value<0.0)
     959                                                  boundValue=columnLower[i];
     960                                                else
     961                                                  boundValue=columnUpper[i];
     962                                              }
     963                                              bound[i]=boundValue;
     964                                              if (fabs(boundValue)>1.0e10)
     965                                                numberBad++;
     966                                            }
     967                                            const double * rowLower = simplex->rowLower();
     968                                            const double * rowUpper = simplex->rowUpper();
     969                                            //int pivotRow = simplex->spareIntArray_[3];
     970                                            //bool badPivot=pivotRow<0;
     971                                            for (int i=0;i<numberRows;i++) {
     972                                              double value = ray[i];
     973                                              double rhsValue=0.0;
     974                                              if (simplex->getRowStatus(i)==ClpSimplex::basic) {
     975                                                // treat as zero if small
     976                                                if (fabs(value)<1.0e-8) {
     977                                                  value=0.0;
     978                                                  ray[i]=0.0;
     979                                                }
     980                                                if (value) {
     981                                                  //printf("row basic %d direction %d ray %g\n",
     982                                                  //       i,simplex->directionOut(),value);
     983                                                  if (value<0.0)
     984                                                    rhsValue=rowLower[i];
     985                                                  else
     986                                                    rhsValue=rowUpper[i];
     987                                                }
     988                                              } else if (fabs(value)>1.0e-10) {
     989                                                if (value<0.0)
     990                                                  rhsValue=rowLower[i];
     991                                                else
     992                                                  rhsValue=rowUpper[i];
     993                                              }
     994                                              effectiveRhs[i]=rhsValue;
     995                                            }
     996                                            simplex->times(-1.0,bound,effectiveRhs);
     997                                            simplex->swapRowScale(saveScale);
     998                                            simplex->swapScaledMatrix(saveMatrix);
     999                                            double bSum=0.0;
     1000                                            for (int i=0;i<numberRows;i++) {
     1001                                              bSum += effectiveRhs[i]*ray[i];
     1002                                            }
     1003                                            if (numberBad||bSum>-1.0e-4) {
     1004                                              printf("Bad infeasibility ray %g  - %d bad\n",
     1005                                                     bSum,numberBad);
     1006                                            } else {
     1007                                              //printf("Good ray - infeasibility %g\n",
     1008                                              //     -bSum);
     1009                                            }
     1010                                            delete [] farkas;
     1011                                          } else {
     1012                                            //printf("No dual ray\n");
     1013                                          }
     1014                                        }
     1015#endif
    9171016                                   } catch (CoinError e) {
    9181017                                        e.print();
     
    26872786                    if (columnUpper[iColumn] > columnLower[iColumn]) {
    26882787                         numberIntegers++;
    2689                          if (columnUpper[iColumn] == 0.0 && columnLower[iColumn] == 1)
     2788                         if (columnLower[iColumn] == 0.0 && columnUpper[iColumn] == 1)
    26902789                              numberBinary++;
    26912790                    }
    26922791               }
    26932792          }
     2793          printf("Original problem has %d integers (%d of which binary)\n",
     2794                 numberIntegers,numberBinary);
    26942795     }
    26952796     numberColumns = model->numberColumns();
     
    27002801     const double * rowUpper = model->rowUpper();
    27012802     const double * objective = model->objective();
     2803     if (model->integerInformation()) {
     2804       const char * integerInformation  = model->integerInformation();
     2805       int numberIntegers = 0;
     2806       int numberBinary = 0;
     2807       double * obj = new double [numberColumns];
     2808       int * which = new int [numberColumns];
     2809       for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     2810         if (columnUpper[iColumn] > columnLower[iColumn]) {
     2811           if (integerInformation[iColumn]) {
     2812             numberIntegers++;
     2813             if (columnLower[iColumn] == 0.0 && columnUpper[iColumn] == 1)
     2814               numberBinary++;
     2815           }
     2816         }
     2817       }
     2818       if(numberColumns != originalModel->numberColumns())
     2819         printf("Presolved problem has %d integers (%d of which binary)\n",
     2820                numberIntegers,numberBinary);
     2821       for (int ifInt=0;ifInt<2;ifInt++) {
     2822         for (int ifAbs=0;ifAbs<2;ifAbs++) {
     2823           int numberSort=0;
     2824           int numberZero=0;
     2825           int numberDifferentObj=0;
     2826           for (int iColumn = 0; iColumn < numberColumns; iColumn++) {
     2827             if (columnUpper[iColumn] > columnLower[iColumn]) {
     2828               if (!ifInt||integerInformation[iColumn]) {
     2829                 obj[numberSort]=(ifAbs) ? fabs(objective[iColumn]) :
     2830                   objective[iColumn];
     2831                 which[numberSort++]=iColumn;
     2832                 if (!objective[iColumn])
     2833                   numberZero++;
     2834               }
     2835             }
     2836           }
     2837           CoinSort_2(obj,obj+numberSort,which);
     2838           double last=obj[0];
     2839           for (int jColumn = 1; jColumn < numberSort; jColumn++) {
     2840             if (fabs(obj[jColumn]-last)>1.0e-12) {
     2841               numberDifferentObj++;
     2842               last=obj[jColumn];
     2843             }
     2844           }
     2845           numberDifferentObj++;
     2846           printf("==== ");
     2847           if (ifInt)
     2848             printf("for integers ");
     2849           if (!ifAbs)
     2850             printf("%d zero objective ",numberZero);
     2851           else
     2852             printf("absolute objective values ");
     2853           printf("%d different\n",numberDifferentObj);
     2854           bool saveModel=false;
     2855           int target=model->logLevel();
     2856           if (target>10000) {
     2857             if (ifInt&&!ifAbs)
     2858               saveModel=true;
     2859             target-=10000;
     2860           }
     2861
     2862           if (target<=100)
     2863             target=12;
     2864           else
     2865             target-=100;
     2866           if (numberDifferentObj<target) {
     2867             int iLast=0;
     2868             double last=obj[0];
     2869             for (int jColumn = 1; jColumn < numberSort; jColumn++) {
     2870               if (fabs(obj[jColumn]-last)>1.0e-12) {
     2871                 printf("%d variables have objective of %g\n",
     2872                        jColumn-iLast,last);
     2873                 iLast=jColumn;
     2874                 last=obj[jColumn];
     2875               }
     2876             }
     2877             printf("%d variables have objective of %g\n",
     2878                    numberSort-iLast,last);
     2879             if (saveModel) {
     2880               int spaceNeeded=numberSort+numberDifferentObj;
     2881               int * columnAdd = new int[spaceNeeded+numberDifferentObj+1];
     2882               double * elementAdd = new double[spaceNeeded];
     2883               int * rowAdd = new int[2*numberDifferentObj+1];
     2884               int * newIsInteger = rowAdd+numberDifferentObj+1;
     2885               double * objectiveNew = new double[3*numberDifferentObj];
     2886               double * lowerNew = objectiveNew+numberDifferentObj;
     2887               double * upperNew = lowerNew+numberDifferentObj;
     2888               memset(columnAdd+spaceNeeded,0,
     2889                      (numberDifferentObj+1)*sizeof(int));
     2890               ClpSimplex tempModel=*model;
     2891               int iLast=0;
     2892               double last=obj[0];
     2893               numberDifferentObj=0;
     2894               int numberElements=0;
     2895               rowAdd[0]=0;
     2896               double * objective = tempModel.objective();
     2897               for (int jColumn = 1; jColumn < numberSort+1; jColumn++) {
     2898                 if (jColumn==numberSort||fabs(obj[jColumn]-last)>1.0e-12) {
     2899                   // not if just one
     2900                   if (jColumn-iLast>1) {
     2901                     bool allInteger=integerInformation!=NULL;
     2902                     int iColumn=which[iLast];
     2903                     objectiveNew[numberDifferentObj]=objective[iColumn];
     2904                     double lower=0.0;
     2905                     double upper=0.0;
     2906                     for (int kColumn=iLast;kColumn<jColumn;kColumn++) {
     2907                       iColumn=which[kColumn];
     2908                       objective[iColumn]=0.0;
     2909                       double lowerValue=columnLower[iColumn];
     2910                       double upperValue=columnUpper[iColumn];
     2911                       double elementValue=-1.0;
     2912                       if (objectiveNew[numberDifferentObj]*objective[iColumn]<0.0) {
     2913                         lowerValue=-columnUpper[iColumn];
     2914                         upperValue=-columnLower[iColumn];
     2915                         elementValue=1.0;
     2916                       }
     2917                       columnAdd[numberElements]=iColumn;
     2918                       elementAdd[numberElements++]=elementValue;
     2919                       if (integerInformation&&!integerInformation[iColumn])
     2920                         allInteger=false;
     2921                       if (lower!=-COIN_DBL_MAX) {
     2922                         if (lowerValue!=-COIN_DBL_MAX)
     2923                           lower += lowerValue;
     2924                         else
     2925                           lower=-COIN_DBL_MAX;
     2926                       }
     2927                       if (upper!=COIN_DBL_MAX) {
     2928                         if (upperValue!=COIN_DBL_MAX)
     2929                           upper += upperValue;
     2930                         else
     2931                           upper=COIN_DBL_MAX;
     2932                       }
     2933                     }
     2934                     columnAdd[numberElements]=numberColumns+numberDifferentObj;
     2935                     elementAdd[numberElements++]=1.0;
     2936                     newIsInteger[numberDifferentObj]= (allInteger) ? 1 : 0;
     2937                     lowerNew[numberDifferentObj]=lower;
     2938                     upperNew[numberDifferentObj]=upper;
     2939                     numberDifferentObj++;
     2940                     rowAdd[numberDifferentObj]=numberElements;
     2941                   }
     2942                   iLast=jColumn;
     2943                   last=obj[jColumn];
     2944                 }
     2945               }
     2946               // add columns
     2947               tempModel.addColumns(numberDifferentObj, lowerNew, upperNew,
     2948                                    objectiveNew,
     2949                                    columnAdd+spaceNeeded, NULL, NULL);
     2950               // add constraints and make integer if all integer in group
     2951               for (int iObj=0; iObj < numberDifferentObj; iObj++) {
     2952                 lowerNew[iObj]=0.0;
     2953                 upperNew[iObj]=0.0;
     2954                 if (newIsInteger[iObj])
     2955                   tempModel.setInteger(numberColumns+iObj);
     2956               }
     2957               tempModel.addRows(numberDifferentObj, lowerNew, upperNew,
     2958                                 rowAdd,columnAdd,elementAdd);
     2959               delete [] columnAdd;
     2960               delete [] elementAdd;
     2961               delete [] rowAdd;
     2962               delete [] objectiveNew;
     2963               // save
     2964               std::string tempName = model->problemName();
     2965               if (ifInt)
     2966                 tempName += "_int";
     2967               if (ifAbs)
     2968                 tempName += "_abs";
     2969               tempName += ".mps";
     2970               tempModel.writeMps(tempName.c_str());
     2971             }
     2972           }
     2973         }
     2974       }
     2975       delete [] which;
     2976       delete [] obj;
     2977       printf("===== end objective counts\n");
     2978     }
    27022979     CoinPackedMatrix * matrix = model->matrix();
    27032980     CoinBigIndex numberElements = matrix->getNumElements();
  • trunk/Clp/src/ClpModel.cpp

    r1895 r1924  
    27602760     if (problemStatus_ == 1 && ray_) {
    27612761          array = ClpCopyOfArray(ray_, numberRows_);
    2762 #ifndef CLP_NO_SWAP_SIGN
     2762#if 0 //ndef CLP_NO_SWAP_SIGN
    27632763          // swap signs to be consistent with norm
    27642764          for (int i = 0; i < numberRows_; i++)
     
    40644064               coinModel->setColumnIsInteger(i, true);
    40654065     }
    4066      // do names
     4066     // do names - clear out
     4067     coinModel->zapRowNames();
     4068     coinModel->zapColumnNames();
    40674069     for (i = 0; i < numberRows_; i++) {
    40684070          char temp[30];
  • trunk/Clp/src/ClpModel.hpp

    r1901 r1924  
    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)
     
    756767     double * infeasibilityRay() 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 {
  • trunk/Clp/src/ClpPresolve.cpp

    r1910 r1924  
    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
     
    988999                                            nTightened));
    9891000            paction_ = duprow_action::presolve(prob, paction_);
     1001            printProgress('D',0);
    9901002          }
    9911003          if (doGubrow()) {
    9921004            possibleSkip;
    9931005               paction_ = gubrow_action::presolve(prob, paction_);
     1006               printProgress('E',0);
    9941007          }
    9951008
    9961009          if ((presolveActions_ & 16384) != 0)
    9971010               prob->setPresolveOptions(prob->presolveOptions() | 16384);
     1011          // For inaccurate data in implied free
     1012          if ((presolveActions_ & 1024) != 0)
     1013               prob->setPresolveOptions(prob->presolveOptions() | 0x20000);
    9981014          // Check number rows dropped
    9991015          int lastDropped = 0;
     
    10151031               // See if we want statistics
    10161032               if ((presolveActions_ & 0x80000000) != 0)
    1017                     printf("Starting major pass %d after %g seconds\n", iLoop + 1, CoinCpuTime() - prob->startTime_);
     1033                 printf("Starting major pass %d after %g seconds with %d rows, %d columns\n", iLoop + 1, CoinCpuTime() - prob->startTime_,
     1034                        nrows_-prob->countEmptyRows(),
     1035                        ncols_-prob->countEmptyCols());
    10181036#ifdef PRESOLVE_SUMMARY
    10191037               printf("Starting major pass %d\n", iLoop + 1);
     
    10511069                                         notFinished);
    10521070                         }
     1071                         printProgress('F',iLoop+1);
    10531072                         if (prob->status_)
    10541073                              break;
     
    10601079                         if (prob->status_)
    10611080                              break;
     1081                         printProgress('G',iLoop+1);
    10621082                    }
    10631083
     
    10671087                         if (prob->status_)
    10681088                              break;
     1089                         printProgress('H',iLoop+1);
    10691090                    }
    10701091                    if (tripleton) {
     
    10731094                         if (prob->status_)
    10741095                              break;
     1096                         printProgress('I',iLoop+1);
    10751097                    }
    10761098
     
    10801102                         if (prob->status_)
    10811103                              break;
     1104                         printProgress('J',iLoop+1);
    10821105                    }
    10831106#ifndef NO_FORCING
     
    10871110                         if (prob->status_)
    10881111                              break;
     1112                         printProgress('K',iLoop+1);
    10891113                    }
    10901114#endif
     
    10951119                         if (prob->status_)
    10961120                              break;
     1121                         printProgress('L',iLoop+1);
    10971122                    }
    10981123
     
    11991224                         if (prob->status_)
    12001225                              break;
     1226                         printProgress('M',iLoop+1);
    12011227                         const CoinPresolveAction * const paction2 = paction_;
    12021228                         if (ifree) {
     
    12141240                              if (prob->status_)
    12151241                                   break;
     1242                              printProgress('N',iLoop+1);
    12161243                         }
    12171244                         if (paction_ == paction2)
     
    12311258                    if (prob->status_)
    12321259                         break;
     1260                    printProgress('O',iLoop+1);
    12331261               }
    12341262#if     PRESOLVE_DEBUG
     
    12431271                    if (prob->status_)
    12441272                         break;
     1273                    printProgress('P',iLoop+1);
    12451274               }
    12461275#if     PRESOLVE_DEBUG
     
    12531282                    if (prob->status_)
    12541283                         break;
     1284                    printProgress('Q',iLoop+1);
    12551285               }
    12561286               // Marginally slower on netlib if this call is enabled.
     
    12901320                         stopLoop = true;
    12911321                    }
     1322                    printProgress('R',iLoop+1);
    12921323               }
    12931324#if     PRESOLVE_DEBUG
  • trunk/Clp/src/ClpSimplex.cpp

    r1878 r1924  
    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
     
    80328042     // for now assume primal is feasible (or in dual)
    80338043     dualOut_ = dj_[sequenceOut_];
    8034      assert(fabs(dualOut_) < 1.0e-6);
     8044     assert(fabs(dualOut_) < 1.0e-5);
    80358045     bool roundAgain = true;
    80368046     int returnCode = 0;
     
    80898099          // see where something went to
    80908100#ifndef NDEBUG
    8091           CoinRelFltEq eq(1.0e-9);
     8101          CoinRelFltEq eq(1.0e-7);
    80928102#endif
    80938103          if (sequenceOut_ < 0) {
     
    98589868                      sumDualInfeasibilities_ += fabs(dualValue) - dualTolerance_;
    98599869                         numberDualInfeasibilities_ ++;
     9870                         if (fabs(dualValue) > 1000.0 * dualTolerance)
     9871                           setColumnStatus(iColumn,superBasic);
    98609872                    }
    98619873                    break;
     
    1151011522     //abort();
    1151111523#endif
     11524     // make sure clean
     11525     whatsChanged_=0;
    1151211526     dual(0, 7);
    1151311527#if 0
     
    1188711901{
    1188811902     ClpModel::resize(newNumberRows, newNumberColumns);
     11903     delete [] perturbationArray_;
     11904     perturbationArray_ = NULL;
     11905     maximumPerturbationSize_=0;
    1188911906     if (saveStatus_) {
    1189011907          // delete arrays
     
    1195211969     fprintf(fp, "%d  clpModel->setPerturbation(save_perturbation);\n", iValue1 == iValue2 ? 7 : 6);
    1195311970}
     11971// Copy across enabled stuff from one solver to another
     11972void
     11973ClpSimplex::copyEnabledStuff(const ClpSimplex * rhs)
     11974{
     11975  solveType_=rhs->solveType_;
     11976  if (rhs->solution_) {
     11977    int numberTotal = numberRows_+numberColumns_;
     11978    assert (!solution_);
     11979    solution_ = CoinCopyOfArray(rhs->solution_,numberTotal);
     11980    lower_ = CoinCopyOfArray(rhs->lower_,numberTotal);
     11981    upper_ = CoinCopyOfArray(rhs->upper_,numberTotal);
     11982    dj_ = CoinCopyOfArray(rhs->dj_,numberTotal);
     11983    cost_ = CoinCopyOfArray(rhs->cost_,2*numberTotal);
     11984    reducedCostWork_ = dj_;
     11985    rowReducedCost_ = dj_ + numberColumns_;
     11986    columnActivityWork_ = solution_;
     11987    rowActivityWork_ = solution_ + numberColumns_;
     11988    objectiveWork_ = cost_;
     11989    rowObjectiveWork_ = cost_ + numberColumns_;
     11990    rowLowerWork_ = lower_ + numberColumns_;
     11991    columnLowerWork_ = lower_;
     11992    rowUpperWork_ = upper_ + numberColumns_;
     11993    columnUpperWork_ = upper_;
     11994  }
     11995  if (rhs->factorization_) {
     11996    delete factorization_;
     11997    factorization_ = new ClpFactorization(*rhs->factorization_);
     11998    delete [] pivotVariable_;
     11999    pivotVariable_ = CoinCopyOfArray(rhs->pivotVariable_,numberRows_);
     12000  }
     12001  for (int i = 0; i < 6; i++) {
     12002    if (rhs->rowArray_[i])
     12003      rowArray_[i] = new CoinIndexedVector(*rhs->rowArray_[i]);
     12004    if (rhs->columnArray_[i])
     12005      columnArray_[i] = new CoinIndexedVector(*rhs->columnArray_[i]);
     12006  }
     12007  if (rhs->nonLinearCost_)
     12008    nonLinearCost_=new ClpNonLinearCost(*rhs->nonLinearCost_);
     12009  if (rhs->dualRowPivot_)
     12010    dualRowPivot_ = rhs->dualRowPivot_->clone();
     12011  if (rhs->primalColumnPivot_)
     12012    primalColumnPivot_ = rhs->primalColumnPivot_->clone();
     12013}
  • trunk/Clp/src/ClpSimplex.hpp

    r1921 r1924  
    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
  • trunk/Clp/src/ClpSimplexDual.cpp

    r1918 r1924  
    17551755                              ray_ = new double [ numberRows_];
    17561756                              rowArray_[0]->expand(); // in case packed
    1757                               CoinMemcpyN(rowArray_[0]->denseVector(), numberRows_, ray_);
     1757                              // swap sign NO
     1758                              const double * array = rowArray_[0]->denseVector();
     1759                              for (int i=0;i<numberRows_;i++)
     1760                                ray_[i] = array[i];
    17581761                         } else {
    17591762                              ray_ = NULL;
     
    74537456               if (fakeStatus != ClpSimplexDual::noFake) {
    74547457                    Status status = getStatus(iSequence);
    7455                     if (status == basic) {
     7458                    if (status == basic || status == isFixed) {
    74567459                         setFakeBound(iSequence, ClpSimplexDual::noFake);
    74577460                         continue;
     
    74687471                              solution_[iSequence] = upper_[iSequence];
    74697472                         } else {
     7473                              printf("Unknown status %d for variable %d in %s line %d\n",
     7474                                  status,iSequence,__FILE__,__LINE__);
    74707475                              abort();
    74717476                         }
     
    74777482                              solution_[iSequence] = upperValue;
    74787483                         } else {
     7484                              printf("Unknown status %d for variable %d in %s line %d\n",
     7485                                  status,iSequence,__FILE__,__LINE__);
    74797486                              abort();
    74807487                         }
     
    74927499                              upper_[iSequence] = value + 0.5 * dualBound_;
    74937500                         } else {
     7501                              printf("Unknown status %d for variable %d in %s line %d\n",
     7502                                  status,iSequence,__FILE__,__LINE__);
    74947503                              abort();
    74957504                         }
  • trunk/Clp/src/ClpSimplexNonlinear.cpp

    r1665 r1924  
    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) {
  • trunk/Clp/src/ClpSimplexPrimal.cpp

    r1878 r1924  
    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];
    12981303                              // and get feasible duals
    12991304                              infeasibilityCost_ = 0.0;
     
    31343139                    }
    31353140 #endif
    3136                     if (!factorization_->pivots() && acceptablePivot_ <= 1.0e-8) {
     3141                    if (!factorization_->pivots() && acceptablePivot_ <= 1.0e-8 ) {
    31373142                         returnCode = 2; //say looks unbounded
    31383143                         // do ray
    3139                          primalRay(rowArray_[1]);
     3144                         if (!nonLinearCost_->sumInfeasibilities())
     3145                           primalRay(rowArray_[1]);
    31403146                    } else if (solveType_ == 2 && (moreSpecialOptions_ & 512) == 0) {
    31413147                         // refactorize
  • trunk/Clp/src/ClpSolve.cpp

    r1881 r1924  
    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
  • trunk/Clp/src/ClpSolve.hpp

    r1910 r1924  
    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
  • trunk/Clp/src/Clp_C_Interface.cpp

    r1902 r1924  
    649649          array = static_cast<double*>(malloc(numberRows*sizeof(double)));
    650650          memcpy(array,ray,numberRows*sizeof(double));
    651 #ifndef CLP_NO_SWAP_SIGN
     651#if 0 //ndef CLP_NO_SWAP_SIGN
    652652          // swap signs to be consistent with norm
    653653          for (int i = 0; i < numberRows; i++)
  • trunk/Clp/src/OsiClp/OsiClpSolverInterface.cpp

    r1887 r1924  
    20392039      //small->setLogLevel(0);
    20402040      // Could be infeasible if forced one way (and other way stopped on iterations)
    2041       if (small->status()==1) {
     2041      // could also be stopped on iterations
     2042      if (small->status()) {
    20422043#ifndef KEEP_SMALL
    20432044        if (small!=modelPtr_)
     
    23542355    double saveObjectiveValue = arrayD[0];
    23552356    double * saveSolution = arrayD+1;
     2357    // double check arrays exist (? for nonlinear)
     2358    //if (!smallModel_->solutionRegion())
     2359    //smallModel_->createRim(63);
    23562360    int numberRows2 = smallModel_->numberRows();
    23572361    int numberColumns2 = smallModel_->numberColumns();
     
    34783482  modelPtr_->scaledMatrix_=NULL;
    34793483  if (saveRowCopy) {
    3480 #if 1
    34813484    matrixByRow_=saveRowCopy;
    34823485    matrixByRow_->deleteRows(num,rowIndices);
    3483     assert (matrixByRow_->getNumElements()==modelPtr_->clpMatrix()->getNumElements());
    3484 #else
    3485     delete saveRowCopy;
    3486 #endif
     3486    if (matrixByRow_->getNumElements()!=modelPtr_->clpMatrix()->getNumElements()) {
     3487      delete matrixByRow_; // odd type matrix
     3488      matrixByRow_=NULL;
     3489    }
    34873490  }
    34883491  lastAlgorithm_ = saveAlgorithm;
     
    42784281  }
    42794282  starts[numberCuts]=size;
    4280   if (!modelPtr_->clpMatrix())
     4283 if (!modelPtr_->clpMatrix())
    42814284    modelPtr_->createEmptyMatrix();
    42824285  //modelPtr_->matrix()->appendRows(numberCuts,rows);
    42834286  modelPtr_->clpMatrix()->appendMatrix(numberCuts,0,starts,indices,elements);
    42844287  modelPtr_->setNewRowCopy(NULL);
     4288  modelPtr_->setClpScaledMatrix(NULL);
    42854289  freeCachedResults1();
    42864290  redoScaleFactors( numberCuts,starts, indices, elements);
     
    42894293    matrixByRow_=saveRowCopy;
    42904294    matrixByRow_->appendRows(numberCuts,starts,indices,elements,0);
    4291     assert (matrixByRow_->getNumElements()==modelPtr_->clpMatrix()->getNumElements());
     4295    if (matrixByRow_->getNumElements()!=modelPtr_->clpMatrix()->getNumElements()) {
     4296      delete matrixByRow_; // odd type matrix
     4297      matrixByRow_=NULL;
     4298    }
    42924299#else
    42934300    delete saveRowCopy;
     
    53345341OsiClpSolverInterface::getRowName(int rowIndex, unsigned int /*maxLen*/) const
    53355342{
    5336         if (rowIndex == getNumRows())
    5337                 return getObjName();
    5338   return modelPtr_->getRowName(rowIndex);
     5343  if (rowIndex == getNumRows())
     5344    return getObjName();
     5345  int useNames;
     5346  getIntParam (OsiNameDiscipline,useNames);
     5347  if (useNames)
     5348    return modelPtr_->getRowName(rowIndex);
     5349  else
     5350    return dfltRowColName('r',rowIndex);
    53395351}
    53405352   
     
    53575369OsiClpSolverInterface::getColName(int colIndex, unsigned int /*maxLen*/) const
    53585370{
    5359   return modelPtr_->getColumnName(colIndex);
     5371  int useNames;
     5372  getIntParam (OsiNameDiscipline,useNames);
     5373  if (useNames)
     5374    return modelPtr_->getColumnName(colIndex);
     5375  else
     5376    return dfltRowColName('c',colIndex);
    53605377}
    53615378   
     
    55015518  delete modelPtr_->scaledMatrix_;
    55025519  modelPtr_->scaledMatrix_=NULL;
     5520  // make sure using standard factorization
     5521  modelPtr_->factorization()->forceOtherFactorization(4);
    55035522#ifdef NDEBUG
    55045523  modelPtr_->startup(0);
     
    67066725          delete [] modelPtr_->ray_;
    67076726          modelPtr_->ray_=NULL;
     6727          if (problemStatus==1&&small->ray_) {
     6728            // get ray to full problem
     6729            int numberRows = modelPtr_->numberRows();
     6730            int numberRows2 = small->numberRows();
     6731            double * ray = new double [numberRows];
     6732            memset(ray,0,numberRows*sizeof(double));
     6733            for (int i = 0; i < numberRows2; i++) {
     6734              int iRow = whichRow[i];
     6735              ray[iRow] = small->ray_[i];
     6736            }
     6737            // Column copy of matrix
     6738            const double * element = getMatrixByCol()->getElements();
     6739            const int * row = getMatrixByCol()->getIndices();
     6740            const CoinBigIndex * columnStart = getMatrixByCol()->getVectorStarts();
     6741            const int * columnLength = getMatrixByCol()->getVectorLengths();
     6742            // translate
     6743            //pivotRow=whichRow[pivotRow];
     6744            //modelPtr_->spareIntArray_[3]=pivotRow;
     6745            int pivotRow=-1;
     6746            for (int jRow = nBound; jRow < 2 * numberRows; jRow++) {
     6747              int iRow = whichRow[jRow];
     6748              int iColumn = whichRow[jRow+numberRows];
     6749              if (modelPtr_->getColumnStatus(iColumn) == ClpSimplex::basic) {
     6750                double value = 0.0;
     6751                double sum = 0.0;
     6752                for (CoinBigIndex j = columnStart[iColumn];
     6753                     j < columnStart[iColumn] + columnLength[iColumn]; j++) {
     6754                  if (iRow == row[j]) {
     6755                    value = element[j];
     6756                  } else {
     6757                    sum += ray[row[j]]*element[j];
     6758                  }
     6759                }
     6760                if (iRow!=pivotRow) {
     6761                  ray[iRow] = -sum / value;
     6762                } else {
     6763                  printf("what now - direction %d wanted %g sum %g value %g\n",
     6764                         small->directionOut_,ray[iRow],
     6765                         sum,value);
     6766                }
     6767              }
     6768            }
     6769            for (int i=0;i<modelPtr_->numberColumns_;i++) {
     6770              if (modelPtr_->getStatus(i)!=ClpSimplex::basic&&
     6771                  modelPtr_->columnLower_[i]==modelPtr_->columnUpper_[i])
     6772                modelPtr_->setStatus(i,ClpSimplex::isFixed);
     6773            }
     6774            modelPtr_->ray_=ray;
     6775            modelPtr_->directionOut_=small->directionOut_;
     6776          }
    67086777        }
    67096778      }
Note: See TracChangeset for help on using the changeset viewer.