LSSTApplications  19.0.0-14-gb0260a2+72efe9b372,20.0.0+7927753e06,20.0.0+8829bf0056,20.0.0+995114c5d2,20.0.0+b6f4b2abd1,20.0.0+bddc4f4cbe,20.0.0-1-g253301a+8829bf0056,20.0.0-1-g2b7511a+0d71a2d77f,20.0.0-1-g5b95a8c+7461dd0434,20.0.0-12-g321c96ea+23efe4bbff,20.0.0-16-gfab17e72e+fdf35455f6,20.0.0-2-g0070d88+ba3ffc8f0b,20.0.0-2-g4dae9ad+ee58a624b3,20.0.0-2-g61b8584+5d3db074ba,20.0.0-2-gb780d76+d529cf1a41,20.0.0-2-ged6426c+226a441f5f,20.0.0-2-gf072044+8829bf0056,20.0.0-2-gf1f7952+ee58a624b3,20.0.0-20-geae50cf+e37fec0aee,20.0.0-25-g3dcad98+544a109665,20.0.0-25-g5eafb0f+ee58a624b3,20.0.0-27-g64178ef+f1f297b00a,20.0.0-3-g4cc78c6+e0676b0dc8,20.0.0-3-g8f21e14+4fd2c12c9a,20.0.0-3-gbd60e8c+187b78b4b8,20.0.0-3-gbecbe05+48431fa087,20.0.0-38-ge4adf513+a12e1f8e37,20.0.0-4-g97dc21a+544a109665,20.0.0-4-gb4befbc+087873070b,20.0.0-4-gf910f65+5d3db074ba,20.0.0-5-gdfe0fee+199202a608,20.0.0-5-gfbfe500+d529cf1a41,20.0.0-6-g64f541c+d529cf1a41,20.0.0-6-g9a5b7a1+a1cd37312e,20.0.0-68-ga3f3dda+5fca18c6a4,20.0.0-9-g4aef684+e18322736b,w.2020.45
LSSTDataManagementBasePackage
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 
30 namespace lsst { namespace geom { namespace polynomials {
31 
32 template <typename Basis1d, PackingOrder packing>
34 
35 
41 public:
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 
49 private:
50 
51  template <typename Recurrence, PackingOrder packing>
52  friend class PackedBasis2d;
53 
54  Eigen::VectorXd _x;
55  Eigen::VectorXd _y;
56 };
57 
58 template <typename Basis>
59 class Function2d;
60 
74 template <typename Basis1d, PackingOrder packing>
75 class PackedBasis2d {
76 public:
77 
80 
83 
86 
89 
91  static constexpr std::size_t computeSize(std::size_t order) { return IndexRange::computeSize(order); }
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 
107  PackedBasis2d & operator=(PackedBasis2d const &) = default;
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 
130  return IndexRange::computeIndex(x, y);
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 
244 private:
245  Basis1d _basis1d;
246 };
247 
248 }}} // namespace lsst::geom::polynomials
249 
250 #endif // !LSST_AFW_MATH_POLYNOMIALS_PackedBasis2d_h_INCLUDED
y
int y
Definition: SpanSet.cc:49
lsst::geom::polynomials::PackedBasis2d
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:33
lsst::geom::polynomials::Scaling2d
A 2-d separable affine transform that can be used to map one interval to another.
Definition: Scaling2d.h:48
lsst::geom::polynomials::PackedBasis2d::operator=
PackedBasis2d & operator=(PackedBasis2d const &)=default
Default copy assignment.
ScaledBasis2d.h
SafeSum.h
lsst::geom::polynomials::PackedBasis2d::PackedBasis2d
PackedBasis2d(PackedBasis2d &&)=default
Default move constructor.
lsst::geom::polynomials::PackedBasis2d::PackedBasis2d
PackedBasis2d(Args &&...args)
Construct by forwarding all arguments to the 1-d basis constructor.
Definition: PackedBasis2d.h:98
lsst::meas::algorithms.psfSelectionFromMatchList.args
list args
Definition: psfSelectionFromMatchList.py:27
coefficients
ndarray::Array< double const, 2, 2 > coefficients
Definition: ChebyshevBoundedField.cc:276
lsst::geom::polynomials::ScaledBasis2d
A 2-d basis that transforms all input points before evaluating nested basis.
Definition: ScaledBasis2d.h:43
lsst::geom::polynomials::PackedBasis2d::computeSize
static constexpr std::size_t computeSize(std::size_t order)
Return the size of a PackedBasis with the given order.
Definition: PackedBasis2d.h:91
lsst::geom::polynomials::PackedBasis2d::fill
void fill(geom::Point2D const &point, Vector &&basis, Workspace &workspace) const
Evaluate the basis at a given point.
Definition: PackedBasis2d.h:228
lsst::geom::polynomials::PackedBasis2d::getOrder
std::size_t getOrder() const noexcept
Return the maximum order of the basis.
Definition: PackedBasis2d.h:113
lsst::geom::polynomials::Basis1d::fill
void fill(double x, Vector &&basis) const
Evaluate the basis at a given point.
lsst::geom::polynomials::PackedBasisWorkspace2d
A workspace object that can be used to avoid extra memory allocations in repeated calls to PackedBasi...
Definition: PackedBasis2d.h:40
lsst::afw::table._match.first
first
Definition: _match.py:74
lsst::geom::polynomials::PackedIndexIterator::makeEnd
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
PackedIndex.h
lsst::geom::polynomials::Basis1d::getOrder
std::size_t getOrder() const
Return the order of the basis.
lsst::geom::polynomials::PackedBasis2d::fill
void fill(geom::Point2D const &point, Vector &&basis) const
Evaluate the basis at a given point (internal workspace version).
Definition: PackedBasis2d.h:239
lsst::geom::polynomials::PackedBasis2d::operator=
PackedBasis2d & operator=(PackedBasis2d &&)=default
Default move assignment.
lsst::geom::polynomials::PackedBasis2d::sumWith
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).
Definition: PackedBasis2d.h:210
lsst::geom::polynomials::PackedBasis2d::IndexRange
PackedIndexRange< packing > IndexRange
The type returned by getIndices().
Definition: PackedBasis2d.h:88
lsst::geom::polynomials::PackedBasisWorkspace2d::getOrder
std::size_t getOrder() const
Return the maximum order this workspace supports.
Definition: PackedBasis2d.h:47
Point.h
lsst::geom::polynomials::PackedIndexIterator
An iterator for traversing "packed" triangular 2-d series expansions, in which two 1-d expansions are...
Definition: PackedIndex.h:164
lsst::geom::polynomials::PackedBasis2d::PackedBasis2d
PackedBasis2d(Basis1d const &basis1d)
Construct from a 1-d basis that will be used for both x and y.
Definition: PackedBasis2d.h:94
lsst::geom::polynomials::PackedBasis2d::getIndices
IndexRange getIndices() const noexcept
Return a range of iterators that dereference to Index2d.
Definition: PackedBasis2d.h:155
z
double z
Definition: Match.cc:44
x
double x
Definition: ChebyshevBoundedField.cc:277
lsst::geom::polynomials::SumMode
SumMode
Enum used to control how to sum polynomial terms.
Definition: SafeSum.h:32
lsst::geom::polynomials::PackedBasis2d::Scaled
ScaledBasis2d< PackedBasis2d > Scaled
The type returned by scale().
Definition: PackedBasis2d.h:82
lsst::geom::polynomials::PackedBasis2d::Workspace
PackedBasisWorkspace2d Workspace
The type returned by makeWorkspace().
Definition: PackedBasis2d.h:85
lsst::meas::modelfit::Vector
Eigen::Matrix< Scalar, Eigen::Dynamic, 1 > Vector
Definition: common.h:46
lsst::geom::polynomials::PackedIndexRange::computeIndex
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
lsst::geom::polynomials::PackedBasis2d::PackedBasis2d
PackedBasis2d(PackedBasis2d const &)=default
Default copy constructor.
basis
table::Key< table::Array< double > > basis
Definition: PsfexPsf.cc:361
lsst::geom::polynomials::PackedBasis2d::sumWith
double sumWith(geom::Point2D const &point, Vector const &coefficients, Workspace &workspace, SumMode mode=SumMode::FAST) const
Evaluate a basis expansion with the given coefficients.
Definition: PackedBasis2d.h:182
result
py::object result
Definition: _schema.cc:429
lsst::geom::polynomials::PackedBasis2d::makeWorkspace
Workspace makeWorkspace() const
Allocate a workspace that can be passed to sumWith() and fill() to avoid repeated memory allocations.
Definition: PackedBasis2d.h:160
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
lsst::geom::polynomials::PackedIndexRange::computeSize
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
lsst::geom::polynomials::PackedIndexRange
A specialized iterator range class for PackedIndexIterator, providing size calculation,...
Definition: PackedIndex.h:248
lsst::geom
Definition: AffineTransform.h:36
std
STL namespace.
lsst::geom::Point< double, 2 >
lsst::geom::polynomials::PackedBasis2d::index
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.
Definition: PackedBasis2d.h:129
lsst::geom::polynomials::SafeSum
A numerically stable summation algorithm for floating-point numbers.
Definition: SafeSum.h:62
std::size_t
lsst::geom::polynomials::PackedBasisWorkspace2d::PackedBasisWorkspace2d
PackedBasisWorkspace2d(std::size_t order)
Construct workspace for a basis with the given order.
Definition: PackedBasis2d.h:44
lsst::geom::polynomials::PackedBasis2d::size
std::size_t size() const noexcept
Return the number of basis functions.
Definition: PackedBasis2d.h:116
lsst::geom::polynomials::Basis1d
A basis interface for 1-d series expansions.
Definition: Basis1d.h:36
lsst::geom::polynomials::PackedBasis2d::scaled
Scaled scaled(Scaling2d const &first) const
Return a scaled basis that delegates to a copy of this.
Definition: PackedBasis2d.h:124
lsst::geom::polynomials::SumMode::FAST
@ FAST
Summation using regular floating-point addition.
lsst::geom::polynomials::Function2d
A 2-d function defined by a series expansion and its coefficients.
Definition: Function2d.h:42