RooFit::MultiProcess & TestStatistics part 5b: test RooGradMinimizerFcn

math/mathcore/inc/Fit/Chi2FCN.h

@@ -126,6 +126,14 @@ class Chi2FCN : public BasicFCN<DerivFunType, ModelFunType, BinData> {
       FitUtil::Evaluate<T>::EvalChi2Gradient(BaseFCN::ModelFunction(), BaseFCN::Data(), x, g, fNEffPoints,
                                              fExecutionPolicy);
    }
+   /// In some cases, the gradient algorithm will use information from the previous step, these can be passed
+   /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+   /// so that these can be passed forward again as well at the call site, if necessary.
+   /// \warning This implementation just calls the two-parameter overload.
+   virtual void Gradient(const double *x, double *g, double */*previous_grad*/, double */*previous_g2*/, double */*previous_gstep*/) const
+   {
+      Gradient(x, g);
+   }
 
    /// get type of fit method function
    virtual  typename BaseObjFunction::Type_t Type() const { return BaseObjFunction::kLeastSquare; }
@@ -154,6 +162,15 @@ class Chi2FCN : public BasicFCN<DerivFunType, ModelFunType, BinData> {
       Gradient(x, fGrad.data());
       return fGrad[icoord];
    }
+   /// In some cases, the derivative algorithm will use information from the previous step, these can be passed
+   /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+   /// so that these can be passed forward again as well at the call site, if necessary.
+   /// \warning This implementation just calls the two-parameter overload.
+   virtual double DoDerivative(const double *x, unsigned int icoord, double * /*previous_grad*/, double * /*previous_g2*/,
+                               double * /*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
 
 
    mutable unsigned int fNEffPoints;  // number of effective points used in the fit

math/mathcore/inc/Fit/LogLikelihoodFCN.h

@@ -129,6 +129,14 @@ class LogLikelihoodFCN : public BasicFCN<DerivFunType,ModelFunType,UnBinData>  {
       FitUtil::Evaluate<typename BaseFCN::T>::EvalLogLGradient(BaseFCN::ModelFunction(), BaseFCN::Data(), x, g,
                                                                fNEffPoints, fExecutionPolicy);
    }
+   /// In some cases, the gradient algorithm will use information from the previous step, these can be passed
+   /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+   /// so that these can be passed forward again as well at the call site, if necessary.
+   /// \warning This overload just calls the two-parameter version.
+   virtual void Gradient(const double *x, double *g, double */*previous_grad*/, double */*previous_g2*/, double */*previous_gstep*/) const
+   {
+      Gradient(x, g);
+   }
 
    /// get type of fit method function
    virtual  typename BaseObjFunction::Type_t Type() const { return BaseObjFunction::kLogLikelihood; }
@@ -162,6 +170,14 @@ class LogLikelihoodFCN : public BasicFCN<DerivFunType,ModelFunType,UnBinData>  {
       Gradient(x, &fGrad[0]);
       return fGrad[icoord];
    }
+   /// In some cases, the derivative algorithm will use information from the previous step, these can be passed
+   /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+   /// so that these can be passed forward again as well at the call site, if necessary.
+   virtual double DoDerivative(const double *x, unsigned int icoord, double * /*previous_grad*/, double * /*previous_g2*/,
+                               double * /*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
 
 
       //data member

math/mathcore/inc/Fit/PoissonLikelihoodFCN.h

@@ -130,6 +130,14 @@ class PoissonLikelihoodFCN : public BasicFCN<DerivFunType,ModelFunType,BinData>
       FitUtil::Evaluate<typename BaseFCN::T>::EvalPoissonLogLGradient(BaseFCN::ModelFunction(), BaseFCN::Data(), x, g,
                                                                       fNEffPoints, fExecutionPolicy);
    }
+   /// In some cases, the gradient algorithm will use information from the previous step, these can be passed
+   /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+   /// so that these can be passed forward again as well at the call site, if necessary.
+   /// \warning This implementation just calls the two-parameter overload.
+   virtual void Gradient(const double *x, double *g, double */*previous_grad*/, double */*previous_g2*/, double */*previous_gstep*/) const
+   {
+      Gradient(x, g);
+   }
 
    /// get type of fit method function
    virtual  typename BaseObjFunction::Type_t Type() const { return BaseObjFunction::kLogLikelihood; }
