mt_cplex_cbk.h

Go to the documentation of this file.

/* MTgomory "multi tableau gomory cut" provides an implementation for gomory
 * cuts derived from multiple tableau rows in the spirit of the work of
 * Andersen et al (IPCO 2007), Cornuejols (es presented in George Nemhauser
 * Birthday Conference in Atlanta 2007) and Gomory (presented in the same
 * conference).
 *
 * Copyright (C) 2007 Daniel Espinoza.
 * 
 * This library is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by the
 * Free Software Foundation; either version 2.1 of the License, or (at your
 * option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public 
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA 
 * */
/* ========================================================================= */
#ifndef __MT_CPLEX_CBK_H__
#define __MT_CPLEX_CBK_H__
#include "cplex.h"
#include "EGlib.h"
#include "mt_types.h"
#include "mt_cutpool.h"
/** @file 
 * @ingroup MTgomory */
/** @addtogroup MTgomory */
/** @{ */
/* ========================================================================= */
/** @brief Minimum violation for a cut to be added. Note that we scale the cut
 * in such a way that the maximum absolute value of a non-zero coefficient is
 * one. */
#define MT_CCBK_MIN_VIO 0x1p-10
/* ========================================================================= */
/** @brief Minimum fractionality required for a tableau to be considered, i.e.
 * if abs(x-round(x))< min_frac we discard the asociated tableau */
#define MT_CCBK_MIN_FRAC 0x1p-12
/* ========================================================================= */
/** @brief Maximum allowed cut ratio. The cut ratio is defined as the ratio 
 * between the maximum absolute value and minimum absolute value for the 
 * non-zero coefficients. It is importatn because is a measure of the error 
 * inducing capabilities of the inequality */
#define MT_CCBK_MAX_RATIO 0x1p15
/* ========================================================================= */
/** @brief Minimum tableau row ratio. This is defined as minabsval/maxabsval
 * for a tableau row. Tableau rows that have a ratio bellow the given threshold
 * will not be considered at the moment of cut genweration */
#define MT_CCBK_MIN_TABLEAU_RATIO 0x1p-12
/* ========================================================================= */
/** @brief internal error string for cplex */
extern char __mt_cplex_errbuf[4096];

/* ========================================================================= */
/** @brief if se to one, use real variable names while displaying cut/tableau
 * information */
#define MT_CCBK_USE_NAMES 1
/* ========================================================================= */
/** @brief internal debugging information for CPLEX
 * @param __rval cplex return value (zero means success)
 * @param env as returned by CPXopenCPLEX function.
 * @param where to jump if an error is found. 
 * */
#define MTcplexCHECKRVALG(__env,__rval,__where) do{\
  if(__rval)\
  {\
    CPXgeterrorstring(__env, __rval, __mt_cplex_errbuf);\
    fprintf(stderr,__mt_cplex_errbuf);\
    __EG_PRINTLOC__;\
    goto __where;\
  }\
}while(0)
/* ========================================================================= */
/** @brief display a compress tableau into the given file 
 * @param file where to write the tableau.
 * @param lp all LP-related information (including length of the tableau)
 * @param matval values of the compresed tableau
 * @param matind indices of the non-zeros in the tableau
 * @param length of the compresed tableau
 * @note The function support compressed tableau with logical variables
 * @note Also, the function would prefix a ~ for all variables that are at its
 * upper bound.
 * */
void MTcplex_display_compress_tableau(FILE* file,
                                      const MTlp_t*const lp,
                                      const double*const matval,
                                      const int*const matind,
                                      const int nz);
/* ========================================================================= */
/** @brief display a tableau into the given file
 * @param file where to write the tableau.
 * @param lp all LP-related information (including length of the tableau)
 * @param tableau actual values of the tableau.
 * */
void MTcplex_display_tableau( FILE* file,
                              const MTlp_t*const lp, 
                              const double*const tableau);
/* ========================================================================= */
/** @brief initialize an #MTlp_t structure 
 * @param __lp pointer to an #MTlp_t structure.
 * */
