LSST Applications  21.0.0+04719a4bac,21.0.0-1-ga51b5d4+f5e6047307,21.0.0-11-g2b59f77+a9c1acf22d,21.0.0-11-ga42c5b2+86977b0b17,21.0.0-12-gf4ce030+76814010d2,21.0.0-13-g1721dae+760e7a6536,21.0.0-13-g3a573fe+768d78a30a,21.0.0-15-g5a7caf0+f21cbc5713,21.0.0-16-g0fb55c1+b60e2d390c,21.0.0-19-g4cded4ca+71a93a33c0,21.0.0-2-g103fe59+bb20972958,21.0.0-2-g45278ab+04719a4bac,21.0.0-2-g5242d73+3ad5d60fb1,21.0.0-2-g7f82c8f+8babb168e8,21.0.0-2-g8f08a60+06509c8b61,21.0.0-2-g8faa9b5+616205b9df,21.0.0-2-ga326454+8babb168e8,21.0.0-2-gde069b7+5e4aea9c2f,21.0.0-2-gecfae73+1d3a86e577,21.0.0-2-gfc62afb+3ad5d60fb1,21.0.0-25-g1d57be3cd+e73869a214,21.0.0-3-g357aad2+ed88757d29,21.0.0-3-g4a4ce7f+3ad5d60fb1,21.0.0-3-g4be5c26+3ad5d60fb1,21.0.0-3-g65f322c+e0b24896a3,21.0.0-3-g7d9da8d+616205b9df,21.0.0-3-ge02ed75+a9c1acf22d,21.0.0-4-g591bb35+a9c1acf22d,21.0.0-4-g65b4814+b60e2d390c,21.0.0-4-gccdca77+0de219a2bc,21.0.0-4-ge8a399c+6c55c39e83,21.0.0-5-gd00fb1e+05fce91b99,21.0.0-6-gc675373+3ad5d60fb1,21.0.0-64-g1122c245+4fb2b8f86e,21.0.0-7-g04766d7+cd19d05db2,21.0.0-7-gdf92d54+04719a4bac,21.0.0-8-g5674e7b+d1bd76f71f,master-gac4afde19b+a9c1acf22d,w.2021.13
LSST Data Management Base Package
_function.cc
Go to the documentation of this file.
1 /*
2  * LSST Data Management System
3  * Copyright 2008-2016 AURA/LSST.
4  *
5  * This product includes software developed by the
6  * LSST Project (http://www.lsst.org/).
7  *
8  * This program is free software: you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation, either version 3 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the LSST License Statement and
19  * the GNU General Public License along with this program. If not,
20  * see <https://www.lsstcorp.org/LegalNotices/>.
21  */
22 #include <memory>
23 #include <string>
24 
25 #include <pybind11/pybind11.h>
26 #include <lsst/utils/python.h>
27 #include <pybind11/stl.h>
28 
29 #include "lsst/afw/table/io/python.h" // for addPersistableMethods
30 #include "lsst/afw/math/Function.h"
31 
32 namespace py = pybind11;
33 using namespace pybind11::literals;
34 
35 namespace lsst {
36 namespace afw {
37 namespace math {
38 
39 namespace {
40 
41 template <typename ReturnT>
42 void declareFunction(lsst::utils::python::WrapperCollection &wrappers, std::string const &suffix) {
43  auto const name = "Function" + suffix;
44  wrappers.wrapType(
45  py::class_<Function<ReturnT>, std::shared_ptr<Function<ReturnT>>>(wrappers.module, name.c_str()),
46  [](auto &mod, auto &cls) {
47  cls.def(py::init<unsigned int>(), "nParams"_a);
48  cls.def(py::init<std::vector<double> const &>(), "params"_a);
49 
50  table::io::python::addPersistableMethods<Function<ReturnT>>(cls);
51 
52  cls.def("getNParameters", &Function<ReturnT>::getNParameters);
53  cls.def("getParameters", &Function<ReturnT>::getParameters, py::return_value_policy::copy);
54  cls.def("getParameter", &Function<ReturnT>::getParameter, "index"_a);
55  cls.def("isLinearCombination", &Function<ReturnT>::isLinearCombination);
56  cls.def("setParameter", &Function<ReturnT>::setParameter, "index"_a, "value"_a);
57  cls.def("setParameters", &Function<ReturnT>::setParameters);
58  cls.def("toString", &Function<ReturnT>::toString, "prefix"_a = "");
59  });
60 }
61 
62 template <typename ReturnT>
63 void declareFunction1(lsst::utils::python::WrapperCollection &wrappers, const std::string &suffix) {
64  auto const name = "Function1" + suffix;
65  using PyClass = py::class_<Function1<ReturnT>, std::shared_ptr<Function1<ReturnT>>, Function<ReturnT>>;
66  wrappers.wrapType(PyClass(wrappers.module, name.c_str()), [](auto &mod, auto &cls) {
67  table::io::python::addPersistableMethods<Function1<ReturnT>>(cls);
68 
69  cls.def("clone", &Function1<ReturnT>::clone);
70  cls.def("__call__", &Function1<ReturnT>::operator(), "x"_a);
71  cls.def("toString", &Function1<ReturnT>::toString, "prefix"_a = "");
72  cls.def("computeCache", &Function1<ReturnT>::computeCache, "n"_a);
73  });
74 }
75 
76 template <typename ReturnT>
77 void declareFunction2(lsst::utils::python::WrapperCollection &wrappers, const std::string &suffix) {
78  auto const name = "Function2" + suffix;
79  using PyClass = py::class_<Function2<ReturnT>, std::shared_ptr<Function2<ReturnT>>, Function<ReturnT>>;
80  wrappers.wrapType(PyClass(wrappers.module, name.c_str()), [](auto &mod, auto &cls) {
81  table::io::python::addPersistableMethods<Function2<ReturnT>>(cls);
82 
83  cls.def("clone", &Function2<ReturnT>::clone);
84  cls.def("__call__", &Function2<ReturnT>::operator(), "x"_a, "y"_a);
85  cls.def("toString", &Function2<ReturnT>::toString, "prefix"_a = "");
86  cls.def("getDFuncDParameters", &Function2<ReturnT>::getDFuncDParameters, "x"_a, "y"_a);
87  });
88 }
89 
90 template <typename ReturnT>
91 void declareBasePolynomialFunction2(lsst ::utils::python::WrapperCollection &wrappers,
92  const std::string &suffix) {
93  auto const name = "BasePolynomialFunction2" + suffix;
94  using PyClass = py::class_<BasePolynomialFunction2<ReturnT>,
96  wrappers.wrapType(PyClass(wrappers.module, name.c_str()), [](auto &mod, auto &cls) {
97  cls.def("getOrder", &BasePolynomialFunction2<ReturnT>::getOrder);
98  cls.def("isLinearCombination", &BasePolynomialFunction2<ReturnT>::isLinearCombination);
99  cls.def_static("nParametersFromOrder", &BasePolynomialFunction2<ReturnT>::nParametersFromOrder,
100  "order"_a);
101  cls.def_static("orderFromNParameters", &BasePolynomialFunction2<ReturnT>::orderFromNParameters,
102  "nParameters"_a);
103  cls.def("getDFuncDParameters", &BasePolynomialFunction2<ReturnT>::getDFuncDParameters, "x"_a, "y"_a);
104  });
105 }
106 
107 template <typename ReturnT>
108 void declareNullFunction1(lsst::utils::python::WrapperCollection &wrappers, const std::string &suffix) {
109  auto const name = "NullFunction1" + suffix;
110  using PyClass =
111  py::class_<NullFunction1<ReturnT>, std::shared_ptr<NullFunction1<ReturnT>>, Function1<ReturnT>>;
112  wrappers.wrapType(PyClass(wrappers.module, name.c_str()), [](auto &mod, auto &cls) {
113  cls.def(py::init<>());
114 
115  cls.def("clone", &NullFunction1<ReturnT>::clone);
116  });
117 }
118 
119 template <typename ReturnT>
120 void declareNullFunction2(lsst::utils::python::WrapperCollection &wrappers, const std::string &suffix) {
121  auto const name = "NullFunction2" + suffix;
122  using PyClass =
123  py::class_<NullFunction2<ReturnT>, std::shared_ptr<NullFunction2<ReturnT>>, Function2<ReturnT>>;
124  wrappers.wrapType(PyClass(wrappers.module, name.c_str()), [](auto &mod, auto &cls) {
125  cls.def(py::init<>());
126  cls.def("clone", &NullFunction2<ReturnT>::clone);
127  });
128 }
129 
130 template <typename ReturnT>
131 void declareAllFunctions(lsst::utils::python::WrapperCollection &wrappers, const std::string &suffix) {
132  declareFunction<ReturnT>(wrappers, suffix);
133  declareFunction1<ReturnT>(wrappers, suffix);
134  declareFunction2<ReturnT>(wrappers, suffix);
135  declareBasePolynomialFunction2<ReturnT>(wrappers, suffix);
136  declareNullFunction1<ReturnT>(wrappers, suffix);
137  declareNullFunction2<ReturnT>(wrappers, suffix);
138 };
139 
140 } // namespace
141 
143  wrappers.addSignatureDependency("lsst.afw.table.io");
144  declareAllFunctions<float>(wrappers, "F");
145  declareAllFunctions<double>(wrappers, "D");
146 }
147 
148 } // namespace math
149 } // namespace afw
150 } // namespace lsst
table::Key< std::string > name
Definition: Amplifier.cc:116
A helper class for subdividing pybind11 module across multiple translation units (i....
Definition: python.h:242
pybind11::module module
The module object passed to the PYBIND11_MODULE block that contains this WrapperCollection.
Definition: python.h:448
PyType wrapType(PyType cls, ClassWrapperCallback function, bool setModuleName=true)
Add a type (class or enum) wrapper, deferring method and other attribute definitions until finish() i...
Definition: python.h:391
void addSignatureDependency(std::string const &name)
Indicate an external module that provides a type used in function/method signatures.
Definition: python.h:357
void wrapFunction(lsst::utils::python::WrapperCollection &wrappers)
Definition: _function.cc:142
py::class_< PixelAreaBoundedField, std::shared_ptr< PixelAreaBoundedField >, BoundedField > PyClass
A base class for image defects.