@@ -170,6 +178,15 @@ class PoissonLikelihoodFCN : public BasicFCN<DerivFunType,ModelFunType,BinData>
       Gradient(x, &fGrad[0]);
       return fGrad[icoord];
    }
+   /// In some cases, the derivative algorithm will use information from the previous step, these can be passed
+   /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+   /// so that these can be passed forward again as well at the call site, if necessary.
+   /// \warning This implementation just calls the two-parameter overload.
+   virtual double DoDerivative(const double *x, unsigned int icoord, double * /*previous_grad*/, double * /*previous_g2*/,
+                               double * /*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
 
 
       //data member

math/mathcore/inc/Math/Functor.h

@@ -128,6 +128,14 @@ private :
       return fFunc.Derivative(x,icoord);
    }
 
+   // TODO: implementing this will require extending with another function signature in GradFunctor
+   /// \warning This overload just calls the two-parameter version.
+   inline double DoDerivative(const double *x, unsigned int icoord, double */*previous_grad*/, double */*previous_g2*/,
+                              double */*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
+
 
    unsigned int fDim;
    mutable Func fFunc;  // should here be a reference and pass a non-const ref in ctor
@@ -211,6 +219,13 @@ private :
       return fGradFunc(x, icoord);
    }
 
+   // TODO: implementing this will require extending with another function signature in GradFunctor
+   /// \warning This overload just calls the two-parameter version.
+   inline double DoDerivative(const double *x, unsigned int icoord, double */*previous_grad*/, double */*previous_g2*/,
+                              double */*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
 
    unsigned int fDim;
    mutable Func fFunc;
@@ -348,6 +363,14 @@ private :
       return ((*fObj).*fGradMemFn)(x,icoord);
    }
 
+   // TODO: implementing this will require extending with another function signature in GradFunctor
+   /// \warning This overload just calls the two-parameter version.
+   inline double DoDerivative(const double *x, unsigned int icoord, double */*previous_grad*/, double */*previous_g2*/,
+                              double */*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
+
    unsigned int fDim;
    mutable PointerToObj fObj;
    PointerToMemFn fMemFn;
@@ -702,6 +725,14 @@ private :
       return fImpl->Derivative(x,icoord);
    }
 
+   // TODO: implementing this will require extending with another function signature in GradFunctor
+   /// \warning This overload just calls the two-parameter version.
+   inline double DoDerivative(const double *x, unsigned int icoord, double */*previous_grad*/, double */*previous_g2*/,
+                              double */*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
+
    std::unique_ptr<Impl> fImpl;    // pointer to base grad functor handler
 
 

math/mathcore/inc/Math/IFunction.h

@@ -215,6 +215,14 @@ namespace ROOT {
             Return the partial derivative with respect to the passed coordinate
          */
          T Derivative(const T *x, unsigned int icoord = 0) const { return DoDerivative(x, icoord); }
+         /// In some cases, the derivative algorithm will use information from the previous step, these can be passed
+         /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+         /// so that these can be passed forward again as well at the call site, if necessary.
+         T Derivative(const T *x, unsigned int icoord, T *previous_grad, T *previous_g2,
+                      T *previous_gstep) const
+         {
+            return DoDerivative(x, icoord, previous_grad, previous_g2, previous_gstep);
+         }
 
          /**
              Optimized method to evaluate at the same time the function value and derivative at a point x.
@@ -232,6 +240,14 @@ namespace ROOT {
             function to evaluate the derivative with respect each coordinate. To be implemented by the derived class
          */
          virtual T DoDerivative(const T *x, unsigned int icoord) const = 0;
+         /// In some cases, the derivative algorithm will use information from the previous step, these can be passed
+         /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+         /// so that these can be passed forward again as well at the call site, if necessary.
+         virtual T DoDerivative(const T *x, unsigned int icoord, T * /*previous_grad*/, T * /*previous_g2*/,
+                                T * /*previous_gstep*/) const
+         {
+            return DoDerivative(x, icoord);
+         };
       };
 
 //___________________________________________________________________________________
