Index: /trunk/SophyaLib/NTools/classfunc.h
===================================================================
--- /trunk/SophyaLib/NTools/classfunc.h	(revision 3097)
+++ /trunk/SophyaLib/NTools/classfunc.h	(revision 3098)
@@ -10,8 +10,8 @@
 namespace SOPHYA {
 
-//abstract class-function
+//! Abstract interface definition for functions (double f(double)) viewed as classes
 class ClassFunc {
 public:
-  virtual double operator()(double x)=0;
+  virtual double operator()(double x) const =0;
 };
 
@@ -22,5 +22,5 @@
  public:
   Function(double (*g)(double)):f(g){}
-  inline  double operator()(double x){ return f(x);}
+  virtual  double operator()(double x) const { return f(x);}
 };
 
Index: /trunk/SophyaLib/NTools/integ.cc
===================================================================
--- /trunk/SophyaLib/NTools/integ.cc	(revision 3097)
+++ /trunk/SophyaLib/NTools/integ.cc	(revision 3098)
@@ -17,4 +17,5 @@
 
   On fournit une fonction double f(double) au constructeur, ou
+  une classe-fonction (ClassFuc) ou 
   une GeneralFunction avec des paramètres définis.
   L'objet Integrator est convertible en valeur double qui est la valeur
@@ -28,23 +29,34 @@
 //!  Constructeur par défaut. L'objet n'est pas utilisable en l'état.
 Integrator::Integrator()
-: mFunc(NULL), mGFF(NULL), mGFFParm(NULL),
+: mFunc(NULL), mClFun(NULL), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
   mXMin(0), mXMax(1)
+{}
+
+//! Constructeur à partir d'une classe-fonction, et des bornes d'intégration.
+Integrator::Integrator(ClassFunc const & f, double xmin, double xmax)
+: mFunc(NULL), mClFun(&f), mGFF(NULL), mGFFParm(NULL),
+  mNStep(50), mDX(-1), mReqPrec(-1),
+  mXMin(xmin), mXMax(xmax)
 {}
 
 //! Constructeur à partir de la fonction double->double, et des bornes d'intégration.
 Integrator::Integrator(FUNC f, double xmin, double xmax)
-: mFunc(f), mGFF(NULL), mGFFParm(NULL),
+: mFunc(f), mClFun(NULL), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
   mXMin(xmin), mXMax(xmax)
 {}
 
-//! Constructeur à partir de la fonction double->double, et des bornes d'intégration.
-Integrator::Integrator(fun f, double xmin, double xmax)
-: mFunc(new Function(f)), mGFF(NULL), mGFFParm(NULL),
-  mNStep(50), mDX(-1), mReqPrec(-1),
-  mXMin(xmin), mXMax(xmax)
-{}
-
+
+/*!
+  Constructeur a partir d'une classe-fonction 
+  sans spécifier les bornes. Elles sont positionnées
+  à [0,1], et on pourra les modifier plus tard.
+*/
+Integrator::Integrator(ClassFunc const & f)
+: mFunc(NULL), mClFun(&f), mGFF(NULL), mGFFParm(NULL),
+  mNStep(50), mDX(-1), mReqPrec(-1),
+  mXMin(0), mXMax(1)
+{}
 
 /*!
@@ -53,15 +65,5 @@
 */
 Integrator::Integrator(FUNC f)
-: mFunc(f), mGFF(NULL), mGFFParm(NULL),
-  mNStep(50), mDX(-1), mReqPrec(-1),
-  mXMin(0), mXMax(1)
-{}
-
-/*!
-  Constructeur sans spécifier les bornes. Elles sont positionnées
-  à [0,1], et on pourra les modifier plus tard.
-*/
-Integrator::Integrator(fun f)
-: mFunc(new Function(f)), mGFF(NULL), mGFFParm(NULL),
+: mFunc(f), mClFun(NULL), mGFF(NULL), mGFFParm(NULL),
   mNStep(50), mDX(-1), mReqPrec(-1),
   mXMin(0), mXMax(1)
