Changeset 933 for trunk


Ignore:
Timestamp:
Dec 29, 2012 8:23:40 AM (7 years ago)
Author:
pbelotti
Message:

partial cleanup in CutGen?.cpp. Added option on sparsity, not yet used. Cut duplicate addition of disjunctive cuts

Location:
trunk/Couenne/src
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/Couenne/src/cut/sdpcuts/CouennePSDcon.cpp

    r910 r933  
    2121{X_ = c.X_ -> clone ();}
    2222
     23/// assignment operator
     24CouennePSDcon &CouennePSDcon::operator= (const CouennePSDcon &c)
     25{X_ = c.X_ -> clone (); return *this;}
     26
    2327/// decompose body of constraint through auxiliary variables
    2428exprAux *CouennePSDcon::standardize (CouenneProblem *p)
  • trunk/Couenne/src/cut/sdpcuts/CouennePSDcon.hpp

    r930 r933  
    4141    CouennePSDcon (const CouennePSDcon &c, Domain *d = NULL);
    4242
     43    /// Assignment operator
     44    CouennePSDcon &operator= (const CouennePSDcon &c);
     45
    4346    /// Cloning method
    4447    inline CouenneConstraint *clone (Domain *d = NULL) const
  • trunk/Couenne/src/cut/sdpcuts/CouenneSdpCuts.cpp

    r931 r933  
    229229     "yes", "exclude all non-negative eigenvalues"
    230230    );
    231 }
     231
     232  /////////////////////////////////////////
     233
     234  roptions -> AddStringOption2
     235    ("sdp_cuts_sparsify",
     236     "Make cuts sparse by greedily reducing X one column at a time before extracting eigenvectors.",
     237     "yes",
     238     "no", "",
     239     "yes", ""
     240    );
     241
     242#if 0
     243  roptions -> AddStringOption2
     244    ("sdp_cuts_neg_ev",
     245     "Only use negative eigenvalues to create sdp cuts.",
     246     "yes",
     247     "no", "use all eigenvalues regardless of their sign",
     248     "yes", "exclude all non-negative eigenvalues"
     249    );
     250#endif
     251}
  • trunk/Couenne/src/cut/sdpcuts/CouenneSdpCuts.hpp

    r930 r933  
    114114                    int *ploc_card_selected, int *ploc_card_new_selected,
    115115                    double *ploc_lhs,
    116                     double *locmargin, double **locmat,
    117                     const double *sol, double *locv,
     116                    double *locmargin, double *locmat,
     117                    double *locv,
    118118                    const int evidx, bool wise,
    119119                    int *evdec_num,
     
    131131                       int *ploc_card_new_selected,
    132132                       double *ploc_lhs,
    133                        double *locmargin, double **locmat,
     133                       double *locmargin, double *locmat,
    134134                       int *pnchanged,
    135                        const double *sol, double *locv,
     135                       double *locv,
    136136                       const int evidx, bool wise,double *recomp_gap, double *threshold,
    137137                       int *pcard_selected,
     
    141141                       const int init_card_selected, int *has_init_vect,
    142142                       int *evdec_num) const;
    143 
    144     // void zero_valid_delta(const int np, const int *order,
    145     //                    const int * selected,
    146     //                    const int min_card_new_selected,
    147     //                    const double min_delta, const int start_point,
    148     //                    const int curr_i,
    149     //                    int *loc_selected,
    150     //                    int *ploc_card_selected,
    151     //                    int *ploc_card_new_selected,
    152     //                    double *ploc_lhs,
    153     //                    double *locmargin, double **locmat,
    154     //                    int *pnchanged,
    155     //                    const double *sol, double *locv,
    156     //                    const int evidx, bool wise,double *recomp_gap, double *threshold,
    157     //                    int *pcard_selected,
    158     //                    int *pnew_selected,
    159     //                    double **sparse_v_mat,
    160     //                    int *pcard_v_mat,
    161     //                    const int init_card_selected, int *has_init_vect,
    162     //                    int *evdec_num) const;
    163 
    164     // void zero_selected(const int np, const int *order,
    165     //                 const int *selected,
    166     //                 const int min_card_new_selected,
    167     //                 const double min_delta, const int start_point,
    168     //                 const int curr_i,
    169     //                 int *loc_selected, int *ploc_card_selected,
    170     //                 int *ploc_card_new_selected,
    171     //                 double *ploc_lhs,
    172     //                 double *locmargin, double **locmat,
    173     //                 int *pnchanged,
    174     //                 const double *sol, double *locv,
    175     //                 const int evidx, bool wise,double *recomp_gap, double *threshold,
    176     //                 int *pcard_selected,
    177     //                 int *pnew_selected,
    178     //                 double **sparse_v_mat,
    179     //                 int *pcard_v_mat,
    180     //                 const int init_card_selected, int *has_init_vect,
    181     //                 int *evdec_num) const;
    182 
    183     // void zero_pos_delta(const int np, const int *order,
    184     //                  const int *selected,
    185     //                  const int min_card_new_selected,
    186     //                  const int start_point, const int curr_i,
    187     //                  int *loc_selected, int *ploc_card_selected,
    188     //                  int *ploc_card_new_selected,
    189     //                  double *ploc_lhs,
    190     //                  double *locmargin, double **locmat,
    191     //                  int *pnchanged,
    192     //                  const double *sol, double *locv,
    193     //                  const int evidx, bool wise,
    194     //                  double *recomp_gap, double *threshold,
    195     //                  int *pcard_selected,
    196     //                  int *pnew_selected,
    197     //                  double **sparse_v_mat,
    198     //                  int *pcard_v_mat,
    199     //                  const int init_card_selected, int *has_init_vect,
    200     //                  int *evdec_num) const;
    201143
    202144    void add_v_cut(const int np,
     
    211153
    212154    void update_sparsify_structures(const int np,
    213                                     const double *sol, double *v,double* margin,
    214                                     double** mat, double *lhs, const int *zeroed,
     155                                    double *v, double* margin,
     156                                    double *A, double *lhs, const int *zeroed,
    215157                                    int evidx, bool decompose, int *evdec_num) const;
    216158
     
    221163                   int *card_v_mat,
    222164                   int *evdec_num) const;
    223 
    224     void myremoveBestOneRowCol(double *matrix,
    225                                int n,
    226                                int running_n,
    227                                int min_nz,
    228                                bool *del_idx,
    229                                double **sparse_v_mat,
    230                                int *card_v_mat ,
    231                                int *evdec_num) const;
    232165  };
    233166}
  • trunk/Couenne/src/cut/sdpcuts/CutGen.cpp

    r932 r933  
    2828
    2929#define SPARSIFY
    30 //#define SPARSIFY2
     30#define SPARSIFY2
    3131#define SPARSIFY_MINOR_SDP_CUTS
    3232
     
    5050using namespace Couenne;
    5151
    52 /************************************************************************/
    53 // sdpcut separator
     52
     53// sdpcut separator -- all minors
    5454void CouenneSdpCuts::generateCuts (const OsiSolverInterface &si, OsiCuts &cs,
    5555                                   const CglTreeInfo info) const {
     
    6969}
    7070
    71 // sdpcut separator
     71
     72// sdpcut separator -- one minor at a time
    7273void CouenneSdpCuts::genCutSingle (CouenneExprMatrix * const & minor,
    7374                                   const OsiSolverInterface &si,
     
    616617
    617618
    618 /***********************************************************************/
    619 void CouenneSdpCuts::myremoveBestOneRowCol (double *matrix,
    620                                             int n, int running_n,
    621                                             int min_nz,
    622                                             bool *del_idx,
    623                                             double **sparse_v_mat,
    624                                             int *card_v_mat,
    625                                             int *evdec_num) const {
    626   if (running_n == 1)
    627     return;
    628 
    629   int
    630     best_idx = -1,
    631     rnsq     = (running_n - 1) * (running_n - 1),
    632     card_ev_best;
    633 
    634   double
    635     best_val    = 1,
    636 
    637     *matrixCopy = CoinCopyOfArray (matrix, running_n * running_n),
    638 
    639     *T          = new double [rnsq],
    640     *Tcopy      = new double [rnsq],
    641     *Tbest      = new double [rnsq],
    642 
    643     *wbest      = new double [running_n - 1],
    644     *zbest      = new double [rnsq],
    645 
    646     *w          = new double [running_n - 1],
    647     *z          = new double [rnsq];
    648 
    649   // while (running_n > 1)
    650 
    651   for (int k=0; k<running_n; k++) {
    652 
    653     /// construct two matrices T and Tcopy that cut k-th row and k-th column
    654 
    655     for (int i=0, ii=0; i<running_n; i++) {
    656 
    657       if (i==k) continue;
    658 
    659       for(int j=0, jj=0; j<running_n;j++) {
    660 
    661         if (j==k) continue;
    662 
    663         int    idx1 = (running_n-1)*ii+jj;
    664         double val2 = matrixCopy [running_n*i+j];
    665 
    666         T     [idx1] =
    667         Tcopy [idx1] = val2;
    668 
    669         jj++;
    670       }
    671 
    672       ii++;
    673     }
    674 
    675     int card_ev;
    676 
    677     (*evdec_num)++;
    678 
    679     //------------------------------------------------------------------------------------------------------------------------------
    680     dsyevx_interface (running_n - 1, T, card_ev, w, z, EV_TOL, -COIN_DBL_MAX, 0., 1, (running_n-1 == min_nz) ? (running_n - 1) : 1);
    681     //------------------------------------------------------------------------------------------------------------------------------
    682 
    683     double val = w [0]; // minimum eigenvalue
    684 
    685     if (val < 0 && val < best_val) {
    686 
    687       best_val=val;
    688       best_idx=k;
    689 
    690       std::memcpy (Tbest, Tcopy, rnsq            * sizeof (double));
    691       std::memcpy (zbest, z,     rnsq            * sizeof (double));
    692       std::memcpy (wbest, w,     (running_n - 1) * sizeof (double));
    693 
    694       card_ev_best = card_ev;
    695     }
    696   }
    697 
    698   if (best_idx >= 0) {
    699                
    700     if (del_idx == NULL) {
    701       del_idx = new bool[n];
    702       CoinFillN (del_idx, n, false);
    703 
    704       // for (int i=0;i<n;i++)
    705       //        del_idx[i]=false;
    706     }
    707 
    708     int cnt_idx_orig = 0;
    709     int cnt_idx_minor = 0;
    710 
    711     while (cnt_idx_minor < running_n) {
    712       if (del_idx[cnt_idx_orig] == false) {
    713         if (cnt_idx_minor == best_idx) {
    714           del_idx[cnt_idx_orig] = true;
    715           break;
    716         }
    717         else
    718           cnt_idx_minor++;
    719       }
    720       cnt_idx_orig++;
    721     }
    722 
    723     if (running_n - 1 == min_nz) {
    724       for(int i=0;i<card_ev_best;i++) {
    725         if (wbest[i] < 0) {
    726           double *curr_ev = zbest + (i*(running_n-1));
    727                                        
    728           for(int j=0;j<n;j++)
    729             sparse_v_mat[i][j]=0.0;
    730                                        
    731           int idx_orig = 0;
    732           int idx_minor = 0;
    733 
    734           while (idx_orig < n) {
    735             if (!(del_idx[idx_orig])) {
    736               sparse_v_mat[i][idx_orig] = curr_ev[idx_minor];
    737               idx_minor++;
    738             }
    739             idx_orig++;
    740           }
    741 
    742           (*card_v_mat)++;
    743         }
    744         else //no more negative eigenvalues
    745           break;
    746       }
    747     }
    748     else {
    749       myremoveBestOneRowCol (Tbest, n, running_n - 1, min_nz, del_idx, sparse_v_mat, card_v_mat, evdec_num);
    750     }
    751   }
    752 
    753   // copy Tbest in matrixCopy
    754 
    755   // } // end while
    756 
    757   delete [] del_idx;
    758 
    759   delete [] z;
    760   delete [] w;
    761 
    762   delete [] T;
    763   delete [] Tcopy;
    764   delete [] matrixCopy;
    765 
    766   delete [] Tbest;
    767   delete [] zbest;
    768   delete [] wbest;
    769 
    770 }// myremoveBestOneRowCol ()
    771 
    772 
    773619/************************************************************************/
    774620void CouenneSdpCuts::sparsify2 (const int n,
     
    776622                                int *card_v_mat, int min_nz, int *evdec_num) const {
    777623
    778   double *matrix = new double [n*n];
    779 
    780   for (int i=0; i<n; i++)
    781     for (int j=i; j<n; j++)
    782       matrix [j*n+i] = A [j*n+i];
    783 
    784   myremoveBestOneRowCol (matrix, n, n, min_nz, NULL, sparse_v_mat, card_v_mat, evdec_num);
     624  double *matrix = CoinCopyOfArray (A, n*n);
     625
     626  int running_n = n;
     627
     628  bool *del_idx = NULL;
     629
     630  if (running_n == 1)
     631    return;
     632
     633  int
     634    best_idx,
     635    rnsq     = (running_n - 1) * (running_n - 1),
     636    card_ev_best;
     637
     638  double
     639    best_val,
     640
     641    *matrixCopy = CoinCopyOfArray (matrix, running_n * running_n),
     642
     643    *T          = new double [rnsq],
     644    *Tcopy      = new double [rnsq],
     645    *Tbest      = new double [rnsq],
     646
     647    *wbest      = new double [running_n - 1],
     648    *zbest      = new double [rnsq],
     649
     650    *w          = new double [running_n - 1],
     651    *z          = new double [rnsq];
     652
     653  // remove one column/row at a time to get smaller and smaller minor
     654
     655  while (running_n > 1) {
     656
     657    best_val = 0.;
     658    best_idx = -1;
     659
     660  for (int k=0; k < running_n; ++k) {
     661
     662    /// construct two matrices T and Tcopy that cut k-th row and k-th column
     663
     664    for (int i=0, ii=0; i<running_n; i++) {
     665
     666      if (i==k) continue;
     667
     668      for (int j=0, jj=0; j<running_n; j++) {
     669
     670        if (j==k) continue;
     671
     672        int    idx1 = (running_n-1)*ii+jj;
     673        double val2 = matrixCopy [running_n*i + j];
     674
     675        T     [idx1] =
     676        Tcopy [idx1] = val2;
     677
     678        ++jj;
     679      }
     680
     681      ++ii;
     682    }
     683
     684    int card_ev;
     685
     686    (*evdec_num)++;
     687
     688    //--------------------------------------------------------------------------------------------------------------------------------
     689    dsyevx_interface (running_n - 1, T, card_ev, w, z, EV_TOL, -COIN_DBL_MAX, 0., 1, (running_n - 1 == min_nz) ? (running_n - 1) : 1);
     690    //--------------------------------------------------------------------------------------------------------------------------------
     691
     692    double val = w [0]; // minimum eigenvalue
     693
     694    if (val < best_val) {
     695
     696      best_val = val;
     697      best_idx = k;
     698
     699      std::memcpy (Tbest, Tcopy, rnsq            * sizeof (double));
     700      std::memcpy (zbest, z,     rnsq            * sizeof (double));
     701      std::memcpy (wbest, w,     (running_n - 1) * sizeof (double));
     702
     703      card_ev_best = card_ev;
     704    }
     705  }
     706
     707  // For this value of k, now we have in Tbest the best minor of size
     708  // running_n
     709
     710  if (best_idx >= 0) {
     711
     712    if (del_idx == NULL) {
     713      del_idx = new bool[n];
     714      CoinFillN (del_idx, n, false);
     715    }
     716
     717    int cnt_idx_orig = 0;
     718    int cnt_idx_minor = 0;
     719
     720    while (cnt_idx_minor < running_n) {
     721      if (del_idx [cnt_idx_orig] == false) {
     722        if (cnt_idx_minor == best_idx) {
     723          del_idx [cnt_idx_orig] = true;
     724          break;
     725        }
     726
     727        cnt_idx_minor++;
     728      }
     729
     730      cnt_idx_orig++;
     731    }
     732
     733    if (running_n - 1 == min_nz) {
     734
     735      for (int i=0; i < card_ev_best && wbest [i] < 0; i++) {
     736
     737        CoinFillN (sparse_v_mat [i], n, 0.);
     738
     739        double *curr_ev = zbest + i * (running_n - 1);
     740
     741        for (int idx_orig = 0, idx_minor = 0; idx_orig < n; ++idx_orig)
     742
     743          if (!(del_idx [idx_orig]))
     744            sparse_v_mat [i] [idx_orig] = curr_ev [idx_minor++];
     745
     746        ++ *card_v_mat;
     747      }
     748
     749      break; // done when reached min_nz dimension
     750    }
     751  }
     752
     753  CoinCopyN (Tbest, (n-1) * (n-1), matrixCopy);
     754
     755  --running_n;
     756
     757  } // end while
     758
     759  delete [] del_idx;
     760
     761  delete [] z;
     762  delete [] w;
     763
     764  delete [] T;
     765  delete [] Tcopy;
     766  delete [] matrixCopy;
     767
     768  delete [] Tbest;
     769  delete [] zbest;
     770  delete [] wbest;
    785771
    786772  delete [] matrix;
     
    859845
    860846/************************************************************************/
    861 void CouenneSdpCuts::update_sparsify_structures (const int n, const double *sol, double *v,
    862                                                  double* margin, double** mat, double *lhs,
     847void CouenneSdpCuts::update_sparsify_structures (const int n, double *v,
     848                                                 double* margin, double* A, double *lhs,
    863849                                                 const int *zeroed, int evidx, bool decompose,
    864850                                                 int *evdec_num) const {
    865 
    866   // copy sol[] in mat[][]
    867   mat[0][0] = 1;
    868   for(int i=1; i<n; i++) {
    869     mat[0][i] = sol[i-1];
    870     mat[i][0] = sol[i-1];
    871   }
    872 
    873   for(int i=1; i<n; i++)
    874     for(int j=i; j<n; j++) {
    875       int ind = indexQ (i-1, j-1, n-1);
    876       mat[i][j] = sol[ind];
    877       mat[j][i] = sol[ind];
    878     }
    879 
    880851  int minor_n = n;
    881852  if (zeroed != NULL) {
     
    885856  }
    886857
    887   if ((decompose) && (minor_n > 2)) {
     858  if (decompose && (minor_n > 2)) {
    888859
    889860    /*
     
    896867      }
    897868    */
     869
    898870    decomposition_counter++;
    899871    (*evdec_num)++;
    900     double *minor_A = new double[n*n];
    901     double *minor_w = new double[n];
    902     double *minor_z = new double[n*n];
     872
     873    double *minor_A = new double [n*n];
     874    double *minor_w = new double [n];
     875    double *minor_z = new double [n*n];
    903876
    904877    //prepare active submatrix (induced by zeroed vector)
     
    913886        if (zeroed[j] == 0)
    914887          continue;
    915         minor_A[(minor_n*ii) + jj] = mat[i][j];
     888        minor_A [minor_n*ii + jj] = A [n*i+j];
    916889        jj++;
    917890      }
    918891      ii++;
    919892    }
    920     //eigendecomposition
     893
     894    // eigendecomposition
    921895    int m;
    922896    //          dsyevx_wrapper_first_p (minor_n, minor_A, m, minor_w, minor_z,evidx+1,tracer_);
    923897    dsyevx_interface (minor_n, minor_A, m, minor_w, minor_z, EV_TOL, -COIN_DBL_MAX, 0., 1, 1);
    924898
    925     //update v (reindex the evidx-th eigenvector entries)
     899    // update v (reindex the evidx-th eigenvector entries)
    926900    ii = 0;
    927901    for (int i=0;i<n;i++) {
     
    932906      ii++;
    933907    }
     908
    934909    delete [] minor_A;
    935910    delete [] minor_w;
     
    937912  }
    938913
    939   for(int i=0; i<n; i++) {
    940     for(int j=0; j<n; j++) {
    941       mat[i][j] *= v[i] * v[j];
    942       if ((zeroed != NULL) && (zeroed[j] == 0)) {
    943         mat[i][j] = 0;
    944         mat[j][i] = 0;
    945       }
    946     }
    947   }
    948 
    949   (*lhs) = 0;
    950   for(int i=0; i<n; i++) {
     914  for   (int i=0; i<n; ++i)
     915    for (int j=0; j<n; ++j) {
     916      A [i*n + j] *= v[i] * v[j];
     917      A [j*n + i] *= v[i] * v[j];
     918      if ((zeroed != NULL) && (zeroed [j] == 0))
     919        A [i*n + j] = A [j*n + i] = 0;
     920    }
     921
     922  *lhs = 0;
     923
     924  for (int i=0; i<n; i++) {
     925
    951926    margin[i] = 0;
    952     for(int j=0; j<n; j++) {
    953       margin[i] += mat[i][j];   
    954     }
    955     (*lhs) += margin[i];
     927
     928    for(int j=0; j<n; j++)
     929      margin[i] += A [i*n + j];
     930
     931    *lhs += margin[i];
    956932  }
    957933}
     
    964940                                int *ploc_card_selected, int *ploc_card_new_selected,
    965941                                double *ploc_lhs,
    966                                 double *locmargin, double **locmat,
    967                                 const double *sol, double *locv,
     942                                double *locmargin, double *locmat,
     943                                double *locv,
    968944                                const int evidx, bool wise, int *evdec_num, double *recomp_gap, double *threshold) const {
    969945
     
    986962  (*ploc_lhs) -= delta;
    987963
    988   update_sparsify_structures (n,sol,locv,locmargin,locmat,ploc_lhs, loc_selected, evidx, local_wise, evdec_num);
     964  update_sparsify_structures (n,locv, locmargin, locmat, ploc_lhs, loc_selected, evidx, local_wise, evdec_num);
    989965
    990966} /* zero_comp */
     
    1003979                                       int *ploc_card_new_selected,
    1004980                                       double *ploc_lhs,
    1005                                        double *locmargin, double **locmat,
     981                                       double *locmargin, double *locmat,
    1006982                                       int *pnchanged,
    1007                                        const double *sol, double *locv,
     983                                       double *locv,
    1008984                                       const int evidx, bool wise, double *recomp_gap, double *threshold,
    1009985                                       int *pcard_selected,
     
    10351011      continue;
    10361012   
    1037     double delta = 2 * locmargin[ind_i] - locmat[ind_i][ind_i];
     1013    double delta = 2 * locmargin[ind_i] - locmat[ind_i * n + ind_i];
    10381014    if (((type == VALID_DELTA || type == SELECTED) && (*ploc_lhs - delta < min_delta)) ||
    10391015        ((type == POS_DELTA)                       && (delta > 0))) {
     
    10411017      zero_comp(ind_i, delta, n, selected, loc_selected,
    10421018                ploc_card_selected, ploc_card_new_selected,
    1043                 ploc_lhs, locmargin, locmat, sol, locv, evidx, wise, evdec_num, recomp_gap, threshold);
     1019                ploc_lhs, locmargin, locmat, locv, evidx, wise, evdec_num, recomp_gap, threshold);
    10441020      (*pnchanged)++;
    10451021    }
     
    11281104    *locv_orig = new double  [n],
    11291105    *locmargin = new double  [n],
    1130    **mat       = new double* [n],
    1131    **locmat    = new double* [n];
     1106    *mat       = new double  [n*n],
     1107    *locmat    = new double  [n*n];
    11321108
    11331109  *card_v_mat = 0;
     
    11361112
    11371113    selected[i] = 0;
    1138     mat[i] = new double[n];
    1139     locmat[i] = new double[n];
     1114    //    mat[i] = new double[n*n];
     1115    //locmat[i] = new double[n];
    11401116    order[i] = i;
    11411117
     
    11611137  }
    11621138
    1163   update_sparsify_structures (n,sol,locv_orig,margin,mat,&lhs, NULL, evidx, false, evdec_num);
     1139  update_sparsify_structures (n, locv_orig, margin, mat, &lhs, NULL, evidx, false, evdec_num);
    11641140
    11651141  int init_card_selected = card_selected; // to recognize if cut from original
     
    12021178      locmargin[i] = margin[i];
    12031179      for(j=0; j<n; j++)
    1204         locmat[i][j] = mat[i][j];
     1180        locmat[i * n + j] = mat[i*n+j];
    12051181    }
    12061182
     
    12251201                        &loc_card_selected, &loc_card_new_selected,
    12261202                        &loc_lhs, locmargin, locmat,
    1227                         &curr_nchanged,sol,locv,evidx, use_new_sparsify, &recomp_gap,&threshold,
     1203                        &curr_nchanged,locv,evidx, use_new_sparsify, &recomp_gap,&threshold,
    12281204                        &card_selected, &new_selected,
    12291205                        sparse_v_mat, card_v_mat,
     
    12441220                        &loc_card_selected, &loc_card_new_selected,
    12451221                        &loc_lhs, locmargin, locmat,
    1246                         &curr_nchanged,sol,locv,evidx,use_new_sparsify, &recomp_gap,&threshold,
     1222                        &curr_nchanged,locv,evidx,use_new_sparsify, &recomp_gap,&threshold,
    12471223                        &card_selected, &new_selected,
    12481224                        sparse_v_mat, card_v_mat,
     
    12701246                        &loc_card_selected, &loc_card_new_selected,
    12711247                        &loc_lhs, locmargin, locmat,
    1272                         &curr_nchanged,sol,locv,evidx, use_new_sparsify, &recomp_gap,&threshold,
     1248                        &curr_nchanged,locv,evidx, use_new_sparsify, &recomp_gap,&threshold,
    12731249                        &card_selected, &new_selected,
    12741250                        sparse_v_mat, card_v_mat,
     
    13131289  delete[] order;
    13141290       
    1315   for (i=0; i<n; i++) {
    1316     delete [] mat[i];
    1317     delete [] locmat[i];
    1318   }
    13191291  delete [] mat;
    13201292  delete [] locmat;
  • trunk/Couenne/src/main/BonCouenneSetup.cpp

    r918 r933  
    804804  }
    805805
    806   // Add disjunctive cuts ///////////////////////////////////////////////////////
    807 
    808   options () -> GetIntegerValue ("minlp_disj_cuts", freq, "couenne.");
    809 
    810   if (freq != 0) {
    811 
    812     CouenneDisjCuts * couenneDisj =
    813       new CouenneDisjCuts (ci, this,
    814                            couenneCg,
    815                            branchingMethod_,
    816                            varSelection == OSI_STRONG, // if true, use strong branching candidates
    817                            journalist (),
    818                            options ());
    819 
    820     CuttingMethod cg;
    821     cg.frequency = freq;
    822     cg.cgl = couenneDisj;
    823     cg.id = "Couenne disjunctive cuts";
    824     cutGenerators (). push_back(cg);
    825   }
     806  // // Add disjunctive cuts ///////////////////////////////////////////////////////
     807
     808  // options () -> GetIntegerValue ("minlp_disj_cuts", freq, "couenne.");
     809
     810  // if (freq != 0) {
     811
     812  //   CouenneDisjCuts * couenneDisj =
     813  //     new CouenneDisjCuts (ci, this,
     814  //                       couenneCg,
     815  //                       branchingMethod_,
     816  //                       varSelection == OSI_STRONG, // if true, use strong branching candidates
     817  //                       journalist (),
     818  //                       options ());
     819
     820  //   CuttingMethod cg;
     821  //   cg.frequency = freq;
     822  //   cg.cgl = couenneDisj;
     823  //   cg.id = "Couenne disjunctive cuts";
     824  //   cutGenerators (). push_back(cg);
     825  // }
    826826
    827827  return retval;
Note: See TracChangeset for help on using the changeset viewer.