@@ -346,6 +362,16 @@ namespace ROOT {
                grad[icoord] = BaseGrad::Derivative(x, icoord);
          }
 
+         /// In some cases, the gradient algorithm will use information from the previous step, these can be passed
+         /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+         /// so that these can be passed forward again as well at the call site, if necessary.
+         virtual void Gradient(const T *x, T *grad, T *previous_grad, T *previous_g2, T *previous_gstep) const
+         {
+            unsigned int ndim = NDim();
+            for (unsigned int icoord  = 0; icoord < ndim; ++icoord)
+               grad[icoord] = BaseGrad::Derivative(x, icoord, previous_grad, previous_g2, previous_gstep);
+         }
+
          using  BaseFunc::NDim;
 
          /**

math/mathcore/inc/Math/MinimTransformFunction.h

@@ -123,6 +123,14 @@ class MinimTransformFunction : public IMultiGradFunction {
       //std::cout << "Derivative icoord (ext)" << fIndex[icoord] << "   dtrafo " << dExtdInt << "  " << deriv << std::endl;
       return deriv * dExtdInt;
    }
+   /// In some cases, the derivative algorithm will use information from the previous step, these can be passed
+   /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+   /// so that these can be passed forward again as well at the call site, if necessary.
+   virtual double DoDerivative(const double *x, unsigned int icoord, double * /*previous_grad*/, double * /*previous_g2*/,
+                               double * /*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
 
    // copy constructor for this class (disable by having it private)
    MinimTransformFunction( const MinimTransformFunction & ) :

math/mathcore/test/fit/testMinim.cxx

@@ -188,6 +188,10 @@ public :
       }
 
    }
+   void Gradient(const double *x, double *g, double */*previous_grad*/, double */*previous_g2*/, double */*previous_gstep*/) const
+   {
+      Gradient(x, g);
+   }
 
 #ifdef USE_FDF
    void FdF (const double * x, double & f, double * g) const {
@@ -240,6 +244,11 @@ public :
       Gradient(x,&g[0]);
       return  g[i];
    }
+   double DoDerivative(const double *x, unsigned int icoord, double * /*previous_grad*/, double * /*previous_g2*/,
+                       double * /*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
 
 private:
 
@@ -322,6 +331,10 @@ public :
 
 
    }
+   void Gradient(const double *x, double *g, double */*previous_grad*/, double */*previous_g2*/, double */*previous_gstep*/) const
+   {
+      Gradient(x, g);
+   }
 
    private:
 
@@ -342,6 +355,11 @@ public :
       Gradient(x,&g[0]);
       return  g[i];
    }
