lsst::geom::polynomials::PackedBasis2d< Basis1d, packing > Class Template Reference

A Basis2d formed from the product of a Basis1d for each of x and y, truncated at the sum of their orders. More...

#include <PackedBasis2d.h>

Public Types
using	Function = Function2d<PackedBasis2d>
	A Function2d object that uses this basis.
using	Scaled = ScaledBasis2d<PackedBasis2d>
	The type returned by scale().
using	Workspace = PackedBasisWorkspace2d
	The type returned by makeWorkspace().
using	IndexRange = PackedIndexRange<packing>
	The type returned by getIndices().

Public Member Functions
	PackedBasis2d (Basis1d const &basis1d)
	Construct from a 1-d basis that will be used for both x and y.
template<typename ... Args>
	PackedBasis2d (Args &&...args)
	Construct by forwarding all arguments to the 1-d basis constructor.
	PackedBasis2d (PackedBasis2d const &)=default
	Default copy constructor.
	PackedBasis2d (PackedBasis2d &&)=default
	Default move constructor.
PackedBasis2d &	operator= (PackedBasis2d const &)=default
	Default copy assignment.
PackedBasis2d &	operator= (PackedBasis2d &&)=default
	Default move assignment.
std::size_t	getOrder () const noexcept
	Return the maximum order of the basis.
std::size_t	size () const noexcept
	Return the number of basis functions.
Scaled	scaled (Scaling2d const &first) const
	Return a scaled basis that delegates to a copy of this.
std::size_t	index (std::size_t x, std::size_t y) const
	Return the flattened index of the basis function with the given x and y orders.
IndexRange	getIndices () const noexcept
	Return a range of iterators that dereference to Index2d.
Workspace	makeWorkspace () const
	Allocate a workspace that can be passed to sumWith() and fill() to avoid repeated memory allocations.
template<typename Vector>
double	sumWith (geom::Point2D const &point, Vector const &coefficients, Workspace &workspace, SumMode mode=SumMode::FAST) const
	Evaluate a basis expansion with the given coefficients.
template<typename Vector>
double	sumWith (geom::Point2D const &point, Vector const &coefficients, SumMode mode=SumMode::FAST) const
	Evaluate a basis expansion with the given coefficients (internal workspace version).
template<typename Vector>
void	fill (geom::Point2D const &point, Vector &&basis, Workspace &workspace) const
	Evaluate the basis at a given point.
template<typename Vector>
void	fill (geom::Point2D const &point, Vector &&basis) const
	Evaluate the basis at a given point (internal workspace version).

Static Public Member Functions
static constexpr std::size_t	computeSize (std::size_t order)
	Return the size of a PackedBasis with the given order.

Detailed Description

template<typename Basis1d, PackingOrder packing>
class lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >

A Basis2d formed from the product of a Basis1d for each of x and y, truncated at the sum of their orders.

If $B_n(x)$ are the basis functions for the nested Basis1d, the basis functions of a PackedBasis2d with order $N$ are $B_m(x)B_n(y)$ for all combinations with $m + n \le N$.

The ordering of the products of 1-d basis functions in this 2-d basis is defined by the PackedIndexRange class, which is accessible as the PackedBasis2d::IndexRange. Note that while PackedBasis2d uses this ordering, Basis2d objects in general are not required to.

Definition at line 75 of file PackedBasis2d.h.

Member Typedef Documentation

Function

template<typename Basis1d, PackingOrder packing>

using lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::Function = Function2d<PackedBasis2d>

A Function2d object that uses this basis.

Definition at line 79 of file PackedBasis2d.h.

IndexRange

template<typename Basis1d, PackingOrder packing>

using lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::IndexRange = PackedIndexRange<packing>

The type returned by getIndices().

Definition at line 88 of file PackedBasis2d.h.

Scaled

template<typename Basis1d, PackingOrder packing>

using lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::Scaled = ScaledBasis2d<PackedBasis2d>

The type returned by scale().

Definition at line 82 of file PackedBasis2d.h.

Workspace

