---

vndstat.h

Go to the documentation of this file.

// FILE vndstat.h


#ifndef INCLUDED_VNDSTATS_H
#define INCLUDED_VNDSTATS_H

#include <assert.h>
#include "vnodecnf.h" 


class ERROR
{

public:
  
  ERROR() : T(0), E(-1) {;}
  
  void SetError( double t, double e )  { assert(e>=0); T = t; E = e; }
    
  double GetError() const { return E; }
  
  double GetT() const { return T; }
  

private:

  double T;

  double E; 
};




class SOLVER_STATS
{
  
public:
  
  SOLVER_STATS();
  
  void Reset();
  
  void SetRelError( double t, double e );
  
  void SetAbsError( double t, const double e );
  
  double GetMaxRelError() const;
  
  double GetMaxAbsError() const;
    
  double GetWhereMaxRelError() const;
  
  double GetWhereMaxAbsError() const;
  
  double GetRelError() const;
    
  double GetAbsError() const;
  
  double GetWhereRelError() const;
  
  double GetWhereAbsError() const;
  
  void AddUserTime( double time );
  
  double GetUserTime()  const;
  
  unsigned int  GetAcceptedSteps() const;
  
  unsigned int  GetRejectedSteps() const;

  unsigned int  GetTotalSteps() const;
  
  void AccRejStep( bool b );

  
private:
  
  unsigned int NofSteps;
  
  unsigned int NofRejectedSteps;
  
  double   CPUTime;
  
  ERROR MaxRelError, RelError, MaxAbsError, AbsError;
  
}; 


typedef SOLVER_STATS * PtrSolverStats;


inline SOLVER_STATS :: SOLVER_STATS()
{
  Reset();
}


inline void SOLVER_STATS :: SetRelError( double t, double e ) 
{ 
  assert( e>=0 );
  
  RelError.SetError( t,e ) ; 
  
  if ( e > MaxRelError.GetError() ) 
    MaxRelError.SetError( t,e ); 
} 


inline double SOLVER_STATS :: GetMaxRelError() const 
{ 
  return MaxRelError.GetError(); 
}


inline double SOLVER_STATS :: GetWhereMaxRelError() const 
{ 
  return MaxRelError.GetT(); 
}


inline double SOLVER_STATS :: GetRelError() const 
{ 
  return RelError.GetError(); 
}


inline double SOLVER_STATS :: GetWhereRelError() const 
{ 
  return RelError.GetT(); 
}


inline void SOLVER_STATS :: SetAbsError( double t, double e ) 
{ 
  assert( e>=0 );
  AbsError.SetError(t,e); 
  
  if ( e > MaxAbsError.GetError() ) 
    MaxAbsError.SetError(t,e); 
} 


inline double SOLVER_STATS :: GetMaxAbsError() const 
{ 
  return MaxAbsError.GetError(); 
}


inline double SOLVER_STATS :: GetWhereMaxAbsError() const 
{ 
  return MaxAbsError.GetT(); 
}


inline double SOLVER_STATS :: GetAbsError() const 
{ 
  return AbsError.GetError(); 
}


inline double SOLVER_STATS :: GetWhereAbsError() const 
{ 
  return AbsError.GetT(); 
}


inline void SOLVER_STATS :: AddUserTime ( double time ) 
{ 
  assert( time>=0 );

  BiasRoundNear();
  CPUTime += time; 
}


inline double  SOLVER_STATS :: GetUserTime () const 
{ 
  return CPUTime; 
}


inline unsigned int SOLVER_STATS ::  GetRejectedSteps() const 
{ 
  return NofRejectedSteps; 
};


inline unsigned int SOLVER_STATS ::  GetAcceptedSteps() const 
{ 
  return NofSteps; 
};


inline unsigned int SOLVER_STATS ::  GetTotalSteps() const 
{ 
  return NofSteps+NofRejectedSteps; 
};


inline void SOLVER_STATS :: AccRejStep( bool b )
{
  if ( b )
    NofSteps++;
  else
    NofRejectedSteps++;
}


#endif

---