#define MTlp_init(__lp) memset((__lp),0,sizeof(MTlp_t))
/* ========================================================================= */
/** @brief free any internally allocated memory inside an #MTlp_t structure. 
 * @param MTlp pointer to an #MTlp_t structure.
 * */
void MTlp_clear(MTlp_t*const MTlp);
/* ========================================================================= */
/** @brief Given an LP problem pointer, load it into an 
 * (initialized) #MTlp_t structure.
 * @param lp pointer to an #MTlp_t structure.
 * @param CPXlp pointer to a CPLEX LP problem 
 * @param env as returned by CPXopenCPLEX function.
 * @param cbdata A pointer passed from the optimization routine to the
 * user-written callback that identifies the problem being optimized. The only 
 * purpose of this pointer is to pass it to the callback information routines.
 * @param wherefrom An integer value indicating where in the optimization this
 * function was called. It has the value CPX_CALLBACK_MIP_CUT.
 * @return zero on success.
 * */ 
int MTlp_load_problem(CPXCENVptr env, 
                      MTlp_t*const lp, 
                      CPXLPptr CPXlp, 
                      void*cbdata, 
                      int wherefrom);
/* ========================================================================= */
/** @brief Initialize an #MTrowmatrix_t structure too an empty matrix
 * @param __mt matrix to initialize */
#define MTrowmatrix_init(__mt) memset((__mt),0,sizeof(MTrowmatrix_t))
/* ========================================================================= */
/** @brief resize a #MTrowmatrix_t structure
 * @param MTrm rowmatrix to resize
 * @param MTrsz new row-space (it will only grow).
 * @param MTnsz new non-zero space (it will only grow).
 * */
void MTrowmatrix_rsz(MTrowmatrix_t*const MTrm,
              const int MTrsz,
              const int MTnsz);
/* ========================================================================= */
/** @brief free any internally allocated memory inside an #MTrowmatrix_t
 * structure.
 * @param MTrm rowmatrix to clear */
void MTrowmatrix_clear(MTrowmatrix_t*const MTrm);
/* ========================================================================= */
/** @brief initialize a #MTsol_t structure */
#define MTsol_init(__sol) memset(__sol,0,sizeof(MTsol_t))
/* ========================================================================= */
/** @brief resize a solution structure 
 * @param MTsol solution to resize
 * @param cnz new column space
 * @param rnz new row space
 * */
void MTsol_rsz( MTsol_t*const MTsol,
                const int cnz,
                const int rnz);
/* ========================================================================= */
/** @brief clear any internal memory asociated with an #MTsol_t structure 
 * @param MTsol structure to clear */
void MTsol_clear(MTsol_t*const MTsol);
/* ========================================================================= */
/** @name #MTccbk_info_t set/get functions */
/*@{*/
#define MTcbkiSetCutsAtRoot(__cbki,__val) ((__cbki)->root_only=(__val))
#define MTcbkiSetCuts(__cbki,__val) ((__cbki)->use_cuts=(__val))
#define MTcbkiSetMaxRows(__cbki,__val) ((__cbki)->max_rows=(__val))
#define MTcbkiSetMaxNodeCuts(__cbki,__val) ((__cbki)->max_cuts=(size_t)(__val))
#define MTcbkiSetMaxRoundCuts(__cbki,__val) ((__cbki)->max_cpr=(__val))
#define MTcbkiSetCutStyle(__cbki,__val) ((__cbki)->cut_style=(__val))
/*@}*/
/* ========================================================================= */
/** @brief initialize an #MTccbk_info_t structure */
#define MTccbk_info_init(__cbinf) memset(__cbinf,0,sizeof(MTccbk_info_t))
/* ========================================================================= */
/** @brief display callback info */
void MTccbk_info_display(const MTccbk_info_t*const info,FILE*out);
/* ========================================================================= */
/** @brief test if we should proceed with the cuting process, and update
 * information
 * @param info calllback info to use.
 * @param env as returned by CPXopenCPLEX function.
 * @param cbdata A pointer passed from the optimization routine to the
 * user-written callback that identifies the problem being optimized. The only 
 * purpose of this pointer is to pass it to the callback information routines.
 * @param wherefrom An integer value indicating where in the optimization this
 * function was called. It has the value CPX_CALLBACK_MIP_CUT.
 * @param action pointer to an integer where we return action, zero to
 * continue cutting, non-zero to stop. 
 * @return zero on succsess, non-zero otherwise. */ 
