LSSTApplications  21.0.0+75b29a8a7f,21.0.0+e70536a077,21.0.0-1-ga51b5d4+62c747d40b,21.0.0-11-ga6ea59e8e+47cba9fc36,21.0.0-2-g103fe59+914993bf7c,21.0.0-2-g1367e85+e2614ded12,21.0.0-2-g45278ab+e70536a077,21.0.0-2-g4bc9b9f+7b2b5f8678,21.0.0-2-g5242d73+e2614ded12,21.0.0-2-g54e2caa+6403186824,21.0.0-2-g7f82c8f+3ac4acbffc,21.0.0-2-g8dde007+04a6aea1af,21.0.0-2-g8f08a60+9402881886,21.0.0-2-ga326454+3ac4acbffc,21.0.0-2-ga63a54e+81dd751046,21.0.0-2-gc738bc1+5f65c6e7a9,21.0.0-2-gde069b7+26c92b3210,21.0.0-2-gecfae73+0993ddc9bd,21.0.0-2-gfc62afb+e2614ded12,21.0.0-21-gba890a8+5a4f502a26,21.0.0-23-g9966ff26+03098d1af8,21.0.0-3-g357aad2+8ad216c477,21.0.0-3-g4be5c26+e2614ded12,21.0.0-3-g6d51c4a+4d2fe0280d,21.0.0-3-g7d9da8d+75b29a8a7f,21.0.0-3-gaa929c8+522e0f12c2,21.0.0-3-ge02ed75+4d2fe0280d,21.0.0-4-g3300ddd+e70536a077,21.0.0-4-gc004bbf+eac6615e82,21.0.0-4-gccdca77+f94adcd104,21.0.0-4-gd1c1571+18b81799f9,21.0.0-5-g7b47fff+4d2fe0280d,21.0.0-5-gb155db7+d2632f662b,21.0.0-5-gdf36809+637e4641ee,21.0.0-6-g722ad07+28c848f42a,21.0.0-7-g959bb79+522e0f12c2,21.0.0-7-gfd72ab2+cf01990774,21.0.0-9-g87fb7b8d+e2ab11cdd6,w.2021.04
LSSTDataManagementBasePackage
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 <pybind11/stl.h>
27 
28 #include "lsst/afw/table/io/python.h" // for addPersistableMethods
29 #include "lsst/afw/math/Function.h"
30 
31 namespace py = pybind11;
32 using namespace pybind11::literals;
33 
34 namespace lsst {
35 namespace afw {
36 namespace math {
37 
38 namespace {
39 
40 template <typename ReturnT>
41 void declareFunction(py::module &mod, std::string const &suffix) {
42  auto const name = "Function" + suffix;
43 
44  py::class_<Function<ReturnT>, std::shared_ptr<Function<ReturnT>>> cls(mod, name.c_str());
45 
46  cls.def(py::init<unsigned int>(), "nParams"_a);
47  cls.def(py::init<std::vector<double> const &>(), "params"_a);
48 
49  table::io::python::addPersistableMethods<Function<ReturnT>>(cls);
50 
51  cls.def("getNParameters", &Function<ReturnT>::getNParameters);
52  cls.def("getParameters", &Function<ReturnT>::getParameters, py::return_value_policy::copy);
53  cls.def("getParameter", &Function<ReturnT>::getParameter, "index"_a);
54  cls.def("isLinearCombination", &Function<ReturnT>::isLinearCombination);
55  cls.def("setParameter", &Function<ReturnT>::setParameter, "index"_a, "value"_a);
56  cls.def("setParameters", &Function<ReturnT>::setParameters);
57  cls.def("toString", &Function<ReturnT>::toString, "prefix"_a = "");
58 }
59 
60 template <typename ReturnT>
61 void declareFunction1(py::module &mod, const std::string &suffix) {
62  auto const name = "Function1" + suffix;
63 
64  py::class_<Function1<ReturnT>, std::shared_ptr<Function1<ReturnT>>, Function<ReturnT>> cls(mod,
65  name.c_str());
66 
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 template <typename ReturnT>
76 void declareFunction2(py::module &mod, const std::string &suffix) {
77  auto const name = "Function2" + suffix;
78 
79  py::class_<Function2<ReturnT>, std::shared_ptr<Function2<ReturnT>>, Function<ReturnT>> cls(mod,
80  name.c_str());
81 
82  table::io::python::addPersistableMethods<Function2<ReturnT>>(cls);
83 
84  cls.def("clone", &Function2<ReturnT>::clone);
85  cls.def("__call__", &Function2<ReturnT>::operator(), "x"_a, "y"_a);
86  cls.def("toString", &Function2<ReturnT>::toString, "prefix"_a = "");
87  cls.def("getDFuncDParameters", &Function2<ReturnT>::getDFuncDParameters, "x"_a, "y"_a);
88 }
89 
90 template <typename ReturnT>
91 void declareBasePolynomialFunction2(py::module &mod, const std::string &suffix) {
92  auto const name = "BasePolynomialFunction2" + suffix;
93 
94  py::class_<BasePolynomialFunction2<ReturnT>, std::shared_ptr<BasePolynomialFunction2<ReturnT>>,
95  Function2<ReturnT>>
96  cls(mod, name.c_str());
97 
98  cls.def("getOrder", &BasePolynomialFunction2<ReturnT>::getOrder);
99  cls.def("isLinearCombination", &BasePolynomialFunction2<ReturnT>::isLinearCombination);
100  cls.def_static("nParametersFromOrder", &BasePolynomialFunction2<ReturnT>::nParametersFromOrder,
101  "order"_a);
102  cls.def_static("orderFromNParameters", &BasePolynomialFunction2<ReturnT>::orderFromNParameters,
103  "nParameters"_a);
104  cls.def("getDFuncDParameters", &BasePolynomialFunction2<ReturnT>::getDFuncDParameters, "x"_a, "y"_a);
105 }
106 
107 template <typename ReturnT>
108 void declareNullFunction1(py::module &mod, const std::string &suffix) {
109  auto const name = "NullFunction1" + suffix;
110 
111  py::class_<NullFunction1<ReturnT>, std::shared_ptr<NullFunction1<ReturnT>>, Function1<ReturnT>> cls(
112  mod, name.c_str());
113 
114  cls.def(py::init<>());
115 
116  cls.def("clone", &NullFunction1<ReturnT>::clone);
117 }
118 
119 template <typename ReturnT>
120 void declareNullFunction2(py::module &mod, const std::string &suffix) {
121  auto const name = "NullFunction2" + suffix;
122 
123  py::class_<NullFunction2<ReturnT>, std::shared_ptr<NullFunction2<ReturnT>>, Function2<ReturnT>> cls(
124  mod, name.c_str());
125 
126  cls.def(py::init<>());
127 
128  cls.def("clone", &NullFunction2<ReturnT>::clone);
129 }
130 
131 template <typename ReturnT>
132 void declareAllFunctions(py::module &mod, const std::string &suffix) {
133  declareFunction<ReturnT>(mod, suffix);
134  declareFunction1<ReturnT>(mod, suffix);
135  declareFunction2<ReturnT>(mod, suffix);
136  declareBasePolynomialFunction2<ReturnT>(mod, suffix);
137  declareNullFunction1<ReturnT>(mod, suffix);
138  declareNullFunction2<ReturnT>(mod, suffix);
139 };
140 
141 } // namespace <anonymous>
142 
143 PYBIND11_MODULE(function, mod) {
144  declareAllFunctions<float>(mod, "F");
145  declareAllFunctions<double>(mod, "D");
146 }
147 
148 } // namespace math
149 } // namespace afw
150 } // namespace lsst
std::string
STL class.
std::shared_ptr
STL class.
std::vector< double >
lsst::afw
Definition: imageAlgorithm.dox:1
lsst::afw::geom.transform.transformContinued.name
string name
Definition: transformContinued.py:32
lsst::afw::geom.transform.transformContinued.cls
cls
Definition: transformContinued.py:33
lsst
A base class for image defects.
Definition: imageAlgorithm.dox:1
python.h
pybind11
Definition: _GenericMap.cc:40
lsst::afw::math::PYBIND11_MODULE
PYBIND11_MODULE(function, mod)
Definition: function.cc:143
lsst::utils.tests.init
def init()
Definition: tests.py:59
Function.h
lsst::afw::image.slicing.clone
clone
Definition: slicing.py:257
lsst::meas::modelfit.psf.psfContinued.module
module
Definition: psfContinued.py:42