// @(#)root/unuran:$Name:  $:$Id: TUnuranDistr.h,v 1.2 2006/11/24 09:42:54 moneta Exp $
// Author: L. Moneta Wed Sep 27 11:53:27 2006

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

// Header file for class TUnuranDistr

#ifndef ROOT_Math_TUnuranDistr
#define ROOT_Math_TUnuranDistr


#include <cassert> 
#include "TF1.h"

/** 
   TUnuranDistr class
   wrapper class for one dimensional distribution
*/ 
class TUnuranDistr {

public: 

   /**
      Default constructor.
      Set by default a value of  min > max for the distribution range, which means
      that  is undefined. If the variable fHasDomain is not set the range is used only for
      finding the mode of the distribution
   */
   TUnuranDistr() :
      fFunc(0),
      fCdf(0),
      fDeriv(0),
      fXmin(1.), fXmax(-1.),
      fHasDomain(0)
   {}

   /**
      Constructor from a TF1 objects
   */
   TUnuranDistr (const TF1 * func, const TF1 * cdf = 0, const TF1 * deriv = 0 ) :
      fFunc(func),
      fCdf(cdf),
      fDeriv(deriv),
      fXmin(1.), fXmax(-1.), // if min > max range is undef.
      fHasDomain(0)
   {
      assert(func != 0);
      // use by default the range specified in TF1
      func->GetRange(fXmin, fXmax);
   }

   /**
      Destructor (no operations)
   */
   ~TUnuranDistr () {}


   /**
      Copy constructor
   */
   TUnuranDistr(const TUnuranDistr &);

   /**
      Assignment operator
   */
   TUnuranDistr & operator = (const TUnuranDistr & rhs);


   /// evaluate the destribution 
   inline double operator() ( double x) const {
      return fFunc->Eval(x);
   }

   /// evaluate the derivative of the function
   inline double Derivative( double x) const {
      if (fDeriv != 0) return fDeriv->Eval(x);
      // do numerical derivation
      return fFunc->Derivative(x);
   }

   /// evaluate the integral (cdf)  on the domain
   inline double Cdf(double x) const {
      if (fCdf != 0) return fCdf->Eval(x);
      TF1 * f =  const_cast<TF1*>(fFunc);
      return f->Integral(fXmin, x);
   }

   bool GetDomain(double & xmin, double & xmax) const {
      xmin = fXmin;
      xmax = fXmax;
      return fHasDomain;
   }

   void SetDomain(double xmin, double xmax)  {
      fXmin = xmin;
      fXmax = xmax;
      fHasDomain = true;
   }

   /// get the mode   (x location of function maximum)  
   double Mode() const {
      return fFunc->GetMaximumX(fXmin, fXmax);
   }

protected: 


private: 

   const TF1 * fFunc;
   const TF1 * fCdf;
   const TF1 * fDeriv;
   double fXmin;
   double fXmax;
   bool fHasDomain;
}; 



#endif /* ROOT_Math_TUnuranDistr */