[Minuit2] Remove output buffers from FCNAdapter

The FCNBase interface requres returning `std::vector` by value, so the
buffers would have to be copied anyway. Therefore, there is no benefit
of using in-place output buffers.

Author: guitargeek

math/minuit2/inc/Minuit2/FCNAdapter.h

@@ -37,8 +37,6 @@ class FCNAdapter : public FCNBase {
 public:
    FCNAdapter(std::function<double(double const *)> f, double up = 1.) : fUp(up), fFunc(std::move(f)) {}
 
-   void SetGradientBufferSize(std::size_t n) { fGrad.resize(n); }
-
    bool HasGradient() const override { return bool(fGradFunc); }
    bool HasG2() const override { return bool(fG2Func); }
    bool HasHessian() const override { return bool(fHessianFunc); }
@@ -49,65 +47,59 @@ class FCNAdapter : public FCNBase {
 
    std::vector<double> Gradient(std::vector<double> const &v) const override
    {
-      fGradFunc(v.data(), fGrad.data());
-      return fGrad;
+      std::vector<double> output(v.size());
+      fGradFunc(v.data(), output.data());
+      return output;
    }
    std::vector<double> GradientWithPrevResult(std::vector<double> const &v, double *previous_grad, double *previous_g2,
                                               double *previous_gstep) const override
    {
-      fGradWithPrevResultFunc(v.data(), fGrad.data(), previous_grad, previous_g2, previous_gstep);
-      return fGrad;
+      std::vector<double> output(v.size());
+      fGradWithPrevResultFunc(v.data(), output.data(), previous_grad, previous_g2, previous_gstep);
+      return output;
    }
 
    GradientParameterSpace gradParameterSpace() const override
    {
-      if (fReturnsInMinuit2ParameterSpace) {
-         return GradientParameterSpace::Internal;
-      } else {
-         return GradientParameterSpace::External;
-      }
+      return fReturnsInMinuit2ParameterSpace ? GradientParameterSpace::Internal : GradientParameterSpace::External;
    }
 
    /// return second derivatives (diagonal of the Hessian matrix)
    std::vector<double> G2(std::vector<double> const &x) const override
    {
+      std::vector<double> output;
       if (fG2Func)
          return fG2Func(x);
       if (fHessianFunc) {
-         unsigned int n = fGrad.size();
-         if (fG2Vec.empty())
-            fG2Vec.resize(n);
+         std::size_t n = x.size();
+         output.resize(n);
          if (fHessian.empty())
             fHessian.resize(n * n);
          fHessianFunc(x, fHessian.data());
          if (!fHessian.empty()) {
             // get diagonal element of h
             for (unsigned int i = 0; i < n; i++)
-               fG2Vec[i] = fHessian[i * n + i];
-         } else
-            fG2Vec.clear();
-      } else if (!fG2Vec.empty())
-         fG2Vec.clear();
-      return fG2Vec;
+               output[i] = fHessian[i * n + i];
+         }
+      }
+      return output;
    }
 
    /// compute Hessian. Return Hessian as a std::vector of size(n*n)
    std::vector<double> Hessian(std::vector<double> const &x) const override
    {
-      unsigned int n = fGrad.size();
+      std::vector<double> output;
       if (fHessianFunc) {
-         if (fHessian.empty())
-            fHessian.resize(n * n);
-         bool ret = fHessianFunc(x, fHessian.data());
+         std::size_t n = x.size();
+         output.resize(n * n);
+         bool ret = fHessianFunc(x, output.data());
          if (!ret) {
-            fHessian.clear();
+            output.clear();
             fHessianFunc = nullptr;
          }
-      } else {
-         fHessian.clear();
       }
 
-      return fHessian;
+      return output;
    }
 
    void SetReturnsInMinuit2ParameterSpace(bool flag) { fReturnsInMinuit2ParameterSpace = flag; }
@@ -134,9 +126,7 @@ class FCNAdapter : public FCNBase {
 
    bool fReturnsInMinuit2ParameterSpace = false;
    double fUp = 1.;
-   mutable std::vector<double> fGrad;
    mutable std::vector<double> fHessian;
-   mutable std::vector<double> fG2Vec;
 
    Function fFunc;
    GradFunction fGradFunc;

math/minuit2/src/Minuit2Minimizer.cxx

@@ -404,7 +404,6 @@ void Minuit2Minimizer::SetFunction(const ROOT::Math::IMultiGenFunction &func)
             gradFunc.GradientWithPrevResult(params, grad, previous_grad, previous_g2, previous_gstep);
          };
          adapter->SetGradientFunction(lambdaGrad);
-         adapter->SetGradientBufferSize(func.NDim());
          adapter->SetGradWithPrevResultFunction(lambdaGradWithPrevResult);
          adapter->SetReturnsInMinuit2ParameterSpace(gradFunc.returnsInMinuit2ParameterSpace());
       }