Loading...
Searching...
No Matches
Cgl012cut.hpp
Go to the documentation of this file.
// $Id$
// Copyright (C) 2010, International Business Machines
// Corporation and others. All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
#ifndef CGL012CUT
#define CGL012CUT
#include <cstdio>
#include <cstdlib>
#include <cmath>
#define CGL_NEW_SHORT
#ifndef CGL_NEW_SHORT
typedef /* arc */
struct arc_st
{
int len; /* length of the arc */
struct node_st *head; /* head node */
}
arc;
typedef /* node */
struct node_st
{
arc *first; /* first outgoing arc */
int dist; /* tentative shortest path length */
struct node_st *parent; /* parent pointer */
struct node_st *next; /* next node in queue */
struct node_st *prev; /* previous node in queue */
int status; /* status of node */
int temp; /* for temporary labels */
int index; /* index of the node in the graph */
} node;
#endif
typedef struct
{
int length; // Length of arc
int to; // To node
} cgl_arc;
typedef struct
{
cgl_arc * firstArc; // First outgoing arc
int parentNode; // Parent node in shortest path
int index; // Which node I am
int distanceBack; // Distance back to source
} cgl_node;
typedef struct
{
int nnodes; // Number of nodes in graph
int narcs; // Number of arcs in graph
cgl_node * nodes;
cgl_arc * arcs;
} cgl_graph;
/* #define PRINT */
/* #define PRINT_CUTS */
#define REDUCTION
typedef struct {
int mr; /* number of rows in the ILP matrix */
int mc; /* number of columns in the ILP matrix */
int mnz; /* number of nonzero's in the ILP matrix */
int *mtbeg; /* starting position of each row in arrays mtind and mtval */
int *mtcnt; /* number of entries of each row in arrays mtind and mtval */
int *mtind; /* column indices of the nonzero entries of the ILP matrix */
int *mtval; /* values of the nonzero entries of the ILP matrix */
int *vlb; /* lower bounds on the variables */
int *vub; /* upper bounds on the variables */
int *mrhs; /* right hand sides of the constraints */
char *msense; /* senses of the constraints: 'L', 'G' or 'E' */
const double *xstar; /* current optimal solution of the LP relaxation */
} ilp;
typedef struct {
int mr; /* number of rows in the parity ILP matrix */
int mc; /* number of columns in the parity ILP matrix */
int mnz; /* number of 1's in the parity ILP matrix */
int *mtbeg; /* starting position of each row in arrays mtind and mtval */
int *mtcnt; /* number of entries of each row in arrays mtind and mtval */
int *mtind; /* column indices of the 1's of the parity ILP matrix */
short int *mrhs; /* right hand side parity of the constraints */
double *xstar; /* current optimal solution of the LP relaxation */
double *slack; /* slack of the constraints w.r.t. xstar */
short int *row_to_delete; /* flag for marking rows not to be considered */
short int *col_to_delete; /* flag for marking columns not to be considered */
int *gcd; /* greatest common divisor of each row in the input ILP matrix */
short int *possible_weak; /* possible weakening types of each column */
short int *type_even_weak; /* type of even weakening of each column
(lower or upper bound weakening) */
short int *type_odd_weak; /* type of odd weakening of each column
(lower or upper bound weakening) */
double *loss_even_weak; /* loss for the even weakening of each column */
double *loss_odd_weak; /* loss for the odd weakening of each column */
double *min_loss_by_weak; /* minimum loss for the weakening of each column */
} parity_ilp;
typedef struct {
int nweak; /* number of variables weakened */
int *var; /* list of variables weakened */
short int *type; /* type of weakening (lower or upper bound weakening) */
} info_weak;
typedef struct {
int endpoint1, endpoint2; /* endpoints of the edge */
double weight; /* edge weight */
short int parity; /* edge parity (even or odd) */
int constr; /* constraint associated with the edge */
info_weak *weak; /* weakening information */
} edge;
typedef struct {
int nnodes; /* number of nodes */
int nedges; /* number of edges */
int *nodes; /* indexes of the ILP columns corresponding to the nodes */
int *ind; /* indexes of the nodes corresponding to the ILP columns */
edge **even_adj_list; /* pointers to the even edges */
edge **odd_adj_list; /* pointers to the odd edges */
} separation_graph;
#ifndef CGL_NEW_SHORT
typedef struct {
int nnodes; /* number of nodes */
int narcs; /* number of arcs */
node *nodes; /* array of the nodes - see "types_db.h" */
arc *arcs; /* array of the arcs - see "types_db.h" */
} auxiliary_graph;
#else
typedef struct {
int nnodes; /* number of nodes */
int narcs; /* number of arcs */
cgl_node *nodes; /* array of the nodes - see "types_db.h" */
cgl_arc *arcs; /* array of the arcs - see "types_db.h" */
} auxiliary_graph;
#endif
typedef struct {
long dist; /* distance from/to root */
int pred; /* index of the predecessor */
} short_path_node;
typedef struct {
double weight; /* overall weight of the cycle */
int length; /* number of edges in the cycle */
edge **edge_list; /* list of edges in the cycle */
} cycle;
typedef struct {
int cnum; /* overall number of cycles */
cycle **list; /* pointers to the cycles in the list */
} cycle_list;
typedef struct {
int n_of_constr; /* number of constraints combined to get the cut */
int *constr_list; /* list of the constraints combined */
short int *in_constr_list; /* flag saying whether a given constraint is
in the list of constraints of the cut (IN)
or not (OUT) */
int cnzcnt; /* overall number of nonzero's in the cut */
int *cind; /* column indices of the nonzero entries of the cut */
int *cval; /* values of the nonzero entries of the cut */
int crhs; /* right hand side of the cut */
char csense; /* sense of the cut: 'L', 'G' or 'E' */
double violation; /* violation of the cut w.r.t. the current LP solution */
} cut;
typedef struct {
int cnum; /* overall number of cuts */
cut **list; /* pointers to the cuts in the list */
} cut_list;
typedef struct {
int n_of_constr; /* number of constraints combined to get the cut */
int *constr_list; /* list of the constraints combined */
int code; /* identifier of the cut */
int n_it_violated; /* number of consecutive iterations (starting from the
last and going backward) in which the cut was
violated by the LP solution */
int it_found; /* iteration in which the cut was separated */
double score; /* score of the cut, used to choose wich cut should be
added to the current LP (if any) */
} pool_cut;
typedef struct {
int cnum; /* overall number of cuts */
pool_cut **list; /* pointers to the cuts in the list */
int *ncod; /* number of cuts with a given code in the pool */
} pool_cut_list;
typedef struct {
int *ccoef; /* coefficients of the cut */
int crhs; /* right hand side of the cut */
int pool_index; /* index of the cut in the pool */
double score; /* cut score (to be maximized) */
} select_cut;
typedef struct {
int n_it_zero; /* number of consecutive iterations (starting from the
last and going backward) in which each variable took
the value 0 in the LP solution */
} log_var;
class Cgl012Cut {
public:
int sep_012_cut(
/*
INPUT parameters:
*/
int mr, /* number of rows in the ILP matrix */
int mc, /* number of columns in the ILP matrix */
int mnz, /* number of nonzero's in the ILP matrix */
int *mtbeg, /* starting position of each row in arrays mtind and mtval */
int *mtcnt, /* number of entries of each row in arrays mtind and mtval */
int *mtind, /* column indices of the nonzero entries of the ILP matrix */
int *mtval, /* values of the nonzero entries of the ILP matrix */
int *vlb, /* lower bounds on the variables */
int *vub, /* upper bounds on the variables */
int *mrhs, /* right hand sides of the constraints */
char *msense, /* senses of the constraints: 'L', 'G' or 'E' */
const double *xstar, /* current optimal solution of the LP relaxation */
bool aggressive, /* flag asking whether as many cuts as possible are
required on output (TRUE) or not (FALSE) */
/*
OUTPUT parameters (the memory for the vectors is allocated INTERNALLY
by the procedure: if some memory is already allocated, it is FREED):
*/
int *cnum, /* number of violated 0-1/2 cuts identified by the procedure */
int *cnzcnt, /* overall number of nonzero's in the cuts */
int **cbeg, /* starting position of each cut in arrays cind and cval */
int **ccnt, /* number of entries of each cut in arrays cind and cval */
int **cind, /* column indices of the nonzero entries of the cuts */
int **cval, /* values of the nonzero entries of the cuts */
int **crhs, /* right hand sides of the cuts */
char **csense /* senses of the cuts: 'L', 'G' or 'E' */
/*
NOTE that all the numerical input/output vectors are INTEGER (with
the exception of xstar), since the procedure is intended to work
with pure ILP's, and that the ILP matrix has to be given on input
in ROW format.
*/
);
void ilp_load(
int mr, /* number of rows in the ILP matrix */
int mc, /* number of columns in the ILP matrix */
int mnz, /* number of nonzero's in the ILP matrix */
int *mtbeg, /* starting position of each row in arrays mtind and mtval */
int *mtcnt, /* number of entries of each row in arrays mtind and mtval */
int *mtind, /* column indices of the nonzero entries of the ILP matrix */
int *mtval, /* values of the nonzero entries of the ILP matrix */
int *vlb, /* lower bounds on the variables */
int *vub, /* upper bounds on the variables */
int *mrhs, /* right hand sides of the constraints */
char *msense /* senses of the constraints: 'L', 'G' or 'E' */
);
void free_ilp();
/* alloc_parity_ilp: allocate the memory for the parity ILP data structure */
void alloc_parity_ilp(
int mr, /* number of rows in the ILP matrix */
int mc, /* number of columns in the ILP matrix */
int mnz /* number of nonzero's in the ILP matrix */
);
void free_parity_ilp();
void initialize_log_var();
/* free_log_var */
void free_log_var();
private:
/* best_weakening: find the best upper/lower bound weakening of a set
of variables */
int best_weakening(
int n_to_weak, /* number of variables to weaken */
int *vars_to_weak, /* indices of the variables to weaken */
short int original_parity, /* original parity of the constraint to weaken */
double original_slack, /* original slack of the constraint to weaken */
double *best_even_slack, /* best possible slack of a weakened constraint
with even right-hand-side */
double *best_odd_slack, /* best possible slack of a weakened constraint
with odd right-hand-side */
info_weak **info_even_weak, /* weakening information about the best possible
even weakened constraint */
info_weak **info_odd_weak, /* weakening information about the best possible
odd weakened constraint */
short int only_odd, /* flag which tells whether only an odd weakening is of
interest (TRUE) or both weakenings are (FALSE) */
short int only_viol /* flag which tells whether only an inequality of
slack smaller than MAX_SLACK is of interest (TRUE)
otherwise (FALSE) */
);
/* best_cut: find the coefficients, the rhs and the violation of the
best possible cut that can be obtained by weakening a given set of
coefficients to even and a rhs to odd, dividing by 2 and rounding */
short int best_cut(
int *ccoef, /* vector of the coefficients */
int *crhs, /* pointer to rhs value */
double *violation, /* violation of the cut */
short int update, /* TRUE/FALSE: if TRUE, the new ccoef and crhs are
given on output */
short int only_viol /* flag which tells whether only an inequality of
slack smaller than MAX_SLACK is of interest (TRUE)
otherwise (FALSE) */
);
/* get_cut: extract a hopefully violated cut from an odd cycle of the
separation graph */
cut *get_cut(
cycle *s_cyc /* shortest odd cycles identified in the separation graph */
);
/* update_log_var: update the log information for the problem variables */
void update_log_var();
/* basic_separation: try to identify violated 0-1/2 cuts by using the
original procedure described in Caprara and Fischetti's MP paper */
cut_list *basic_separation();
/* score_by_moving: compute the score of the best cut obtainable from
the current local search solution by inserting/deleting a constraint */
double score_by_moving(
int i, /* constraint to be moved */
short int itype, /* type of move - ADD or DEL */
double thresh /* minimum value of an interesting score */
);
/* modify_current: update the current local search solution by inserting/
deleting a constraint */
void modify_current(
int i, /* constraint to be moved */
short int itype /* type of move - ADD or DEL */
);
/* best neighbour: find the cut to be added/deleted from the current
solution among those allowed by the tabu rules */
short int best_neighbour(cut_list *out_cuts /* list of the violated cuts found */);
/* add_tight_constraint: initialize the current cut by adding a tight
constraint to it */
void add_tight_constraint();
/* tabu_012: try to identify violated 0-1/2 cuts by a simple tabu search
procedure adapted from that used by Battiti and Protasi for finding
large cliques */
cut_list *tabu_012();
/* initialize: initialize the data structures for local search */
void initialize();
/* restart: perform a restart of the search - IMPORTANT: in the current
implementation vector last_moved is not cleared at restart */
void restart(short int failure /* flag forcing the restart if some trouble occurred */);
void print_constr(int i /* constraint to be printed */);
void print_parity_ilp();
/* get_parity_ilp: construct an internal data structure containing all the
information which can be useful for 0-1/2 cut separation */
void get_parity_ilp();
/* initialize_sep_graph: allocate and initialize the data structure
to contain the information associated with a separation graph */
separation_graph *initialize_sep_graph();
void print_cut(cut *v_cut);
/* get_ori_cut_coef: get the coefficients of a cut, before dividing by 2 and
rounding, starting from the list of the constraints combined to get
the cut */
short int get_ori_cut_coef(
int n_of_constr, /* number of constraints combined */
int *constr_list, /* list of the constraints combined */
int *ccoef, /* cut left hand side coefficients */
int *crhs, /* cut right hand side */
short int only_viol /* flag which tells whether only an inequality of
slack smaller than MAX_SLACK is of interest (TRUE)
otherwise (FALSE) */
);
/* define_cut: construct a cut data structure from a vector of
coefficients and a right-hand-side */
cut *define_cut(
int *ccoef, /* coefficients of the cut */
int crhs /* right hand side of the cut */
);
/* cut_score: define the score of a (violated) cut */
double cut_score(
int *ccoef, /* cut left hand side coefficients */
int crhs, /* cut right hand side */
double viol, /* cut violation */
short int only_viol /* flag which tells whether only an inequality of
slack smaller than MAX_SLACK is of interest (TRUE)
otherwise (FALSE) */
);
/* get_current_cut: return a cut data type with the information about
the current cut of the search procedure */
cut *get_current_cut();
/* print_cur_cut: display cur_cut on output */
void print_cur_cut();
void print_cut_list(cut_list *cuts);
public:
Cgl012Cut ();
Cgl012Cut (
const Cgl012Cut &);
Cgl012Cut &
operator=(
const Cgl012Cut& rhs);
virtual ~Cgl012Cut ();
private:
// Private member methods
ilp *inp_ilp; /* input ILP data structure */
parity_ilp *p_ilp; /* parity ILP data structure */
int iter;
double gap;
double maxgap;
int errorNo;
int sep_iter; /* number of the current separation iteration */
log_var **vlog; /* information about the value attained
by the variables in the last iterations,
used to possibly set to 0 some coefficient
> 0 in a cut to be added */
bool aggr; /* flag saying whether as many cuts as possible are required
from the separation procedure (TRUE) or not (FALSE) */
};
#endif
Cgl012Cut::free_ilp
void free_ilp()
Cgl012Cut::initialize_sep_graph
separation_graph * initialize_sep_graph()
Cgl012Cut::best_weakening
int best_weakening(int n_to_weak, int *vars_to_weak, short int original_parity, double original_slack, double *best_even_slack, double *best_odd_slack, info_weak **info_even_weak, info_weak **info_odd_weak, short int only_odd, short int only_viol)
Cgl012Cut::vlog
log_var ** vlog
Definition Cgl012cut.hpp:456
Cgl012Cut::tabu_012
cut_list * tabu_012()
Cgl012Cut::alloc_parity_ilp
void alloc_parity_ilp(int mr, int mc, int mnz)
Cgl012Cut::get_cut
cut * get_cut(cycle *s_cyc)
Cgl012Cut::score_by_moving
double score_by_moving(int i, short int itype, double thresh)
Cgl012Cut::get_ori_cut_coef
short int get_ori_cut_coef(int n_of_constr, int *constr_list, int *ccoef, int *crhs, short int only_viol)
Cgl012Cut::gap
double gap
Definition Cgl012cut.hpp:452
Cgl012Cut::print_cur_cut
void print_cur_cut()
Cgl012Cut::free_log_var
void free_log_var()
Cgl012Cut::get_current_cut
cut * get_current_cut()
Cgl012Cut::modify_current
void modify_current(int i, short int itype)
Cgl012Cut::initialize_log_var
void initialize_log_var()
Cgl012Cut::aggr
bool aggr
Definition Cgl012cut.hpp:460
Cgl012Cut::print_constr
void print_constr(int i)
Cgl012Cut::print_cut_list
void print_cut_list(cut_list *cuts)
Cgl012Cut::print_parity_ilp
void print_parity_ilp()
Cgl012Cut::add_tight_constraint
void add_tight_constraint()
Cgl012Cut::Cgl012Cut
Cgl012Cut(const Cgl012Cut &)
Copy constructor.
Cgl012Cut::maxgap
double maxgap
Definition Cgl012cut.hpp:453
Cgl012Cut::iter
int iter
Definition Cgl012cut.hpp:451
Cgl012Cut::Cgl012Cut
Cgl012Cut()
Default constructor.
Cgl012Cut::sep_iter
int sep_iter
Definition Cgl012cut.hpp:455
Cgl012Cut::~Cgl012Cut
virtual ~Cgl012Cut()
Destructor.
Cgl012Cut::cut_score
double cut_score(int *ccoef, int crhs, double viol, short int only_viol)
Cgl012Cut::best_neighbour
short int best_neighbour(cut_list *out_cuts)
Cgl012Cut::basic_separation
cut_list * basic_separation()
Cgl012Cut::ilp_load
void ilp_load(int mr, int mc, int mnz, int *mtbeg, int *mtcnt, int *mtind, int *mtval, int *vlb, int *vub, int *mrhs, char *msense)
Cgl012Cut::define_cut
cut * define_cut(int *ccoef, int crhs)
Cgl012Cut::p_ilp
parity_ilp * p_ilp
Definition Cgl012cut.hpp:450
Cgl012Cut::get_parity_ilp
void get_parity_ilp()
Cgl012Cut::print_cut
void print_cut(cut *v_cut)
Cgl012Cut::operator=
Cgl012Cut & operator=(const Cgl012Cut &rhs)
Assignment operator.
Cgl012Cut::sep_012_cut
int sep_012_cut(int mr, int mc, int mnz, int *mtbeg, int *mtcnt, int *mtind, int *mtval, int *vlb, int *vub, int *mrhs, char *msense, const double *xstar, bool aggressive, int *cnum, int *cnzcnt, int **cbeg, int **ccnt, int **cind, int **cval, int **crhs, char **csense)
Cgl012Cut::free_parity_ilp
void free_parity_ilp()
Cgl012Cut::best_cut
short int best_cut(int *ccoef, int *crhs, double *violation, short int update, short int only_viol)
Cgl012Cut::inp_ilp
ilp * inp_ilp
Definition Cgl012cut.hpp:449
Cgl012Cut::errorNo
int errorNo
Definition Cgl012cut.hpp:454
Cgl012Cut::initialize
void initialize()
Cgl012Cut::restart
void restart(short int failure)
Cgl012Cut::update_log_var
void update_log_var()
auxiliary_graph
Definition Cgl012cut.hpp:129
auxiliary_graph::nodes
cgl_node * nodes
Definition Cgl012cut.hpp:132
auxiliary_graph::nnodes
int nnodes
Definition Cgl012cut.hpp:130
auxiliary_graph::arcs
cgl_arc * arcs
Definition Cgl012cut.hpp:133
auxiliary_graph::narcs
int narcs
Definition Cgl012cut.hpp:131
cgl_arc
Definition Cgl012cut.hpp:36
cgl_arc::length
int length
Definition Cgl012cut.hpp:37
cgl_arc::to
int to
Definition Cgl012cut.hpp:38
cgl_graph
Definition Cgl012cut.hpp:50
cgl_graph::nodes
cgl_node * nodes
Definition Cgl012cut.hpp:53
cgl_graph::nnodes
int nnodes
Definition Cgl012cut.hpp:51
cgl_graph::narcs
int narcs
Definition Cgl012cut.hpp:52
cgl_graph::arcs
cgl_arc * arcs
Definition Cgl012cut.hpp:54
cgl_node
Definition Cgl012cut.hpp:42
cgl_node::distanceBack
int distanceBack
Definition Cgl012cut.hpp:46
cgl_node::firstArc
cgl_arc * firstArc
Definition Cgl012cut.hpp:43
cgl_node::parentNode
int parentNode
Definition Cgl012cut.hpp:44
cgl_node::index
int index
Definition Cgl012cut.hpp:45
cut_list
Definition Cgl012cut.hpp:167
cut_list::list
cut ** list
Definition Cgl012cut.hpp:169
cut_list::cnum
int cnum
Definition Cgl012cut.hpp:168
cut
Definition Cgl012cut.hpp:153
cut::csense
char csense
Definition Cgl012cut.hpp:163
cut::constr_list
int * constr_list
Definition Cgl012cut.hpp:155
cut::crhs
int crhs
Definition Cgl012cut.hpp:162
cut::cnzcnt
int cnzcnt
Definition Cgl012cut.hpp:159
cut::cind
int * cind
Definition Cgl012cut.hpp:160
cut::cval
int * cval
Definition Cgl012cut.hpp:161
cut::violation
double violation
Definition Cgl012cut.hpp:164
cut::in_constr_list
short int * in_constr_list
Definition Cgl012cut.hpp:156
cut::n_of_constr
int n_of_constr
Definition Cgl012cut.hpp:154
cycle_list
Definition Cgl012cut.hpp:148
cycle_list::cnum
int cnum
Definition Cgl012cut.hpp:149
cycle_list::list
cycle ** list
Definition Cgl012cut.hpp:150
cycle
Definition Cgl012cut.hpp:142
cycle::length
int length
Definition Cgl012cut.hpp:144
cycle::weight
double weight
Definition Cgl012cut.hpp:143
cycle::edge_list
edge ** edge_list
Definition Cgl012cut.hpp:145
edge
Definition Cgl012cut.hpp:104
edge::constr
int constr
Definition Cgl012cut.hpp:108
edge::parity
short int parity
Definition Cgl012cut.hpp:107
edge::weak
info_weak * weak
Definition Cgl012cut.hpp:109
edge::endpoint2
int endpoint2
Definition Cgl012cut.hpp:105
edge::endpoint1
int endpoint1
Definition Cgl012cut.hpp:105
edge::weight
double weight
Definition Cgl012cut.hpp:106
ilp
Definition Cgl012cut.hpp:60
ilp::mtcnt
int * mtcnt
Definition Cgl012cut.hpp:65
ilp::mtbeg
int * mtbeg
Definition Cgl012cut.hpp:64
ilp::mtval
int * mtval
Definition Cgl012cut.hpp:67
ilp::vlb
int * vlb
Definition Cgl012cut.hpp:68
ilp::mrhs
int * mrhs
Definition Cgl012cut.hpp:70
ilp::mr
int mr
Definition Cgl012cut.hpp:61
ilp::xstar
const double * xstar
Definition Cgl012cut.hpp:72
ilp::mnz
int mnz
Definition Cgl012cut.hpp:63
ilp::vub
int * vub
Definition Cgl012cut.hpp:69
ilp::mc
int mc
Definition Cgl012cut.hpp:62
ilp::mtind
int * mtind
Definition Cgl012cut.hpp:66
ilp::msense
char * msense
Definition Cgl012cut.hpp:71
info_weak
Definition Cgl012cut.hpp:98
info_weak::type
short int * type
Definition Cgl012cut.hpp:101
info_weak::var
int * var
Definition Cgl012cut.hpp:100
info_weak::nweak
int nweak
Definition Cgl012cut.hpp:99
log_var
Definition Cgl012cut.hpp:197
log_var::n_it_zero
int n_it_zero
Definition Cgl012cut.hpp:198
parity_ilp
Definition Cgl012cut.hpp:75
parity_ilp::loss_even_weak
double * loss_even_weak
Definition Cgl012cut.hpp:93
parity_ilp::col_to_delete
short int * col_to_delete
Definition Cgl012cut.hpp:86
parity_ilp::possible_weak
short int * possible_weak
Definition Cgl012cut.hpp:88
parity_ilp::mc
int mc
Definition Cgl012cut.hpp:77
parity_ilp::min_loss_by_weak
double * min_loss_by_weak
Definition Cgl012cut.hpp:95
parity_ilp::slack
double * slack
Definition Cgl012cut.hpp:84
parity_ilp::mtbeg
int * mtbeg
Definition Cgl012cut.hpp:79
parity_ilp::mnz
int mnz
Definition Cgl012cut.hpp:78
parity_ilp::type_even_weak
short int * type_even_weak
Definition Cgl012cut.hpp:89
parity_ilp::mtind
int * mtind
Definition Cgl012cut.hpp:81
parity_ilp::xstar
double * xstar
Definition Cgl012cut.hpp:83
parity_ilp::mrhs
short int * mrhs
Definition Cgl012cut.hpp:82
parity_ilp::mtcnt
int * mtcnt
Definition Cgl012cut.hpp:80
parity_ilp::mr
int mr
Definition Cgl012cut.hpp:76
parity_ilp::loss_odd_weak
double * loss_odd_weak
Definition Cgl012cut.hpp:94
parity_ilp::row_to_delete
short int * row_to_delete
Definition Cgl012cut.hpp:85
parity_ilp::type_odd_weak
short int * type_odd_weak
Definition Cgl012cut.hpp:91
parity_ilp::gcd
int * gcd
Definition Cgl012cut.hpp:87
pool_cut_list
Definition Cgl012cut.hpp:184
pool_cut_list::cnum
int cnum
Definition Cgl012cut.hpp:185
pool_cut_list::list
pool_cut ** list
Definition Cgl012cut.hpp:186
pool_cut_list::ncod
int * ncod
Definition Cgl012cut.hpp:187
pool_cut
Definition Cgl012cut.hpp:172
pool_cut::constr_list
int * constr_list
Definition Cgl012cut.hpp:174
pool_cut::code
int code
Definition Cgl012cut.hpp:175
pool_cut::it_found
int it_found
Definition Cgl012cut.hpp:179
pool_cut::n_it_violated
int n_it_violated
Definition Cgl012cut.hpp:176
pool_cut::n_of_constr
int n_of_constr
Definition Cgl012cut.hpp:173
pool_cut::score
double score
Definition Cgl012cut.hpp:180
select_cut
Definition Cgl012cut.hpp:190
select_cut::crhs
int crhs
Definition Cgl012cut.hpp:192
select_cut::pool_index
int pool_index
Definition Cgl012cut.hpp:193
select_cut::score
double score
Definition Cgl012cut.hpp:194
select_cut::ccoef
int * ccoef
Definition Cgl012cut.hpp:191
separation_graph
Definition Cgl012cut.hpp:112
separation_graph::odd_adj_list
edge ** odd_adj_list
Definition Cgl012cut.hpp:118
separation_graph::nodes
int * nodes
Definition Cgl012cut.hpp:115
separation_graph::ind
int * ind
Definition Cgl012cut.hpp:116
separation_graph::nedges
int nedges
Definition Cgl012cut.hpp:114
separation_graph::even_adj_list
edge ** even_adj_list
Definition Cgl012cut.hpp:117
separation_graph::nnodes
int nnodes
Definition Cgl012cut.hpp:113
short_path_node
Definition Cgl012cut.hpp:137
short_path_node::dist
long dist
Definition Cgl012cut.hpp:138
short_path_node::pred
int pred
Definition Cgl012cut.hpp:139