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 | Static Public Member Functions | List of all members
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. More...
 
using Scaled = ScaledBasis2d< PackedBasis2d >
 The type returned by scale(). More...
 
using Workspace = PackedBasisWorkspace2d
 The type returned by makeWorkspace(). More...
 
using IndexRange = PackedIndexRange< packing >
 The type returned by getIndices(). More...
 

Public Member Functions

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

Static Public Member Functions

static constexpr std::size_t computeSize (std::size_t order)
 Return the size of a PackedBasis with the given order. More...
 

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.

94 : _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.

98 : _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.

91 { return IndexRange::computeSize(order); }
static constexpr std::size_t computeSize(std::size_t order) noexcept
Return the flattened size of an expansion with the given maximum order (inclusive).
Definition: PackedIndex.h:265
table::Key< int > 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.

239  {
240  auto workspace = makeWorkspace();
241  fill(point, std::forward<Vector>(basis), workspace);
242  }
void fill(geom::Point2D const &point, Vector &&basis, Workspace &workspace) const
Evaluate the basis at a given point.
Workspace makeWorkspace() const
Allocate a workspace that can be passed to sumWith() and fill() to avoid repeated memory allocations.
table::Key< table::Array< double > > basis
Definition: PsfexPsf.cc:361

◆ 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]pointPoint at which to evaluate the basis functions.
[out]basisFlattened output vector. See Basis1d::fill more information.
[in]workspaceWorkspace 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.

228  {
229  assert(workspace.getOrder() >= getOrder());
230  _basis1d.fill(point.getX(), workspace._x);
231  _basis1d.fill(point.getY(), workspace._y);
232  for (auto const & index : getIndices()) {
233  std::forward<Vector>(basis)[index.flat] = workspace._x[index.nx]*workspace._y[index.ny];
234  }
235  }
void fill(double x, Vector &&basis) const
Evaluate the basis at a given point.
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.
std::size_t getOrder() const noexcept
Return the maximum order of the basis.

◆ 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);
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)];
}
double x
int y
Definition: SpanSet.cc:48
table::Key< int > b
table::Key< int > a
PackedBasis2d< PolynomialBasis1d, packing > PolynomialBasis2d
A Basis2d for standard polynomials, templated on packing order.
Angle abs(Angle const &a)
Definition: Angle.h:106
T pow(T... args)

See PackedIndexIterator for documentation of the actual order.

Definition at line 155 of file PackedBasis2d.h.

155  {
157  }
PackedIndexRange< packing > IndexRange
The type returned by getIndices().
Definition: PackedBasis2d.h:88
static constexpr PackedIndexIterator makeEnd(std::size_t order) noexcept
Construct an iterator one past the end of an expansion with the given order.
Definition: PackedIndex.h:190
PackedIndexIterator< packing > iterator
Definition: PackedIndex.h:251

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

113 { return _basis1d.getOrder(); }
std::size_t getOrder() const
Return the order of the basis.

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

129  {
130  return IndexRange::computeIndex(x, y);
131  }
static constexpr std::size_t computeIndex(std::size_t nx, std::size_t ny) noexcept
Return the flattened index for the element with the given x and y orders.
Definition: PackedIndex.h:270

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

160 { return Workspace(getOrder());}
PackedBasisWorkspace2d Workspace
The type returned by makeWorkspace().
Definition: PackedBasis2d.h:85

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

124  {
125  return Scaled(*this, first);
126  }
ScaledBasis2d< PackedBasis2d > Scaled
The type returned by scale().
Definition: PackedBasis2d.h:82

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

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

211  {
212  auto workspace = makeWorkspace();
213  return sumWith(point, coefficients, workspace, mode);
214  }
ndarray::Array< double const, 2, 2 > coefficients
double sumWith(geom::Point2D const &point, Vector const &coefficients, Workspace &workspace, SumMode mode=SumMode::FAST) const
Evaluate a basis expansion with the given coefficients.

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

183  {
184  assert(workspace.getOrder() >= getOrder());
185  _basis1d.fill(point.getX(), workspace._x);
186  _basis1d.fill(point.getY(), workspace._y);
187  // This universal lambda lets us effectively template most of the
188  // implementation of this function on double vs. SafeSum<double>
189  // without having to define an external template.
190  auto accumulate = [coefficients, &workspace, this](auto & sum) {
191  for (auto const & index : getIndices()) {
192  sum += coefficients[index.flat]*workspace._x[index.nx]*workspace._y[index.ny];
193  }
194  };
195  double result = 0.0;
196  if (mode == SumMode::FAST) {
197  double z = 0.0;
198  accumulate(z);
199  result = z;
200  } else {
201  SafeSum<double> z;
202  accumulate(z);
203  result = static_cast<double>(z);
204  }
205  return result;
206  }
py::object result
Definition: _schema.cc:429
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: