lsst::geom::polynomials Namespace Reference

Low-level polynomials (including special polynomials) in C++. More...

Namespaces
namespace	detail

Classes
class	Basis1d
	A basis interface for 1-d series expansions. More...
class	Basis2d
	A basis interface for 2-d series expansions. More...
class	BinomialMatrix
	A class that computes binomial coefficients up to a certain power. More...
class	Chebyshev1Recurrence
	A Recurrence for Chebyshev polynomials of the first kind. More...
class	Function1d
	A 1-d function defined by a series expansion and its coefficients. More...
class	Function2d
	A 2-d function defined by a series expansion and its coefficients. More...
struct	Index2d
	A custom tuple that relates the indices of two 1-d functions for x and y to the flattened index for the 2-d function they form. More...
class	PackedBasis2d
	A Basis2d formed from the product of a Basis1d for each of x and y, truncated at the sum of their orders. More...
class	PackedBasisWorkspace2d
	A workspace object that can be used to avoid extra memory allocations in repeated calls to PackedBasis2d methods. More...
class	PackedIndexIterator
	An iterator for traversing "packed" triangular 2-d series expansions, in which two 1-d expansions are truncated according to the sum of their orders and all values for one order are stored before any values of the subsequent order. More...
class	PackedIndexRange
	A specialized iterator range class for PackedIndexIterator, providing size calculation, comparison, and range-based for support. More...
class	PolynomialRecurrence
	A Recurrence for standard polynomials. More...
struct	Recurrence
	A recurrence relation concept for RecurrenceBasis1d. More...
class	RecurrenceBasis1d
	A basis for 1-d series expansions defined by a recurrence relation. More...
class	SafeSum
	A numerically stable summation algorithm for floating-point numbers. More...
class	ScaledBasis1d
	A 1-d basis that transforms all input points before evaluating nested basis. More...
class	ScaledBasis2d
	A 2-d basis that transforms all input points before evaluating nested basis. More...
class	Scaling1d
	A 1-d affine transform that can be used to map one interval to another. More...
class	Scaling2d
	A 2-d separable affine transform that can be used to map one interval to another. More...

Typedefs
using	Chebyshev1Basis1d = RecurrenceBasis1d<Chebyshev1Recurrence>
	A Basis1d for Chebyshev polynomials of the first kind.
using	ScaledChebyshev1Basis1d = ScaledBasis1d<Chebyshev1Basis1d>
	A Basis1d for scaled Chebyshev polynomials of the first kind.
template<PackingOrder packing>
using	Chebyshev1Basis2d = PackedBasis2d<Chebyshev1Basis1d, packing>
	A Basis2d for Chebyshev polynomials of the first kind, templated on packing order.
template<PackingOrder packing>
using	ScaledChebyshev1Basis2d = ScaledBasis2d<Chebyshev1Basis2d<packing>>
	A Basis2d for scaled Chebyshev polynomials of the first kind, templated on packing order.
using	Chebyshev1Basis2dXY = Chebyshev1Basis2d<PackingOrder::XY>
	A Basis2d for Chebyshev polynomials of the first kind, ordered via PackingOrder::XY.
using	Chebyshev1Basis2dYX = Chebyshev1Basis2d<PackingOrder::YX>
	A Basis2d for Chebyshev polynomials of the first kind, ordered via PackingOrder::YX.
using	ScaledChebyshev1Basis2dXY = ScaledChebyshev1Basis2d<PackingOrder::XY>
	A Basis2d for scaled Chebyshev polynomials of the first kind, ordered via PackingOrder::XY.
using	ScaledChebyshev1Basis2dYX = ScaledChebyshev1Basis2d<PackingOrder::YX>
	A Basis2d for scaled Chebyshev polynomials of the first kind, ordered via PackingOrder::YX.
using	Chebyshev1Function1d = Function1d<Chebyshev1Basis1d>
	A Function1d for Chebyshev polynomials of the first kind.
using	ScaledChebyshev1Function1d = Function1d<ScaledChebyshev1Basis1d>
	A Function1d for scaled Chebyshev polynomials of the first kind.
template<PackingOrder packing>
using	Chebyshev1Function2d = Function2d<Chebyshev1Basis2d<packing>>
	A Function2d for Chebyshev polynomials of the first kind, templated on packing order.
template<PackingOrder packing>
using	ScaledChebyshev1Function2d = Function2d<ScaledChebyshev1Basis2d<packing>>
	A Function2d for scaled Chebyshev polynomials of the first kind, templated on packing order.
using	Chebyshev1Function2dXY = Chebyshev1Function2d<PackingOrder::XY>
	A Function2d for Chebyshev polynomials of the first kind, ordered via PackingOrder::XY.
using	Chebyshev1Function2dYX = Chebyshev1Function2d<PackingOrder::YX>
	A Function2d for Chebyshev polynomials of the first kind, ordered via PackingOrder::YX.
using	ScaledChebyshev1Function2dXY = ScaledChebyshev1Function2d<PackingOrder::XY>
	A Function2d for scaled Chebyshev polynomials of the first kind, ordered via PackingOrder::XY.
using	ScaledChebyshev1Function2dYX = ScaledChebyshev1Function2d<PackingOrder::YX>
	A Function2d for scaled Chebyshev polynomials of the first kind, ordered via PackingOrder::YX.
using	PolynomialBasis1d = RecurrenceBasis1d<PolynomialRecurrence>
	A Basis1d for standard polynomials.
using	ScaledPolynomialBasis1d = ScaledBasis1d<PolynomialBasis1d>
	A ScaledBasis1d for standard polynomials.
template<PackingOrder packing>
using	PolynomialBasis2d = PackedBasis2d<PolynomialBasis1d, packing>
	A Basis2d for standard polynomials, templated on packing order.
template<PackingOrder packing>
using	ScaledPolynomialBasis2d = ScaledBasis2d<PolynomialBasis2d<packing>>
	A Basis2d for scaled standard polynomials, templated on packing order.
using	PolynomialBasis2dXY = PolynomialBasis2d<PackingOrder::XY>
	A Basis2d for standard polynomials, ordered via PackingOrder::XY.
using	PolynomialBasis2dYX = PolynomialBasis2d<PackingOrder::YX>
	A Basis2d for standard polynomials, ordered via PackingOrder::YX.
using	ScaledPolynomialBasis2dXY = ScaledPolynomialBasis2d<PackingOrder::XY>
	A Basis2d for scaled standard polynomials, ordered via PackingOrder::XY.
using	ScaledPolynomialBasis2dYX = ScaledPolynomialBasis2d<PackingOrder::YX>
	A Basis2d for scaled standard polynomials, ordered via PackingOrder::YX.
using	PolynomialFunction1d = Function1d<PolynomialBasis1d>
	A Function1d for standard polynomials.
using	ScaledPolynomialFunction1d = Function1d<ScaledPolynomialBasis1d>
	A Function1d for scaled standard polynomials.
template<PackingOrder packing>
using	PolynomialFunction2d = Function2d<PolynomialBasis2d<packing>>
	A Function2d for standard polynomials.
template<PackingOrder packing>
using	ScaledPolynomialFunction2d = Function2d<ScaledPolynomialBasis2d<packing>>
	A Function2d for scaled standard polynomials.
using	PolynomialFunction2dXY = PolynomialFunction2d<PackingOrder::XY>
	A Function2d for standard polynomials, ordered via PackingOrder::XY.
using	PolynomialFunction2dYX = PolynomialFunction2d<PackingOrder::YX>
	A Function2d for standard polynomials, ordered via PackingOrder::YX.
using	ScaledPolynomialFunction2dXY = ScaledPolynomialFunction2d<PackingOrder::XY>
	A Function2d for scaled standard polynomials, ordered via PackingOrder::XY.
using	ScaledPolynomialFunction2dYX = ScaledPolynomialFunction2d<PackingOrder::YX>
	A Function2d for scaled standard polynomials, ordered via PackingOrder::YX.

Enumerations
enum class	PackingOrder { YX , XY }
	Enum defining the packing orders used to order 2-d polynomial coefficients. More...
enum class	SumMode { FAST , SAFE }
	Enum used to control how to sum polynomial terms. More...

Functions
template<typename Basis >
Function1d< Basis >	makeFunction1d (Basis const &basis, Eigen::VectorXd const &coefficients)
	Create a Function1d of the appropriate type from a Basis1d and an Eigen object containing coefficients.
template<typename Basis , typename Iterator >
Function1d< Basis >	makeFunction1d (Basis const &basis, Iterator first, Iterator last)
	Create a Function1d of the appropriate type from a Basis1d and an iterator range to copy coefficients from.