int MTccbk_info_process(MTccbk_info_t*const info,
                        CPXCENVptr env,
                        void*cbdata,
                        int wherefrom,
                        int*const action);
/* ========================================================================= */
/** @name Profiling information for the cuts */
/*@{*/
/* @brief number of tableau rows discarded because they have a small ratio
 * between minabs and maxabs, thus possible inducing bad numericall issues */
extern int MTccbk_fail_tableau_ratio;
/** @brief Number of discarded cuts because tableaus has wrong number
 * of basic variables. */
extern int MTccbk_fail_tableau_nbasic;
/** @brief Number of discarded cuts because tableaus has wrong coefficient for
 * basic variable. */
extern int MTccbk_fail_tableau_coeff;
/** @brief Number of discarded cuts because fraction is too small. */
extern int MTccbk_fail_tableau_frac;
/** @brief Type of basic variable for tableau is not integer */
extern int MTccbk_fail_tableau_btype;
/** @brief Number of discarded cuts because high ratio */
extern int MTccbk_fail_ratio;
/** @brief minimum ratio of discarded inequality */
extern double MTccbk_discarded_ratio;
/** @brief Number of discarded cuts because low violation */
extern int MTccbk_fail_violation;
/** @brief maximum violation of discarded inequality */
extern double MTccbk_discarded_violation;
/** @brief display summary information for the call-back calls 
 * @param __fout where to write the sumary */
#define MTccbk_display_sumary(__fout) do{\
  fprintf(__fout,"MTccbk sumary:\n");\
  fprintf(__fout,"\tDiscarded tableau rows: %4d (coeff %d, nbasic %d,"\
          " ratio %d, type %d, fraction %d)\n", MTccbk_fail_tableau_nbasic + \
          MTccbk_fail_tableau_coeff + MTccbk_fail_tableau_ratio + \
          MTccbk_fail_tableau_btype + MTccbk_fail_tableau_frac,\
          MTccbk_fail_tableau_coeff, MTccbk_fail_tableau_nbasic, \
          MTccbk_fail_tableau_ratio, MTccbk_fail_tableau_btype, \
          MTccbk_fail_tableau_frac);\
  fprintf(__fout,"\tDiscarded by ratio:     %4d (next %.5lg)\n",\
          MTccbk_fail_ratio, MTccbk_discarded_ratio);\
  fprintf(__fout,"\tDiscarded by violation: %4d (next %.5lg)\n",\
          MTccbk_fail_violation, MTccbk_discarded_violation);\
  }while(0)
/*@}*/
/* ========================================================================= */
/** @name #MTgomory_ccbk_t set/get functions */
/*@{*/
#define MTccbkSetCutDominance(__cbdata,__val) MTcutHeapSetDominance((&((__cbdata)->cuth)),__val)
#define MTccbkSetCutSel(__cbdata,__val) MTcutHeapSetCS((&((__cbdata)->cuth)),__val)
#define MTccbkSetCutsAtRoot(__cbdata,__val)  MTcbkiSetCutsAtRoot((&((__cbdata)->info)),__val) 
#define MTccbkSetCuts(__cbdata,__val)  MTcbkiSetCuts((&((__cbdata)->info)),__val) 
#define MTccbkSetCutStyle(__cbdata,__val)  MTcbkiSetCutStyle((&((__cbdata)->info)),__val) 
#define MTccbkSetMaxRows(__cbdata,__val)  MTcbkiSetMaxRows((&((__cbdata)->info)),__val)
#define MTccbkSetMaxNodeCuts(__cbdata,__val)  MTcbkiSetMaxNodeCuts((&((__cbdata)->info)),__val)
#define MTccbkSetMaxRoundCuts(__cbdata,__val) do{\
  MTgomory_ccbk_t*const __MTcbdata = (__cbdata);\
  MTcbkiSetMaxRoundCuts((&(__MTcbdata->info)),__val);\
  MTcutHeapClear(&(__MTcbdata->cuth));\
  MTcutHeapInit(&(__MTcbdata->cuth),((size_t)(__MTcbdata->info.max_cpr)));}while(0)
