CglRedSplit2 Class Reference

Reduce-and-Split Cut Generator Class; See method generateCuts(). More...

#include <CglRedSplit2.hpp>

Inheritance diagram for CglRedSplit2:
Inheritance graph
[legend]
Collaboration diagram for CglRedSplit2:
Collaboration graph
[legend]

List of all members.

Public Member Functions

generateCuts



virtual void generateCuts (const OsiSolverInterface &si, OsiCuts &cs, const CglTreeInfo info=CglTreeInfo())
 Generate Reduce-and-Split Mixed Integer Gomory cuts for the model of the solver interface si.
virtual bool needsOptimalBasis () const
 Return true if needs optimal basis to do cuts (will return true).
int generateMultipliers (const OsiSolverInterface &si, int *lambda, int maxNumMultipliers, int *basicVariables=NULL, OsiCuts *cs=NULL)
 Generate Reduce-and-Split Mixed Integer Gomory cuts for the model of the solver interface si.
int tiltLandPcut (const OsiSolverInterface *si, double *row, double rowRhs, int rownumber, const double *xbar, const int *newnonbasics, OsiRowCut *cs, int *lambda=NULL)
 Generate Reduce-and-Split Mixed Integer Gomory cuts for the model of the solver interface si.
Public Methods



void setParam (const CglRedSplit2Param &source)
 Print some of the data members; used for debugging.
CglRedSplit2Param & getParam ()
 Print some of the data members; used for debugging.
void print () const
 Print some of the data members; used for debugging.
void printOptTab (OsiSolverInterface *solver) const
 Print the current simplex tableau.
Constructors and destructors



 CglRedSplit2 ()
 Default constructor.
 CglRedSplit2 (const CglRedSplit2Param &RS_param)
 Constructor with specified parameters.
 CglRedSplit2 (const CglRedSplit2 &)
 Copy constructor.
virtual CglCutGenerator * clone () const
 Clone.
CglRedSplit2 & operator= (const CglRedSplit2 &rhs)
 Assignment operator.
virtual ~CglRedSplit2 ()
 Destructor.

Private Member Functions

Private member methods



int generateCuts (OsiCuts *cs, int maxNumCuts, int *lambda=NULL)
 Compute the fractional part of value, allowing for small error.
double rs_above_integer (const double value) const
 Compute the fractional part of value, allowing for small error.
void fill_workNonBasicTab (CglRedSplit2Param::ColumnSelectionStrategy strategy, const int *ignore_list=NULL)
 Fill workNonBasicTab, depending on the column selection strategy.
void fill_workNonBasicTab (const int *newnonbasics, const double *xbar, CglRedSplit2Param::ColumnScalingStrategy scaling)
 Fill workNonBasicTab, alternate version for Lift & Project: also reduces columns which are now nonbasic but are basic in xbar.
void reduce_workNonBasicTab (int numRows, CglRedSplit2Param::RowSelectionStrategy rowSelectionStrategy, int maxIterations)
 Reduce rows of workNonBasicTab, i.e.
void generate_row (int index_row, double *row)
 Generate a linear combination of the rows of the current LP tableau, using the row multipliers stored in the matrix pi_mat on the row of index index_row.
int generate_cgcut (double *row, double *rhs)
 Generate a mixed integer Gomory cut, when all non basic variables are non negative and at their lower bound.
void eliminate_slacks (double *row, const double *elements, const int *start, const int *indices, const int *rowLength, const double *rhs, double *rowrhs)
 Use multiples of the initial inequalities to cancel out the coefficients of the slack variables.
void flip (double *row)
 Change the sign of the coefficients of the continuous non basic variables at their upper bound.
void unflip (double *row, double *rowrhs)
 Change the sign of the coefficients of the continuous non basic variables at their upper bound and do the translations restoring the original bounds.
int check_dynamism (double *row)
 Returns 1 if the row has acceptable max/min coeff ratio.
int generate_packed_row (const double *xlp, double *row, int *rowind, double *rowelem, int *card_row, double &rhs)
 Generate the packed cut from the row representation.