template<typename Basis >
Function2d< Basis >	makeFunction2d (Basis const &basis, Eigen::VectorXd const &coefficients)
	Create a Function2d of the appropriate type from a Basis2d and an Eigen object containing coefficients.
template<typename Basis , typename Iterator >
Function2d< Basis >	makeFunction2d (Basis const &basis, Iterator first, Iterator last)
	Create a Function2d of the appropriate type from a Basis2d and an iterator range to copy coefficients from.
PolynomialFunction1d	simplified (ScaledPolynomialFunction1d const &f)
	Calculate the standard polynomial function that is equivalent to a scaled standard polynomial function.
template<PackingOrder packing>
PolynomialFunction2d< packing >	simplified (ScaledPolynomialFunction2d< packing > const &f)
	Calculate the standard polynomial function that is equivalent to a scaled standard polynomial function.
Scaling1d	makeUnitRangeScaling1d (double min, double max) noexcept
	Return a Scaling1d that maps the interval [min, max] to [-1, 1].
Scaling2d	makeUnitRangeScaling2d (geom::Box2D const &box)
	Return a Scaling1d that maps the given box to [-1, 1]x[-1, 1].
template PolynomialFunction2d< PackingOrder::XY >	simplified (ScaledPolynomialFunction2d< PackingOrder::XY > const &)
template PolynomialFunction2d< PackingOrder::YX >	simplified (ScaledPolynomialFunction2d< PackingOrder::YX > const &)

Detailed Description

Low-level polynomials (including special polynomials) in C++.

The geom::polynomials library provides low-level classes for efficiently evaluating polynomial basis functions and expansions in C++. The classes here:

• are not available in Python;
• are not polymorphic (no virtual functions);
• provide workspace objects to minimize memory allocations when appropriate;
• do not throw exceptions (users are responsible for providing valid inputs);
• have almost no outside dependencies (just Eigen);
• use templates to allow them to work with any array/vector objects (not just Eigen).

They are intended to be used as the building blocks of higher-level objects that are visible to Python users and persisted with our data products, such as afw::math::ChebyshevBoundedField and the afw::math::Function hierarchy.

At present, the library only includes support for 1-d and 2-d standard polynomials and Chebyshev polynomials of the first kind, but adding support for any other function defined by a recurrence relation (i.e. any other special polynomial) should be extremely easy (see RecurrenceBasis1d), and need not be done within the polynomials library itself.

For both 1-d and 2-d, the library contains the following kinds of objects:

• Basis1d and Basis2d: objects that evaluate basis functions at individual points. The only concrete Basis1d implementation provided at present is RecurrenceBasis1d template class, which can be used (with the recurrence relation as a template parameter) to implement most special polynomials. Recurrence relations for standard polynomials (PolynomialRecurrence) and Chebyshev polynomials of the first kind (Chebyshev1Recurrence) are provided here. The PackedBasis2d template provides an implementation of Basis2d that evaluates a Basis1d over each dimension. PolynomialBasis1d, Chebyshev1Basis1d, PolynomialBasis2d, and Chebyshev1Basis2d provide typedefs to instantiations of these that should generally be preferred to explicit use of these templates.
• Function1d and Function2d: templates that combine a Basis1d or Basis2d with a vector of coefficients.
• Scaling1d and Scaling2d: transformation objects that, with the ScaledBasis1d and ScaledBasis2d templates, allow a basis or function to be constructed that remaps points as part of evaluating the basis functions. For example, a ScaledChebyshev1Basis1d combines both the a Chebyshev polynomial basis and the scaling from some domain to [-1, 1] that enables most special properties of Chebyshevs. When necessary, the simplified() functions can be used to convert a ScaledPolynomialFunction1d or ScaledPolynomialFunction2d into an equivalent PolynomialFunction1d or PolynomialFunction2d by folding the scaling into the coefficients.

The library also includes a few utility classes and functions:

• BinomialMatrix provides an efficient and stable way to get binomial coefficients.
• PackedIndexIterator and PackedIndexRange implement PackingOrders that allow a conceptual 2-d triangular matrix to be implemented on top of a 1-d array.

Typedef Documentation

Chebyshev1Basis1d

using lsst::geom::polynomials::Chebyshev1Basis1d = RecurrenceBasis1d<Chebyshev1Recurrence>

A Basis1d for Chebyshev polynomials of the first kind.