/*@}*/
/* ========================================================================= */
/** @brief initialize an #MTgomory_ccbk_t structure.
 * @param __cbdata pointer to an #MTgomory_ccbk_t structure.
 * */
#define MTgomory_ccbk_init(__cbdata) do{\
  MTgomory_ccbk_t*const __MTcbdata = (__cbdata);\
  memset((__MTcbdata),0,sizeof(MTgomory_ccbk_t));\
  MTccbk_info_init(&(__MTcbdata->info));\
  MTsol_init(&(__MTcbdata->sol));\
  MTcut_init(&(__MTcbdata->cut));\
  MTrowmatrix_init(&(__MTcbdata->tb));\
  MTcutHeapInit(&(__MTcbdata->cuth),((size_t)(__MTcbdata->info.max_cpr)));\
  MTlp_init(&(__MTcbdata->lp));}while(0)
/* ========================================================================= */
/** @brief if required (i.e. __nrowsz > nrowsz || __ncolsz > colsz || 
 * __ntbsz > tbsz) , resize an #MTgomory_ccbk_t structure
 * @param __cbdata pointer to an #MTgomory_ccbk_t structure.
 * @param __nrowsz new row-size for the structure.
 * @param __ncolsz new col-size for the structure.
 * @param __ntbsz new tableau-size for the structure.
 * @note When we resize the structure, all previous contents are lost. 
 * */
#define MTgomory_ccbk_rsz(__cbdata,__nrowsz,__ncolsz,__ntbsz) do{\
  MTgomory_ccbk_t*const __ccbk = (__cbdata);\
  const int __ccbk_rsz = (__nrowsz);\
  const int __ccbk_csz = (__ncolsz);\
  const int __ccbk_tsz = (__ntbsz);\
  MTrowmatrix_rsz(&(__ccbk->tb),__ccbk_rsz,__ccbk_tsz);\
  MTsol_rsz(&(__ccbk->sol),__ccbk_csz,__ccbk_rsz);\
  MTcut_rsz(&(__ccbk->cut),__ccbk_csz);\
  if(__ccbk->colsz < __ccbk_csz){\
    __ccbk->colsz = __ccbk_csz;\
    EGfree(__ccbk->work);\
    EGfree(__ccbk->extcut);\
    __ccbk->work = EGsMalloc(double,(__ccbk_csz+1));\
    __ccbk->extcut = EGsMalloc(double,__ccbk_csz);}\
  if(__ccbk->rowsz < __ccbk_rsz){\
    __ccbk->rowsz = __ccbk_rsz;\
    EGfree(__ccbk->base);\
    EGfree(__ccbk->f);\
    __ccbk->base = EGsMalloc(double,__ccbk_rsz);\
    __ccbk->f = EGsMalloc(double,__ccbk_rsz);}\
  }while(0)
/* ========================================================================= */
/** @brief free any internally allocated memory inside an #MTgomory_ccbk_t
 * structure. 
 * @param __cbdata pointer to an #MTgomory_ccbk_t structure.
 * */
#define MTgomory_ccbk_clear(__cbdata) do{\
  MTgomory_ccbk_t*const __ccbk = (__cbdata);\
  EGfree(__ccbk->work);\
  EGfree(__ccbk->extcut);\
  EGfree(__ccbk->base);\
  EGfree(__ccbk->f);\
  __ccbk->rowsz = __ccbk->colsz = 0;\
  MTsol_clear(&(__ccbk->sol));\
  MTcut_clear(&(__ccbk->cut));\
  MTrowmatrix_clear(&(__ccbk->tb));\
  MTcutHeapClear(&(__ccbk->cuth));\
  MTlp_clear(&(__ccbk->lp));}while(0)