void compute_is_integer ()
 Compute the fractional part of value, allowing for small error.
bool rs_are_different_vectors (const int *vect1, const int *vect2, const int dim)
 Compute the fractional part of value, allowing for small error.
void rs_allocmatINT (int ***v, int m, int n)
 Compute the fractional part of value, allowing for small error.
void rs_deallocmatINT (int ***v, int m)
 Compute the fractional part of value, allowing for small error.
void rs_allocmatDBL (double ***v, int m, int n)
 Compute the fractional part of value, allowing for small error.
void rs_deallocmatDBL (double ***v, int m)
 Compute the fractional part of value, allowing for small error.
void rs_printvecINT (const char *vecstr, const int *x, int n) const
 Compute the fractional part of value, allowing for small error.
void rs_printvecDBL (const char *vecstr, const double *x, int n) const
 Compute the fractional part of value, allowing for small error.
void rs_printmatINT (const char *vecstr, const int *const *x, int m, int n) const
 Compute the fractional part of value, allowing for small error.
void rs_printmatDBL (const char *vecstr, const double *const *x, int m, int n) const
 Compute the fractional part of value, allowing for small error.
double rs_dotProd (const double *u, const double *v, int dim) const
 Compute the fractional part of value, allowing for small error.
double rs_dotProd (const int *u, const double *v, int dim) const
 Compute the fractional part of value, allowing for small error.
int ludcmp (double **a, int n, int *indx, double *d, double *vv) const
 Compute the fractional part of value, allowing for small error.
void lubksb (double **a, int n, int *indx, double *b) const
 Compute the fractional part of value, allowing for small error.
double compute_norm_change (double oldnorm, const int *listOfRows, int numElemList, const double *multipliers) const
 Compute the fractional part of value, allowing for small error.
int get_list_rows_reduction (int rowIndex, int numRowsReduction, int *list, const double *norm, CglRedSplit2Param::RowSelectionStrategy rowSelectionStrategy) const
 Compute the fractional part of value, allowing for small error.
int sort_rows_by_nonzeroes (struct sortElement *array, int rowIndex, int maxRows, int whichTab) const
 Compute the fractional part of value, allowing for small error.
int sort_rows_by_nonzeroes_greedy (struct sortElement *array, int rowIndex, int maxRows, int whichTab) const
 Compute the fractional part of value, allowing for small error.
int sort_rows_by_cosine (struct sortElement *array, int rowIndex, int maxRows, int whichTab) const
 Compute the fractional part of value, allowing for small error.
bool checkTime () const
 Compute the fractional part of value, allowing for small error.

Private Attributes

Private member data



CglRedSplit2Param param
 Object with CglRedSplit2Param members.
int nrow
 Number of rows ( = number of slack variables) in the current LP.
int ncol
 Number of structural variables in the current LP.
int numRedRows
 Number of rows which have been reduced.
const double * colLower
 Lower bounds for structural variables.
const double * colUpper
 Upper bounds for structural variables.
const double * rowLower
 Lower bounds for constraints.
const double * rowUpper
 Upper bounds for constraints.
const double * rowRhs
 Righ hand side for constraints (upper bound for ranged constraints).
const double * reducedCost
 Reduced costs for columns.
const double * rowPrice
 Row price.
const double * objective
 Objective coefficients.
int card_intBasicVar
 Number of integer basic structural variables.
int card_intBasicVar_frac
 Number of integer basic structural variables that are fractional in the current lp solution (at least param.away_ from being integer).
int card_intNonBasicVar
 Number of integer non basic structural variables in the current lp solution.
int card_contNonBasicVar
 Number of continuous non basic variables (structural or slack) in the current lp solution.
int card_workNonBasicVar
 Number of continuous non basic variables (structural or slack) in the current working set for coefficient reduction.
int card_nonBasicAtUpper
 Number of non basic variables (structural or slack) at their upper bound in the current lp solution.
int card_nonBasicAtLower
 Number of non basic variables (structural or slack) at their lower bound in the current lp solution.
