FiOracle.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------*/
/*--------------------------- File FiOracle.h ------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/*----------------------------- DEFINITIONS --------------------------------*/
/*--------------------------------------------------------------------------*/
 
#ifndef _FiOracle
 #define _FiOracle  /* self-identification: #endif at the end of the file */
 
/*--------------------------------------------------------------------------*/
/*------------------------------ INCLUDES ----------------------------------*/
/*--------------------------------------------------------------------------*/
 
#include "OPTtypes.h"
 
/*--------------------------------------------------------------------------*/
/*------------------------ NAMESPACE and USINGS ----------------------------*/
/*--------------------------------------------------------------------------*/
namespace NDO_di_unipi_it
{
 using namespace OPTtypes_di_unipi_it;
 
/*--------------------------------------------------------------------------*/
/*--------------------------- CLASS NDOSolver ------------------------------*/
/*--------------------------------------------------------------------------*/
class NDOSolver;
 
/*--------------------------------------------------------------------------*/
/*------------------------- CLASS NDOException -----------------------------*/
/*--------------------------------------------------------------------------*/
 class NDOException : public exception {
 public:
  NDOException( const char *const msg = 0 ) { errmsg = msg; }
 
  const char* what( void ) const throw() { return( errmsg ); }
 
 private:
  const char *errmsg;
  };
 
/*--------------------------------------------------------------------------*/
/*--------------------------- CLASS FiOracle -------------------------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------- GENERAL NOTES --------------------------------*/
/*--------------------------------------------------------------------------*/
class FiOracle
{
 
/*--------------------------------------------------------------------------*/
/*----------------------- PUBLIC PART OF THE CLASS -------------------------*/
/*--------------------------------------------------------------------------*/
 
 public:
 
/*--------------------------------------------------------------------------*/
/*---------------------------- PUBLIC TYPES --------------------------------*/
/*--------------------------------------------------------------------------*/
   enum FiStatus { kFiNorm = 0,
           kFiError ,
           kFiChgd ,
           kFiStop ,
           kFiCont
                   };
 
/*--------------------- PUBLIC METHODS OF THE CLASS ------------------------*/
/*--------------------------------------------------------------------------*/
/*---------------------------- CONSTRUCTOR ---------------------------------*/
/*--------------------------------------------------------------------------*/
   FiOracle( void )
   {
    Slvr = 0;
 
    NumVar = MaxName = LamBDim = 0;
    Lambda = 0;
    LamBase = 0;
    LHasChgd = true;  // NewGi() has clearly never be called yet
 
    FiLog = 0;
    FiLLvl = 0;
 
    Fit = 0;
    }
 
/*-------------------------- OTHER INITIALIZATIONS -------------------------*/
/*--------------------------------------------------------------------------*/
   virtual void SetNDOSolver( NDOSolver *NwSlvr = 0 )
   {
    Slvr = NwSlvr;
    }
 
/*--------------------------------------------------------------------------*/
 
   virtual void SetFiLog( ostream *outs = 0 , const char lvl = 0 )
   {
    if( ( FiLog = outs ) )
     FiLLvl = lvl;
    else
     FiLLvl = 0;
    }
 
/*--------------------------------------------------------------------------*/
 
   virtual void SetFiTime( const bool TimeIt = true )
   {
    if( TimeIt )
     if( Fit )
      Fit->ReSet();
     else
      Fit = new OPTtimers();
    else {
     delete Fit;
     Fit = 0;
     }
    }
 
/*--------------------------------------------------------------------------*/
 
   virtual void SetMaxName( cIndex MxNme = 0 )
   {
    MaxName = MxNme;
    }
 
/*-------------- METHODS FOR READING THE DATA OF THE PROBLEM ---------------*/
/*--------------------------------------------------------------------------*/
   virtual Index GetNumVar( void ) const
   {
    return( NumVar );
    }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   virtual Index GetMaxNumVar( void ) const
   {
    return( GetNumVar() );
    }
 
/*--------------------------------------------------------------------------*/
   virtual Index GetNrFi( void ) const
   {
    return( 1 );
    }
 
/*--------------------------------------------------------------------------*/
 
