// @(#)root/mathcore:$Id$
// Author: Magdalena Slawinska 10/2007


/**********************************************************************
 *                                                                    *
 * Copyright (c) 2007  LCG ROOT Math Team, CERN/PH-SFT                *
 *                                                                    *
 *                                                                    *
 **********************************************************************/

// Header file for class Minimizer

#ifndef ROOT_Math_VirtualIntegrator
#define ROOT_Math_VirtualIntegrator

#ifndef ROOT_Math_IFunctionfwd
#include "Math/IFunctionfwd.h"
#endif

#ifndef ROOT_Math_Error
#include "Math/Error.h"
#endif

#ifndef ROOT_Math_IntegratorOptions
#include "Math/IntegratorOptions.h"
#endif


#include <vector>


namespace ROOT {
namespace Math {

//___________________________________________________________________
/**
   Abstract class for all numerical integration methods (1D and multi-dim) 
   Interface defining the common methods for the 
   numerical integrator classes of one and multi dimensions 
   The derived class VirtualIntegratorOneDim defines the methods 
   for one-dimensional integration.
   The derived class VirtualIntegratorMultiDim defines the method for 
   multi-dimensional integration. 
   The concrete classes for one dimension (e.g. GSLIntegrator) or 
   multi-dimension (e.g. GSLMCIntegrator) can be created using the 
   plug-in manager. 
   Users should not use directly this class but the concrete classes ROOT::Math::IntegratorOneDim or 
   ROOT::Math::IntegratorMultiDim
   

   @ingroup  Integration

*/
class VirtualIntegrator{

public:

   // destructor: no operation
   virtual ~VirtualIntegrator() {}

   /**
      set the desired relative Error
   */
   virtual void SetRelTolerance(double ) = 0; 

   /**
      set the desired absolute Error
   */
   virtual void SetAbsTolerance(double ) = 0; 

   /**
      return  the Result of the last Integral calculation
   */
   virtual double Result() const = 0; 

   /**
      return the estimate of the absolute Error of the last Integral calculation
   */
   virtual double Error() const = 0; 
   
   /**
      return the Error Status of the last Integral calculation
   */
   virtual int Status() const = 0;

   /**
      return number of function evaluations in calculating the integral 
      (if integrator do not implement this function returns -1)
   */
   virtual int NEval() const { return -1; }




}; 

//___________________________________________________________________
/**
   Interface (abstract) class for 1D numerical integration
   It must be implemented by the concrate Integrator classes like
   ROOT::Math::GSLIntegrator. 
   Plug-in's exist in ROOT to be able to instantiate the derived classes via the 
   plug-in manager. 
   Users should not use directly this class but the concrete classes ROOT::Math::IntegratorOneDim.


   @ingroup  Integration

*/
class VirtualIntegratorOneDim : public VirtualIntegrator {

public:

   /// destructor: no operation
   virtual ~VirtualIntegratorOneDim() {}

   /// evaluate integral 
   virtual double Integral(double a, double b) = 0; 

   /// set integration function 
   virtual void SetFunction(const IGenFunction &) = 0; 

   /// evaluate un-defined  integral (between -inf, + inf)
   virtual double Integral() = 0; 

   /// evaluate integral over the (a, +inf)
   virtual double IntegralUp(double a) = 0; 

   /// evaluate integral over the (-inf, b)
   virtual double IntegralLow(double b) = 0; 

   /// evaluate integral with singular points
   virtual double Integral( const std::vector<double> & pts) = 0; 

   /// evaluate Cauchy integral 
   virtual double IntegralCauchy(double a, double b, double c) = 0; 

   ///  get the option used for the integration 
   /// must be implemented by derived class 
   virtual ROOT::Math::IntegratorOneDimOptions Options() const = 0; 

   // return type of integrator 
   virtual ROOT::Math::IntegrationOneDim::Type Type() const { 
      return Options().IntegratorType();
   } 

   /// set the options 
   /// (should be re-implemented by derived classes -if more options than tolerance exist
   virtual void SetOptions(const ROOT::Math::IntegratorOneDimOptions & opt) {
      SetRelTolerance(opt.RelTolerance() );
      SetAbsTolerance(opt.AbsTolerance() );
   }



};

//___________________________________________________________________
/**
   Interface (abstract) class for multi numerical integration
   It must be implemented by the concrete Integrator classes like
   ROOT::Math::GSLMCIntegrator. 
   Plug-in's exist in ROOT to be able to instantiate the derived classes via the 
   plug-in manager.
   Users should not use directly this class but the concrete classes ROOT::Math::IntegratorMultiDim.


   @ingroup  Integration

*/
class VirtualIntegratorMultiDim : public VirtualIntegrator { 

public:

   /// destructor: no operation
   virtual ~VirtualIntegratorMultiDim() {}

   /// evaluate multi-dim integral
   virtual double Integral(const double*, const double*)  = 0;  

   /// setting a multi-dim function
   virtual void SetFunction(const IMultiGenFunction &)  = 0; 

   ///  get the option used for the integration 
   /// impelement by derived class otherwise return default ones 
   virtual ROOT::Math::IntegratorMultiDimOptions Options() const = 0;

   // return type of integrator 
   virtual ROOT::Math::IntegrationMultiDim::Type Type() const { 
      return Options().IntegratorType();
   } 

   /// set the options (if needed must be re-implemented by derived classes)
   virtual void SetOptions(const ROOT::Math::IntegratorMultiDimOptions & opt) {
      SetRelTolerance(opt.RelTolerance() );
      SetAbsTolerance(opt.AbsTolerance() );
   }

   
};


}//namespace Math
}//namespace ROOT


#endif /* ROOT_Math_VirtualIntegrator */