/* ========================================================================= */
/** @brief Interface for the CPLEX-callback for the #MTgomoryCut function.
 * @param env as returned by CPXopenCPLEX function.
 * @param cbdata A pointer passed from the optimization routine to the
 * user-written callback that identifies the problem being optimized. The only 
 * purpose of this pointer is to pass it to the callback information routines.
 * @param wherefrom An integer value indicating where in the optimization this
 * function was called. It has the value CPX_CALLBACK_MIP_CUT.
 * @param cbhandle A pointer to user private data.
 * @param useraction_p A pointer to an integer indicating the action for ILOG
 * CPLEX to take at the completion
 * of the user callback. The table summarizes possible actions.
 * - 0 CPX_CALLBACK_DEFAULT Use cuts as added
 * - 1 CPX_CALLBACK_FAIL Exit optimization
 * - 2 CPX_CALLBACK_SET Use cuts as added
 * */
int MTgomory_ccbk(CPXCENVptr env,
                  void*cbdata,
                  int wherefrom,
                  void*cbhandle,
                  int*useraction_p);
/* ========================================================================= */
/** @brief read optionfile and set parameter to CPLEX
 * @param env pointer to the CPLEX environment structure.
 * @param inputfile pointer to the optionfile.*/
int MTread_cplex_options(CPXENVptr env, FILE * inputfile);
/* ========================================================================= */
/** @brief given an LP desvription, and CPLEX binvrow, compute the 
 * actual tableau (including logicals, which are in position i+ncols of
 * the tableau for the i-th logical/slack variable, but we force that
 * the coefficient of equality logicals is zero)
 * @param lp pointer to an #MTlp_t structure.
 * @param binvrow as returned by cplex (length = lp->nrows);
 * @param tableau where to write the tableau (length lp->nrows + 
 * lp->ncols).
 * @return zero on success, non-zero otherwise
 * */ 
int MTcplex_binv_to_tableau(const MTlp_t*const lp, 
                            const double*const binvrow, 
                            double*const tableau);
/* ========================================================================= */
/** @brief test if a given cut is valid to the given cplex LP
 * @param cut cut to be tested
 * @param lp pointer to the asociated #MTlp_t structure.
 * @return zero on success, non-zero otherwise.
 * */
int MTcplex_test_cut( const MTcut_t*const cut,
                      const MTlp_t*const lp);
/* ========================================================================= */
/** @brief compute ax = f for a tableau
 * @param lp pointer to an #MTlp_t structure.
 * @param tableau where to write the tableau (length lp->nrows + 
 * @param x structural variables values
 * @param slack logical variables values
 * @param f where to store ax = f
 * */
void MTcompute_f(const MTlp_t*const lp, 
                const double*const tableau,
                const double*const x,
                const double*const slack,
                double*const f);
/* ========================================================================= */
/** @brief display an LP to the given file 
 * @param lp pointer to an #MTlp_t structure
 * @param sol asociated solution to the LP
 * @param stream file where to write the LP
 * */
void MTdisplay_lp(const MTlp_t*const lp,
                  const MTsol_t*const sol, 
                  FILE*stream);
/* ========================================================================= */
/** @brief get the indices of fractional (structural) variables 
 * @param lp pointer to an #MTlp_t structure
 * @param x current LP x-value
 * @param fracvars array of length  (at least) #MTlp_t::nrows
 * @param nfrac pointer to an integer where the number of fractional variables
 * is returned.
 * @param minitgap minimum distance to closest integer for a variable to be
 * considered fractional
 * @return zero on success, non-zero otherwise
 * */
int MTcompute_fractional_vars(const MTlp_t*const lp,
                              const double*const x,
                              int*const fracvars,
                              int*const nfrac,
                              const double minitgap);
/* ========================================================================= */
/** @brief get the indices of (almost) integer variables 
 * @param lp pointer to an #MTlp_t structure
 * @param x current LP x-value
 * @param intvars array of length  (at least) #MTlp_t::nrows
 * @param nint pointer to an integer where the number of fractional variables
 * is returned.
 * @param intgap integrality gap allowd for a variable to be considered integer
 * @return zero on success, non-zero otherwise
 * */
int MTcompute_integer_vars(const MTlp_t*const lp,
                           const double*const x,
                           int*const intvars,
                           int*const nint,
                           const double intgap);
