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.
using	Scaled = ScaledBasis1d<RecurrenceBasis1d>
	The type returned by scale().

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

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

template<typename Recurrence >

using lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::Function = Function1d<RecurrenceBasis1d>

A Function1d object that uses this basis.

Definition at line 89 of file RecurrenceBasis1d.h.

Scaled

template<typename Recurrence >

using lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::Scaled = ScaledBasis1d<RecurrenceBasis1d>

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.

                                                         :
        _order(order)
    {}

RecurrenceBasis1d() [2/3]

template<typename Recurrence >

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

default

Default copy constructor.

RecurrenceBasis1d() [3/3]

template<typename Recurrence >

lsst::geom::polynomials::RecurrenceBasis1d< Recurrence >::RecurrenceBasis1d ( RecurrenceBasis1d< Recurrence > && )

default

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]	x	Point at which to evaluate the basis functions.
[out]	basis	Output 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.

                                               {
        std::forward<Vector>(basis)[0] = Recurrence::getB0(x);
        if (_order > 0u) {
            std::forward<Vector>(basis)[1] = Recurrence::getB1(x);
            for (std::size_t n = 2; n <= _order; ++n) {
                std::forward<Vector>(basis)[n] = Recurrence::next(
                    x, n,
                    std::forward<Vector>(basis)[n - 1],
                    std::forward<Vector>(basis)[n - 2]
                );
            }
        }
    }

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.

{ 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.

                                                            {
        return Scaled(*this, scaling);
    }

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.

{ 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]	x	Point at which to evaluate the expansion.
[in]	coefficients	Coefficients vector. See Basis1d::sumWith for more information.
[in]	mode	Enum 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.

                                                                                          {
        // This universal lambda lets us effectively template most of the
        // implementation of this function on double vs. SafeSum<double>
        // without having to define an external template.
        auto accumulate = [x, coefficients, this](auto & sum) {
            double previous = Recurrence::getB0(x);
            if (_order > 0u) {
                double current = Recurrence::getB1(x);
                sum += coefficients[1]*current;
                for (std::size_t n = 2; n <= _order; ++n) {
                    double next = Recurrence::next(x, n, current, previous);
                    sum += coefficients[n]*next;
                    previous = current;
                    current = next;
                }
            }
        };
        double result = 0.0;
        if (mode == SumMode::FAST) {
            double z = Recurrence::getB0(x)*coefficients[0];
            accumulate(z);
            result = z;
        } else {
            SafeSum<double> z(Recurrence::getB0(x)*coefficients[0]);
            accumulate(z);
            result = static_cast<double>(z);
        }
        return result;
    }

---

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

• /j/snowflake/release/lsstsw/stack/lsst-scipipe-8.0.0/Linux64/geom/ga1e77700b3+15fc3df1f7/include/lsst/geom/polynomials/RecurrenceBasis1d.h