@@ -74,5 +76,5 @@
 */
 Integrator::Integrator(GeneralFunction* gff, double* par, double xmin, double xmax)
-: mFunc(NULL), mGFF(gff), mGFFParm(par),
+: mFunc(NULL), mClFun(NULL), mGFF(gff), mGFFParm(par),
   mNStep(50), mDX(-1), mReqPrec(-1),
   mXMin(xmin), mXMax(xmax)
@@ -88,5 +90,5 @@
 */
 Integrator::Integrator(GeneralFunction* gff, double* par)
-: mFunc(NULL), mGFF(gff), mGFFParm(par),
+: mFunc(NULL), mClFun(NULL), mGFF(gff), mGFFParm(par),
   mNStep(50), mDX(-1), mReqPrec(-1),
   mXMin(0), mXMax(1)
@@ -96,5 +98,7 @@
 
 Integrator::~Integrator()
-{if(mFunc) delete mFunc;}
+{
+}
+
 
 /*! 
@@ -121,5 +125,6 @@
 {
   mDX = d;
-  mNStep = mReqPrec = -1;
+  mNStep = -1;
+  mReqPrec = -1.;
   StepsChanged();
   return *this;
@@ -154,7 +159,8 @@
 //! Spécifie la fonction à intégrer, sous forme double f(double).
 Integrator& 
-Integrator::Func(FUNC f)
-{
-  mFunc = f;
+Integrator::SetFunc(ClassFunc const & f)
+{
+  mFunc = NULL;
+  mClFun = &f;
   mGFFParm = NULL;
   mFunc = NULL;
@@ -163,4 +169,16 @@
 }
 
+//! Spécifie la fonction à intégrer, sous forme double f(double).
+Integrator& 
+Integrator::SetFunc(FUNC f)
+{
+  mFunc = f;
+  mClFun = NULL;
+  mGFFParm = NULL;
+  mFunc = NULL;
+  FuncChanged();
+  return *this;
+}
+
 /*!
   \brief Spécifie la fonction à intégrer, sous forme de GeneralFunction 
@@ -168,5 +186,5 @@
 */
 Integrator& 
-Integrator::Func(GeneralFunction* gff, double* par)
+Integrator::SetFunc(GeneralFunction* gff, double* par)
 {
   mGFF = gff;
@@ -181,7 +199,8 @@
 Integrator::FVal(double x) const
 {
-  DBASSERT( mFunc || (mGFF && mGFFParm) );
-  return mFunc ? (*mFunc)(x) : mGFF->Value(&x, mGFFParm); 
-  }
+  DBASSERT( mFunc || mClFun || (mGFF && mGFFParm) );
+  if (mFunc) return mFunc(x);
+  else return mClFun ? (*mClFun)(x) : mGFF->Value(&x, mGFFParm); 
+}
 
 double
@@ -197,5 +216,5 @@
  cout<<"Integrator between "<<mXMin<<" and "<<mXMax
      <<" in "<<mNStep<<" steps"<<endl;
- if(lp>1) cout<<"mFunc="<<mFunc<<"mGFF="<<mGFF
+ if(lp>1) cout<<"mFunc="<<mFunc<<"mClFun="<<mClFun<<"mGFF="<<mGFF
               <<"mReqPrec="<<mReqPrec<<"mDX="<<mDX<<endl;
 }
@@ -220,17 +239,17 @@
 {}
 
+TrpzInteg::TrpzInteg(ClassFunc const & f, double xmin, double xmax)
+: Integrator(f, xmin, xmax)
+{}
+
 TrpzInteg::TrpzInteg(FUNC f, double xmin, double xmax)
 : Integrator(f, xmin, xmax)
 {}
 
-TrpzInteg::TrpzInteg(fun f, double xmin, double xmax)
-: Integrator(f, xmin, xmax)
+TrpzInteg::TrpzInteg(ClassFunc const & f)
+: Integrator(f)
 {}
 
 TrpzInteg::TrpzInteg(FUNC f)