int * cv_intBasicVar
 Characteristic vector for integer basic structural variables.
int * cv_intBasicVar_frac
 Characteristic vector for integer basic structural variables with non integer value in the current lp solution.
int * cv_fracRowsTab
 Characteristic vector for rows of the tableau selected for reduction with non integer value in the current lp solution.
int * intBasicVar
 List of integer structural basic variables (in order of pivot in selected rows for cut generation).
int * intBasicVar_frac
 List of integer structural basic variables with fractional value (in order of pivot in selected rows for cut generation).
int * intNonBasicVar
 List of integer structural non basic variables.
int * contNonBasicVar
 List of continuous non basic variables (structural or slack).
int * nonBasicAtUpper
 List of non basic variables (structural or slack) at their upper bound.
int * nonBasicAtLower
 List of non basic variables (structural or slack) at their lower bound.
int mTab
 Number of rows in the reduced tableau (= card_intBasicVar).
int nTab
 Number of columns in the reduced tableau (= card_contNonBasicVar).
int ** pi_mat
 Tableau of multipliers used to alter the rows used in generation.
double ** contNonBasicTab
 Simplex tableau for continuous non basic variables (structural or slack).
double ** workNonBasicTab
 Current tableau for continuous non basic variables (structural or slack).
double ** intNonBasicTab
 Simplex tableau for integer non basic structural variables.
double * rhsTab
 Right hand side of the tableau.
double * norm
 Norm of rows in workNonBasicTab; needed for faster computations.
int * is_integer
 Characteristic vectors of structural integer variables or continuous variables currently fixed to integer values.
OsiSolverInterface * solver
 Pointer on solver. Reset by each call to generateCuts().
const double * xlp
 Pointer on point to separate. Reset by each call to generateCuts().
const double * rowActivity
 Pointer on row activity. Reset by each call to generateCuts().
const CoinPackedMatrix * byRow
 Pointer on matrix of coefficient ordered by rows.
double startTime
 Time at which cut computations began.

Friends

void CglRedSplit2UnitTest (const OsiSolverInterface *siP, const std::string mpdDir)
 A function that tests some of the methods in the CglRedSplit2 class.

Detailed Description

Reduce-and-Split Cut Generator Class; See method generateCuts().

Based on the papers "Practical strategies for generating rank-1 split cuts in mixed-integer linear programming" by G. Cornuejols and G. Nannicini, published on Mathematical Programming Computation, and "Combining Lift-and-Project and Reduce-and-Split" by E. Balas, G. Cornuejols, T. Kis and G. Nannicini, published on INFORMS Journal on Computing. Part of this code is based on CglRedSplit by F. Margot.

Definition at line 31 of file CglRedSplit2.hpp.

Constructor & Destructor Documentation

CglRedSplit2::CglRedSplit2 (  ) 

Default constructor.

CglRedSplit2::CglRedSplit2 ( const CglRedSplit2Param &  RS_param  ) 

Constructor with specified parameters.

CglRedSplit2::CglRedSplit2 ( const CglRedSplit2 &   ) 

Copy constructor.

virtual CglRedSplit2::~CglRedSplit2 (  )  [virtual]

Destructor.

Member Function Documentation

virtual void CglRedSplit2::generateCuts ( const OsiSolverInterface &  si,
OsiCuts &  cs,
const CglTreeInfo  info = CglTreeInfo() 
) [virtual]

Generate Reduce-and-Split Mixed Integer Gomory cuts for the model of the solver interface si.

Insert the generated cuts into OsiCuts cs.

This generator currently works only with the Lp solvers Clp or Cplex9.0 or higher. It requires access to the optimal tableau and optimal basis inverse and makes assumptions on the way slack variables are added by the solver. The Osi implementations for Clp and Cplex verify these assumptions.

When calling the generator, the solver interface si must contain an optimized problem and information related to the optimal basis must be available through the OsiSolverInterface methods (si->optimalBasisIsAvailable() must return 'true'). It is also essential that the integrality of structural variable i can be obtained using si->isInteger(i).

