EIC code displayed by LXR master/​include/​opencascade/​MathUtils_FunctorScalar.hxx	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-09-28 09:20:54

 // Copyright (c) 2025 OPEN CASCADE SAS
 //
 // This file is part of Open CASCADE Technology software library.
 //
 // This library is free software; you can redistribute it and/or modify it under
 // the terms of the GNU Lesser General Public License version 2.1 as published
 // by the Free Software Foundation, with special exception defined in the file
 // OCCT_LGPL_EXCEPTION.txt. Consult the file LICENSE_LGPL_21.txt included in OCCT
 // distribution for complete text of the license and disclaimer of any warranty.
 //
 // Alternatively, this file may be used under the terms of Open CASCADE
 // commercial license or contractual agreement.
 
 #ifndef _MathUtils_FunctorScalar_HeaderFile
 #define _MathUtils_FunctorScalar_HeaderFile
 
 #include <math_Vector.hxx>
 
 #include <cmath>
 #include <initializer_list>
 #include <utility>
 
 //! @file MathUtils_FunctorScalar.hxx
 //! @brief Non-virtual functor classes for scalar (1D) functions.
 //!
 //! Provides ready-to-use functor classes that work with the template-based
 //! math API (MathRoot, MathOpt, MathInteg) without virtual dispatch overhead.
 
 //! Core utilities for modern math solvers.
 namespace MathUtils
 {
 
 //! Lambda wrapper for scalar functions with value only.
 //! Wraps a lambda/callable into a functor with Value() method.
 //!
 //! Usage:
 //! @code
 //! auto aFunc = ScalarLambda([](double x, double& y) {
 //!   y = x * x - 2.0;
 //!   return true;
 //! });
 //! auto aResult = MathRoot::Brent(aFunc, 0.0, 2.0);
 //! @endcode
 //!
 //! @tparam Lambda callable type with signature bool(double, double&)
 template <typename Lambda>
 class ScalarLambda
 {
 public:
   //! Constructor from lambda/callable.
   //! @param theLambda callable with signature bool(double theX, double& theY)
   explicit ScalarLambda(Lambda theLambda)
       : myLambda(std::move(theLambda))
   {
   }
 
   //! Evaluates the function at theX.
   //! @param[in] theX input value
   //! @param[out] theY function value f(theX)
   //! @return true if evaluation succeeded
   bool Value(double theX, double& theY) const { return myLambda(theX, theY); }
 
 private:
   Lambda myLambda;
 };
 
 //! Lambda wrapper for scalar functions with value and derivative.
 //! Wraps a lambda/callable into a functor with Values() method.
 //!
 //! Usage:
 //! @code
 //! auto aFunc = ScalarLambdaWithDerivative([](double x, double& y, double& dy) {
 //!   y = x * x - 2.0;
 //!   dy = 2.0 * x;
 //!   return true;
 //! });
 //! auto aResult = MathRoot::Newton(aFunc, 1.0);
 //! @endcode
 //!
 //! @tparam Lambda callable type with signature bool(double, double&, double&)
 template <typename Lambda>
 class ScalarLambdaWithDerivative
 {
 public:
   //! Constructor from lambda/callable.
   //! @param theLambda callable with signature bool(double theX, double& theY, double& theDY)
   explicit ScalarLambdaWithDerivative(Lambda theLambda)
       : myLambda(std::move(theLambda))
   {
   }
 
   //! Evaluates function and derivative at theX.
   //! @param[in] theX input value
   //! @param[out] theY function value f(theX)
   //! @param[out] theDY derivative value f'(theX)
   //! @return true if evaluation succeeded
   bool Values(double theX, double& theY, double& theDY) const
   {
     return myLambda(theX, theY, theDY);
   }
 
   //! Evaluates only the function value (for algorithms that don't need derivative).
   //! @param[in] theX input value
   //! @param[out] theY function value f(theX)
   //! @return true if evaluation succeeded
   bool Value(double theX, double& theY) const
   {
     double aDummy = 0.0;
     return myLambda(theX, theY, aDummy);
   }
 
 private:
   Lambda myLambda;
 };
 
 //! Helper function to create ScalarLambda with type deduction.
 //! @tparam Lambda callable type (auto-deduced)
 //! @param theLambda callable with signature bool(double, double&)
 //! @return ScalarLambda wrapper
 template <typename Lambda>
 ScalarLambda<Lambda> MakeScalar(Lambda theLambda)
 {
   return ScalarLambda<Lambda>(std::move(theLambda));
 }
 
 //! Helper function to create ScalarLambdaWithDerivative with type deduction.
 //! @tparam Lambda callable type (auto-deduced)
 //! @param theLambda callable with signature bool(double, double&, double&)
 //! @return ScalarLambdaWithDerivative wrapper
 template <typename Lambda>
 ScalarLambdaWithDerivative<Lambda> MakeScalarWithDerivative(Lambda theLambda)
 {
   return ScalarLambdaWithDerivative<Lambda>(std::move(theLambda));
 }
 
 //! Polynomial functor: f(x) = sum(a[i] * x^i).
 //! Coefficients are stored in order: a[0] + a[1]*x + a[2]*x^2 + ...
 //!
 //! Usage:
 //! @code
 //! // x^2 - 2 (find sqrt(2))
 //! Polynomial aPoly({-2.0, 0.0, 1.0});
 //!
 //! // x^3 - 6x^2 + 11x - 6 = (x-1)(x-2)(x-3)
 //! Polynomial aCubic({-6.0, 11.0, -6.0, 1.0});
 //! @endcode
 class Polynomial
 {
 public:
   //! Constructor from initializer list.
   //! @param theCoeffs coefficients in ascending power order
   Polynomial(std::initializer_list<double> theCoeffs)
       : myCoeffs(0, static_cast<int>(theCoeffs.size()) - 1)
   {
     int anIdx = 0;
     for (double aCoeff : theCoeffs)
     {
       myCoeffs(anIdx++) = aCoeff;
     }
   }
 
   //! Constructor from math_Vector.
   //! @param theCoeffs coefficients in ascending power order
   explicit Polynomial(const math_Vector& theCoeffs)
       : myCoeffs(theCoeffs)
   {
   }
 
   //! Evaluates polynomial at theX using Horner's method.
   //! @param[in] theX input value
   //! @param[out] theY polynomial value p(theX)
   //! @return true (always succeeds for polynomials)
   bool Value(double theX, double& theY) const
   {
     if (myCoeffs.Length() <= 0)
     {
       theY = 0.0;
       return true;
     }
 
     // Horner's method: p(x) = a[0] + x*(a[1] + x*(a[2] + ...))
     const int aLast = myCoeffs.Upper();
     theY            = myCoeffs(aLast);
     for (int i = aLast - 1; i >= myCoeffs.Lower(); --i)
     {
       theY = theY * theX + myCoeffs(i);
     }
     return true;
   }
 
   //! Evaluates polynomial and its derivative at theX.
   //! @param[in] theX input value
   //! @param[out] theY polynomial value p(theX)
   //! @param[out] theDY derivative value p'(theX)
   //! @return true (always succeeds for polynomials)
   bool Values(double theX, double& theY, double& theDY) const
   {
     if (myCoeffs.Length() <= 0)
     {
       theY  = 0.0;
       theDY = 0.0;
       return true;
     }
 
     const int n = myCoeffs.Length();
     if (n == 1)
     {
       theY  = myCoeffs(myCoeffs.Lower());
       theDY = 0.0;
       return true;
     }
 
     // Horner's method for value and derivative simultaneously
     const int aLower = myCoeffs.Lower();
     const int aLast  = myCoeffs.Upper();
     theY             = myCoeffs(aLast);
     theDY            = 0.0;
     for (int i = aLast - 1; i >= aLower; --i)
     {
       theDY = theDY * theX + theY;
       theY  = theY * theX + myCoeffs(i);
     }
     return true;
   }
 
   //! Returns the degree of the polynomial.
   //! @return polynomial degree (number of coefficients - 1)
   int Degree() const { return myCoeffs.Length() <= 0 ? 0 : myCoeffs.Length() - 1; }
 
   //! Returns coefficient by index.
   //! @param theIndex coefficient index (0 = constant term)
   //! @return coefficient value
   double Coefficient(int theIndex) const
   {
     const int aIdx = myCoeffs.Lower() + theIndex;
     return (aIdx >= myCoeffs.Lower() && aIdx <= myCoeffs.Upper()) ? myCoeffs(aIdx) : 0.0;
   }
 
 private:
   math_Vector myCoeffs;
 };
 
 //! Rational function functor: f(x) = P(x) / Q(x).
 //! Both numerator P and denominator Q are polynomials.
 //!
 //! Usage:
 //! @code
 //! // (x + 1) / (x^2 + 1)
 //! Rational aRat({1.0, 1.0}, {1.0, 0.0, 1.0});
 //! @endcode
 class Rational
 {
 public:
   //! Constructor from math_Vector.
   //! @param theNum numerator coefficients (ascending power order)
   //! @param theDenom denominator coefficients (ascending power order)
   Rational(const math_Vector& theNum, const math_Vector& theDenom)
       : myNum(theNum),
         myDenom(theDenom)
   {
   }
 
   //! Constructor from initializer lists.
   //! @param theNum numerator coefficients
   //! @param theDenom denominator coefficients
   Rational(std::initializer_list<double> theNum, std::initializer_list<double> theDenom)
       : myNum(0, static_cast<int>(theNum.size()) - 1),
         myDenom(0, static_cast<int>(theDenom.size()) - 1)
   {
     int anIdx = 0;
     for (double aCoeff : theNum)
     {
       myNum(anIdx++) = aCoeff;
     }
     anIdx = 0;
     for (double aCoeff : theDenom)
     {
       myDenom(anIdx++) = aCoeff;
     }
   }
 
   //! Evaluates rational function at theX.
   //! @param[in] theX input value
   //! @param[out] theY function value P(theX)/Q(theX)
   //! @return false if denominator is zero
   bool Value(double theX, double& theY) const
   {
     double aNum   = 0.0;
     double aDenom = 0.0;
 
     // Evaluate numerator using Horner's method
     if (myNum.Length() > 0)
     {
       const int aLast = myNum.Upper();
       aNum            = myNum(aLast);
       for (int i = aLast - 1; i >= myNum.Lower(); --i)
       {
         aNum = aNum * theX + myNum(i);
       }
     }
 
     // Evaluate denominator using Horner's method
     if (myDenom.Length() > 0)
     {
       const int aLast = myDenom.Upper();
       aDenom          = myDenom(aLast);
       for (int i = aLast - 1; i >= myDenom.Lower(); --i)
       {
         aDenom = aDenom * theX + myDenom(i);
       }
     }
 
     // Check for division by zero
     if (std::abs(aDenom) < 1e-15)
     {
       return false;
     }
 
     theY = aNum / aDenom;
     return true;
   }
 
 private:
   math_Vector myNum;
   math_Vector myDenom;
 };
 
 //! Composite functor: f(g(x)).
 //! Evaluates the outer function at the result of the inner function.
 //!
 //! Usage:
 //! @code
 //! Polynomial aInner({0.0, 1.0});         // g(x) = x
 //! Polynomial aOuter({-1.0, 0.0, 1.0});   // f(x) = x^2 - 1
 //! Composite aComp(aOuter, aInner);       // f(g(x)) = x^2 - 1
 //! @endcode
 //!
 //! @tparam Outer outer function type (must have Value method)
 //! @tparam Inner inner function type (must have Value method)
 template <typename Outer, typename Inner>
 class Composite
 {
 public:
   //! Constructor from outer and inner functions.
   //! @param theOuter outer function f
   //! @param theInner inner function g
   Composite(Outer theOuter, Inner theInner)
       : myOuter(std::move(theOuter)),
         myInner(std::move(theInner))
   {
   }
 
   //! Evaluates composite function f(g(theX)).
   //! @param[in] theX input value
   //! @param[out] theY function value f(g(theX))
   //! @return false if either evaluation fails
   bool Value(double theX, double& theY) const
   {
     double aInner = 0.0;
     if (!myInner.Value(theX, aInner))
     {
       return false;
     }
     return myOuter.Value(aInner, theY);
   }
 
 private:
   Outer myOuter;
   Inner myInner;
 };
 
 //! Helper function to create Composite with type deduction.
 //! @tparam Outer outer function type
 //! @tparam Inner inner function type
 //! @param theOuter outer function f
 //! @param theInner inner function g
 //! @return Composite functor representing f(g(x))
 template <typename Outer, typename Inner>
 Composite<Outer, Inner> MakeComposite(Outer theOuter, Inner theInner)
 {
   return Composite<Outer, Inner>(std::move(theOuter), std::move(theInner));
 }
 
 //! Sum of functions functor: f(x) + g(x).
 //!
 //! Usage:
 //! @code
 //! Polynomial aF({1.0, 2.0});   // f(x) = 1 + 2x
 //! Polynomial aG({3.0, 0.0, 1.0}); // g(x) = 3 + x^2
 //! Sum aSum(aF, aG);            // h(x) = 4 + 2x + x^2
 //! @endcode
 //!
 //! @tparam F first function type
 //! @tparam G second function type
 template <typename F, typename G>
 class Sum
 {
 public:
   //! Constructor from two functions.
   //! @param theF first function
   //! @param theG second function
   Sum(F theF, G theG)
       : myF(std::move(theF)),
         myG(std::move(theG))
   {
   }
 
   //! Evaluates sum f(theX) + g(theX).
   //! @param[in] theX input value
   //! @param[out] theY sum value
   //! @return false if either evaluation fails
   bool Value(double theX, double& theY) const
   {
     double aF = 0.0;
     double aG = 0.0;
     if (!myF.Value(theX, aF))
     {
       return false;
     }
     if (!myG.Value(theX, aG))
     {
       return false;
     }
     theY = aF + aG;
     return true;
   }
 
 private:
   F myF;
   G myG;
 };
 
 //! Helper function to create Sum with type deduction.
 template <typename F, typename G>
 Sum<F, G> MakeSum(F theF, G theG)
 {
   return Sum<F, G>(std::move(theF), std::move(theG));
 }
 
 //! Difference of functions functor: f(x) - g(x).
 //!
 //! @tparam F first function type
 //! @tparam G second function type
 template <typename F, typename G>
 class Difference
 {
 public:
   //! Constructor from two functions.
   //! @param theF first function (minuend)
   //! @param theG second function (subtrahend)
   Difference(F theF, G theG)
       : myF(std::move(theF)),
         myG(std::move(theG))
   {
   }
 
   //! Evaluates difference f(theX) - g(theX).
   //! @param[in] theX input value
   //! @param[out] theY difference value
   //! @return false if either evaluation fails
   bool Value(double theX, double& theY) const
   {
     double aF = 0.0;
     double aG = 0.0;
     if (!myF.Value(theX, aF))
     {
       return false;
     }
     if (!myG.Value(theX, aG))
     {
       return false;
     }
     theY = aF - aG;
     return true;
   }
 
 private:
   F myF;
   G myG;
 };
 
 //! Helper function to create Difference with type deduction.
 template <typename F, typename G>
 Difference<F, G> MakeDifference(F theF, G theG)
 {
   return Difference<F, G>(std::move(theF), std::move(theG));
 }
 
 //! Product of functions functor: f(x) * g(x).
 //!
 //! @tparam F first function type
 //! @tparam G second function type
 template <typename F, typename G>
 class Product
 {
 public:
   //! Constructor from two functions.
   //! @param theF first function (multiplicand)
   //! @param theG second function (multiplier)
   Product(F theF, G theG)
       : myF(std::move(theF)),
         myG(std::move(theG))
   {
   }
 
   //! Evaluates product f(theX) * g(theX).
   //! @param[in] theX input value
   //! @param[out] theY product value
   //! @return false if either evaluation fails
   bool Value(double theX, double& theY) const
   {
     double aF = 0.0;
     double aG = 0.0;
     if (!myF.Value(theX, aF))
     {
       return false;
     }
     if (!myG.Value(theX, aG))
     {
       return false;
     }
     theY = aF * aG;
     return true;
   }
 
 private:
   F myF;
   G myG;
 };
 
 //! Helper function to create Product with type deduction.
 template <typename F, typename G>
 Product<F, G> MakeProduct(F theF, G theG)
 {
   return Product<F, G>(std::move(theF), std::move(theG));
 }
 
 //! Quotient of functions functor: f(x) / g(x).
 //!
 //! @tparam F numerator function type
 //! @tparam G denominator function type
 template <typename F, typename G>
 class Quotient
 {
 public:
   //! Constructor from two functions.
   //! @param theF numerator function
   //! @param theG denominator function
   Quotient(F theF, G theG)
       : myF(std::move(theF)),
         myG(std::move(theG))
   {
   }
 
   //! Evaluates quotient f(theX) / g(theX).
   //! @param[in] theX input value
   //! @param[out] theY quotient value
   //! @return false if evaluation fails or denominator is zero
   bool Value(double theX, double& theY) const
   {
     double aF = 0.0;
     double aG = 0.0;
     if (!myF.Value(theX, aF))
     {
       return false;
     }
     if (!myG.Value(theX, aG))
     {
       return false;
     }
     if (std::abs(aG) < 1e-15)
     {
       return false;
     }
     theY = aF / aG;
     return true;
   }
 
 private:
   F myF;
   G myG;
 };
 
 //! Helper function to create Quotient with type deduction.
 template <typename F, typename G>
 Quotient<F, G> MakeQuotient(F theF, G theG)
 {
   return Quotient<F, G>(std::move(theF), std::move(theG));
 }
 
 //! Scaled function functor: c * f(x).
 //!
 //! @tparam F function type
 template <typename F>
 class Scaled
 {
 public:
   //! Constructor from function and scale factor.
   //! @param theF function to scale
   //! @param theScale scale factor
   Scaled(F theF, double theScale)
       : myF(std::move(theF)),
         myScale(theScale)
   {
   }
 
   //! Evaluates scaled function c * f(theX).
   //! @param[in] theX input value
   //! @param[out] theY scaled value
   //! @return false if evaluation fails
   bool Value(double theX, double& theY) const
   {
     double aF = 0.0;
     if (!myF.Value(theX, aF))
     {
       return false;
     }
     theY = myScale * aF;
     return true;
   }
 
 private:
   F      myF;
   double myScale;
 };
 
 //! Helper function to create Scaled with type deduction.
 template <typename F>
 Scaled<F> MakeScaled(F theF, double theScale)
 {
   return Scaled<F>(std::move(theF), theScale);
 }
 
 //! Shifted function functor: f(x) + c.
 //!
 //! @tparam F function type
 template <typename F>
 class Shifted
 {
 public:
   //! Constructor from function and shift value.
   //! @param theF function to shift
   //! @param theShift shift value (added to output)
   Shifted(F theF, double theShift)
       : myF(std::move(theF)),
         myShift(theShift)
   {
   }
 
   //! Evaluates shifted function f(theX) + c.
   //! @param[in] theX input value
   //! @param[out] theY shifted value
   //! @return false if evaluation fails
   bool Value(double theX, double& theY) const
   {
     double aF = 0.0;
     if (!myF.Value(theX, aF))
     {
       return false;
     }
     theY = aF + myShift;
     return true;
   }
 
 private:
   F      myF;
   double myShift;
 };
 
 //! Helper function to create Shifted with type deduction.
 template <typename F>
 Shifted<F> MakeShifted(F theF, double theShift)
 {
   return Shifted<F>(std::move(theF), theShift);
 }
 
 //! Negated function functor: -f(x).
 //!
 //! @tparam F function type
 template <typename F>
 class Negated
 {
 public:
   //! Constructor from function.
   //! @param theF function to negate
   explicit Negated(F theF)
       : myF(std::move(theF))
   {
   }
 
   //! Evaluates negated function -f(theX).
   //! @param[in] theX input value
   //! @param[out] theY negated value
   //! @return false if evaluation fails
   bool Value(double theX, double& theY) const
   {
     double aF = 0.0;
     if (!myF.Value(theX, aF))
     {
       return false;
     }
     theY = -aF;
     return true;
   }
 
 private:
   F myF;
 };
 
 //! Helper function to create Negated with type deduction.
 template <typename F>
 Negated<F> MakeNegated(F theF)
 {
   return Negated<F>(std::move(theF));
 }
 
 //! Constant function functor: f(x) = c.
 class Constant
 {
 public:
   //! Constructor from constant value.
   //! @param theValue constant value
   explicit Constant(double theValue)
       : myValue(theValue)
   {
   }
 
   //! Evaluates constant function.
   //! @param[in] theX input value (ignored)
   //! @param[out] theY constant value
   //! @return true (always succeeds)
   bool Value(double /*theX*/, double& theY) const
   {
     theY = myValue;
     return true;
   }
 
   //! Evaluates constant and derivative (derivative is always 0).
   //! @param[in] theX input value (ignored)
   //! @param[out] theY constant value
   //! @param[out] theDY derivative (always 0)
   //! @return true (always succeeds)
   bool Values(double /*theX*/, double& theY, double& theDY) const
   {
     theY  = myValue;
     theDY = 0.0;
     return true;
   }
 
 private:
   double myValue;
 };
 
 //! Linear function functor: f(x) = a*x + b.
 class Linear
 {
 public:
   //! Constructor from slope and intercept.
   //! @param theSlope coefficient a (slope)
   //! @param theIntercept coefficient b (y-intercept)
   Linear(double theSlope, double theIntercept)
       : mySlope(theSlope),
         myIntercept(theIntercept)
   {
   }
 
   //! Evaluates linear function a*x + b.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @return true (always succeeds)
   bool Value(double theX, double& theY) const
   {
     theY = mySlope * theX + myIntercept;
     return true;
   }
 
   //! Evaluates linear function and derivative.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @param[out] theDY derivative (= slope)
   //! @return true (always succeeds)
   bool Values(double theX, double& theY, double& theDY) const
   {
     theY  = mySlope * theX + myIntercept;
     theDY = mySlope;
     return true;
   }
 
 private:
   double mySlope;
   double myIntercept;
 };
 
 //! Sine function functor: f(x) = a * sin(b*x + c) + d.
 class Sine
 {
 public:
   //! Constructor with full parameters.
   //! @param theAmplitude amplitude a
   //! @param theFrequency angular frequency b
   //! @param thePhase phase shift c
   //! @param theOffset vertical offset d
   Sine(double theAmplitude = 1.0,
        double theFrequency = 1.0,
        double thePhase     = 0.0,
        double theOffset    = 0.0)
       : myAmplitude(theAmplitude),
         myFrequency(theFrequency),
         myPhase(thePhase),
         myOffset(theOffset)
   {
   }
 
   //! Evaluates sine function.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @return true (always succeeds)
   bool Value(double theX, double& theY) const
   {
     theY = myAmplitude * std::sin(myFrequency * theX + myPhase) + myOffset;
     return true;
   }
 
   //! Evaluates sine function and derivative.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @param[out] theDY derivative value
   //! @return true (always succeeds)
   bool Values(double theX, double& theY, double& theDY) const
   {
     const double anArg = myFrequency * theX + myPhase;
     theY               = myAmplitude * std::sin(anArg) + myOffset;
     theDY              = myAmplitude * myFrequency * std::cos(anArg);
     return true;
   }
 
 private:
   double myAmplitude;
   double myFrequency;
   double myPhase;
   double myOffset;
 };
 
 //! Cosine function functor: f(x) = a * cos(b*x + c) + d.
 class Cosine
 {
 public:
   //! Constructor with full parameters.
   //! @param theAmplitude amplitude a
   //! @param theFrequency angular frequency b
   //! @param thePhase phase shift c
   //! @param theOffset vertical offset d
   Cosine(double theAmplitude = 1.0,
          double theFrequency = 1.0,
          double thePhase     = 0.0,
          double theOffset    = 0.0)
       : myAmplitude(theAmplitude),
         myFrequency(theFrequency),
         myPhase(thePhase),
         myOffset(theOffset)
   {
   }
 
   //! Evaluates cosine function.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @return true (always succeeds)
   bool Value(double theX, double& theY) const
   {
     theY = myAmplitude * std::cos(myFrequency * theX + myPhase) + myOffset;
     return true;
   }
 
   //! Evaluates cosine function and derivative.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @param[out] theDY derivative value
   //! @return true (always succeeds)
   bool Values(double theX, double& theY, double& theDY) const
   {
     const double anArg = myFrequency * theX + myPhase;
     theY               = myAmplitude * std::cos(anArg) + myOffset;
     theDY              = -myAmplitude * myFrequency * std::sin(anArg);
     return true;
   }
 
 private:
   double myAmplitude;
   double myFrequency;
   double myPhase;
   double myOffset;
 };
 
 //! Exponential function functor: f(x) = a * exp(b*x) + c.
 class Exponential
 {
 public:
   //! Constructor with full parameters.
   //! @param theScale scale factor a
   //! @param theRate rate b
   //! @param theOffset vertical offset c
   Exponential(double theScale = 1.0, double theRate = 1.0, double theOffset = 0.0)
       : myScale(theScale),
         myRate(theRate),
         myOffset(theOffset)
   {
   }
 
   //! Evaluates exponential function.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @return true (always succeeds)
   bool Value(double theX, double& theY) const
   {
     theY = myScale * std::exp(myRate * theX) + myOffset;
     return true;
   }
 
   //! Evaluates exponential function and derivative.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @param[out] theDY derivative value
   //! @return true (always succeeds)
   bool Values(double theX, double& theY, double& theDY) const
   {
     const double anExp = std::exp(myRate * theX);
     theY               = myScale * anExp + myOffset;
     theDY              = myScale * myRate * anExp;
     return true;
   }
 
 private:
   double myScale;
   double myRate;
   double myOffset;
 };
 
 //! Power function functor: f(x) = a * x^n + b.
 class Power
 {
 public:
   //! Constructor with full parameters.
   //! @param theExponent power n
   //! @param theScale scale factor a
   //! @param theOffset vertical offset b
   Power(double theExponent, double theScale = 1.0, double theOffset = 0.0)
       : myExponent(theExponent),
         myScale(theScale),
         myOffset(theOffset)
   {
   }
 
   //! Evaluates power function.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @return false if x < 0 and exponent is non-integer
   bool Value(double theX, double& theY) const
   {
     if (theX < 0.0 && myExponent != std::floor(myExponent))
     {
       return false;
     }
     theY = myScale * std::pow(theX, myExponent) + myOffset;
     return true;
   }
 
   //! Evaluates power function and derivative.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @param[out] theDY derivative value
   //! @return false if x < 0 and exponent is non-integer
   bool Values(double theX, double& theY, double& theDY) const
   {
     if (theX < 0.0 && myExponent != std::floor(myExponent))
     {
       return false;
     }
     const double aPow = std::pow(theX, myExponent);
     theY              = myScale * aPow + myOffset;
     if (std::abs(theX) < 1e-15)
     {
       theDY = (myExponent == 1.0) ? myScale : 0.0;
     }
     else
     {
       theDY = myScale * myExponent * aPow / theX;
     }
     return true;
   }
 
 private:
   double myExponent;
   double myScale;
   double myOffset;
 };
 
 //! Gaussian function functor: f(x) = a * exp(-((x-mu)^2)/(2*sigma^2)).
 class Gaussian
 {
 public:
   //! Constructor with full parameters.
   //! @param theAmplitude amplitude a (peak height)
   //! @param theMean mean mu (center)
   //! @param theSigma standard deviation sigma (width)
   Gaussian(double theAmplitude = 1.0, double theMean = 0.0, double theSigma = 1.0)
       : myAmplitude(theAmplitude),
         myMean(theMean),
         mySigma(theSigma)
   {
   }
 
   //! Evaluates Gaussian function.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @return false if sigma is zero
   bool Value(double theX, double& theY) const
   {
     if (std::abs(mySigma) < 1e-15)
     {
       return false;
     }
     const double aZ = (theX - myMean) / mySigma;
     theY            = myAmplitude * std::exp(-0.5 * aZ * aZ);
     return true;
   }
 
   //! Evaluates Gaussian function and derivative.
   //! @param[in] theX input value
   //! @param[out] theY function value
   //! @param[out] theDY derivative value
   //! @return false if sigma is zero
   bool Values(double theX, double& theY, double& theDY) const
   {
     if (std::abs(mySigma) < 1e-15)
     {
       return false;
     }
     const double aZ   = (theX - myMean) / mySigma;
     const double aExp = std::exp(-0.5 * aZ * aZ);
     theY              = myAmplitude * aExp;
     theDY             = -myAmplitude * aZ * aExp / mySigma;
     return true;
   }
 
 private:
   double myAmplitude;
   double myMean;
   double mySigma;
 };
 
 } // namespace MathUtils
 
 #endif // _MathUtils_FunctorScalar_HeaderFile

This page was automatically generated by the 2.3.7 LXR engine. The LXR team