template<typename Basis1d, PackingOrder packing>

using lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::Workspace = PackedBasisWorkspace2d

The type returned by makeWorkspace().

Definition at line 85 of file PackedBasis2d.h.

Constructor & Destructor Documentation

PackedBasis2d() [1/4]

template<typename Basis1d, PackingOrder packing>

lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::PackedBasis2d ( Basis1d const & basis1d )

inlineexplicit

Construct from a 1-d basis that will be used for both x and y.

Definition at line 94 of file PackedBasis2d.h.

: _basis1d(basis1d) {}

PackedBasis2d() [2/4]

template<typename Basis1d, PackingOrder packing>

template<typename ... Args>

lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::PackedBasis2d ( Args &&... args )

inlineexplicit

Construct by forwarding all arguments to the 1-d basis constructor.

Definition at line 98 of file PackedBasis2d.h.

: _basis1d(std::forward<Args>(args)...) {}

PackedBasis2d() [3/4]

template<typename Basis1d, PackingOrder packing>

lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::PackedBasis2d ( PackedBasis2d< Basis1d, packing > const & )

default

Default copy constructor.

PackedBasis2d() [4/4]

template<typename Basis1d, PackingOrder packing>

lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::PackedBasis2d ( PackedBasis2d< Basis1d, packing > && )

default

Default move constructor.

Member Function Documentation

computeSize()

template<typename Basis1d, PackingOrder packing>

static constexpr std::size_t lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::computeSize ( std::size_t order )

inlinestaticconstexpr

Return the size of a PackedBasis with the given order.

Definition at line 91 of file PackedBasis2d.h.

{ return IndexRange::computeSize(order); }

fill() [1/2]

template<typename Basis1d, PackingOrder packing>

template<typename Vector>

void lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::fill ( geom::Point2D const & point, Vector && basis ) const

inline

Evaluate the basis at a given point (internal workspace version).

Definition at line 239 of file PackedBasis2d.h.

                                                                {
        auto workspace = makeWorkspace();
        fill(point, std::forward<Vector>(basis), workspace);
    }

fill() [2/2]

template<typename Basis1d, PackingOrder packing>

template<typename Vector>

void lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::fill ( geom::Point2D const & point, Vector && basis, Workspace & workspace ) const

inline

Evaluate the basis at a given point.

Parameters

[in]	point	Point at which to evaluate the basis functions.
[out]	basis	Flattened output vector. See Basis1d::fill more information.
[in]	workspace	Workspace object returned by makeWorkspace().

Exception Safety

Does not throw unless coefficients[n] does, and provides basic exception safety if it does.

Definition at line 228 of file PackedBasis2d.h.

                                                                                       {
        assert(workspace.getOrder() >= getOrder());
        _basis1d.fill(point.getX(), workspace._x);
        _basis1d.fill(point.getY(), workspace._y);
        for (auto const & index : getIndices()) {
            std::forward<Vector>(basis)[index.flat] = workspace._x[index.nx]*workspace._y[index.ny];
        }
    }

getIndices()

template<typename Basis1d, PackingOrder packing>

IndexRange lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::getIndices ( ) const

inlinenoexcept

Return a range of iterators that dereference to Index2d.

This is the recommended way to interpret the packed coefficients and basis functions utilized by PackedBasis2d; for example,

// Evaluate basis functions at a point.
geom::Point2D point(x, y);
PolynomialBasis2d basis(order);
std::vector<double> values(basis.size());
basis.fill(point, values);
// Iterate over tuples of flattened indices and x and y orders.
for (auto const & index : basis.getIndices()) {
    double a = values[index.flat];
    // standard polynomial basis functions are just powers
    double b = std::pow(point.getX(), index.nx)*std::pow(point.getY(), index.ny)];
    assert(std::abs(a - b) < std::numeric_limits<double>::epsilon());
}

See PackedIndexIterator for documentation of the actual order.

Definition at line 155 of file PackedBasis2d.h.

                                           {
        return IndexRange(typename IndexRange::iterator(), IndexRange::iterator::makeEnd(getOrder()));
    }