Definition at line 48 of file Chebyshev1Basis1d.h.

Chebyshev1Basis2d

template<PackingOrder packing>

using lsst::geom::polynomials::Chebyshev1Basis2d = PackedBasis2d<Chebyshev1Basis1d, packing>

A Basis2d for Chebyshev polynomials of the first kind, templated on packing order.

Definition at line 34 of file Chebyshev1Basis2d.h.

Chebyshev1Basis2dXY

using lsst::geom::polynomials::Chebyshev1Basis2dXY = Chebyshev1Basis2d<PackingOrder::XY>

A Basis2d for Chebyshev polynomials of the first kind, ordered via PackingOrder::XY.

Definition at line 41 of file Chebyshev1Basis2d.h.

Chebyshev1Basis2dYX

using lsst::geom::polynomials::Chebyshev1Basis2dYX = Chebyshev1Basis2d<PackingOrder::YX>

A Basis2d for Chebyshev polynomials of the first kind, ordered via PackingOrder::YX.

Definition at line 44 of file Chebyshev1Basis2d.h.

Chebyshev1Function1d

using lsst::geom::polynomials::Chebyshev1Function1d = Function1d<Chebyshev1Basis1d>

A Function1d for Chebyshev polynomials of the first kind.

Definition at line 31 of file Chebyshev1Function1d.h.

Chebyshev1Function2d

template<PackingOrder packing>

using lsst::geom::polynomials::Chebyshev1Function2d = Function2d<Chebyshev1Basis2d<packing>>

A Function2d for Chebyshev polynomials of the first kind, templated on packing order.

Definition at line 32 of file Chebyshev1Function2d.h.

Chebyshev1Function2dXY

using lsst::geom::polynomials::Chebyshev1Function2dXY = Chebyshev1Function2d<PackingOrder::XY>

A Function2d for Chebyshev polynomials of the first kind, ordered via PackingOrder::XY.

Definition at line 39 of file Chebyshev1Function2d.h.

Chebyshev1Function2dYX

using lsst::geom::polynomials::Chebyshev1Function2dYX = Chebyshev1Function2d<PackingOrder::YX>

A Function2d for Chebyshev polynomials of the first kind, ordered via PackingOrder::YX.

Definition at line 42 of file Chebyshev1Function2d.h.

PolynomialBasis1d

using lsst::geom::polynomials::PolynomialBasis1d = RecurrenceBasis1d<PolynomialRecurrence>

A Basis1d for standard polynomials.

Definition at line 50 of file PolynomialBasis1d.h.

PolynomialBasis2d

template<PackingOrder packing>

using lsst::geom::polynomials::PolynomialBasis2d = PackedBasis2d<PolynomialBasis1d, packing>

A Basis2d for standard polynomials, templated on packing order.

Definition at line 34 of file PolynomialBasis2d.h.

PolynomialBasis2dXY

using lsst::geom::polynomials::PolynomialBasis2dXY = PolynomialBasis2d<PackingOrder::XY>

A Basis2d for standard polynomials, ordered via PackingOrder::XY.

Definition at line 41 of file PolynomialBasis2d.h.

PolynomialBasis2dYX

using lsst::geom::polynomials::PolynomialBasis2dYX = PolynomialBasis2d<PackingOrder::YX>

A Basis2d for standard polynomials, ordered via PackingOrder::YX.

Definition at line 44 of file PolynomialBasis2d.h.

PolynomialFunction1d

using lsst::geom::polynomials::PolynomialFunction1d = Function1d<PolynomialBasis1d>

A Function1d for standard polynomials.

Definition at line 31 of file PolynomialFunction1d.h.

PolynomialFunction2d

template<PackingOrder packing>

using lsst::geom::polynomials::PolynomialFunction2d = Function2d<PolynomialBasis2d<packing>>

A Function2d for standard polynomials.

Definition at line 32 of file PolynomialFunction2d.h.

PolynomialFunction2dXY

using lsst::geom::polynomials::PolynomialFunction2dXY = PolynomialFunction2d<PackingOrder::XY>

A Function2d for standard polynomials, ordered via PackingOrder::XY.

Definition at line 39 of file PolynomialFunction2d.h.

PolynomialFunction2dYX

using lsst::geom::polynomials::PolynomialFunction2dYX = PolynomialFunction2d<PackingOrder::YX>