Reduce-and-Split cuts are a class of split cuts. We compute linear combinations of the rows of the simplex tableau, trying to reduce some of the coefficients on the nonbasic continuous columns. We have a large number of heuristics to choose which coefficients should be reduced, and by using which rows. The paper explains everything in detail.

Note that this generator can potentially generate a huge number of cuts, depending on how it is parametered. Default parameters should be good for most situations; if you want to go heavy on split cuts, use more row selection strategies or a different number of rows in the linear combinations. Again, look at the paper for details. If you want to generate a small number of cuts, default parameters are not the best choice.

A combination of Reduce-and-Split with Lift & Project is described in the paper "Combining Lift-and-Project and Reduce-and-Split". The Reduce-and-Split code for the implementation used in that paper is included here.

This generator does not generate the same cuts as CglRedSplit, therefore both generators can be used in conjunction.

Implements CglCutGenerator.

virtual bool CglRedSplit2::needsOptimalBasis (  )  const [virtual]

Return true if needs optimal basis to do cuts (will return true).

Reimplemented from CglCutGenerator.

int CglRedSplit2::generateMultipliers ( const OsiSolverInterface &  si,
int *  lambda,
int  maxNumMultipliers,
int *  basicVariables = NULL,
OsiCuts *  cs = NULL 
)

Generate Reduce-and-Split Mixed Integer Gomory cuts for the model of the solver interface si.

Insert the generated cuts into OsiCuts cs.

This generator currently works only with the Lp solvers Clp or Cplex9.0 or higher. It requires access to the optimal tableau and optimal basis inverse and makes assumptions on the way slack variables are added by the solver. The Osi implementations for Clp and Cplex verify these assumptions.

When calling the generator, the solver interface si must contain an optimized problem and information related to the optimal basis must be available through the OsiSolverInterface methods (si->optimalBasisIsAvailable() must return 'true'). It is also essential that the integrality of structural variable i can be obtained using si->isInteger(i).

Reduce-and-Split cuts are a class of split cuts. We compute linear combinations of the rows of the simplex tableau, trying to reduce some of the coefficients on the nonbasic continuous columns. We have a large number of heuristics to choose which coefficients should be reduced, and by using which rows. The paper explains everything in detail.

Note that this generator can potentially generate a huge number of cuts, depending on how it is parametered. Default parameters should be good for most situations; if you want to go heavy on split cuts, use more row selection strategies or a different number of rows in the linear combinations. Again, look at the paper for details. If you want to generate a small number of cuts, default parameters are not the best choice.

A combination of Reduce-and-Split with Lift & Project is described in the paper "Combining Lift-and-Project and Reduce-and-Split". The Reduce-and-Split code for the implementation used in that paper is included here.

This generator does not generate the same cuts as CglRedSplit, therefore both generators can be used in conjunction.

int CglRedSplit2::tiltLandPcut ( const OsiSolverInterface *  si,
double *  row,
double  rowRhs,
int  rownumber,
const double *  xbar,
const int *  newnonbasics,
OsiRowCut *  cs,
int *  lambda = NULL 
)

Generate Reduce-and-Split Mixed Integer Gomory cuts for the model of the solver interface si.

Insert the generated cuts into OsiCuts cs.

This generator currently works only with the Lp solvers Clp or Cplex9.0 or higher. It requires access to the optimal tableau and optimal basis inverse and makes assumptions on the way slack variables are added by the solver. The Osi implementations for Clp and Cplex verify these assumptions.

When calling the generator, the solver interface si must contain an optimized problem and information related to the optimal basis must be available through the OsiSolverInterface methods (si->optimalBasisIsAvailable() must return 'true'). It is also essential that the integrality of structural variable i can be obtained using si->isInteger(i).

Reduce-and-Split cuts are a class of split cuts. We compute linear combinations of the rows of the simplex tableau, trying to reduce some of the coefficients on the nonbasic continuous columns. We have a large number of heuristics to choose which coefficients should be reduced, and by using which rows. The paper explains everything in detail.