-: Integrator(f)
-{}
-
-TrpzInteg::TrpzInteg(fun f)
 : Integrator(f)
 {}
@@ -301,4 +320,10 @@
 
 
+GLInteg::GLInteg(ClassFunc const & f, double xmin, double xmax)
+: Integrator(f, xmin, xmax), mXPos(NULL), mWeights(NULL), mOrder(8)
+{
+  NStep(1);
+}
+
 GLInteg::GLInteg(FUNC f, double xmin, double xmax)
 : Integrator(f, xmin, xmax), mXPos(NULL), mWeights(NULL), mOrder(8)
@@ -307,6 +332,6 @@
 }
 
-GLInteg::GLInteg(fun f, double xmin, double xmax)
-: Integrator(f, xmin, xmax), mXPos(NULL), mWeights(NULL), mOrder(8)
+GLInteg::GLInteg(ClassFunc const & f)
+: Integrator(f), mXPos(NULL), mWeights(NULL), mOrder(8)
 {
   NStep(1);
@@ -314,10 +339,4 @@
 
 GLInteg::GLInteg(FUNC f)
-: Integrator(f), mXPos(NULL), mWeights(NULL), mOrder(8)
-{
-  NStep(1);
-}
-
-GLInteg::GLInteg(fun f)
 : Integrator(f), mXPos(NULL), mWeights(NULL), mOrder(8)
 {
Index: /trunk/SophyaLib/NTools/integ.h
===================================================================
--- /trunk/SophyaLib/NTools/integ.h	(revision 3097)
+++ /trunk/SophyaLib/NTools/integ.h	(revision 3098)
@@ -18,14 +18,12 @@
 class Integrator {
 public:
-  //typedef double(*FUNC)(double);
-  typedef ClassFunc *FUNC;
-  typedef double (*fun)(double);
+  typedef double(*FUNC)(double);
 
   Integrator();
+  Integrator(ClassFunc const &, double xmin, double xmax);
+  Integrator(ClassFunc const &);
+
   Integrator(FUNC, double xmin, double xmax);
   Integrator(FUNC);
-
-  Integrator(fun, double xmin, double xmax);
-  Integrator(fun);
 
   Integrator(GeneralFunction*, double* par, double xmin, double xmax);
@@ -41,6 +39,7 @@
   virtual Integrator& ReqPrec(double);   // NOT YET !
   virtual Integrator& Limits(double xmin, double xmax);
-  virtual Integrator& Func(FUNC);
-  virtual Integrator& Func(GeneralFunction*, double* par);
+  virtual Integrator& SetFunc(ClassFunc const &);
+  virtual Integrator& SetFunc(FUNC);
+  virtual Integrator& SetFunc(GeneralFunction*, double* par);
 
   virtual inline  int GetNStep(void) {return mNStep;}
@@ -49,4 +48,5 @@
 protected:
   FUNC             mFunc;
+  ClassFunc const* mClFun;
   GeneralFunction* mGFF;
   double*          mGFFParm;
@@ -68,8 +68,8 @@
 public:
   TrpzInteg();
+  TrpzInteg(ClassFunc const &, double xmin, double xmax);
+  TrpzInteg(ClassFunc const &);
   TrpzInteg(FUNC, double xmin, double xmax);
   TrpzInteg(FUNC);
-  TrpzInteg(fun, double xmin, double xmax);
-  TrpzInteg(fun);
   TrpzInteg(GeneralFunction*, double* par, double xmin, double xmax);
   TrpzInteg(GeneralFunction*, double* par);
@@ -83,8 +83,8 @@
 public:
   GLInteg();
+  GLInteg(ClassFunc const &, double xmin, double xmax);
+  GLInteg(ClassFunc const &);
   GLInteg(FUNC, double xmin, double xmax);
   GLInteg(FUNC);
-  GLInteg(fun, double xmin, double xmax);
-  GLInteg(fun);
   GLInteg(GeneralFunction*, double* par, double xmin, double xmax);
   GLInteg(GeneralFunction*, double* par);