/* ========================================================================= */
/** @brief Get the best K tableau (asociated to fractional variables), note
 * that we check for wrongly computed tableau. 
 * Note that we compute Z = f + 0.5+Ax, where A is the tableau and f the
 * fractional value (displaced by 1/2), moreover, all basic variables have zero
 * coefficient in the resulting tableau, and all variables are complemented to
 * their bounds.
 * @param lp pointer to an #MTlp_t structure
 * @param sol asociated node solution
 * @patam tb pointer to an #MTrowmap_t structure
 * @param f fractional value for each tableau.
 * @param max_tableau maximum number of tableaus to consider.
 * used to select the set of best fractional tableau rows.
 * @param env Cplex environment pointer.
 * @param CPXlp cplex lp pointer.
 * @return zero on success, non-zero otherwise.
 * */
int MTget_best_k_tableau_rows(const MTlp_t*const lp,
                              const MTsol_t*const sol,
                              const int max_tableau,
                              CPXCENVptr env,
                              CPXLPptr CPXlp,
                              MTrowmatrix_t*const tb,
                              double*const f);
/* ========================================================================= */
/** @brief Get the best K tableau (asociated to integer basic variables), note
 * that we check for wrongly computed tableau. 
 * Note that we compute Z = f + 0.5+Ax, where A is the tableau and f the
 * fractional value (displaced by 1/2), moreover, all basic variables have zero
 * coefficient in the resulting tableau, and all variables are complemented to
 * their bounds.
 * @param lp pointer to an #MTlp_t structure
 * @param sol asociated node solution
 * @patam tb pointer to an #MTrowmap_t structure
 * @param f fractional value for each tableau.
 * @param max_tableau maximum number of tableaus to consider.
 * used to select the set of best integer tableau rows.
 * @param env Cplex environment pointer.
 * @param CPXlp cplex lp pointer.
 * @return zero on success, non-zero otherwise.
 * */
int MTget_best_k_integer_tableau_rows(const MTlp_t*const lp,
                                      const MTsol_t*const sol,
                                      const int max_tableau,
                                      CPXCENVptr env,
                                      CPXLPptr CPXlp,
                                      MTrowmatrix_t*const tb,
                                      double*const f);
/* ========================================================================= */
/** @brief transform an uncomplemented cut to a complemented form.
 * Note that we expect no coefficient for basic variables in the cut.
 * @param cut pointer to an #MTcut_t structure, we will complement the cut.
 * @param sol asociated node solution
 * @param lp pointer to the related #MTlp_t structure
 * @return zero on success, non-zero otherwise.
 * */
int MTuncomplemented_to_complemented_cut( const MTlp_t*const lp,
                                          const MTsol_t*const sol,
                                          MTcut_t*const cut);
/* ========================================================================= */
/** @brief transform an extened non-complemented cut to a compresed and
 * complemented form. We assume the extended cut is of the form ax >= 1. 
 * Note that we expect no coefficient for basic variables in the cut, moreover,
 * the rhs of the inequality is assumed to be 1 (in raw format).
 * @note The parameter extended WILL CHANGE ITS CONTENTS
 * @param cut pointer to an #MTcut_t structure, we will store the compresed cut
 * here.
 * @param sol asociated node solution
 * @param extended extended cut (length #MTlp_t::nrows + #MTlp_t::ncols), note
 * that this informnation will be modified, and will contain the complemented
 * cut in extended form. 
 * @param lp pointer to the related #MTlp_t structure
 * @return zero on success, non-zero otherwise.
 * */
int MTraw_to_complemented_cut(
    const MTlp_t*const lp,
    const MTsol_t*const sol,
    double*const extended,
    MTcut_t*const cut);
/* ========================================================================= */
/** @brief transform an extened non-complemented cut to a compresed for. We
 * assume the extended cut is of the form ax >= 1.m 
 * Note that we expect no coefficient for basic variables in the cut.
 * @note The parameter extended WILL NOT CHANGE ITS CONTENTS
 * @param cut pointer to an #MTcut_t structure, we will store the compresed cut
 * here.
 * @param extended extended cut (length #MTlp_t::nrows + #MTlp_t::ncols), note
 * that this informnation will be modified, and will contain the complemented
 * cut in extended form. 
 * @param nactive length of array active
 * @param active if not null, it should store the positions of possibly active
 * positions in extended; all positions outside it are assumed to be zero.
 * @param lp pointer to the related #MTlp_t structure
 * @param status if status is zero, the cut should be stored, otherwise, it
 * should be discarded.
 * @return zero on success, non-zero otherwise.
 * */