Note that this generator can potentially generate a huge number of cuts, depending on how it is parametered. Default parameters should be good for most situations; if you want to go heavy on split cuts, use more row selection strategies or a different number of rows in the linear combinations. Again, look at the paper for details. If you want to generate a small number of cuts, default parameters are not the best choice.

A combination of Reduce-and-Split with Lift & Project is described in the paper "Combining Lift-and-Project and Reduce-and-Split". The Reduce-and-Split code for the implementation used in that paper is included here.

This generator does not generate the same cuts as CglRedSplit, therefore both generators can be used in conjunction.

void CglRedSplit2::setParam ( const CglRedSplit2Param &  source  ) 

Print some of the data members; used for debugging.

CglRedSplit2Param& CglRedSplit2::getParam (  )  [inline]

Print some of the data members; used for debugging.

Definition at line 132 of file CglRedSplit2.hpp.

void CglRedSplit2::print (  )  const

Print some of the data members; used for debugging.

void CglRedSplit2::printOptTab ( OsiSolverInterface *  solver  )  const

Print the current simplex tableau.

virtual CglCutGenerator* CglRedSplit2::clone (  )  const [virtual]

Clone.

Implements CglCutGenerator.

CglRedSplit2& CglRedSplit2::operator= ( const CglRedSplit2 &  rhs  ) 

Assignment operator.

Reimplemented from CglCutGenerator.

int CglRedSplit2::generateCuts ( OsiCuts *  cs,
int  maxNumCuts,
int *  lambda = NULL 
) [private]

Compute the fractional part of value, allowing for small error.

double CglRedSplit2::rs_above_integer ( const double  value  )  const [inline, private]

Compute the fractional part of value, allowing for small error.

void CglRedSplit2::fill_workNonBasicTab ( CglRedSplit2Param::ColumnSelectionStrategy  strategy,
const int *  ignore_list = NULL 
) [private]

Fill workNonBasicTab, depending on the column selection strategy.

Accepts a list of variables indices that should be ignored; by default, this list is empty (it is only used by Lift & Project). The list ignore_list contains -1 as the last element. Note that the implementation of the ignore_list is not very efficient if the list is long, so it should be used only if its short.

void CglRedSplit2::fill_workNonBasicTab ( const int *  newnonbasics,
const double *  xbar,
CglRedSplit2Param::ColumnScalingStrategy  scaling 
) [private]

Fill workNonBasicTab, alternate version for Lift & Project: also reduces columns which are now nonbasic but are basic in xbar.

This function should be called only when CglRedSplit2 is used in conjunction with CglLandP to generate L&P+RS cuts.

void CglRedSplit2::reduce_workNonBasicTab ( int  numRows,
CglRedSplit2Param::RowSelectionStrategy  rowSelectionStrategy,
int  maxIterations 
) [private]

Reduce rows of workNonBasicTab, i.e.

compute integral linear combinations of the rows in order to reduce row coefficients on workNonBasicTab

void CglRedSplit2::generate_row ( int  index_row,
double *  row 
) [private]

Generate a linear combination of the rows of the current LP tableau, using the row multipliers stored in the matrix pi_mat on the row of index index_row.

int CglRedSplit2::generate_cgcut ( double *  row,
double *  rhs 
) [private]

Generate a mixed integer Gomory cut, when all non basic variables are non negative and at their lower bound.

void CglRedSplit2::eliminate_slacks ( double *  row,
const double *  elements,
const int *  start,
const int *  indices,
const int *  rowLength,
const double *  rhs,
double *  rowrhs 
) [private]

Use multiples of the initial inequalities to cancel out the coefficients of the slack variables.

void CglRedSplit2::flip ( double *  row  )  [private]

Change the sign of the coefficients of the continuous non basic variables at their upper bound.

void CglRedSplit2::unflip ( double *  row,
double *  rowrhs 
) [private]

Change the sign of the coefficients of the continuous non basic variables at their upper bound and do the translations restoring the original bounds.

Modify the right hand side accordingly.

int CglRedSplit2::check_dynamism ( double *  row  )  [private]