+   double DoDerivative(const double *x, unsigned int icoord, double * /*previous_grad*/, double * /*previous_g2*/,
+                       double * /*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
 
    void DoCalculatefi(const double * x) const {
       // calculate the i- element ; F(X) = Sum {fi]

math/mathmore/inc/Math/GSLNLSMinimizer.h

@@ -102,6 +102,14 @@ class LSResidualFunc : public IMultiGradFunction {
       double f0 = 0;
       FdF(x,f0,g);
    }
+   /// In some cases, the gradient algorithm will use information from the previous step, these can be passed
+   /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+   /// so that these can be passed forward again as well at the call site, if necessary.
+   /// \warning This implementation just calls the two-parameter overload.
+   virtual void Gradient(const double *x, double *g, double */*previous_grad*/, double */*previous_g2*/, double */*previous_gstep*/) const
+   {
+      Gradient(x, g);
+   }
 
    void FdF (const double * x, double & f, double * g) const {
       unsigned int n = NDim();
@@ -129,6 +137,15 @@ class LSResidualFunc : public IMultiGradFunction {
       fX2[icoord] += kEps;
       return ( DoEval(&fX2.front()) - DoEval(x) )/kEps;
    }
+   /// In some cases, the derivative algorithm will use information from the previous step, these can be passed
+   /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+   /// so that these can be passed forward again as well at the call site, if necessary.
+   /// \warning This implementation just calls the two-parameter overload.
+   virtual double DoDerivative(const double *x, unsigned int icoord, double * /*previous_grad*/, double * /*previous_g2*/,
+                               double * /*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
 
    unsigned int fIndex;
    const ROOT::Math::FitMethodFunction * fChi2;

math/mathmore/inc/Math/MultiNumGradFunction.h

@@ -122,6 +122,15 @@ class MultiNumGradFunction : public IMultiGradFunction {
 
    // calculate derivative using mathcore derivator
    double DoDerivative (const double * x, unsigned int icoord  ) const;
+   /// In some cases, the derivative algorithm will use information from the previous step, these can be passed
+   /// in with this overload. The `previous_*` arrays can also be used to return second derivative and step size
+   /// so that these can be passed forward again as well at the call site, if necessary.
+   /// \warning This implementation just calls the two-parameter overload.
+   virtual double DoDerivative(const double *x, unsigned int icoord, double * /*previous_grad*/, double * /*previous_g2*/,
+                               double * /*previous_gstep*/) const
+   {
+      return DoDerivative(x, icoord);
+   }
 
    // adapat internal function type to IMultiGenFunction needed by derivative calculation
    const IMultiGenFunction * fFunc;

math/minuit2/inc/Minuit2/FCNGradAdapter.h

@@ -54,6 +54,18 @@ class FCNGradAdapter : public FCNGradientBase {
       });
       return fGrad;
    }
+   std::vector<double> Gradient(const std::vector<double> &v, double *previous_grad, double *previous_g2,
+                                double *previous_gstep) const override
+   {
+      fFunc.Gradient(&v[0], &fGrad[0], previous_grad, previous_g2, previous_gstep);
+
+      MnPrint("FCNGradAdapter").Debug([&](std::ostream &os) {
+         os << "gradient in FCNAdapter = {";
+         for (unsigned int i = 0; i < fGrad.size(); ++i)
+            os << fGrad[i] << (i == fGrad.size() - 1 ? '}' : '\t');
+      });
+      return fGrad;
+   }
    // forward interface
    // virtual double operator()(int npar, double* params,int iflag = 4) const;
    bool CheckGradient() const override { return false; }

math/minuit2/inc/Minuit2/FCNGradientBase.h

@@ -41,6 +41,8 @@ class FCNGradientBase : public FCNBase {
    virtual ~FCNGradientBase() {}
 
    virtual std::vector<double> Gradient(const std::vector<double> &) const = 0;
+   virtual std::vector<double> Gradient(const std::vector<double> &parameters, double */*previous_grad*/, double */*previous_g2*/,
+                                        double */*previous_gstep*/) const { return Gradient(parameters); };
 
    virtual bool CheckGradient() const { return true; }
 

math/minuit2/inc/Minuit2/NumericalDerivator.h

@@ -70,8 +70,7 @@ class NumericalDerivator {
    double Ext2int(const ROOT::Fit::ParameterSettings &parameter, double val) const;
    double DInt2Ext(const ROOT::Fit::ParameterSettings &parameter, double val) const;
 
-   void SetInitialGradient(const ROOT::Math::IBaseFunctionMultiDim *function,
-                           const std::vector<ROOT::Fit::ParameterSettings> &parameters,
+   void SetInitialGradient(const std::vector<ROOT::Fit::ParameterSettings> &parameters,
                            std::vector<DerivatorElement> &gradient);
 
    inline bool AlwaysExactlyMimicMinuit2() const { return fAlwaysExactlyMimicMinuit2; }