A Function2d for standard polynomials, ordered via PackingOrder::YX.

Definition at line 42 of file PolynomialFunction2d.h.

ScaledChebyshev1Basis1d

using lsst::geom::polynomials::ScaledChebyshev1Basis1d = ScaledBasis1d<Chebyshev1Basis1d>

A Basis1d for scaled Chebyshev polynomials of the first kind.

Definition at line 51 of file Chebyshev1Basis1d.h.

ScaledChebyshev1Basis2d

template<PackingOrder packing>

using lsst::geom::polynomials::ScaledChebyshev1Basis2d = ScaledBasis2d<Chebyshev1Basis2d<packing>>

A Basis2d for scaled Chebyshev polynomials of the first kind, templated on packing order.

Definition at line 38 of file Chebyshev1Basis2d.h.

ScaledChebyshev1Basis2dXY

using lsst::geom::polynomials::ScaledChebyshev1Basis2dXY = ScaledChebyshev1Basis2d<PackingOrder::XY>

A Basis2d for scaled Chebyshev polynomials of the first kind, ordered via PackingOrder::XY.

Definition at line 47 of file Chebyshev1Basis2d.h.

ScaledChebyshev1Basis2dYX

using lsst::geom::polynomials::ScaledChebyshev1Basis2dYX = ScaledChebyshev1Basis2d<PackingOrder::YX>

A Basis2d for scaled Chebyshev polynomials of the first kind, ordered via PackingOrder::YX.

Definition at line 50 of file Chebyshev1Basis2d.h.

ScaledChebyshev1Function1d

using lsst::geom::polynomials::ScaledChebyshev1Function1d = Function1d<ScaledChebyshev1Basis1d>

A Function1d for scaled Chebyshev polynomials of the first kind.

Definition at line 34 of file Chebyshev1Function1d.h.

ScaledChebyshev1Function2d

template<PackingOrder packing>

using lsst::geom::polynomials::ScaledChebyshev1Function2d = Function2d<ScaledChebyshev1Basis2d<packing>>

A Function2d for scaled Chebyshev polynomials of the first kind, templated on packing order.

Definition at line 36 of file Chebyshev1Function2d.h.

ScaledChebyshev1Function2dXY

using lsst::geom::polynomials::ScaledChebyshev1Function2dXY = ScaledChebyshev1Function2d<PackingOrder::XY>

A Function2d for scaled Chebyshev polynomials of the first kind, ordered via PackingOrder::XY.

Definition at line 45 of file Chebyshev1Function2d.h.

ScaledChebyshev1Function2dYX

using lsst::geom::polynomials::ScaledChebyshev1Function2dYX = ScaledChebyshev1Function2d<PackingOrder::YX>

A Function2d for scaled Chebyshev polynomials of the first kind, ordered via PackingOrder::YX.

Definition at line 48 of file Chebyshev1Function2d.h.

ScaledPolynomialBasis1d

using lsst::geom::polynomials::ScaledPolynomialBasis1d = ScaledBasis1d<PolynomialBasis1d>

A ScaledBasis1d for standard polynomials.

Definition at line 53 of file PolynomialBasis1d.h.

ScaledPolynomialBasis2d

template<PackingOrder packing>

using lsst::geom::polynomials::ScaledPolynomialBasis2d = ScaledBasis2d<PolynomialBasis2d<packing>>

A Basis2d for scaled standard polynomials, templated on packing order.

Definition at line 38 of file PolynomialBasis2d.h.

ScaledPolynomialBasis2dXY

using lsst::geom::polynomials::ScaledPolynomialBasis2dXY = ScaledPolynomialBasis2d<PackingOrder::XY>

A Basis2d for scaled standard polynomials, ordered via PackingOrder::XY.

Definition at line 47 of file PolynomialBasis2d.h.

ScaledPolynomialBasis2dYX

using lsst::geom::polynomials::ScaledPolynomialBasis2dYX = ScaledPolynomialBasis2d<PackingOrder::YX>

A Basis2d for scaled standard polynomials, ordered via PackingOrder::YX.

Definition at line 50 of file PolynomialBasis2d.h.

ScaledPolynomialFunction1d

using lsst::geom::polynomials::ScaledPolynomialFunction1d = Function1d<ScaledPolynomialBasis1d>

A Function1d for scaled standard polynomials.

Definition at line 34 of file PolynomialFunction1d.h.