   virtual Index MaxNConst( void ) {
    return( 0 );
    }
 
/*--------------------------------------------------------------------------*/
   virtual bool IsFiContinuous( cIndex NrFi = Inf< Index >() )
   {
    return( true );
    }
 
/*--------------------------------------------------------------------------*/
   virtual bool IsFiConvex( cIndex NrFi = Inf< Index >() )
   {
    return( true );
    }
 
/*--------------------------------------------------------------------------*/
   virtual bool HasGi( cIndex NrFi = Inf< Index >() )
   {
    return( true );
    }
 
/*--------------------------------------------------------------------------*/
   virtual bool IsGiContinuous( cIndex NrFi )
   {
    return( false );
    }
 
/*--------------------------------------------------------------------------*/
   virtual bool HasH( cIndex NrFi )
   {
    return( false );
    }
 
/*--------------------------------------------------------------------------*/
   virtual bool IsHContinuous( cIndex NrFi )
   {
    return( false );
    }
 
/*--------------------------------------------------------------------------*/
   virtual Index GetMaxName( void ) const
   {
    return( MaxName );
    }
 
/*--------------------------------------------------------------------------*/
   virtual HpNum GetMinusInfinity( void )
   {
    return( - Inf< HpNum >() );
    }
 
/*--------------------------------------------------------------------------*/
   virtual Index GetMaxNZ( cIndex wFi = Inf< Index >() ) const
   {
    return( GetMaxNumVar() );
    }
 
/*--------------------------------------------------------------------------*/
   virtual Index GetMaxCNZ( cIndex wFi = Inf< Index >() ) const
   {
    return( GetMaxNumVar() );
    }
 
/*--------------------------------------------------------------------------*/
   virtual bool GetUC( cIndex i )
   {
    return( true );
    }
 
/*--------------------------------------------------------------------------*/
   virtual LMNum GetUB( cIndex i )
   {
    return( Inf< LMNum >() );
    }
 
/*--------------------------------------------------------------------------*/
   virtual LMNum GetBndEps( void )
   {
    return( 0 );
    }
 
/*--------------------------------------------------------------------------*/
   virtual HpNum GetGlobalLipschitz( cIndex wFi = Inf< Index >() )
 
   {
    return( Inf< HpNum >() );
    }
 
/*--------------------------------------------------------------------------*/
   virtual Index GetBNC( cIndex wFi )
   {
    return( 0 );
    }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   virtual Index GetBNR( cIndex wFi )
   {
    return( 0 );
    }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   virtual Index GetBNZ( cIndex wFi )
   {
    return( 0 );
    }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   virtual void GetBDesc( cIndex wFi , int *Bbeg , int *Bind , double *Bval ,
              double *lhs , double *rhs , double *cst ,
              double *lbd , double *ubd )
   {
    throw( NDOException( "GetBDesc: this component is not easy" ) );
    }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   virtual Index GetANZ( cIndex wFi , cIndex strt = 0 ,
             Index stp = Inf< Index >() )
   {
    return( 0 );
    }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   virtual void GetADesc( cIndex wFi , int *Abeg , int *Aind , double *Aval ,
              cIndex strt = 0 , Index stp = Inf< Index >() )
   {
    throw( NDOException( "GetADesc: this component is not easy" ) );
    }
 
   virtual NDOSolver *GetNDOSolver( void )
   {
    return( Slvr );
    }
 
/*---------------------- METHODS FOR SETTING LAMBDA ------------------------*/
/*--------------------------------------------------------------------------*/
   virtual void SetLambda( cLMRow Lmbd = 0 )
   {
    Lambda = Lmbd;
    LHasChgd = true;
    }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   virtual void SetLamBase( cIndex_Set LmbdB = 0 , cIndex LmbdBD = 0 )
   {
    LamBase = LmbdB;
    LamBDim = LamBase ? LmbdBD : NumVar;
    }
 
/*--------------------------------------------------------------------------*/
   virtual bool SetPrecision( HpNum Eps )
   {
    return( false );
    }
 
/*----------------------- METHODS FOR COMPUTING Fi() -----------------------*/
/*--------------------------------------------------------------------------*/
   virtual HpNum Fi( cIndex wFi = Inf< Index >() ) = 0;
 
/*------------- METHODS FOR READING SUBGRADIENTS / CONSTRAINTS -------------*/
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
   virtual bool NewGi( cIndex wFi = Inf< Index >() )
   {
    return( LHasChgd );
    }
 
/*--------------------------------------------------------------------------*/
 