Returns 1 if the row has acceptable max/min coeff ratio.

Compute max_coeff: maximum absolute value of the coefficients. Compute min_coeff: minimum absolute value of the coefficients larger than EPS_COEFF. Return 0 if max_coeff/min_coeff > MAXDYN.

int CglRedSplit2::generate_packed_row ( const double *  xlp,
double *  row,
int *  rowind,
double *  rowelem,
int *  card_row,
double &  rhs 
) [private]

Generate the packed cut from the row representation.

void CglRedSplit2::compute_is_integer (  )  [private]

Compute the fractional part of value, allowing for small error.

bool CglRedSplit2::rs_are_different_vectors ( const int *  vect1,
const int *  vect2,
const int  dim 
) [private]

Compute the fractional part of value, allowing for small error.

void CglRedSplit2::rs_allocmatINT ( int ***  v,
int  m,
int  n 
) [private]

Compute the fractional part of value, allowing for small error.

void CglRedSplit2::rs_deallocmatINT ( int ***  v,
int  m 
) [private]

Compute the fractional part of value, allowing for small error.

void CglRedSplit2::rs_allocmatDBL ( double ***  v,
int  m,
int  n 
) [private]

Compute the fractional part of value, allowing for small error.

void CglRedSplit2::rs_deallocmatDBL ( double ***  v,
int  m 
) [private]

Compute the fractional part of value, allowing for small error.

void CglRedSplit2::rs_printvecINT ( const char *  vecstr,
const int *  x,
int  n 
) const [private]

Compute the fractional part of value, allowing for small error.

void CglRedSplit2::rs_printvecDBL ( const char *  vecstr,
const double *  x,
int  n 
) const [private]

Compute the fractional part of value, allowing for small error.

void CglRedSplit2::rs_printmatINT ( const char *  vecstr,
const int *const *  x,
int  m,
int  n 
) const [private]

Compute the fractional part of value, allowing for small error.

void CglRedSplit2::rs_printmatDBL ( const char *  vecstr,
const double *const *  x,
int  m,
int  n 
) const [private]

Compute the fractional part of value, allowing for small error.

double CglRedSplit2::rs_dotProd ( const double *  u,
const double *  v,
int  dim 
) const [private]

Compute the fractional part of value, allowing for small error.

double CglRedSplit2::rs_dotProd ( const int *  u,
const double *  v,
int  dim 
) const [private]

Compute the fractional part of value, allowing for small error.

int CglRedSplit2::ludcmp ( double **  a,
int  n,
int *  indx,
double *  d,
double *  vv 
) const [private]

Compute the fractional part of value, allowing for small error.

void CglRedSplit2::lubksb ( double **  a,
int  n,
int *  indx,
double *  b 
) const [private]

Compute the fractional part of value, allowing for small error.

double CglRedSplit2::compute_norm_change ( double  oldnorm,
const int *  listOfRows,
int  numElemList,
const double *  multipliers 
) const [private]

Compute the fractional part of value, allowing for small error.

int CglRedSplit2::get_list_rows_reduction ( int  rowIndex,
int  numRowsReduction,
int *  list,
const double *  norm,
CglRedSplit2Param::RowSelectionStrategy  rowSelectionStrategy 
) const [private]

Compute the fractional part of value, allowing for small error.

int CglRedSplit2::sort_rows_by_nonzeroes ( struct sortElement *  array,
int  rowIndex,
int  maxRows,
int  whichTab 
) const [private]

Compute the fractional part of value, allowing for small error.

int CglRedSplit2::sort_rows_by_nonzeroes_greedy ( struct sortElement *  array,
int  rowIndex,
int  maxRows,
int  whichTab 
) const [private]

Compute the fractional part of value, allowing for small error.

int CglRedSplit2::sort_rows_by_cosine ( struct sortElement *  array,
int  rowIndex,
int  maxRows,
int  whichTab 
) const [private]

Compute the fractional part of value, allowing for small error.

bool CglRedSplit2::checkTime (  )  const [inline, private]

