OSIMPSolver.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/*------------------------- File OSIMPSolver.h -----------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*----------------------------- DEFINITIONS --------------------------------*/
/*--------------------------------------------------------------------------*/
 
#ifndef __OSIMPSolver
 #define __OSIMPSolver /* self-identification: #endif at the end of the file*/
 
/*--------------------------------------------------------------------------*/
/*-------------------------------- MACROS ----------------------------------*/
/*--------------------------------------------------------------------------*/
/* As the name implies, OSIMPSolver uses an object derived from
 * OsiSolverInterface to solve the MP. Certain usage patterns cause the MP to
 * be changed, and *after that* the previous optimal primal and dual solution
 * to be accessed. Certain OsiSolvers graciously allow that, by keeping the
 * previous solution even in face of changes until the MP is explicitly
 * re-solved, while others are more strict and delete any previous solution
 * as soon as anything changes in the MP.
 *
 * This macro, if set to 1, dictates that the OSIMPSolver object stores the
 * solution information of the OsiSolver in its own data structures, so that
 * it remains available even after changes in the MP. Doing so is safe, but
 * it may be useless (and therefore better avoided for higher efficiency in
 * both space and time) with certain OsiSolvers. */
 
#define PRESERVE_OSI_SOLS 1
 
/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
#include "MPSolver.h"
 
#include "OsiSolverInterface.hpp"
 
/*--------------------------------------------------------------------------*/
/*------------------------------ NAMESPACE ---------------------------------*/
/*--------------------------------------------------------------------------*/
 
namespace NDO_di_unipi_it
{
 
/*--------------------------------------------------------------------------*/
/*----------------------------- CLASSES ------------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------- GENERAL NOTES --------------------------------*/
/*--------------------------------------------------------------------------*/
class OSIMPSolver : public MPSolver
{
/*--------------------------------------------------------------------------*/
/*----------------------- PUBLIC PART OF THE CLASS -------------------------*/
/*--------------------------------------------------------------------------*/
 
 public:
 
/*--------------------------------------------------------------------------*/
/*---------------------------- PUBLIC TYPES --------------------------------*/
/*--------------------------------------------------------------------------*/
 
 enum StabFun { unset = 0 , none , boxstep , quadratic };
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 enum OsiAlg { kAuto = 0 , kPrim , kDual , kNet , kBar , kSif , kCon };
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
 enum OsiRed { rNo = 0 , rPrim , rDual , rBoth };
 
/*--------------------- PUBLIC METHODS OF THE CLASS ------------------------*/
/*--------------------------------------------------------------------------*/
/*------------------------------ CONSTRUCTOR -------------------------------*/
/*--------------------------------------------------------------------------*/
 OSIMPSolver( std::istream *iStrm = nullptr );
 
/*-------------------------- OTHER INITIALIZATIONS -------------------------*/
/*--------------------------------------------------------------------------*/
 void SetDim( cIndex MxBSz = 0 , FiOracle * Oracle = nullptr ,
          const bool UsAvSt = false ) override;
 
/*--------------------------------------------------------------------------*/
 
 void Sett( cHpNum tt = 1 ) override;
 
/*--------------------------------------------------------------------------*/
 
 void SetPar( const int wp , cHpNum value ) override;
 
/*--------------------------------------------------------------------------*/
 
 void SetThreads( int nthreads ) override;
 
/*--------------------------------------------------------------------------*/
 
 void SetLowerBound( cHpNum LwBnd = - Inf< HpNum >() ,
             cIndex wFi = Inf< Index >() ) override;
 
/*--------------------------------------------------------------------------*/
 void SetMPLog( ostream *outs = 0 , const char lvl = 0 ) override;
 
/*--------------------------------------------------------------------------*/
 void SetAlgo( const OsiAlg algo = kAuto , const OsiRed reduc = rNo );
 
/*---------------------- OSIMPSolver-SPECIFIC METHODS ----------------------*/
/*--------------------------------------------------------------------------*/
 
 void SetOsi( OsiSolverInterface * osi = nullptr );
 
/*--------------------------------------------------------------------------*/
 
 OsiSolverInterface * GetOsi( void ) const { return( osiSlvr ); }
 
/*--------------------------------------------------------------------------*/
 
