The AdditivelySeparableScalarField3 class constructs a scalar field F in R^3 as a sum of scalar functions i.e. F(x, y, z) = k (p(x) + q(y) + r(z)). More...

#include <gz/math/AdditivelySeparableScalarField3.hh>

Public Member Functions
	AdditivelySeparableScalarField3 (ScalarT _k, ScalarFunctionT _p, ScalarFunctionT _q, ScalarFunctionT _r)
	Constructor.

ScalarT	Evaluate (const Vector3< ScalarT > &_point) const
	Evaluate the scalar field at `_point`

ScalarT	Minimum () const
	Compute scalar field minimum.

ScalarT	Minimum (const Region3< ScalarT > &_region) const
	Compute scalar field minimum in a `_region`

ScalarT	Minimum (const Region3< ScalarT > &_region, Vector3< ScalarT > &_pMin) const
	Compute scalar field minimum in a `_region`

ScalarT	Minimum (Vector3< ScalarT > &_pMin) const
	Compute scalar field minimum.

ScalarT	operator() (const Vector3< ScalarT > &_point) const
	Call operator overload.

Detailed Description

template<typename ScalarFunctionT, typename ScalarT>
class gz::math::AdditivelySeparableScalarField3< ScalarFunctionT, ScalarT >

The AdditivelySeparableScalarField3 class constructs a scalar field F in R^3 as a sum of scalar functions i.e. F(x, y, z) = k (p(x) + q(y) + r(z)).

Template Parameters

ScalarFunctionT

a callable type that taking a single ScalarT value as argument and returning another ScalarT value. Additionally:

for AdditivelySeparableScalarField3T to have a stream operator overload, ScalarFunctionT must implement a void Print(std::ostream &, const std::string &) method that streams a representation of it using the given string as argument variable name;
for AdditivelySeparableScalarField3T::Minimum to be callable, ScalarFunctionT must implement a ScalarT Minimum(const Interval<ScalarT> &, ScalarT &) method that computes its minimum in the given interval and returns an argument value that yields said minimum.

ScalarT a numeric type for which std::numeric_limits<> traits have been specialized.

Example

#include <iostream>
#include <gz/math/AdditivelySeparableScalarField3.hh>
#include <gz/math/Polynomial3.hh>
 
int main(int argc, char **argv)
{
  const double kConstant = 1.;
  const gz::math::Polynomial3d xPoly(
      gz::math::Vector4d(0., 1., 0., 1.));
  const gz::math::Polynomial3d yPoly(
      gz::math::Vector4d(1., 0., 1., 0.));
  const gz::math::Polynomial3d zPoly(
      gz::math::Vector4d(1., 0., 0., -1.));
  using AdditivelySeparableScalarField3dT =
      gz::math::AdditivelySeparableScalarField3d<
        gz::math::Polynomial3d>;
  const AdditivelySeparableScalarField3dT scalarField(
      kConstant, xPoly, yPoly, zPoly);
 
  // A printable, additively separable scalar field.
  std::cout << "An additively separable scalar field in R^3 "
            << "can be expressed as a sum of scalar functions "
            << "e.g. F(x, y, z) = " << scalarField << std::endl;
 
  // An additively separable scalar field can be evaluated.
  std::cout << "Evaluating F(x, y, z) at (0, 1, 0) yields "
            << scalarField(gz::math::Vector3d::UnitY)
            << std::endl;
 
  // An additively separable scalar field can be queried for its
  // minimum (provided the underlying scalar function allows it).
  std::cout << "The global minimum of F(x, y, z) is "
            << scalarField.Minimum() << std::endl;
}