LSST Applications 27.0.0,g0265f82a02+469cd937ee,g02d81e74bb+21ad69e7e1,g1470d8bcf6+cbe83ee85a,g2079a07aa2+e67c6346a6,g212a7c68fe+04a9158687,g2305ad1205+94392ce272,g295015adf3+81dd352a9d,g2bbee38e9b+469cd937ee,g337abbeb29+469cd937ee,g3939d97d7f+72a9f7b576,g487adcacf7+71499e7cba,g50ff169b8f+5929b3527e,g52b1c1532d+a6fc98d2e7,g591dd9f2cf+df404f777f,g5a732f18d5+be83d3ecdb,g64a986408d+21ad69e7e1,g858d7b2824+21ad69e7e1,g8a8a8dda67+a6fc98d2e7,g99cad8db69+f62e5b0af5,g9ddcbc5298+d4bad12328,ga1e77700b3+9c366c4306,ga8c6da7877+71e4819109,gb0e22166c9+25ba2f69a1,gb6a65358fc+469cd937ee,gbb8dafda3b+69d3c0e320,gc07e1c2157+a98bf949bb,gc120e1dc64+615ec43309,gc28159a63d+469cd937ee,gcf0d15dbbd+72a9f7b576,gdaeeff99f8+a38ce5ea23,ge6526c86ff+3a7c1ac5f1,ge79ae78c31+469cd937ee,gee10cc3b42+a6fc98d2e7,gf1cff7945b+21ad69e7e1,gfbcc870c63+9a11dc8c8f
LSST Data Management Base Package
Loading...
Searching...
No Matches
_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
31
32namespace py = pybind11;
33using namespace pybind11::literals;
34
35namespace lsst {
36namespace afw {
37namespace math {
38
39namespace {
40
41template <typename ReturnT>
42void 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
62template <typename ReturnT>
63void 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
76template <typename ReturnT>
77void 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
90template <typename ReturnT>
91void 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
107template <typename ReturnT>
108void 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
119template <typename ReturnT>
120void 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
130template <typename ReturnT>
131void 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
142void wrapFunction(lsst::utils::python::WrapperCollection &wrappers) {
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
py::class_< PixelAreaBoundedField, std::shared_ptr< PixelAreaBoundedField >, BoundedField > PyClass
void wrapFunction(lsst::utils::python::WrapperCollection &wrappers)
Definition _function.cc:142