ScaledPolynomialFunction2d

template<PackingOrder packing>

using lsst::geom::polynomials::ScaledPolynomialFunction2d = Function2d<ScaledPolynomialBasis2d<packing>>

A Function2d for scaled standard polynomials.

Definition at line 36 of file PolynomialFunction2d.h.

ScaledPolynomialFunction2dXY

using lsst::geom::polynomials::ScaledPolynomialFunction2dXY = ScaledPolynomialFunction2d<PackingOrder::XY>

A Function2d for scaled standard polynomials, ordered via PackingOrder::XY.

Definition at line 45 of file PolynomialFunction2d.h.

ScaledPolynomialFunction2dYX

using lsst::geom::polynomials::ScaledPolynomialFunction2dYX = ScaledPolynomialFunction2d<PackingOrder::YX>

A Function2d for scaled standard polynomials, ordered via PackingOrder::YX.

Definition at line 48 of file PolynomialFunction2d.h.

Enumeration Type Documentation

PackingOrder

enum class lsst::geom::polynomials::PackingOrder

strong

Enum defining the packing orders used to order 2-d polynomial coefficients.

Enumerator
YX	A pair of indices \((nx, ny)\) is mapped to the flattened position \(i = (nx+ny)(nx+ny+1)/2 + nx\), which yields the (nx, ny) ordering. (0, 0), (0, 1), (1, 0), (0, 2), (1, 1), (2, 0), ... In other words, if \(a_i\) are the coefficients of a 2-d polynomial expansion with order=2, the full polynomial is: \[ a_0 + a_1 y + a_2 x + a_3 y^2 + a_4 x y + a_5 x^2 \]
XY	A pair of indices \((nx, ny)\) is mapped to the flattened position \(i = (nx+ny)(nx+ny+1)/2 + ny\), which yields the (nx, ny) ordering. (0, 0), (1, 0), (0, 1), (2, 0), (1, 1), (0, 2), ... In other words, if \(a_i\) are the coefficients of a 2-d polynomial expansion with order=2, the full polynomial is: \[ a_0 + a_1 x + a_2 y + a_3 x^2 + a_4 x y + a_5 y^2 \]

Definition at line 28 of file PackedIndex.h.

                        {
 
    YX,
 
    XY
};

SumMode

enum class lsst::geom::polynomials::SumMode

strong

Enum used to control how to sum polynomial terms.

Enumerator
FAST	Summation using regular floating-point addition.
SAFE	Compensated summation using SafeSum. Involves ~4x as many floating point operations.

Definition at line 32 of file SafeSum.h.

                   {
    FAST,
    SAFE
};

Function Documentation

makeFunction1d() [1/2]

template<typename Basis >

Function1d< Basis > lsst::geom::polynomials::makeFunction1d	(	Basis const &	basis,
		Eigen::VectorXd const &	coefficients )

Create a Function1d of the appropriate type from a Basis1d and an Eigen object containing coefficients.

Definition at line 144 of file Function1d.h.

                                                                                          {
    return Function1d<Basis>(basis, coefficients);
}

makeFunction1d() [2/2]

template<typename Basis , typename Iterator >

Function1d< Basis > lsst::geom::polynomials::makeFunction1d	(	Basis const &	basis,
		Iterator	first,
		Iterator	last )

Create a Function1d of the appropriate type from a Basis1d and an iterator range to copy coefficients from.

Definition at line 150 of file Function1d.h.

                                                                                     {
    return Function1d<Basis>(basis, first, last);
}

makeFunction2d() [1/2]

template<typename Basis >

Function2d< Basis > lsst::geom::polynomials::makeFunction2d	(	Basis const &	basis,
		Eigen::VectorXd const &	coefficients )

Create a Function2d of the appropriate type from a Basis2d and an Eigen object containing coefficients.

Definition at line 155 of file Function2d.h.

                                                                                          {
    return Function2d<Basis>(basis, coefficients);
}

makeFunction2d() [2/2]

template<typename Basis , typename Iterator >

Function2d< Basis > lsst::geom::polynomials::makeFunction2d	(	Basis const &	basis,
		Iterator	first,
		Iterator	last )

Create a Function2d of the appropriate type from a Basis2d and an iterator range to copy coefficients from.

Definition at line 161 of file Function2d.h.

                                                                                     {
    return Function2d<Basis>(basis, first, last);
}

makeUnitRangeScaling1d()

