LSSTApplications  17.0+11,17.0+34,17.0+56,17.0+57,17.0+59,17.0+7,17.0-1-g377950a+33,17.0.1-1-g114240f+2,17.0.1-1-g4d4fbc4+28,17.0.1-1-g55520dc+49,17.0.1-1-g5f4ed7e+52,17.0.1-1-g6dd7d69+17,17.0.1-1-g8de6c91+11,17.0.1-1-gb9095d2+7,17.0.1-1-ge9fec5e+5,17.0.1-1-gf4e0155+55,17.0.1-1-gfc65f5f+50,17.0.1-1-gfc6fb1f+20,17.0.1-10-g87f9f3f+1,17.0.1-11-ge9de802+16,17.0.1-16-ga14f7d5c+4,17.0.1-17-gc79d625+1,17.0.1-17-gdae4c4a+8,17.0.1-2-g26618f5+29,17.0.1-2-g54f2ebc+9,17.0.1-2-gf403422+1,17.0.1-20-g2ca2f74+6,17.0.1-23-gf3eadeb7+1,17.0.1-3-g7e86b59+39,17.0.1-3-gb5ca14a,17.0.1-3-gd08d533+40,17.0.1-30-g596af8797,17.0.1-4-g59d126d+4,17.0.1-4-gc69c472+5,17.0.1-6-g5afd9b9+4,17.0.1-7-g35889ee+1,17.0.1-7-gc7c8782+18,17.0.1-9-gc4bbfb2+3,w.2019.22
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 
104  PackedBasis2d(PackedBasis2d &&) = default;
105 
107  PackedBasis2d & operator=(PackedBasis2d const &) = default;
108 
110  PackedBasis2d & operator=(PackedBasis2d &&) = default;
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 {
156  return IndexRange(typename IndexRange::iterator(), IndexRange::iterator::makeEnd(getOrder()));
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
PackedBasisWorkspace2d(std::size_t order)
Construct workspace for a basis with the given order.
Definition: PackedBasis2d.h:44
std::size_t getOrder() const noexcept
Return the maximum order of the basis.
py::object result
Definition: schema.cc:418
int y
Definition: SpanSet.cc:49
STL namespace.
Summation using regular floating-point addition.
Workspace makeWorkspace() const
Allocate a workspace that can be passed to sumWith() and fill() to avoid repeated memory allocations...
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).
A numerically stable summation algorithm for floating-point numbers.
Definition: SafeSum.h:62
void fill(geom::Point2D const &point, Vector &&basis, Workspace &workspace) 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 specialized iterator range class for PackedIndexIterator, providing size calculation, comparison, and range-based for support.
Definition: PackedIndex.h:248
int computeSize(int order)
Return the size of the coefficient vector for the given order.
Definition: constants.h:97
std::size_t size() const noexcept
Return the number of basis functions.
SumMode
Enum used to control how to sum polynomial terms.
Definition: SafeSum.h:32
void fill(geom::Point2D const &point, Vector &&basis) const
Evaluate the basis at a given point (internal workspace version).
A 2-d separable affine transform that can be used to map one interval to another. ...
Definition: Scaling2d.h:48
double sumWith(geom::Point2D const &point, Vector const &coefficients, Workspace &workspace, SumMode mode=SumMode::FAST) const
Evaluate a basis expansion with the given coefficients.
A base class for image defects.
Eigen::Matrix< Scalar, Eigen::Dynamic, 1 > Vector
Typedefs to be used for probability and parameter values.
Definition: common.h:46
An iterator for traversing "packed" triangular 2-d series expansions, in which two 1-d expansions are...
Definition: PackedIndex.h:164
PackedBasis2d(Args &&...args)
Construct by forwarding all arguments to the 1-d basis constructor.
Definition: PackedBasis2d.h:98
table::Key< table::Array< double > > basis
Definition: PsfexPsf.cc:361
IndexRange getIndices() const noexcept
Return a range of iterators that dereference to Index2d.
double x
A 2-d basis that transforms all input points before evaluating nested basis.
Definition: ScaledBasis2d.h:43
std::size_t getOrder() const
Return the maximum order this workspace supports.
Definition: PackedBasis2d.h:47
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
PackedBasis2d(Basis1d const &basis1d)
Construct from a 1-d basis that will be used for both x and y.
Definition: PackedBasis2d.h:94
A basis interface for 1-d series expansions.
Definition: Basis1d.h:36
A workspace object that can be used to avoid extra memory allocations in repeated calls to PackedBasi...
Definition: PackedBasis2d.h:40
Scaled scaled(Scaling2d const &first) const
Return a scaled basis that delegates to a copy of this.
static constexpr std::size_t computeSize(std::size_t order)
Return the size of a PackedBasis with the given order.
Definition: PackedBasis2d.h:91
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.
ndarray::Array< double const, 2, 2 > coefficients
double z
Definition: Match.cc:44