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();
}
