Changeset 619


Ignore:
Timestamp:
Jun 9, 2011 9:55:21 AM (9 years ago)
Author:
berthold
Message:

moved SCIP call from CouenneFPSolveMILP to CouenneFPFindSolution; added FP parameter to use SCIP

Location:
trunk/Couenne/src/heuristics
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/Couenne/src/heuristics/CouenneFPFindSolution.cpp

    r609 r619  
    4545  /// solve MILP
    4646
    47   milp_ -> branchAndBound ();
     47#ifdef COIN_HAS_SCIP
     48
     49  printf ("USING SCIP\n");
     50
     51  if (useSCIP_) {
     52     SCIP* scip;
     53
     54     SCIP_VAR** vars;
     55     const SCIP_Real* lbs;
     56     const SCIP_Real* ubs;
     57     const SCIP_Real* objs;
     58     const char* vartypes;
     59     const CoinPackedMatrix * matrix;
     60     const CoinBigIndex* rowstarts;
     61     const int* rowlengths;
     62     const SCIP_Real* coeffs;
     63     const SCIP_Real* lhss;
     64     const SCIP_Real* rhss;
     65     const int* indices;
     66
     67     double infinity;
     68     int nvars;
     69     int nconss;
     70     
     71     // COUENNE_INFINITY , getInfinity()
     72
     73     // get problem data
     74     nvars    = milp_ -> getNumCols ();
     75     nconss   = milp_ -> getNumRows ();
     76     infinity = milp_ -> getInfinity ();
     77
     78     // get variable data
     79     lbs =      milp_ -> getColLower ();
     80     ubs =      milp_ -> getColUpper ();
     81     objs =     milp_ -> getObjCoefficients ();
     82     vartypes = milp_ -> getColType ();
     83
     84     // get row data
     85     lhss = milp_ -> getRowLower ();
     86     rhss = milp_ -> getRowUpper ();
     87
     88     // get matrix data
     89     matrix     = milp_ -> getMatrixByRow();
     90     rowstarts  = matrix -> getVectorStarts();
     91     rowlengths = matrix -> getVectorLengths();
     92     coeffs     = matrix -> getElements();
     93     indices    = matrix -> getIndices();
     94     
     95     // initialize SCIP
     96     SCIP_CALL_ABORT( SCIPcreate(&scip) );
     97     assert(scip != NULL);
     98     
     99     // include default SCIP plugins
     100     SCIP_CALL_ABORT( SCIPincludeDefaultPlugins(scip) );
     101
     102     // one variable for objective !!!!!!!!!
     103
     104     // create variables
     105     for (int i=0; i<nvars; i++) {
     106        char varname[SCIP_MAXSTRLEN]; 
     107
     108        // check that all data is in valid ranges
     109        assert( 0 <= vartypes[i] && vartypes[i] <= 2);
     110        checkInfinity(scip, lbs[i], infinity);
     111        checkInfinity(scip, ubs[i], infinity);
     112
     113        // all variables are named x_i
     114        (void) SCIPsnprintf(varname, SCIP_MAXSTRLEN, "x_%d", i);
     115        SCIP_CALL_ABORT( SCIPcreateVar(scip, &vars[i], varname, lbs[i], ubs[i], objs[i],
     116              vartypes[i] == 0 ? SCIP_VARTYPE_CONTINUOUS : (vartypes[i] == 1 ? SCIP_VARTYPE_BINARY : SCIP_VARTYPE_INTEGER),
     117              TRUE, FALSE, NULL, NULL, NULL, NULL, NULL) );
     118
     119        // add the variable to SCIP
     120        SCIP_CALL_ABORT( SCIPaddVar(scip, vars[i]) );
     121       
     122        // because the variable was added to the problem, it is captured by SCIP and we can safely release it right now
     123        SCIP_CALL_ABORT( SCIPreleaseVar(scip, &vars[i]) );
     124     }
     125
     126     // create constraints
     127     for (int i=0; i<nconss; i++) {
     128
     129        SCIP_CONS* cons;
     130       
     131        char consname[SCIP_MAXSTRLEN]; 
     132        (void) SCIPsnprintf(consname, SCIP_MAXSTRLEN, "row_%d", i);
     133
     134        // check that all data is in valid ranges
     135        checkInfinity(scip, lhss[i], infinity);
     136        checkInfinity(scip, rhss[i], infinity);
     137       
     138        SCIP_CALL_ABORT( SCIPcreateConsLinear(scip, &cons, consname, 0, NULL, NULL, lhss[i], rhss[i],
     139              TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE) );
     140       
     141        // add variables to constraint
     142        for(int j=rowstarts[i]; j<rowstarts[i]+rowlengths[i]; j++)       
     143        {
     144           checkInfinity(scip, coeffs[j], infinity);
     145           SCIP_CALL_ABORT( SCIPaddCoefLinear(scip, cons, vars[indices[j]], coeffs[j]) );
     146        }
     147
     148        SCIP_CALL_ABORT( SCIPaddCons(scip, cons) );
     149        SCIP_CALL_ABORT( SCIPreleaseCons(scip, &cons) );       
     150     }
     151     
     152     // solve the MILP
     153     SCIP_CALL_ABORT( SCIPsolve(scip) );
     154
     155     // free memory
     156     SCIP_CALL_ABORT( SCIPfree(&scip) );
     157   
     158     BMScheckEmptyMemory();
     159  }
     160   else
     161#endif     
     162      milp_ -> branchAndBound ();
    48163}
    49164
  • trunk/Couenne/src/heuristics/CouenneFPSolveMILP.cpp

    r618 r619  
    7575                                    // solveMILP; initialization will be
    7676                                    // necessary
    77 
    78 #ifdef COIN_HAS_SCIP
    79 
    80   printf ("USING SCIP\n");
    81 
    82   if (useSCIP_) {
    83      SCIP* scip;
    84 
    85      SCIP_VAR** vars;
    86      const SCIP_Real* lbs;
    87      const SCIP_Real* ubs;
    88      const SCIP_Real* objs;
    89      const char* vartypes;
    90      const CoinPackedMatrix * matrix;
    91      const CoinBigIndex* rowstarts;
    92      const int* rowlengths;
    93      const SCIP_Real* coeffs;
    94      const SCIP_Real* lhss;
    95      const SCIP_Real* rhss;
    96      const int* indices;
    97 
    98      double infinity;
    99      int nvars;
    100      int nconss;
    101      
    102      // COUENNE_INFINITY , getInfinity()
    103 
    104      // get problem data
    105      nvars    = model_ -> solver() -> getNumCols ();
    106      nconss   = model_ -> solver() -> getNumRows ();
    107      infinity = model_ -> solver() -> getInfinity ();
    108 
    109      // get variable data
    110      lbs =      model_ -> solver() -> getColLower ();
    111      ubs =      model_ -> solver() -> getColUpper ();
    112      objs =     model_ -> solver() -> getObjCoefficients ();
    113      vartypes = model_ -> solver() -> getColType ();
    114 
    115      // get row data
    116      lhss = model_ -> solver() -> getRowLower ();
    117      rhss = model_ -> solver() -> getRowUpper ();
    118 
    119      // get matrix data
    120      matrix     = model_ -> solver() -> getMatrixByRow();
    121      rowstarts  = matrix -> getVectorStarts();
    122      rowlengths = matrix -> getVectorLengths();
    123      coeffs     = matrix -> getElements();
    124      indices    = matrix -> getIndices();
    125      
    126      // initialize SCIP
    127      SCIP_CALL( SCIPcreate(&scip) );
    128      assert(scip != NULL);
    129      
    130      // include default SCIP plugins
    131      SCIP_CALL( SCIPincludeDefaultPlugins(scip) );
    132 
    133      // one variable for objective !!!!!!!!!
    134 
    135      // create variables
    136      for (int i=0; i<nvars; i++) {
    137         char varname[SCIP_MAXSTRLEN]; 
    138 
    139         // check that all data is in valid ranges
    140         assert( 0 <= vartypes[i] && vartypes[i] <= 2);
    141         checkInfinity(scip, lbs[i], infinity);
    142         checkInfinity(scip, ubs[i], infinity);
    143 
    144         // all variables are named x_i
    145         (void) SCIPsnprintf(varname, SCIP_MAXSTRLEN, "x_%d", i);
    146         SCIP_CALL( SCIPcreateVar(scip, &vars[i], varname, lbs[i], ubs[i], objs[i],
    147               vartypes[i] == 0 ? SCIP_VARTYPE_CONTINUOUS : (vartypes[i] == 1 ? SCIP_VARTYPE_BINARY : SCIP_VARTYPE_INTEGER),
    148               TRUE, FALSE, NULL, NULL, NULL, NULL, NULL) );
    149 
    150         // add the variable to SCIP
    151         SCIP_CALL( SCIPaddVar(scip, vars[i]) );
    152        
    153         // because the variable was added to the problem, it is captured by SCIP and we can safely release it right now
    154         SCIP_CALL( SCIPreleaseVar(scip, &vars[i]) );
    155      }
    156 
    157      // create constraints
    158      for (int i=0; i<nconss; i++) {
    159 
    160         SCIP_CONS* cons;
    161        
    162         char consname[SCIP_MAXSTRLEN]; 
    163         (void) SCIPsnprintf(consname, SCIP_MAXSTRLEN, "row_%d", i);
    164 
    165         // check that all data is in valid ranges
    166         checkInfinity(scip, lhss[i], infinity);
    167         checkInfinity(scip, rhss[i], infinity);
    168        
    169         SCIP_CALL( SCIPcreateConsLinear(scip, &cons, consname, 0, NULL, NULL, lhss[i], rhss[i],
    170               TRUE, TRUE, TRUE, TRUE, TRUE, FALSE, FALSE, TRUE, TRUE, FALSE) );
    171        
    172         // add variables to constraint
    173         for(int j=rowstarts[i]; j<rowstarts[i]+rowlengths[i]; j++)       
    174         {
    175            checkInfinity(scip, coeffs[j], infinity);
    176            SCIP_CALL( SCIPaddCoefLinear(scip, cons, vars[indices[j]], coeffs[j]) );
    177         }
    178 
    179         SCIP_CALL( SCIPaddCons(scip, cons) );
    180         SCIP_CALL( SCIPreleaseCons(scip, &cons) );       
    181      }
    182      
    183      // solve the MILP
    184      SCIP_CALL( SCIPsolve(scip) );
    185 
    186      // free memory
    187      SCIP_CALL( SCIPfree(&scip) );
    188    
    189      BMScheckEmptyMemory();
    190   }
    191  
    192   else
    193 
    194 #endif
    195 
    196   {
     77 
    19778    if (!milp_) {
    19879
     
    327208
    328209    return milp_ -> getObjValue ();
    329   }
    330210}
  • trunk/Couenne/src/heuristics/CouenneFeasPumpConstructors.cpp

    r618 r619  
    9191  options -> GetStringValue  ("feas_pump_lincut",   s, "couenne."); milpCuttingPlane_ = (s == "yes");
    9292  options -> GetStringValue  ("feas_pump_dist_int", s, "couenne."); compDistInt_      = (s == "yes");
     93  options -> GetStringValue  ("feas_pump_usescip", s, "couenne."); useSCIP_      = (s == "yes");
    9394
    9495  // Although app_ is only used in CouenneFPSolveNLP, we need to have
     
    289290     "yes","",
    290291     "");
    291 }
     292
     293  roptions -> AddStringOption2
     294    ("feas_pump_usescip",
     295     "Should SCIP be used to solve the MILPs?",
     296     "no",
     297     "no","",
     298     "yes","",
     299     "");
     300
     301}
Note: See TracChangeset for help on using the changeset viewer.