init_scs_direct(void) #endif { import_array(); /* for numpy arrays */ moduleinit(); }
// Init module methods PyMODINIT_FUNC init_pyana(void) { (void) Py_InitModule("_pyana", PyanaMethods); // Init numpy usage import_array(); }
void import_10_02_int() { // Without this import, the converter will segfault import_array(); NumpyEigenConverter<Eigen::Matrix< int, 10, 2 > >::register_converter(); }
/* then looks for a method named "PyInit_"+X and calls it. */ PyObject *PyInit_dwt (void) { PyObject *module = PyModule_Create(&moduledef); import_array(); return module; }
PyMODINIT_FUNC initpywrapper(void) { (void) Py_InitModule("pywrapper",pywrapper_methods); import_array(); }
PyMODINIT_FUNC initacae7b905fe2bdc6e9ed024439c42561(void){ import_array(); (void) Py_InitModule("acae7b905fe2bdc6e9ed024439c42561", MyMethods); }
// Python 3+ PyMODINIT_FUNC PyInit_opkc_v3(void) { import_array(); return PyModule_Create(&optimpack_module); }
/* This function must be called before the module can work because PyArray_API is defined static, in order not to share that symbol within the dso. (import_array() asks the pointer value to the python process) */ void fffpy_import_array(void) { import_array(); return; }
void import_03_16_float() { // Without this import, the converter will segfault import_array(); NumpyEigenConverter<Eigen::Matrix< float, 3, 16 > >::register_converter(); }
void init_numpy() { import_array(); return; }
PyMODINIT_FUNC initnumpy_quaternion(void) { PyObject *m; int quaternionNum; PyObject* numpy = PyImport_ImportModule("numpy"); PyObject* numpy_dict = PyModule_GetDict(numpy); int arg_types[3]; m = Py_InitModule("numpy_quaternion", QuaternionMethods); if (m == NULL) { return; } /* Make sure NumPy is initialized */ import_array(); import_umath(); /* Register the quaternion array scalar type */ #if defined(NPY_PY3K) PyQuaternionArrType_Type.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE; #else PyQuaternionArrType_Type.tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_CHECKTYPES; #endif PyQuaternionArrType_Type.tp_new = quaternion_arrtype_new; PyQuaternionArrType_Type.tp_richcompare = gentype_richcompare; PyQuaternionArrType_Type.tp_hash = quaternion_arrtype_hash; PyQuaternionArrType_Type.tp_repr = quaternion_arrtype_repr; PyQuaternionArrType_Type.tp_str = quaternion_arrtype_str; PyQuaternionArrType_Type.tp_base = &PyGenericArrType_Type; if (PyType_Ready(&PyQuaternionArrType_Type) < 0) { PyErr_Print(); PyErr_SetString(PyExc_SystemError, "could not initialize PyQuaternionArrType_Type"); return; } /* The array functions */ PyArray_InitArrFuncs(&_PyQuaternion_ArrFuncs); _PyQuaternion_ArrFuncs.getitem = (PyArray_GetItemFunc*)QUATERNION_getitem; _PyQuaternion_ArrFuncs.setitem = (PyArray_SetItemFunc*)QUATERNION_setitem; _PyQuaternion_ArrFuncs.copyswap = (PyArray_CopySwapFunc*)QUATERNION_copyswap; _PyQuaternion_ArrFuncs.copyswapn = (PyArray_CopySwapNFunc*)QUATERNION_copyswapn; _PyQuaternion_ArrFuncs.compare = (PyArray_CompareFunc*)QUATERNION_compare; _PyQuaternion_ArrFuncs.argmax = (PyArray_ArgFunc*)QUATERNION_argmax; _PyQuaternion_ArrFuncs.nonzero = (PyArray_NonzeroFunc*)QUATERNION_nonzero; _PyQuaternion_ArrFuncs.fillwithscalar = (PyArray_FillWithScalarFunc*)QUATERNION_fillwithscalar; /* The quaternion array descr */ quaternion_descr = PyObject_New(PyArray_Descr, &PyArrayDescr_Type); quaternion_descr->typeobj = &PyQuaternionArrType_Type; quaternion_descr->kind = 'q'; quaternion_descr->type = 'j'; quaternion_descr->byteorder = '='; quaternion_descr->type_num = 0; /* assigned at registration */ quaternion_descr->elsize = 8*4; quaternion_descr->alignment = 8; quaternion_descr->subarray = NULL; quaternion_descr->fields = NULL; quaternion_descr->names = NULL; quaternion_descr->f = &_PyQuaternion_ArrFuncs; Py_INCREF(&PyQuaternionArrType_Type); quaternionNum = PyArray_RegisterDataType(quaternion_descr); if (quaternionNum < 0) return; register_cast_function(NPY_BOOL, quaternionNum, (PyArray_VectorUnaryFunc*)BOOL_to_quaternion); register_cast_function(NPY_BYTE, quaternionNum, (PyArray_VectorUnaryFunc*)BYTE_to_quaternion); register_cast_function(NPY_UBYTE, quaternionNum, (PyArray_VectorUnaryFunc*)UBYTE_to_quaternion); register_cast_function(NPY_SHORT, quaternionNum, (PyArray_VectorUnaryFunc*)SHORT_to_quaternion); register_cast_function(NPY_USHORT, quaternionNum, (PyArray_VectorUnaryFunc*)USHORT_to_quaternion); register_cast_function(NPY_INT, quaternionNum, (PyArray_VectorUnaryFunc*)INT_to_quaternion); register_cast_function(NPY_UINT, quaternionNum, (PyArray_VectorUnaryFunc*)UINT_to_quaternion); register_cast_function(NPY_LONG, quaternionNum, (PyArray_VectorUnaryFunc*)LONG_to_quaternion); register_cast_function(NPY_ULONG, quaternionNum, (PyArray_VectorUnaryFunc*)ULONG_to_quaternion); register_cast_function(NPY_LONGLONG, quaternionNum, (PyArray_VectorUnaryFunc*)LONGLONG_to_quaternion); register_cast_function(NPY_ULONGLONG, quaternionNum, (PyArray_VectorUnaryFunc*)ULONGLONG_to_quaternion); register_cast_function(NPY_FLOAT, quaternionNum, (PyArray_VectorUnaryFunc*)FLOAT_to_quaternion); register_cast_function(NPY_DOUBLE, quaternionNum, (PyArray_VectorUnaryFunc*)DOUBLE_to_quaternion); register_cast_function(NPY_LONGDOUBLE, quaternionNum, (PyArray_VectorUnaryFunc*)LONGDOUBLE_to_quaternion); register_cast_function(NPY_CFLOAT, quaternionNum, (PyArray_VectorUnaryFunc*)CFLOAT_to_quaternion); register_cast_function(NPY_CDOUBLE, quaternionNum, (PyArray_VectorUnaryFunc*)CDOUBLE_to_quaternion); register_cast_function(NPY_CLONGDOUBLE, quaternionNum, (PyArray_VectorUnaryFunc*)CLONGDOUBLE_to_quaternion); #define REGISTER_UFUNC(name)\ PyUFunc_RegisterLoopForType((PyUFuncObject *)PyDict_GetItemString(numpy_dict, #name),\ quaternion_descr->type_num, quaternion_##name##_ufunc, arg_types, NULL) #define REGISTER_SCALAR_UFUNC(name)\ PyUFunc_RegisterLoopForType((PyUFuncObject *)PyDict_GetItemString(numpy_dict, #name),\ quaternion_descr->type_num, quaternion_##name##_scalar_ufunc, arg_types, NULL) /* quat -> bool */ arg_types[0] = quaternion_descr->type_num; arg_types[1] = NPY_BOOL; REGISTER_UFUNC(isnan); REGISTER_UFUNC(isinf); REGISTER_UFUNC(isfinite); /* quat -> double */ arg_types[1] = NPY_DOUBLE; REGISTER_UFUNC(absolute); /* quat -> quat */ arg_types[1] = quaternion_descr->type_num; REGISTER_UFUNC(log); REGISTER_UFUNC(exp); REGISTER_UFUNC(negative); REGISTER_UFUNC(conjugate); /* quat, quat -> bool */ arg_types[2] = NPY_BOOL; REGISTER_UFUNC(equal); REGISTER_UFUNC(not_equal); REGISTER_UFUNC(less); REGISTER_UFUNC(less_equal); /* quat, double -> quat */ arg_types[1] = NPY_DOUBLE; arg_types[2] = quaternion_descr->type_num; REGISTER_SCALAR_UFUNC(multiply); REGISTER_SCALAR_UFUNC(divide); REGISTER_SCALAR_UFUNC(power); /* quat, quat -> quat */ arg_types[1] = quaternion_descr->type_num; REGISTER_UFUNC(add); REGISTER_UFUNC(subtract); REGISTER_UFUNC(multiply); REGISTER_UFUNC(divide); REGISTER_UFUNC(power); REGISTER_UFUNC(copysign); PyModule_AddObject(m, "quaternion", (PyObject *)&PyQuaternionArrType_Type); }
int init_numpy() { import_array(); return 0; }
PyObject * mlabraw_put(PyObject *, PyObject *args) { char *lName; PyObject *lHandle; PyObject *lSource; mxArray *lArray = NULL; //FIXME should make these objects const if (! PyArg_ParseTuple(args, "OsO:put", &lHandle, &lName, &lSource)) return NULL; if (! PyCObject_Check(lHandle)) { PyErr_SetString(PyExc_TypeError, "Invalid object passed as mlabraw session handle"); return NULL; } Py_INCREF(lSource); if (PyString_Check(lSource)) { lArray = char2mx(lSource); } else { lArray = numeric2mx(lSource); } Py_DECREF(lSource); if (lArray == NULL) { return NULL; // Above converter already set error message } // for matlab version >= 6.5 (FIXME UNTESTED) #ifdef _V6_5_OR_LATER if (engPutVariable((Engine *)PyCObject_AsVoidPtr(lHandle), lName, lArray) != 0) { #else mxSetName(lArray, lName); if (engPutArray((Engine *)PyCObject_AsVoidPtr(lHandle), lArray) != 0) { #endif PyErr_SetString(mlabraw_error, "Unable to put matrix into MATLAB(TM) workspace"); mxDestroyArray(lArray); return NULL; } mxDestroyArray(lArray); Py_INCREF(Py_None); return Py_None; } static PyMethodDef MlabrawMethods[] = { { "open", mlabraw_open, METH_VARARGS, open_doc }, { "close", mlabraw_close, METH_VARARGS, close_doc }, { "oldeval", mlabraw_oldeval, METH_VARARGS, "" }, { "eval", mlabraw_eval, METH_VARARGS, eval_doc }, //FIXME doc { "get", mlabraw_get, METH_VARARGS, get_doc }, { "put", mlabraw_put, METH_VARARGS, put_doc }, { NULL, NULL, 0 , NULL}, // sentinel }; PyMODINIT_FUNC initmlabraw(void) { PyObject *module = Py_InitModule4("mlabraw", MlabrawMethods, "Mlabraw -- Low-level MATLAB(tm) Engine Interface\n" "\n" " open - Open a MATLAB(tm) engine session\n" " close - Close a MATLAB(tm) engine session\n" " eval - Evaluates a string in the MATLAB(tm) session\n" " get - Gets a matrix from the MATLAB(tm) session\n" " put - Places a matrix into the MATLAB(tm) session\n" "\n" "The Numeric package must be installed for this module to be used.\n" "\n" "Copyright & Disclaimer\n" "======================\n" "Copyright (c) 2002-2007 Alexander Schmolck <*****@*****.**>\n" "\n" "Copyright (c) 1998,1999 Andrew Sterian. All Rights Reserved. mailto: [email protected]\n" "\n" "Copyright (c) 1998,1999 THE REGENTS OF THE UNIVERSITY OF MICHIGAN. ALL RIGHTS RESERVED \n" "\n" "Permission to use, copy, modify, and distribute this software and its\n" "documentation for any purpose and without fee is hereby granted, provided\n" "that the above copyright notices appear in all copies and that both these\n" "copyright notices and this permission notice appear in supporting\n" "documentation, and that the name of The University of Michigan not be used\n" "in advertising or publicity pertaining to distribution of the software\n" "without specific, written prior permission.\n" "\n" "THIS SOFTWARE IS PROVIDED AS IS, WITHOUT REPRESENTATION AS TO ITS FITNESS\n" "FOR ANY PURPOSE, AND WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR\n" "IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF\n" "MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE REGENTS OF THE\n" "UNIVERSITY OF MICHIGAN SHALL NOT BE LIABLE FOR ANY DAMAGES, INCLUDING\n" "SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, WITH RESPECT TO ANY\n" "CLAIM ARISING OUT OF OR IN CONNECTION WITH THE USE OF THE SOFTWARE, EVEN IF\n" "IT HAS BEEN OR IS HEREAFTER ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\n" "\n", 0, PYTHON_API_VERSION); /* This macro, defined in arrayobject.h, loads the Numeric API interface */ import_array(); PyModule_AddStringConstant(module, "__version__", MLABRAW_VERSION); mlabraw_error = PyErr_NewException("mlabraw.error", NULL, NULL); Py_INCREF(mlabraw_error); PyModule_AddObject(module, "error", mlabraw_error); }
PyMODINIT_FUNC init59909faa2705d3bf61ec33384221a9ae(void){ import_array(); (void) Py_InitModule("59909faa2705d3bf61ec33384221a9ae", MyMethods); }
PyMODINIT_FUNC init_decomp_modc(void) { (void) Py_InitModule3("_decomp_modc", decomp_modc_methods, decomp_modc__doc__); import_array(); };
PyMODINIT_FUNC init7dddb3f1e85d52e04b9a8481cbf42d1e(void){ import_array(); (void) Py_InitModule("7dddb3f1e85d52e04b9a8481cbf42d1e", MyMethods); }
void import_D_2_double() { // Without this import, the converter will segfault import_array(); NumpyEigenConverter<Eigen::Matrix< double, Eigen::Dynamic, 2 > >::register_converter(); }
PyMODINIT_FUNC initf0c70c6cb39edeb753588795195a4f35(void){ import_array(); (void) Py_InitModule("f0c70c6cb39edeb753588795195a4f35", MyMethods); }
/* Numpy import */ void polyaffine_import_array(void) { import_array(); return; }
void import_13_D_float() { // Without this import, the converter will segfault import_array(); NumpyEigenConverter<Eigen::Matrix< float, 13, Eigen::Dynamic > >::register_converter(); }
// PYTHON2 PyMODINIT_FUNC initopkc_v3(void) { (void) Py_InitModule("opkc_v3", Methods); import_array(); }
PyMODINIT_FUNC init_distance_wrap(void) { (void) Py_InitModule("_distance_wrap", _distanceWrapMethods); import_array(); // Must be present for NumPy. Called first after above line. }
/* then looks for a method named "init"+X and calls it. */ void initdwt(void){ Py_InitModule3("dwt", dwt_methods, dwt__doc__); import_array(); }
PyMODINIT_FUNC init_nd_image(void) { Py_InitModule("_nd_image", methods); import_array(); }
PyMODINIT_FUNC initccoeffs (void) { (void) Py_InitModule ("ccoeffs", ccoeffsmethods); import_array (); }
void init_bbox() { import_array(); (void)Py_InitModule("_bbox", methods); }
void import_D_13_int() { // Without this import, the converter will segfault import_array(); NumpyEigenConverter<Eigen::Matrix< int, Eigen::Dynamic, 13 > >::register_converter(); }
PyMODINIT_FUNC initcgauss(void) { (void) Py_InitModule("cgauss", Methods); import_array(); }
void import_03_11_double() { // Without this import, the converter will segfault import_array(); NumpyEigenConverter<Eigen::Matrix< double, 3, 11 > >::register_converter(); }
/******************************************************************************* ** Module initialisation function *******************************************************************************/ PyMODINIT_FUNC init_bond_order(void) { (void)Py_InitModule("_bond_order", methods); import_array(); }