LSST Applications g0b6bd0c080+a72a5dd7e6,g1182afd7b4+2a019aa3bb,g17e5ecfddb+2b8207f7de,g1d67935e3f+06cf436103,g38293774b4+ac198e9f13,g396055baef+6a2097e274,g3b44f30a73+6611e0205b,g480783c3b1+98f8679e14,g48ccf36440+89c08d0516,g4b93dc025c+98f8679e14,g5c4744a4d9+a302e8c7f0,g613e996a0d+e1c447f2e0,g6c8d09e9e7+25247a063c,g7271f0639c+98f8679e14,g7a9cd813b8+124095ede6,g9d27549199+a302e8c7f0,ga1cf026fa3+ac198e9f13,ga32aa97882+7403ac30ac,ga786bb30fb+7a139211af,gaa63f70f4e+9994eb9896,gabf319e997+ade567573c,gba47b54d5d+94dc90c3ea,gbec6a3398f+06cf436103,gc6308e37c7+07dd123edb,gc655b1545f+ade567573c,gcc9029db3c+ab229f5caf,gd01420fc67+06cf436103,gd877ba84e5+06cf436103,gdb4cecd868+6f279b5b48,ge2d134c3d5+cc4dbb2e3f,ge448b5faa6+86d1ceac1d,gecc7e12556+98f8679e14,gf3ee170dca+25247a063c,gf4ac96e456+ade567573c,gf9f5ea5b4d+ac198e9f13,gff490e6085+8c2580be5c,w.2022.27
LSST Data Management Base Package
PackedBasis2d.h
Go to the documentation of this file.
1// -*- LSST-C++ -*-
2/*
3 * Developed for the LSST Data Management System.
4 * This product includes software developed by the LSST Project
5 * (https://www.lsst.org).
6 * See the COPYRIGHT file at the top-level directory of this distribution
7 * for details of code ownership.
8 *
9 * This program is free software: you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation, either version 3 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program. If not, see <https://www.gnu.org/licenses/>.
21 */
22#ifndef LSST_AFW_MATH_POLYNOMIALS_PackedBasis2d_h_INCLUDED
23#define LSST_AFW_MATH_POLYNOMIALS_PackedBasis2d_h_INCLUDED
24
25#include "lsst/geom/Point.h"
29
30namespace lsst { namespace geom { namespace polynomials {
31
32template <typename Basis1d, PackingOrder packing>
33class PackedBasis2d;
34
35
41public:
42
44 explicit PackedBasisWorkspace2d(std::size_t order) : _x(order + 1), _y(order + 1) {}
45
47 std::size_t getOrder() const { return _x.size() - 1; }
48
49private:
50
51 template <typename Recurrence, PackingOrder packing>
52 friend class PackedBasis2d;
53
54 Eigen::VectorXd _x;
55 Eigen::VectorXd _y;
56};
57
58template <typename Basis>
59class Function2d;
60
74template <typename Basis1d, PackingOrder packing>
76public:
77
80
83
86
89
92
94 explicit PackedBasis2d(Basis1d const & basis1d) : _basis1d(basis1d) {}
95
97 template <typename ...Args>
98 explicit PackedBasis2d(Args&& ...args) : _basis1d(std::forward<Args>(args)...) {}
99
101 PackedBasis2d(PackedBasis2d const &) = default;
102
105
108
111
113 std::size_t getOrder() const noexcept { return _basis1d.getOrder(); }
114
116 std::size_t size() const noexcept{ return IndexRange::computeSize(getOrder()); }
117
124 Scaled scaled(Scaling2d const & first) const {
125 return Scaled(*this, first);
126 }
127
131 }
132
155 IndexRange getIndices() const noexcept {
157 }
158
161
181 template <typename Vector>
182 double sumWith(geom::Point2D const & point, Vector const & coefficients,
183 Workspace & workspace, SumMode mode=SumMode::FAST) const {
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 {
202 accumulate(z);
203 result = static_cast<double>(z);
204 }
205 return result;
206 }
207
209 template <typename Vector>
210 double sumWith(geom::Point2D const & point, Vector const & coefficients,
211 SumMode mode=SumMode::FAST) const {
212 auto workspace = makeWorkspace();
213 return sumWith(point, coefficients, workspace, mode);
214 }
215
227 template <typename Vector>
228 void fill(geom::Point2D const & point, Vector && basis, Workspace & workspace) const {
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 }
236
238 template <typename Vector>
239 void fill(geom::Point2D const & point, Vector && basis) const {
240 auto workspace = makeWorkspace();
241 fill(point, std::forward<Vector>(basis), workspace);
242 }
243
244private:
245 Basis1d _basis1d;
246};
247
248}}} // namespace lsst::geom::polynomials
249
250#endif // !LSST_AFW_MATH_POLYNOMIALS_PackedBasis2d_h_INCLUDED
py::object result
Definition: _schema.cc:429
ndarray::Array< double const, 2, 2 > coefficients
double x
double z
Definition: Match.cc:44
int y
Definition: SpanSet.cc:48
A basis interface for 1-d series expansions.
Definition: Basis1d.h:36
std::size_t getOrder() const
Return the order of the basis.
void fill(double x, Vector &&basis) const
Evaluate the basis at a given point.
A 2-d function defined by a series expansion and its coefficients.
Definition: Function2d.h:42
A Basis2d formed from the product of a Basis1d for each of x and y, truncated at the sum of their ord...
Definition: PackedBasis2d.h:75
void fill(geom::Point2D const &point, Vector &&basis, Workspace &workspace) const
Evaluate the basis at a given point.
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).
void fill(geom::Point2D const &point, Vector &&basis) const
Evaluate the basis at a given point (internal workspace version).
PackedBasis2d & operator=(PackedBasis2d &&)=default
Default move assignment.
PackedBasis2d(PackedBasis2d &&)=default
Default move constructor.
static constexpr std::size_t computeSize(std::size_t order)
Return the size of a PackedBasis with the given order.
Definition: PackedBasis2d.h:91
PackedBasis2d(PackedBasis2d const &)=default
Default copy constructor.
PackedBasis2d(Basis1d const &basis1d)
Construct from a 1-d basis that will be used for both x and y.
Definition: PackedBasis2d.h:94
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.
double sumWith(geom::Point2D const &point, Vector const &coefficients, Workspace &workspace, SumMode mode=SumMode::FAST) const
Evaluate a basis expansion with the given coefficients.
PackedBasis2d & operator=(PackedBasis2d const &)=default
Default copy assignment.
std::size_t getOrder() const noexcept
Return the maximum order of the basis.
ScaledBasis2d< PackedBasis2d > Scaled
The type returned by scale().
Definition: PackedBasis2d.h:82
Workspace makeWorkspace() const
Allocate a workspace that can be passed to sumWith() and fill() to avoid repeated memory allocations.
Scaled scaled(Scaling2d const &first) const
Return a scaled basis that delegates to a copy of this.
PackedBasisWorkspace2d Workspace
The type returned by makeWorkspace().
Definition: PackedBasis2d.h:85
PackedBasis2d(Args &&...args)
Construct by forwarding all arguments to the 1-d basis constructor.
Definition: PackedBasis2d.h:98
PackedIndexRange< packing > IndexRange
The type returned by getIndices().
Definition: PackedBasis2d.h:88
std::size_t size() const noexcept
Return the number of basis functions.
A workspace object that can be used to avoid extra memory allocations in repeated calls to PackedBasi...
Definition: PackedBasis2d.h:40
std::size_t getOrder() const
Return the maximum order this workspace supports.
Definition: PackedBasis2d.h:47
PackedBasisWorkspace2d(std::size_t order)
Construct workspace for a basis with the given order.
Definition: PackedBasis2d.h:44
An iterator for traversing "packed" triangular 2-d series expansions, in which two 1-d expansions are...
Definition: PackedIndex.h:164
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
A specialized iterator range class for PackedIndexIterator, providing size calculation,...
Definition: PackedIndex.h:248
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
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
A numerically stable summation algorithm for floating-point numbers.
Definition: SafeSum.h:62
A 2-d basis that transforms all input points before evaluating nested basis.
Definition: ScaledBasis2d.h:43
A 2-d separable affine transform that can be used to map one interval to another.
Definition: Scaling2d.h:48
SumMode
Enum used to control how to sum polynomial terms.
Definition: SafeSum.h:32
@ FAST
Summation using regular floating-point addition.
Eigen::Matrix< Scalar, Eigen::Dynamic, 1 > Vector
Definition: common.h:46
A base class for image defects.
STL namespace.
table::Key< table::Array< double > > basis
Definition: PsfexPsf.cc:361
table::Key< int > order