int MTraw_to_uncomplemented_cut(
    const MTlp_t*const lp,
    const double*const extended,
    const int nactive,
    const int*const active,
    MTcut_t*const cut,
    int*const status);
/* ========================================================================= */
/** @brief obtain a solution to the current node LP 
 * @param lp pointer to an #MTlp_t structure
 * @param env Cplex environment pointer.
 * @param CPXlp cplex lp pointer.
 * @param sol where to store the solution
 * @param CPLEX callback cbdata.
 * @param wherefrom CPLEX callback wherefrom parameter.
 * @return zero on success, non-zero otherwise
 * */
int MTget_sol(const MTlp_t*const lp,
              CPXCENVptr env,
              CPXLPptr CPXlp,
              void*cbdata,
              int wherefrom,
              MTsol_t*const sol);
/* ========================================================================= */
/** @biref if we have CPLEX 11 or later, we use sense as 'g' instead of 'G',
 * because, in theory, it enables cutpool management, we will see */
#if CPX_VERSION >= 1100
#define MT_CPLEX_SENSE 'g'
#else
#define MT_CPLEX_SENSE 'G'
#endif
/* ========================================================================= */
/** @brief initialize an #MTns_ccbk_t structure */
#define MTns_ccbk_init(__ns_ccbk) do{\
  MTns_ccbk_t*const __MTns_ccbk = (__ns_ccbk);\
  memset(__MTns_ccbk,0,sizeof(MTns_ccbk_t));}while(0)
/* ========================================================================= */
/** @brief resize node-solve arrays */
#define MTns_ccbk_rsz(__ns_ccbk,__ncsz,__nrsz) do{\
  MTns_ccbk_t*const __MTns_ccbk = (__ns_ccbk);\
  const size_t __MTns_ncsz = (size_t)(__ncsz);\
  const size_t __MTns_nrsz = (size_t)(__nrsz);\
  if( __MTns_ccbk->rsz < __MTns_nrsz){\
    __MTns_ccbk->rsz = __MTns_nrsz;\
    __MTns_ccbk->rfix = EGrealloc(__MTns_ccbk->rfix,sizeof(char)*__MTns_nrsz);\
    __MTns_ccbk->rstat = EGrealloc(__MTns_ccbk->rstat,sizeof(int)*__MTns_nrsz);\
    __MTns_ccbk->sense = EGrealloc(__MTns_ccbk->sense,sizeof(char)*__MTns_nrsz);\
    __MTns_ccbk->pi = EGrealloc(__MTns_ccbk->pi,sizeof(double)*__MTns_nrsz);}\
  if( __MTns_ccbk->csz < __MTns_ncsz){\
    __MTns_ccbk->csz = __MTns_ncsz;\
    __MTns_ccbk->oobj = EGrealloc(__MTns_ccbk->oobj,sizeof(double)*__MTns_ncsz);\
    __MTns_ccbk->lb = EGrealloc(__MTns_ccbk->lb,sizeof(double)*__MTns_ncsz);\
    __MTns_ccbk->ub = EGrealloc(__MTns_ccbk->ub,sizeof(double)*__MTns_ncsz);\
    __MTns_ccbk->x0 = EGrealloc(__MTns_ccbk->x0,sizeof(double)*__MTns_ncsz);\
    __MTns_ccbk->x1 = EGrealloc(__MTns_ccbk->x1,sizeof(double)*__MTns_ncsz);\
    __MTns_ccbk->cfix = EGrealloc(__MTns_ccbk->cfix,sizeof(char)*__MTns_ncsz);\
    __MTns_ccbk->cstat = EGrealloc(__MTns_ccbk->cstat,sizeof(int)*__MTns_ncsz);\
    __MTns_ccbk->matind = EGrealloc(__MTns_ccbk->matind,sizeof(int)*__MTns_ncsz);\
    __MTns_ccbk->matval = EGrealloc(__MTns_ccbk->matval,sizeof(double)*__MTns_ncsz);\
    __MTns_ccbk->dj = EGrealloc(__MTns_ccbk->dj,sizeof(double)*__MTns_ncsz);\
    }\
  }while(0)
