LSST Applications  21.0.0-172-gfb10e10a+18fedfabac,22.0.0+297cba6710,22.0.0+80564b0ff1,22.0.0+8d77f4f51a,22.0.0+a28f4c53b1,22.0.0+dcf3732eb2,22.0.1-1-g7d6de66+2a20fdde0d,22.0.1-1-g8e32f31+297cba6710,22.0.1-1-geca5380+7fa3b7d9b6,22.0.1-12-g44dc1dc+2a20fdde0d,22.0.1-15-g6a90155+515f58c32b,22.0.1-16-g9282f48+790f5f2caa,22.0.1-2-g92698f7+dcf3732eb2,22.0.1-2-ga9b0f51+7fa3b7d9b6,22.0.1-2-gd1925c9+bf4f0e694f,22.0.1-24-g1ad7a390+a9625a72a8,22.0.1-25-g5bf6245+3ad8ecd50b,22.0.1-25-gb120d7b+8b5510f75f,22.0.1-27-g97737f7+2a20fdde0d,22.0.1-32-gf62ce7b1+aa4237961e,22.0.1-4-g0b3f228+2a20fdde0d,22.0.1-4-g243d05b+871c1b8305,22.0.1-4-g3a563be+32dcf1063f,22.0.1-4-g44f2e3d+9e4ab0f4fa,22.0.1-42-gca6935d93+ba5e5ca3eb,22.0.1-5-g15c806e+85460ae5f3,22.0.1-5-g58711c4+611d128589,22.0.1-5-g75bb458+99c117b92f,22.0.1-6-g1c63a23+7fa3b7d9b6,22.0.1-6-g50866e6+84ff5a128b,22.0.1-6-g8d3140d+720564cf76,22.0.1-6-gd805d02+cc5644f571,22.0.1-8-ge5750ce+85460ae5f3,master-g6e05de7fdc+babf819c66,master-g99da0e417a+8d77f4f51a,w.2021.48
LSST Data Management Base Package
Public Types | Public Member Functions | List of all members
lsst::geom::polynomials::RecurrenceBasis1d< Recurrence > Class Template Reference

A basis for 1-d series expansions defined by a recurrence relation. More...

#include <RecurrenceBasis1d.h>

Public Types

using Function = Function1d< RecurrenceBasis1d >
 A Function1d object that uses this basis. More...
 
using Scaled = ScaledBasis1d< RecurrenceBasis1d >
 The type returned by scale(). More...
 

Public Member Functions

 RecurrenceBasis1d (std::size_t order) noexcept
 Construct a basis with the given order (inclusive). More...
 
 RecurrenceBasis1d (RecurrenceBasis1d const &)=default
 Default copy constructor. More...
 
 RecurrenceBasis1d (RecurrenceBasis1d &&)=default
 Default move constructor. More...
 
RecurrenceBasis1doperator= (RecurrenceBasis1d const &)=default
 Default copy assignment. More...
 
RecurrenceBasis1doperator= (RecurrenceBasis1d &&)=default
 Default move assignment. More...
 
std::size_t getOrder () const noexcept
 Return the order of the basis. More...
 
std::size_t size () const noexcept
 Return the number of elements in the basis. More...
 
Scaled scaled (Scaling1d const &scaling) const noexcept
 Return a scaled basis with the same order and recurrence. More...
 
template<typename Vector >
double sumWith (double x, Vector const &coefficients, SumMode mode=SumMode::FAST) const
 Evaluate a basis expansion with the given coefficients. More...
 
template<typename Vector >
void fill (double x, Vector &&basis) const
 Evaluate the basis at a given point. More...
 

Detailed Description

template<typename Recurrence>
class lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >

A basis for 1-d series expansions defined by a recurrence relation.

The recurrence relations utilized by RecurrenceBasis1d must have the following form:

\[ B_{n+1}(x) = R(x, n, B_n(x), B_{n-1}(x)) \]

with explicit expressions for \(B_0(x)\) and \(B_1(x)\) also given. This includes all special polynomials (e.g. Chebyshev, Legendre, Hermite, Laguerre) and products of special polynomials with their natural weight functions (e.g. Gauss-Hermite functions). The template parameter must be a model of the Recurrence concept.

RecurrenceBasis1d is a model of the Basis1d concept.

Definition at line 85 of file RecurrenceBasis1d.h.

Member Typedef Documentation

◆ Function

A Function1d object that uses this basis.

Definition at line 89 of file RecurrenceBasis1d.h.

◆ Scaled

The type returned by scale().

Definition at line 92 of file RecurrenceBasis1d.h.

Constructor & Destructor Documentation

◆ RecurrenceBasis1d() [1/3]

template<typename Recurrence >
lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::RecurrenceBasis1d ( std::size_t  order)
inlineexplicitnoexcept

Construct a basis with the given order (inclusive).

Definition at line 95 of file RecurrenceBasis1d.h.

95  :
96  _order(order)
97  {}
table::Key< int > order