Scaling1d lsst::geom::polynomials::makeUnitRangeScaling1d ( double min, double max )

inlinenoexcept

Return a Scaling1d that maps the interval [min, max] to [-1, 1].

Definition at line 120 of file Scaling1d.h.

                                                                         {
    return Scaling1d(2.0/(max - min), -0.5*(min + max));
}

makeUnitRangeScaling2d()

Scaling2d lsst::geom::polynomials::makeUnitRangeScaling2d ( geom::Box2D const & box )

inline

Return a Scaling1d that maps the given box to [-1, 1]x[-1, 1].

Definition at line 112 of file Scaling2d.h.

                                                               {
    return Scaling2d(
        makeUnitRangeScaling1d(box.getMinX(), box.getMaxX()),
        makeUnitRangeScaling1d(box.getMinY(), box.getMaxY())
    );
}

simplified() [1/4]

PolynomialFunction1d lsst::geom::polynomials::simplified

(

ScaledPolynomialFunction1d const &

f

)

Calculate the standard polynomial function that is equivalent to a scaled standard polynomial function.

The returned polynomial will course have different coefficients than the input one, as these need to account for the scaling without it being explicitly applied.

Definition at line 32 of file PolynomialFunction1d.cc.

                                                                      {
    auto const & basis = f.getBasis();
    std::vector<SafeSum<double>> sums(basis.size());
    double const s = basis.getScaling().getScale();
    double const v = basis.getScaling().getShift();
    double sn = 1; // s^n
    BinomialMatrix binomial(basis.getNested().getOrder());
    for (std::size_t n = 0; n < basis.size(); ++n, sn *= s) {
        double vk = 1; // v^k
        for (std::size_t k = 0; k <= n; ++k, vk *= v) {
            sums[n - k] += sn*binomial(n, k)*f[n]*vk;
        }
    }
    Eigen::VectorXd result = Eigen::VectorXd::Zero(basis.size());
    for (std::size_t n = 0; n < basis.size(); ++n) {
        result[n] = static_cast<double>(sums[n]);
    }
    return makeFunction1d(basis.getNested(), result);
}

simplified() [2/4]

template<PackingOrder packing>

PolynomialFunction2d< packing > lsst::geom::polynomials::simplified

(

ScaledPolynomialFunction2d< packing > const &

f

)

Calculate the standard polynomial function that is equivalent to a scaled standard polynomial function.

The coefficients of the returned polynomial will be different from those of the input in order to fold in the scaling. This is primarily useful in contexts where external code does not support the (more numerically stable) scaled representation, such as the FITS WCS SIP convention.

Definition at line 47 of file PolynomialFunction2d.cc.

                                                                                        {
    auto const & basis = f.getBasis();
    std::vector<SafeSum<double>> sums(basis.size());
    std::size_t const n = basis.getOrder();
    auto rPow = computePowers(basis.getScaling().getX().getScale(), n);
    auto sPow = computePowers(basis.getScaling().getY().getScale(), n);
    auto uPow = computePowers(basis.getScaling().getX().getShift(), n);
    auto vPow = computePowers(basis.getScaling().getY().getShift(), n);
    BinomialMatrix binomial(basis.getNested().getOrder());
    for (auto const & i : basis.getIndices()) {
        for (std::size_t j = 0; j <= i.nx; ++j) {
            double tmp = binomial(i.nx, j)*uPow[j] *
                f[i.flat]*rPow[i.nx]*sPow[i.ny];
            for (std::size_t k = 0; k <= i.ny; ++k) {
                sums[basis.index(i.nx - j, i.ny - k)] +=
                    binomial(i.ny, k)*vPow[k]*tmp;
            }
        }
    }
    Eigen::VectorXd result = Eigen::VectorXd::Zero(basis.size());
    for (std::size_t i = 0; i < basis.size(); ++i) {
        result[i] = static_cast<double>(sums[i]);
    }
    return makeFunction2d(basis.getNested(), result);
}

simplified() [3/4]

template PolynomialFunction2d< PackingOrder::XY > lsst::geom::polynomials::simplified

(

ScaledPolynomialFunction2d< PackingOrder::XY > const &

)

simplified() [4/4]

template PolynomialFunction2d< PackingOrder::YX > lsst::geom::polynomials::simplified

(

ScaledPolynomialFunction2d< PackingOrder::YX > const &

)