getOrder()

template<typename Basis1d, PackingOrder packing>

std::size_t lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::getOrder ( ) const

inlinenoexcept

Return the maximum order of the basis.

Definition at line 113 of file PackedBasis2d.h.

{ return _basis1d.getOrder(); }

index()

template<typename Basis1d, PackingOrder packing>

std::size_t lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::index ( std::size_t x, std::size_t y ) const

inline

Return the flattened index of the basis function with the given x and y orders.

Definition at line 129 of file PackedBasis2d.h.

                                                    {
        return IndexRange::computeIndex(x, y);
    }

makeWorkspace()

template<typename Basis1d, PackingOrder packing>

Workspace lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::makeWorkspace ( ) const

inline

Allocate a workspace that can be passed to sumWith() and fill() to avoid repeated memory allocations.

Definition at line 160 of file PackedBasis2d.h.

{ return Workspace(getOrder());}

operator=() [1/2]

template<typename Basis1d, PackingOrder packing>

PackedBasis2d & lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::operator= ( PackedBasis2d< Basis1d, packing > && )

default

Default move assignment.

operator=() [2/2]

template<typename Basis1d, PackingOrder packing>

PackedBasis2d & lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::operator= ( PackedBasis2d< Basis1d, packing > const & )

default

Default copy assignment.

scaled()

template<typename Basis1d, PackingOrder packing>

Scaled lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::scaled ( Scaling2d const & first ) const

inline

Return a scaled basis that delegates to a copy of this.

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 124 of file PackedBasis2d.h.

                                                 {
        return Scaled(*this, first);
    }

size()

template<typename Basis1d, PackingOrder packing>

std::size_t lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::size ( ) const

inlinenoexcept

Return the number of basis functions.

Definition at line 116 of file PackedBasis2d.h.

{ return IndexRange::computeSize(getOrder()); }

sumWith() [1/2]

template<typename Basis1d, PackingOrder packing>

template<typename Vector>

double lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::sumWith ( geom::Point2D const & point, Vector const & coefficients, SumMode mode = SumMode::FAST ) const

inline

Evaluate a basis expansion with the given coefficients (internal workspace version).

Definition at line 210 of file PackedBasis2d.h.

                                                   {
        auto workspace = makeWorkspace();
        return sumWith(point, coefficients, workspace, mode);
    }

sumWith() [2/2]

template<typename Basis1d, PackingOrder packing>

template<typename Vector>

double lsst::geom::polynomials::PackedBasis2d< Basis1d, packing >::sumWith ( geom::Point2D const & point, Vector const & coefficients, Workspace & workspace, SumMode mode = SumMode::FAST ) const

inline

Evaluate a basis expansion with the given coefficients.

If the 1-d basis elements are $B_n(x)$ and the given coefficients are a vector $a_{p, q}$, this computes

$$\sum_{p = 0, q = 0}^{p + q \le N} a_{p,q} B_{p}(x) B_{q}(y)$$

Parameters

[in]	point	Point at which to evaluate the expansion.
[in]	coefficients	Flattened coefficients vector. See Basis1d::sumWith for more information.
[in]	workspace	Workspace object returned by makeWorkspace().
[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 182 of file PackedBasis2d.h.

                                                                          {
        assert(workspace.getOrder() >= getOrder());
        _basis1d.fill(point.getX(), workspace._x);
        _basis1d.fill(point.getY(), workspace._y);
        // 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 = [coefficients, &workspace, this](auto & sum) {
            for (auto const & index : getIndices()) {
                sum += coefficients[index.flat]*workspace._x[index.nx]*workspace._y[index.ny];
            }
        };
        double result = 0.0;
        if (mode == SumMode::FAST) {
            double z = 0.0;
            accumulate(z);
            result = z;
        } else {
            SafeSum<double> z;
            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-10.0.0/Linux64/geom/gd6cbbdb0b4+75aa4b1db4/include/lsst/geom/polynomials/PackedBasis2d.h