// @(#)root/unuran:$Name:  $:$Id: TUnuranDistrMulti.h,v 1.1 2006/11/15 17:40:36 brun Exp $
// Author: L. Moneta Wed Sep 27 17:07:37 2006

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

// Header file for class TUnuranDistrMulti

#ifndef ROOT_Math_TUnuranDistrMulti
#define ROOT_Math_TUnuranDistrMulti


#include "TF1.h"

#include <cassert>

/** 
   TUnuranDistrMulti class
*/ 
class TUnuranDistrMulti {

public: 

   /**
      Default constructor
   */
   TUnuranDistrMulti () :
     fFunc(0),
     fHasDomain(0)
   {}


   /**
      Constructor from a TF1 objects
   */
   TUnuranDistrMulti (TF1 * func) :
      fFunc(func),
      fHasDomain(0)
   {
      assert(func != 0);
      fDim = func->GetNdim();
   }

   /**
      Destructor (no operations)
   */
   ~TUnuranDistrMulti ();


   // usually copying is non trivial, so we make this unaccessible

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

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



   unsigned int NDim() const {
      return fDim;
   }

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

   /// evaluate the derivative of the function
   void Gradient( const double * x, double * grad) const;

   /// evaluate the partial derivative for the given coordinate
   double Derivative( const double * x, int icoord) const;


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

   void SetDomain(double *xmin, double *xmax)  {
      fXmin = std::vector<double>(xmin,xmin+fDim);
      fXmax = std::vector<double>(xmax,xmax+fDim);
      fHasDomain = true;
   }

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



protected: 


private: 

   mutable TF1 * fFunc;
   unsigned int fDim;
   std::vector<double> fXmin;
   std::vector<double> fXmax;
   bool fHasDomain;


}; 



#endif /* ROOT_Math_TUnuranDistrMulti */