◆ RecurrenceBasis1d() [2/3]

template<typename Recurrence >
lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::RecurrenceBasis1d ( RecurrenceBasis1d< Recurrence > const &  )
default

Default copy constructor.

◆ RecurrenceBasis1d() [3/3]

Default move constructor.

Member Function Documentation

◆ fill()

template<typename Recurrence >
template<typename Vector >
void lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::fill ( double  x,
Vector &&  basis 
) const
inline

Evaluate the basis at a given point.

Parameters
[in]xPoint at which to evaluate the basis functions.
[out]basisOutput vector. See Basis1d::fill more information.
Exception Safety
Does not throw unless coefficients[n] does, and provides basic exception safety if it does.

Definition at line 187 of file RecurrenceBasis1d.h.

187  {
188  std::forward<Vector>(basis)[0] = Recurrence::getB0(x);
189  if (_order > 0u) {
190  std::forward<Vector>(basis)[1] = Recurrence::getB1(x);
191  for (std::size_t n = 2; n <= _order; ++n) {
192  std::forward<Vector>(basis)[n] = Recurrence::next(
193  x, n,
194  std::forward<Vector>(basis)[n - 1],
195  std::forward<Vector>(basis)[n - 2]
196  );
197  }
198  }
199  }
double x
table::Key< table::Array< double > > basis
Definition: PsfexPsf.cc:361
static double getB1(double x)
Return the first element of the basis, .
static double next(double x, std::size_t n, double current, double previous)
Return the next element in the recurrence.
static double getB0(double x)
Return the zeroth element of the basis, .

◆ getOrder()

template<typename Recurrence >
std::size_t lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::getOrder ( ) const
inlinenoexcept

Return the order of the basis.

Definition at line 112 of file RecurrenceBasis1d.h.

112 { return _order; }

◆ operator=() [1/2]

template<typename Recurrence >
RecurrenceBasis1d& lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::operator= ( RecurrenceBasis1d< Recurrence > &&  )
default

Default move assignment.

◆ operator=() [2/2]

template<typename Recurrence >
RecurrenceBasis1d& lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::operator= ( RecurrenceBasis1d< Recurrence > const &  )
default

Default copy assignment.

◆ scaled()

template<typename Recurrence >
Scaled lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::scaled ( Scaling1d const &  scaling) const
inlinenoexcept

Return a scaled basis with the same order and recurrence.

The scaled basis will transform all points by the given scaling before evaluating the basis functions in the same way as this.

Definition at line 123 of file RecurrenceBasis1d.h.

123  {
124  return Scaled(*this, scaling);
125  }
table::Key< double > scaling
ScaledBasis1d< RecurrenceBasis1d > Scaled
The type returned by scale().

◆ size()

template<typename Recurrence >
std::size_t lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::size ( ) const
inlinenoexcept

Return the number of elements in the basis.

Definition at line 115 of file RecurrenceBasis1d.h.

115 { return _order + 1; }

◆ sumWith()

template<typename Recurrence >
template<typename Vector >
double lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::sumWith ( double  x,
Vector const &  coefficients,
SumMode  mode = SumMode::FAST 
) const
inline

Evaluate a basis expansion with the given coefficients.

If the basis elements are \(B_n(x)\) and the given coefficients are a vector \(a_n\), this computes

\[ \sum_{n = 0}^{n \le N} a_n B_n(x) \]

Parameters
[in]xPoint at which to evaluate the expansion.
[in]coefficientsCoefficients vector. See Basis1d::sumWith for more information.
[in]modeEnum indicating the tradeoff to make between speed and numerical precision.
Exception Safety
Does not throw unless coefficients[n] does, and provides the same exception safety as it if it does.

Definition at line 146 of file RecurrenceBasis1d.h.

146  {
147  // This universal lambda lets us effectively template most of the
148  // implementation of this function on double vs. SafeSum<double>
149  // without having to define an external template.
150  auto accumulate = [x, coefficients, this](auto & sum) {
151  double previous = Recurrence::getB0(x);
152  if (_order > 0u) {
153  double current = Recurrence::getB1(x);
154  sum += coefficients[1]*current;
155  for (std::size_t n = 2; n <= _order; ++n) {
156  double next = Recurrence::next(x, n, current, previous);
157  sum += coefficients[n]*next;
158  previous = current;
159  current = next;
160  }
161  }
162  };
163  double result = 0.0;
164  if (mode == SumMode::FAST) {
165  double z = Recurrence::getB0(x)*coefficients[0];
166  accumulate(z);
167  result = z;
168  } else {
169  SafeSum<double> z(Recurrence::getB0(x)*coefficients[0]);
170  accumulate(z);
171  result = static_cast<double>(z);
172  }
173  return result;
174  }
py::object result
Definition: _schema.cc:429
ndarray::Array< double const, 2, 2 > coefficients
double z
Definition: Match.cc:44
T accumulate(T... args)
@ FAST
Summation using regular floating-point addition.

The documentation for this class was generated from the following file: