本文整理汇总了C++中py::module类的典型用法代码示例。如果您正苦于以下问题:C++ module类的具体用法?C++ module怎么用?C++ module使用的例子?那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。
在下文中一共展示了module类的20个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于我们的系统推荐出更棒的C++代码示例。
示例1: init_ex10
void init_ex10(py::module &m) {
// Vectorize all arguments of a function (though non-vector arguments are also allowed)
m.def("vectorized_func", py::vectorize(my_func));
// Vectorize a lambda function with a capture object (e.g. to exclude some arguments from the vectorization)
m.def("vectorized_func2",
[](py::array_dtype<int> x, py::array_dtype<float> y, float z) {
return py::vectorize([z](int x, float y) { return my_func(x, y, z); })(x, y);
}
);
// Vectorize a complex-valued function
m.def("vectorized_func3", py::vectorize(my_func3));
}
开发者ID:heartvalve,项目名称:pybind11,代码行数:14,代码来源:example10.cpp
示例2: init_ex12
void init_ex12(py::module &m) {
/* Important: use the wrapper type as a template
argument to class_<>, but use the original name
to denote the type */
py::class_<PyExample12>(m, "Example12")
/* Declare that 'PyExample12' is really an alias for the original type 'Example12' */
.alias<Example12>()
.def(py::init<int>())
/* Reference original class in function definitions */
.def("run", &Example12::run)
.def("pure_virtual", &Example12::pure_virtual);
m.def("runExample12", &runExample12);
m.def("runExample12Virtual", &runExample12Virtual);
}
开发者ID:GerardGarcia,项目名称:aDTNPlus,代码行数:15,代码来源:example12.cpp
示例3: define_target
void define_target(py::module &m) {
// Disambiguate some ambigious methods
int (Target::*natural_vector_size_method)(const Type &t) const = &Target::natural_vector_size;
bool (Target::*supports_type1_method)(const Type &t) const = &Target::supports_type;
bool (Target::*supports_type2_method)(const Type &t, DeviceAPI device) const = &Target::supports_type;
auto target_class =
py::class_<Target>(m, "Target")
.def(py::init<>())
.def(py::init<const std::string &>())
.def(py::init<Target::OS, Target::Arch, int>())
.def(py::init<Target::OS, Target::Arch, int, std::vector<Target::Feature>>())
.def("__eq__", [](const Target &value, Target *value2) { return value2 && value == *value2; })
.def("__ne__", [](const Target &value, Target *value2) { return !value2 || value != *value2; })
.def_readwrite("os", &Target::os)
.def_readwrite("arch", &Target::arch)
.def_readwrite("bits", &Target::bits)
.def("__repr__", &target_repr)
.def("__str__", &Target::to_string)
.def("to_string", &Target::to_string)
.def("has_feature", &Target::has_feature)
.def("features_any_of", &Target::features_any_of, py::arg("features"))
.def("features_all_of", &Target::features_all_of, py::arg("features"))
.def("set_feature", &Target::set_feature, py::arg("f"), py::arg("value") = true)
.def("set_features", &Target::set_features, py::arg("features"), py::arg("value") = true)
.def("with_feature", &Target::with_feature, py::arg("feature"))
.def("without_feature", &Target::without_feature, py::arg("feature"))
.def("has_gpu_feature", &Target::has_gpu_feature)
.def("supports_type", supports_type1_method, py::arg("type"))
.def("supports_type", supports_type2_method, py::arg("type"), py::arg("device"))
.def("supports_device_api", &Target::supports_device_api, py::arg("device"))
.def("natural_vector_size", natural_vector_size_method, py::arg("type"))
.def("has_large_buffers", &Target::has_large_buffers)
.def("maximum_buffer_size", &Target::maximum_buffer_size)
.def("supported", &Target::supported)
.def_static("validate_target_string", &Target::validate_target_string, py::arg("name"));
;
m.def("get_host_target", &get_host_target);
m.def("get_target_from_environment", &get_target_from_environment);
m.def("get_jit_target_from_environment", &get_jit_target_from_environment);
m.def("target_feature_for_device_api", &target_feature_for_device_api);
}
开发者ID:halide,项目名称:Halide,代码行数:48,代码来源:PyTarget.cpp
示例4: wrap_messaging
void wrap_messaging(py::module &m) {
py::module mMessaging = m.def_submodule("messaging");
mMessaging.def("init_transport", &xmessaging::init_transport);
mMessaging.def("stop_transport", &xmessaging::stop_transport);
mMessaging.def("alloc_read_buffer", []() {
xmessaging::alloc_read_buffer(BUFFER_LEN);
});
mMessaging.def("dealloc_read_buffer", []() {
xmessaging::dealloc_read_buffer();
});
// this will change to a buffer object
mMessaging.def("send_bytes", [](py::buffer pb) {
py::buffer_info req = pb.request();
xmessaging::queue((const char*)req.ptr, req.size);
});
mMessaging.def("update", []() -> bool {
bool message_read = false;
char *buffer;
size_t buffer_len;
xmessaging::update(message_read, buffer, buffer_len);
if (message_read)
{
simulation::process_step(buffer, buffer_len);
}
return message_read;
});
}
开发者ID:rufeooo,项目名称:py4xsim,代码行数:29,代码来源:wrap_messaging.cpp
示例5: define_module
void define_module(py::module &m) {
auto module_class = py::class_<Module>(m, "Module")
.def(py::init<const std::string &, const Target &>(), py::arg("name"), py::arg("target"))
.def("target", &Module::target)
.def("name", &Module::name)
.def("auto_schedule", &Module::auto_schedule)
.def("buffers", &Module::buffers)
.def("submodules", &Module::submodules)
.def("append", (void (Module::*)(const Buffer<> &)) &Module::append, py::arg("buffer"))
.def("append", (void (Module::*)(const Module &)) &Module::append, py::arg("module"))
.def("compile", &Module::compile, py::arg("outputs"))
.def("compile_to_buffer", &Module::compile_to_buffer)
.def("resolve_submodules", &Module::resolve_submodules)
.def("remap_metadata_name", &Module::remap_metadata_name)
.def("get_metadata_name_map", &Module::get_metadata_name_map)
.def("set_auto_schedule", &Module::set_auto_schedule)
// TODO: ExternalCode-related methods deliberately skipped for now.
// .def("append", (void (Module::*)(const ExternalCode &)) &Module::append, py::arg("external_code"))
// .def("external_code", &Module::external_code)
// TODO: Internal::LoweredFunc-related methods deliberately skipped for now.
// .def("functions", &Module::functions)
// .def("get_function_by_name", &Module::get_function_by_name, py::arg("name"))
// .def("append", (void (Module::*)(const Internal::LoweredFunc &)) &Module::append, py::arg("function"))
.def("__repr__", [](const Module &m) -> std::string {
std::ostringstream o;
o << "<halide.Module '" << m.name() << "'>";
return o.str();
})
;
m.def("link_modules", &link_modules, py::arg("name"), py::arg("modules"));
m.def("compile_standalone_runtime", (void (*)(const std::string &, Target)) &compile_standalone_runtime, py::arg("filename"), py::arg("target"));
m.def("compile_standalone_runtime", (Outputs (*)(const Outputs &, Target)) &compile_standalone_runtime, py::arg("outputs"), py::arg("target"));
// TODO: compile_multitarget() deliberately skipped for now.
}
开发者ID:adityaatluri,项目名称:Halide,代码行数:47,代码来源:PyModule.cpp
示例6: init_ex9
void init_ex9(py::module &m) {
py::module m_sub = m.def_submodule("submodule");
m_sub.def("submodule_func", &submodule_func);
py::class_<A>(m_sub, "A")
.def(py::init<int>())
.def("__repr__", &A::toString);
py::class_<B>(m_sub, "B")
.def(py::init<>())
.def("get_a1", &B::get_a1, "Return the internal A 1", py::return_value_policy::reference_internal)
.def("get_a2", &B::get_a2, "Return the internal A 2", py::return_value_policy::reference_internal)
.def_readwrite("a1", &B::a1) // def_readonly uses an internal reference return policy by default
.def_readwrite("a2", &B::a2);
m.attr("OD") = py::module::import("collections").attr("OrderedDict");
}
开发者ID:GerardGarcia,项目名称:aDTNPlus,代码行数:17,代码来源:example9.cpp
示例7: python_export_igl_tetgen
void python_export_igl_tetgen(py::module &me) {
py::module m = me.def_submodule(
"tetgen", "Wrappers for libigl functions that use tetgen");
#include "../../py_igl/copyleft/tetgen/py_tetrahedralize.cpp"
}
开发者ID:Codermay,项目名称:libigl,代码行数:8,代码来源:py_igl_tetgen.cpp
示例8: python_export_igl_png
void python_export_igl_png(py::module &me) {
py::module m = me.def_submodule(
"png", "Wrappers for libigl functions that use png");
#include "../py_igl/png/py_readPNG.cpp"
#include "../py_igl/png/py_writePNG.cpp"
}
开发者ID:bbrrck,项目名称:libigl,代码行数:9,代码来源:py_igl_png.cpp
示例9: python_export_igl_embree
void python_export_igl_embree(py::module &me) {
py::module m = me.def_submodule(
"embree", "Wrappers for libigl functions that use embree");
#include "../py_igl/embree/py_ambient_occlusion.cpp"
#include "../py_igl/embree/py_reorient_facets_raycast.cpp"
#include "../py_igl/embree/py_line_mesh_intersection.cpp"
}
开发者ID:dukecyto,项目名称:libigl,代码行数:10,代码来源:py_igl_embree.cpp
示例10: define_lambda
void define_lambda(py::module &m) {
// TODO: 'lambda' is a reserved word in Python, so we
// can't use it for a function. Using 'lambda_func' for now.
m.def("lambda_func", [](py::args args) -> Func {
auto vars = args_to_vector<Var>(args, 0, 1);
Expr e = args[args.size() - 1].cast<Expr>();
Func f("lambda" + Internal::unique_name('_'));
f(vars) = e;
return f;
});
}
开发者ID:adityaatluri,项目名称:Halide,代码行数:11,代码来源:PyLambda.cpp
示例11: init_ex4
void init_ex4(py::module &m) {
m.def("test_function", &test_function1);
m.def("test_function", &test_function2);
m.def("test_function", &test_function3);
m.attr("some_constant") = py::int_(14);
py::enum_<EMyEnumeration>(m, "EMyEnumeration")
.value("EFirstEntry", EFirstEntry)
.value("ESecondEntry", ESecondEntry)
.export_values();
py::class_<Example4> ex4_class(m, "Example4");
ex4_class.def_static("test_function", &Example4::test_function);
py::enum_<Example4::EMode>(ex4_class, "EMode")
.value("EFirstMode", Example4::EFirstMode)
.value("ESecondMode", Example4::ESecondMode)
.export_values();
m.def("return_bytes", &return_bytes);
m.def("print_bytes", &print_bytes);
}
开发者ID:FynnBe,项目名称:fastfilters,代码行数:21,代码来源:example4.cpp
示例12: import
bool Context::import(py::module m)
{
if (!m)
return false;
string name = PyModule_GetName(m.ptr());
if (!name.empty())
{
py_global[name.c_str()] = m;
}
return true;
}
开发者ID:satoruhiga,项目名称:ofxPy,代码行数:13,代码来源:ofxPy.cpp
示例13: pyqpp_cell_export
void pyqpp_cell_export (py::module m) {
py_cell_export<float>(m, "periodic_cell_f");
qpp::gen_cell<float, qpp::matrix3<float> >::py_export(
m, "point_group_f");
qpp::gen_cell<float, qpp::rotrans<float,false> >::py_export(
m, "crystal_group_f");
qpp::gen_cell<float, qpp::rotrans<float,true> >::py_export(
m, "finite_crystal_group_f");
qpp::array_group<qpp::matrix3<float> >::py_export(
m, "array_point_group_f");
qpp::array_group<qpp::rotrans<float,true> >::py_export(
m, "array_fincryst_group_f");
m.def("generator_form", py_generator_form<float, qpp::matrix3<float>,
qpp::array_group<qpp::matrix3<float> > > );
m.def("generator_form", py_generator_form<float, qpp::rotrans<float,true>,
qpp::array_group<qpp::rotrans<float,true> > >);
#ifdef PYTHON_EXP_EXT
py_cell_export<double>(m, "periodic_cell_d");
qpp::gen_cell<double, qpp::matrix3<double> >::py_export(
m, "point_group_d");
qpp::gen_cell<double, qpp::rotrans<double,false> >::py_export(
m, "crystal_group_d");
qpp::gen_cell<double, qpp::rotrans<double,true> >::py_export(
m, "finite_crystal_group_d");
qpp::array_group<qpp::matrix3<double> >::py_export(
m, "array_point_group_d");
qpp::array_group<qpp::rotrans<double,true> >::py_export(
m, "array_fincryst_group_d");
m.def("generator_form", py_generator_form<double, qpp::matrix3<double>,
qpp::array_group<qpp::matrix3<double> > >);
m.def("generator_form", py_generator_form<double, qpp::rotrans<double,true>,
qpp::array_group<qpp::rotrans<double,true> > >);
#endif
}
开发者ID:ZloyBabai,项目名称:qpp,代码行数:37,代码来源:pyqpp_cell.cpp
示例14: wrap_world_map
// World map is generally a point of danger
// A global static contains all of the tiles
// Python accesses those by reference, and is not necessarily aware of mutations to the global static map of tiles
void wrap_world_map(py::module &m)
{
py::module mMap = m.def_submodule("map");
mMap.def("get_map", &world_map::get_map, py::return_value_policy::reference);
mMap.def("get_tile", &world_map::get_tile, py::return_value_policy::reference);
mMap.def("tile_owner", &world_map::tile_owner);
mMap.def("get_map_size", &world_map::get_map_size);
mMap.def("save_file_fb", &world_map::save_file_fb);
mMap.def("for_each_tile", [](py::function func) {
auto fp = [&func](const sf::Vector3i& coord, const Tile& tile) { func(coord, tile); };
world_map::for_each_tile(fp);
});
}
开发者ID:rufeooo,项目名称:py4xsim,代码行数:18,代码来源:wrap_world_map.cpp
示例15: init_ex11
void init_ex11(py::module &m) {
m.def("kw_func", &kw_func, py::arg("x"), py::arg("y"));
m.def("kw_func2", &kw_func, py::arg("x") = 100, py::arg("y") = 200);
m.def("kw_func3", [](const char *) { }, py::arg("data") = std::string("Hello world!"));
/* A fancier default argument */
std::vector<int> list;
list.push_back(13);
list.push_back(17);
m.def("kw_func4", &kw_func4, py::arg("myList") = list);
m.def("call_kw_func", &call_kw_func);
m.def("args_function", &args_function);
m.def("args_kwargs_function", &args_kwargs_function);
using namespace py::literals;
m.def("kw_func_udl", &kw_func, "x"_a, "y"_a=300);
m.def("kw_func_udl_z", &kw_func, "x"_a, "y"_a=0);
}
开发者ID:JerryAtSpiria,项目名称:pybind11,代码行数:20,代码来源:example11.cpp
示例16: bind_vector
// ----------------------------------------------------------------------------------------
void bind_vector(py::module& m)
{
{
py::class_<cv, std::shared_ptr<cv>>(m, "vector", "This object represents the mathematical idea of a column vector.")
.def(py::init())
.def("set_size", &cv_set_size)
.def("resize", &cv_set_size)
.def(py::init(&cv_from_object))
.def("__repr__", &cv__repr__)
.def("__str__", &cv__str__)
.def("__len__", &cv__len__)
.def("__getitem__", &cv__getitem__)
.def("__getitem__", &cv__getitem2__)
.def("__setitem__", &cv__setitem__)
.def_property_readonly("shape", &cv_get_matrix_size)
.def(py::pickle(&getstate<cv>, &setstate<cv>));
m.def("dot", &dotprod, "Compute the dot product between two dense column vectors.");
}
{
typedef point type;
py::class_<type>(m, "point", "This object represents a single point of integer coordinates that maps directly to a dlib::point.")
.def(py::init<long,long>(), py::arg("x"), py::arg("y"))
.def("__repr__", &point__repr__)
.def("__str__", &point__str__)
.def_property_readonly("x", &point_x, "The x-coordinate of the point.")
.def_property_readonly("y", &point_y, "The y-coordinate of the point.")
.def(py::pickle(&getstate<type>, &setstate<type>));
}
{
typedef std::vector<point> type;
py::bind_vector<type>(m, "points", "An array of point objects.")
.def("clear", &type::clear)
.def("resize", resize<type>)
.def("extend", extend_vector_with_python_list<point>)
.def(py::pickle(&getstate<type>, &setstate<type>));
}
}
开发者ID:HimalayPatel,项目名称:dlib,代码行数:39,代码来源:vector.cpp
示例17: init_issues
void init_issues(py::module &m) {
py::module m2 = m.def_submodule("issues");
#if !defined(_MSC_VER)
// Visual Studio 2015 currently cannot compile this test
// (see the comment in type_caster_base::make_copy_constructor)
// #70 compilation issue if operator new is not public
class NonConstructible { private: void *operator new(size_t bytes) throw(); };
py::class_<NonConstructible>(m, "Foo");
m2.def("getstmt", []() -> NonConstructible * { return nullptr; },
py::return_value_policy::reference);
#endif
// #137: const char* isn't handled properly
m2.def("print_cchar", [](const char *string) { std::cout << string << std::endl; });
// #150: char bindings broken
m2.def("print_char", [](char c) { std::cout << c << std::endl; });
// #159: virtual function dispatch has problems with similar-named functions
struct Base { virtual void dispatch(void) const {
/* for some reason MSVC2015 can't compile this if the function is pure virtual */
}; };
struct DispatchIssue : Base {
virtual void dispatch(void) const {
PYBIND11_OVERLOAD_PURE(void, Base, dispatch, /* no arguments */);
}
};
py::class_<Base, std::unique_ptr<Base>, DispatchIssue>(m2, "DispatchIssue")
.def(py::init<>())
.def("dispatch", &Base::dispatch);
m2.def("dispatch_issue_go", [](const Base * b) { b->dispatch(); });
struct Placeholder { int i; Placeholder(int i) : i(i) { } };
py::class_<Placeholder>(m2, "Placeholder")
.def(py::init<int>())
.def("__repr__", [](const Placeholder &p) { return "Placeholder[" + std::to_string(p.i) + "]"; });
// #171: Can't return reference wrappers (or STL datastructures containing them)
m2.def("return_vec_of_reference_wrapper", [](std::reference_wrapper<Placeholder> p4){
Placeholder *p1 = new Placeholder{1};
Placeholder *p2 = new Placeholder{2};
Placeholder *p3 = new Placeholder{3};
std::vector<std::reference_wrapper<Placeholder>> v;
v.push_back(std::ref(*p1));
v.push_back(std::ref(*p2));
v.push_back(std::ref(*p3));
v.push_back(p4);
return v;
});
// #181: iterator passthrough did not compile
m2.def("iterator_passthrough", [](py::iterator s) -> py::iterator {
return py::make_iterator(std::begin(s), std::end(s));
});
// #187: issue involving std::shared_ptr<> return value policy & garbage collection
struct ElementBase { virtual void foo() { } /* Force creation of virtual table */ };
struct ElementA : ElementBase {
ElementA(int v) : v(v) { }
int value() { return v; }
int v;
};
struct ElementList {
void add(std::shared_ptr<ElementBase> e) { l.push_back(e); }
std::vector<std::shared_ptr<ElementBase>> l;
};
py::class_<ElementBase, std::shared_ptr<ElementBase>> (m2, "ElementBase");
py::class_<ElementA, std::shared_ptr<ElementA>>(m2, "ElementA", py::base<ElementBase>())
.def(py::init<int>())
.def("value", &ElementA::value);
py::class_<ElementList, std::shared_ptr<ElementList>>(m2, "ElementList")
.def(py::init<>())
.def("add", &ElementList::add)
.def("get", [](ElementList &el){
py::list list;
for (auto &e : el.l)
list.append(py::cast(e));
return list;
});
// (no id): should not be able to pass 'None' to a reference argument
m2.def("print_element", [](ElementA &el) { std::cout << el.value() << std::endl; });
// (no id): don't cast doubles to ints
m2.def("expect_float", [](float f) { return f; });
m2.def("expect_int", [](int i) { return i; });
// (no id): don't invoke Python dispatch code when instantiating C++
// classes that were not extended on the Python side
struct A {
virtual ~A() {}
//.........这里部分代码省略.........
开发者ID:Hubble1942,项目名称:pybind11,代码行数:101,代码来源:issues.cpp
示例18: init_ex18
void init_ex18(py::module & m) {
m.def("example18", &example18);
}
开发者ID:hadesragon,项目名称:pybind11,代码行数:3,代码来源:example18.cpp
示例19: define_operators
void define_operators(py::module &m) {
m.def("max", [](py::args args) -> Expr {
if (args.size() < 2) {
throw py::value_error("max() must have at least 2 arguments");
}
int pos = (int) args.size() - 1;
Expr value = args[pos--].cast<Expr>();
while (pos >= 0) {
value = max(args[pos--].cast<Expr>(), value);
}
return value;
});
m.def("min", [](py::args args) -> Expr {
if (args.size() < 2) {
throw py::value_error("min() must have at least 2 arguments");
}
int pos = (int) args.size() - 1;
Expr value = args[pos--].cast<Expr>();
while (pos >= 0) {
value = min(args[pos--].cast<Expr>(), value);
}
return value;
});
m.def("clamp", &clamp);
m.def("abs", &abs);
m.def("absd", &absd);
m.def("select", [](py::args args) -> Expr {
if (args.size() < 3) {
throw py::value_error("select() must have at least 3 arguments");
}
if ((args.size() % 2) == 0) {
throw py::value_error("select() must have an odd number of arguments");
}
int pos = (int) args.size() - 1;
Expr false_value = args[pos--].cast<Expr>();
while (pos > 0) {
Expr true_value = args[pos--].cast<Expr>();
Expr condition = args[pos--].cast<Expr>();
false_value = select(condition, true_value, false_value);
}
return false_value;
});
m.def("tuple_select", [](py::args args) -> py::tuple {
_halide_user_assert(args.size() >= 3)
<< "tuple_select() must have at least 3 arguments";
_halide_user_assert((args.size() % 2) != 0)
<< "tuple_select() must have an odd number of arguments";
int pos = (int) args.size() - 1;
Tuple false_value = args[pos--].cast<Tuple>();
bool has_tuple_cond = false, has_expr_cond = false;
while (pos > 0) {
Tuple true_value = args[pos--].cast<Tuple>();;
// Note that 'condition' can be either Expr or Tuple, but must be consistent across all
py::object py_cond = args[pos--];
Expr expr_cond;
Tuple tuple_cond(expr_cond);
try {
tuple_cond = py_cond.cast<Tuple>();
has_tuple_cond = true;
} catch (...) {
expr_cond = py_cond.cast<Expr>();
has_expr_cond = true;
}
if (expr_cond.defined()) {
false_value = tuple_select(expr_cond, true_value, false_value);
} else {
false_value = tuple_select(tuple_cond, true_value, false_value);
}
}
_halide_user_assert(!(has_tuple_cond && has_expr_cond))
<<"tuple_select() may not mix Expr and Tuple for the condition elements.";
return to_python_tuple(false_value);
});
m.def("sin", &sin);
m.def("asin", &asin);
m.def("cos", &cos);
m.def("acos", &acos);
m.def("tan", &tan);
m.def("atan", &atan);
m.def("atan", &atan2);
m.def("atan2", &atan2);
m.def("sinh", &sinh);
m.def("asinh", &asinh);
m.def("cosh", &cosh);
m.def("acosh", &acosh);
m.def("tanh", &tanh);
m.def("atanh", &atanh);
m.def("sqrt", &sqrt);
m.def("hypot", &hypot);
m.def("exp", &exp);
m.def("log", &log);
m.def("pow", &pow);
m.def("erf", &erf);
//.........这里部分代码省略.........
开发者ID:adityaatluri,项目名称:Halide,代码行数:101,代码来源:PyIROperator.cpp
示例20: init_ResonancePdf
void init_ResonancePdf(py::module &m) {
auto m_ls = m.def_submodule("Resonances");
py::class_<ResonancePdf, GooPdf>(m, "ResonancePdf").def_static("help", []() {
return HelpPrinter(ResonancePdf_docs);
});
py::class_<Resonances::RBW, ResonancePdf>(m_ls, "RBW")
.def(py::init<std::string, Variable, Variable, Variable, Variable, unsigned int, unsigned int, bool>(),
"Constructor for regular BW",
"name"_a,
"ar"_a,
"ai"_a,
"mass"_a,
"width"_a,
"sp"_a,
"cyc"_a,
"sym"_a = false);
py::class_<Resonances::GS, ResonancePdf>(m_ls, "GS")
.def(py::init<std::string, Variable, Variable, Variable, Variable, unsigned int, unsigned int>(),
"Constructor for regular Gounaris-Sakurai",
"name"_a,
"ar"_a,
"ai"_a,
"mass"_a,
"width"_a,
"sp"_a,
"cyc"_a);
py::class_<Resonances::LASS, ResonancePdf>(m_ls, "LASS")
.def(py::init<std::string, Variable, Variable, Variable, Variable, unsigned int, unsigned int>(),
"Constructor for LASS",
"name"_a,
"ar"_a,
"ai"_a,
"mass"_a,
"width"_a,
"sp"_a,
"cyc"_a);
py::class_<Resonances::NonRes, ResonancePdf>(m_ls, "NonRes")
.def(py::init<std::string, Variable, Variable>(), "Constructor for NonResonant", "name"_a, "ar"_a, "ai"_a);
py::class_<Resonances::Gauss, ResonancePdf>(m_ls, "Gauss")
.def(py::init<std::string, Variable, Variable, Variable, Variable, unsigned int>(),
"Constructor for regular GAUSS",
"name"_a,
"ar"_a,
"ai"_a,
"mean"_a,
"sigma"_a,
"cyc"_a);
py::class_<Resonances::FLATTE, ResonancePdf>(m_ls, "FLATTE")
.def(py::init<std::string, Variable, Variable, Variable, Variable, Variable, unsigned int, bool>(),
"Constructor for regular FLATTE",
"name"_a,
"ar"_a,
"ai"_a,
"mean"_a,
"g1"_a,
"rg2og1"_a,
"cyc"_a,
"symmDP"_a);
py::class_<Resonances::Spline, ResonancePdf>(m_ls, "Spline")
.def(py::init<std::string,
Variable,
Variable,
std::vector<fptype> &,
std::vector<Variable> &,
std::vector<Variable> &,
unsigned int,
bool>(),
"Constructor for regular cubic spline",
"name"_a,
"ar"_a,
"ai"_a,
"HH_bin_limits"_a,
"pwa_coefs_reals"_a,
"pwa_coefs_imags"_a,
"cyc"_a,
"symmDP"_a = false,
py::keep_alive<1, 5>(),
py::keep_alive<1, 6>(),
py::keep_alive<1, 7>());
}
开发者ID:GooFit,项目名称:GooFit,代码行数:88,代码来源:ResonancePdf.cpp
注:本文中的py::module类示例由纯净天空整理自Github/MSDocs等源码及文档管理平台,相关代码片段筛选自各路编程大神贡献的开源项目,源码版权归原作者所有,传播和使用请参考对应项目的License;未经允许,请勿转载。 |
请发表评论