 void SetStabType( const StabFun sf = none );
 
/*-------------------- METHODS FOR SOLVING THE PROBLEM ---------------------*/
/*--------------------------------------------------------------------------*/
 MPStatus SolveMP( void ) override;
 
/*---------------------- METHODS FOR READING RESULTS -----------------------*/
/*--------------------------------------------------------------------------*/
 HpNum ReadFiBLambda( cIndex wFi = Inf< Index >() ) override;
 
 HpNum ReadDt( cHpNum tt = 1 ) override;
 
 HpNum ReadSigma( cIndex wFi = Inf< Index >() ) override;
 
 HpNum ReadDStart( cHpNum tt = 1 ) override;
 
 cLMRow Readd( bool Fulld = false ) override;
 
 void ReadZ( LMRow tz , cIndex_Set & I , Index & D ,
         cIndex wFi = Inf< Index >() ) override;
 
 cHpRow ReadMult( cIndex_Set & I , Index & D , cIndex wFi = Inf< Index >() ,
          const bool IncldCnst = true ) override;
 
 HpNum ReadLBMult( cIndex wFi = Inf< Index >() ) override;
 
 cHpRow ReadDualEasy( cIndex wFi ) override;
 
 cHpRow ReadReducedCostsEasy( cIndex wFi ) override;
 
 HpNum ReadGid( cIndex Nm = Inf< Index >() ) override;
 
 void MakeLambda1( cHpRow Lmbd , HpRow Lmbd1 , cHpNum Tau ) override;
 
 void SensitAnals( HpNum &lp , HpNum &cp ) override;
 
/*-------------- METHODS FOR READING THE DATA OF THE PROBLEM ---------------*/
/*--------------------------------------------------------------------------*/
 Index BSize( cIndex wFi = Inf< Index >() ) override;
 
 Index BCSize( cIndex wFi = Inf< Index >() ) override;
 
 Index MaxName( cIndex wFi = Inf< Index >() ) override;
 
 Index WComponent( cIndex i ) override;
 
 bool IsSubG( cIndex i ) override;
 
 Index NumNNVars( void ) override;
 
 Index NumBxdVars( void ) override;
 
 bool IsNN( cIndex i ) override;
 
 void CheckIdentical( const bool Chk = true ) override;
 
 cHpRow ReadLinErr( void ) override;
  
 HpNum ReadLowerBound( cIndex wFi = Inf< Index >() ) override;
 
 HpNum EpsilonD( void ) override;
 
 bool FiBLambdaIsExact( cIndex wFi );
 
/*------------- METHODS FOR ADDING / REMOVING / CHANGING DATA --------------*/
/*--------------------------------------------------------------------------*/
 SgRow GetItem( cIndex wFi = Inf< Index >() ) override;
 
 void SetItemBse( cIndex_Set SGBse = nullptr , cIndex SGBDm = 0 ) override;
 
 Index CheckSubG( cHpNum DFi , cHpNum Tau , HpNum & Ai , HpNum & ScPri )
  override;
 
 Index CheckCnst( HpNum & Ai , HpNum & ScPri , cHpRow CrrPnt ) override;
 
 bool ChangesMPSol( void ) override;
 
 void SetItem( cIndex Nm = Inf< Index >() ) override;
 
 void SubstItem( cIndex Nm ) override;
 
/*--------------------------------------------------------------------------*/
 
 void RmvItem( cIndex i ) override;
 
 void RmvItems( void ) override;
 
/*--------------------------------------------------------------------------*/
 
 void SetActvSt( cIndex_Set AVrs = nullptr , cIndex AVDm = 0 ) override;
 
 void AddActvSt( cIndex_Set Addd , cIndex AdDm , cIndex_Set AVrs ) override;
 
 void RmvActvSt( cIndex_Set Rmvd , cIndex RmDm , cIndex_Set AVrs ) override;
 
/*--------------------------------------------------------------------------*/
 
 void AddVars( cIndex NNwVrs ) override;
 
 void RmvVars( cIndex_Set whch = nullptr , Index hwmny = 0 ) override;
 
/*--------------------------------------------------------------------------*/
 
 void ChgAlfa( cHpRow DeltaAlfa ) override;
 
 void ChgAlfa( cHpRow NewAlfa , cIndex wFi ) override;
 
 void ChgAlfa( cIndex i , cHpNum Ai ) override;
 
/*--------------------------------------------------------------------------*/
 
 void ChangeCurrPoint( cLMRow DLambda , cHpRow DFi ) override;
 
 void ChangeCurrPoint( cHpNum Tau , cHpRow DFi ) override;
 
/*--------------------------------------------------------------------------*/
 