Compute the fractional part of value, allowing for small error.

Definition at line 314 of file CglRedSplit2.hpp.

Friends And Related Function Documentation

void CglRedSplit2UnitTest ( const OsiSolverInterface *  siP,
const std::string  mpdDir 
) [friend]

A function that tests some of the methods in the CglRedSplit2 class.

The only reason for it not to be a member method is that this way it doesn't have to be compiled into the library. And that's a gain, because the library should be compiled with optimization on, but this method should be compiled with debugging.

Member Data Documentation

CglRedSplit2Param CglRedSplit2::param [private]

Object with CglRedSplit2Param members.

Definition at line 331 of file CglRedSplit2.hpp.

int CglRedSplit2::nrow [private]

Number of rows ( = number of slack variables) in the current LP.

Definition at line 334 of file CglRedSplit2.hpp.

int CglRedSplit2::ncol [private]

Number of structural variables in the current LP.

Definition at line 337 of file CglRedSplit2.hpp.

int CglRedSplit2::numRedRows [private]

Number of rows which have been reduced.

Definition at line 340 of file CglRedSplit2.hpp.

const double* CglRedSplit2::colLower [private]

Lower bounds for structural variables.

Definition at line 343 of file CglRedSplit2.hpp.

const double* CglRedSplit2::colUpper [private]

Upper bounds for structural variables.

Definition at line 346 of file CglRedSplit2.hpp.

const double* CglRedSplit2::rowLower [private]

Lower bounds for constraints.

Definition at line 349 of file CglRedSplit2.hpp.

const double* CglRedSplit2::rowUpper [private]

Upper bounds for constraints.

Definition at line 352 of file CglRedSplit2.hpp.

const double* CglRedSplit2::rowRhs [private]

Righ hand side for constraints (upper bound for ranged constraints).

Definition at line 355 of file CglRedSplit2.hpp.

const double* CglRedSplit2::reducedCost [private]

Reduced costs for columns.

Definition at line 358 of file CglRedSplit2.hpp.

const double* CglRedSplit2::rowPrice [private]

Row price.

Definition at line 361 of file CglRedSplit2.hpp.

const double* CglRedSplit2::objective [private]

Objective coefficients.

Definition at line 364 of file CglRedSplit2.hpp.

int CglRedSplit2::card_intBasicVar [private]

Number of integer basic structural variables.

Definition at line 367 of file CglRedSplit2.hpp.

int CglRedSplit2::card_intBasicVar_frac [private]

Number of integer basic structural variables that are fractional in the current lp solution (at least param.away_ from being integer).

Definition at line 371 of file CglRedSplit2.hpp.

int CglRedSplit2::card_intNonBasicVar [private]

Number of integer non basic structural variables in the current lp solution.

Definition at line 375 of file CglRedSplit2.hpp.

int CglRedSplit2::card_contNonBasicVar [private]

Number of continuous non basic variables (structural or slack) in the current lp solution.

Definition at line 379 of file CglRedSplit2.hpp.

int CglRedSplit2::card_workNonBasicVar [private]

Number of continuous non basic variables (structural or slack) in the current working set for coefficient reduction.

Definition at line 383 of file CglRedSplit2.hpp.

int CglRedSplit2::card_nonBasicAtUpper [private]

Number of non basic variables (structural or slack) at their upper bound in the current lp solution.

Definition at line 387 of file CglRedSplit2.hpp.

int CglRedSplit2::card_nonBasicAtLower [private]

Number of non basic variables (structural or slack) at their lower bound in the current lp solution.

Definition at line 391 of file CglRedSplit2.hpp.

int* CglRedSplit2::cv_intBasicVar [private]

Characteristic vector for integer basic structural variables.

Definition at line 394 of file CglRedSplit2.hpp.

int* CglRedSplit2::cv_intBasicVar_frac [private]

Characteristic vector for integer basic structural variables with non integer value in the current lp solution.

Definition at line 398 of file CglRedSplit2.hpp.

int* CglRedSplit2::cv_fracRowsTab [private]

