# CglRedSplit2 Class Reference

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

`#include <CglRedSplit2.hpp>`

Inheritance diagram for CglRedSplit2:
[legend]
Collaboration diagram for CglRedSplit2:
[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:

- /home/coin/svn-release/Alps-1.4.8/Cgl/src/CglRedSplit2/CglRedSplit2.hpp