 void ChgSubG( cIndex strt , Index stp , cIndex wFi ) override;
 
/*--------------------------------------------------------------------------*/
 
 void ChgCosts( Index wFi , cLMRow Lambda ) override;
 
/*--------------------------------------------------------------------------*/
 void ChgRLHS( Index wFi ) override;
 
/*--------------------------------------------------------------------------*/
 void ChgLUBD( Index wFi ) override;
 
/*------------------------------ DESTRUCTOR --------------------------------*/
/*--------------------------------------------------------------------------*/
 virtual ~OSIMPSolver();
 
/*--------------------- PRIVATE PART OF THE CLASS --------------------------*/
/*--------------------------------------------------------------------------*/
 
 private:
 
/*--------------------------------------------------------------------------*/
/*-------------------------- PRIVATE METHODS -------------------------------*/
/*--------------------------------------------------------------------------*/
 
 void cleanup( void );
 
/*--------------------------------------------------------------------------*/
/* Update the prices after either t has changed or if the current point
   has been changed. The last form changes the prices in tmpHP[], assumed to
   hold the whole vector of cost coefficients of the master problem. */
 
 void tUpdatePrices( cIndex strt = 0 , Index stp = Inf< Index >() );
 
 void ptUpdatePrices( cIndex strt = 0 , Index stp = Inf< Index >() );
 
 void ptUpdatePricesInPlace( void );
 
/*--------------------------------------------------------------------------*/
 
 void UpdateRhoCol( void );
 
/*--------------------------------------------------------------------------*/
/* Private method for handling the quadratic stabilization. */
 
 void switchToQP( void );
 
/*--------------------------------------------------------------------------*/
//  inline bool isactive( Index i );
 
 void activate( Index i );
 
 void deactivate( Index i );
 
 void resizeHP( Index i );
 
 void resizeI( Index i );
 
/*--------------------------------------------------------------------------*/
/* Placeholder method: it should do nothing, but depending on the value of
   the macro CHECK_DS [see OSIMPSolver.C] some extra checking is done in
   there for debugging purposes. */
 
 void CheckDS( void );
 
/*--------------------------------------------------------------------------*/
 
 Index CheckBCopy( void );
 
/*--------------------------------------------------------------------------*/
/*----------------------- PRIVATE DATA STRUCTURES  -------------------------*/
/*--------------------------------------------------------------------------*/
 
 OsiSolverInterface *osiSlvr;  
 FiOracle *FIO;                
 
 OsiAlg algorithm;          
 
 bool useactiveset;     
 bool first;            
 bool checkID;
 Bool_Vec weasy;            
 Index NrEasy;              
 
 StabFun stab;              
 HpNum t;           
 
 double MaxTime;            
 double OptEps;             
 double FsbEps;             
 
 double * RhoCol;           
 int  * RhoColBse;          
 Index  RhoColBDm;          
 Index RhoColSgPos;         
 SgRow NewItem;             
 Index NewItemFi;       
 cIndex_Set NewItemBse;     
 Index NewItemBDm;      
 
 Index MaxNZ;           
 
 bool NewItemisSG;      
 double NewItemprice;       
 double NewItemScPri;       
 
 Index_Set NSubG;           
 Index_Set NConst;          
 
 Index_Set comp_row;        
 Index_Set dict_item;       
 Index_Set dict_slack;      
 Index_Set dict_stab;       
 
 Index_Set wcomp;           
 Index_Set comp_col;        
 
 Index item_maxname;        
 
 HpRow tempHP;          
 int*  tempI;               
 Index tempHP_size;         
 Index tempI_size;          
 
 LMRow Upper;           
 LMRow Lower;           
 
 Index NNVars;              
 Index BxdVars;             
 
 cIndex_Set Aset;           
 Index Asetdim;             
 
 HpRow LwrBnds;             
  
 HpRow GiPerd;              
 #if( PRESERVE_OSI_SOLS )
  double * csol;            
  int csols;                
  double * rsol;            
  int rsols;                
  double * rcst;            
 #endif
 
 CoinMessageHandler *derhand;
 
 Index NRCall;              
 
/*--------------------------------------------------------------------------*/
 
 };  // end( class OSIMPSolver )
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
 }  // end( namespace NDO_di_unipi_it )
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
#endif /* __OSIMPSolver */
 
/*--------------------------------------------------------------------------*/
/*---------------------- End File OSIMPSolver.h ----------------------------*/
/*--------------------------------------------------------------------------*/