Characteristic vector for rows of the tableau selected for reduction with non integer value in the current lp solution.

Definition at line 402 of file CglRedSplit2.hpp.

int* CglRedSplit2::intBasicVar [private]

List of integer structural basic variables (in order of pivot in selected rows for cut generation).

Definition at line 406 of file CglRedSplit2.hpp.

int* CglRedSplit2::intBasicVar_frac [private]

List of integer structural basic variables with fractional value (in order of pivot in selected rows for cut generation).

Definition at line 410 of file CglRedSplit2.hpp.

int* CglRedSplit2::intNonBasicVar [private]

List of integer structural non basic variables.

Definition at line 413 of file CglRedSplit2.hpp.

int* CglRedSplit2::contNonBasicVar [private]

List of continuous non basic variables (structural or slack).

Definition at line 417 of file CglRedSplit2.hpp.

int* CglRedSplit2::nonBasicAtUpper [private]

List of non basic variables (structural or slack) at their upper bound.

Definition at line 421 of file CglRedSplit2.hpp.

int* CglRedSplit2::nonBasicAtLower [private]

List of non basic variables (structural or slack) at their lower bound.

Definition at line 425 of file CglRedSplit2.hpp.

int CglRedSplit2::mTab [private]

Number of rows in the reduced tableau (= card_intBasicVar).

Definition at line 428 of file CglRedSplit2.hpp.

int CglRedSplit2::nTab [private]

Number of columns in the reduced tableau (= card_contNonBasicVar).

Definition at line 431 of file CglRedSplit2.hpp.

int** CglRedSplit2::pi_mat [private]

Tableau of multipliers used to alter the rows used in generation.

Dimensions: mTab by mTab. Initially, pi_mat is the identity matrix.

Definition at line 435 of file CglRedSplit2.hpp.

double** CglRedSplit2::contNonBasicTab [private]

Simplex tableau for continuous non basic variables (structural or slack).

Only rows used for generation. Dimensions: mTab by card_contNonBasicVar.

Definition at line 440 of file CglRedSplit2.hpp.

double** CglRedSplit2::workNonBasicTab [private]

Current tableau for continuous non basic variables (structural or slack).

Only columns used for coefficient reduction. Dimensions: mTab by card_workNonBasicVar.

Definition at line 445 of file CglRedSplit2.hpp.

double** CglRedSplit2::intNonBasicTab [private]

Simplex tableau for integer non basic structural variables.

Only rows used for generation.

Definition at line 450 of file CglRedSplit2.hpp.

double* CglRedSplit2::rhsTab [private]

Right hand side of the tableau.

Only rows used for generation.

Definition at line 454 of file CglRedSplit2.hpp.

double* CglRedSplit2::norm [private]

Norm of rows in workNonBasicTab; needed for faster computations.

Definition at line 457 of file CglRedSplit2.hpp.

int* CglRedSplit2::is_integer [private]

Characteristic vectors of structural integer variables or continuous variables currently fixed to integer values.

Definition at line 461 of file CglRedSplit2.hpp.

OsiSolverInterface* CglRedSplit2::solver [private]

Pointer on solver. Reset by each call to generateCuts().

Definition at line 464 of file CglRedSplit2.hpp.

const double* CglRedSplit2::xlp [private]

Pointer on point to separate. Reset by each call to generateCuts().

Definition at line 467 of file CglRedSplit2.hpp.

const double* CglRedSplit2::rowActivity [private]

Pointer on row activity. Reset by each call to generateCuts().

Definition at line 470 of file CglRedSplit2.hpp.

const CoinPackedMatrix* CglRedSplit2::byRow [private]

Pointer on matrix of coefficient ordered by rows.

Reset by each call to generateCuts().

Definition at line 474 of file CglRedSplit2.hpp.

double CglRedSplit2::startTime [private]

Time at which cut computations began.

Reset by each call to generateCuts().

Definition at line 478 of file CglRedSplit2.hpp.

The documentation for this class was generated from the following file:
Generated on 10 Feb 2015 by  doxygen 1.6.1