/* ========================================================================= */
/** @brief clear any internally allocated memory within an #MTns_ccbk_t
 * structure. */
#define MTns_ccbk_clear(__ns_ccbk) do{\
  MTns_ccbk_t*const __MTns_ccbk = (__ns_ccbk);\
  EGfree(__MTns_ccbk->rfix);\
  EGfree(__MTns_ccbk->pi);\
  EGfree(__MTns_ccbk->cfix);\
  EGfree(__MTns_ccbk->dj);\
  EGfree(__MTns_ccbk->rstat);\
  EGfree(__MTns_ccbk->sense);\
  EGfree(__MTns_ccbk->oobj);\
  EGfree(__MTns_ccbk->lb);\
  EGfree(__MTns_ccbk->ub);\
  EGfree(__MTns_ccbk->x1);\
  EGfree(__MTns_ccbk->x0);\
  EGfree(__MTns_ccbk->matind);\
  EGfree(__MTns_ccbk->matval);\
  EGfree(__MTns_ccbk->cstat);}while(0)
/* ========================================================================= */
/** @brief Display stats in the given #MTns_ccbk_t structure */
#define MTns_ccbk_display(__ns_ccbk) do{\
  const MTns_ccbk_t*const __MTns = (__ns_ccbk);\
  const double __MTd = ((double)(__MTns->nzrd))/((double)__MTns->ncalls);\
  const double __MTd2 = ((double)(__MTns->loops))/((double)__MTns->ncalls);\
  fprintf(stderr,"\tAverage solution difference  %.7le in %zd calls\n",__MTns->xdiff/((double)__MTns->ncalls),__MTns->ncalls);\
  fprintf(stderr,"\tAverage Primal degenerancy   %.4lf in %zd calls\n",__MTd,__MTns->ncalls);\
  fprintf(stderr,"\tAverage Reoptimization steps %.4lf in %zd calls\n",__MTd2,__MTns->ncalls);}while(0)
/* ========================================================================= */
/** @brief simple node solve callback, we use it to count primal degenerancy,
 * i.e. the number of variables with zero reduced cost, this should indicate
 * posibility of doing nested objective funcions to avoid primal degenerancy */
int MTnode_solve( CPXCENVptr env, 
                  void*cbdata,
                  int wherefrom, 
                  void*cbhandle, 
                  int*useraction_p);
/* ========================================================================= */
/** @brief given a tableau in extended notation, verify that it is indeed a
 * numerically stable and correct tableau. 
 * @param tableau table to check
 * @param lp Internal LP description
 * @param status on return zero fi everything is OK, non-zero otherwise.
 * @param ratio if status==0, store the ratio for the tableau.
 * @param etnz if status == 0, store the number of non-zeros in the tableau
 * @return 0 on success, non-zero otherwise
 * */
int MTcheckTabrow(
    const MTlp_t*const lp,
    const double*tableau,
    int*const status,
    double*const ratio,
    int*const etnz);
/* ========================================================================= */
/** @brief given a tableau row in extended format, store it as a compresed form, it include setting row to row - integer_part[row] and updating the rhs.
 * @param lp internal LP description,
 * @param sol current optimal solution.
 * @param rowval on input extended row description, on output, non-zeros
 * coefficients
 * @param rowind array of length ncols where we will store the indices of
 * non-zero coefficients in the row
 * @param nz on output, non-zeros found
 * @return zero on success, non-zero otherwise */
int MTcompressTabRow(
    const MTlp_t*const lp,
    const MTsol_t*const sol,
    double*rowval,
    int*rowind,
    double*const rhs,
    int*const nz);
/* ========================================================================= */
/** @} */
/* end of mt_cplex_cbk.h */
#endif

---