   virtual Index GetGi( SgRow SubG , cIndex_Set &SGBse ,
            cIndex Name = Inf< Index >() ,
            cIndex strt = 0 , Index stp = Inf< Index >() ) = 0;
 
/*--------------------------------------------------------------------------*/
   virtual HpNum GetVal( cIndex Name = Inf< Index >() )
   {
    if( Name < MaxName )
     throw( NDOException( "GetVal: past information is not recorded" ) );
 
    return( 0 );
    }
 
/*--------------------------------------------------------------------------*/
 
   virtual void SetGiName( cIndex Name ) {}
 
/*--------------------------------------------------------------------------!!
 
  virtual void GetH( ... )
 
  < We must decide exactly the signature of GetH(), whether or not we need
  something like "NewH()", whether or not we need "SetHName()", etc.
  In particular, we must decide a reasonable format for the Hessians.
  The best would be an abstract C++ matrix class which can hold different
  types of matrices (diagonal, banded, sparse, dense, ...). One may use
  some existing C++ library for that; however, being this an abstract
  interface it would be better to have it depend on the smallest possible
  number of other libraries (possibly none); if we do use some, it should
  be a "very light" library, i.e., not one such that compiling it is
  very complicated, since many of the solvers would not actually use it.
  In other words, I don't think that lapack++ is the right one.
 
  However, I don't have a clear opinion on that. Suggestions? */
 
/*-------------------- METHODS FOR READING OTHER RESULTS -------------------*/
/*--------------------------------------------------------------------------*/
   virtual HpNum GetLowerBound( cIndex wFi = Inf< Index >() )
   {
    return( - Inf< HpNum >() );
    }
 
/*--------------------------------------------------------------------------*/
   virtual FiStatus GetFiStatus( Index wFi = Inf< Index >() )
   {
    return( kFiNorm );
    }
 
/*--------------------------------------------------------------------------*/
   void FiTime( double &t_us , double &t_ss )
   {
    t_us = t_ss = 0;
    if( Fit ) Fit->Read( t_us , t_ss ); 
    }
 
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
   double FiTime( void )
   {
    return( Fit ? Fit->Read() : 0 );
    }
 
/*------------- METHODS FOR ADDING / REMOVING / CHANGING DATA --------------*/
/*--------------------------------------------------------------------------*/
   virtual void Deleted( cIndex i = Inf< Index >() ) {}
 
/*--------------------------------------------------------------------------*/
 
   virtual void Aggregate( cHpRow Mlt , cIndex_Set NmSt , cIndex Dm ,
               cIndex NwNm ) {}
 
/*------------------------------ DESTRUCTOR --------------------------------*/
/*--------------------------------------------------------------------------*/
   virtual ~FiOracle() { delete Fit; }
 
/*-------------------- PROTECTED PART OF THE CLASS -------------------------*/
/*--------------------------------------------------------------------------*/
 
 protected:
 
/*--------------------------------------------------------------------------*/
/*----------------------- PROTECTED DATA STRUCTURES  -----------------------*/
/*--------------------------------------------------------------------------*/
  NDOSolver *Slvr;     
  Index NumVar;        
  Index MaxName;       
 
  cLMRow Lambda;       
  cIndex_Set LamBase;  
  Index LamBDim;       
  bool LHasChgd;       
  ostream *FiLog;      
  char FiLLvl;         
 
  OPTtimers *Fit;      
 
/*--------------------------------------------------------------------------*/
 
 };  // end( class FiOracle )
 
/*--------------------------------------------------------------------------*/
 
 }  // end( namespace NDO_di_unipi_it )
 
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
 
#endif  /* FiOracle.h included */
 
/*--------------------------------------------------------------------------*/
/*------------------------- End File FiOracle.h ----------------------------*/
/*--------------------------------------------------------------------------*/