From: Dimitrios Eftaxiopoulos Date: Sat, 7 Apr 2018 10:37:41 +0000 (+0300) Subject: Build python3-mathgl module only X-Git-Tag: archive/raspbian/2.5-2+rpi1^2~67 X-Git-Url: https://dgit.raspbian.org/?a=commitdiff_plain;h=e2517652b7f59d3936bc82bf7973073f0a060833;p=mathgl.git Build python3-mathgl module only --- diff --git a/debian/control b/debian/control index 73bb828..87d5341 100644 --- a/debian/control +++ b/debian/control @@ -8,7 +8,7 @@ Build-Depends: debhelper (>= 11), libltdl-dev, libgsl-dev, freeglut3-dev, libgl1-mesa-dev | libgl-dev, libpng-dev, libhdf5-dev, libqt5opengl5-dev, libjpeg-dev, libtiff-dev, libfltk1.3-dev, qtwebengine5-dev, libwxgtk3.0-dev, texinfo, texlive, texlive-generic-recommended, liblua5.1-dev, libxcursor-dev, - libgif-dev, python-dev, python-numpy, libfontconfig1-dev, libqt5webkit5-dev, + libgif-dev, python3-dev, python3-numpy, libfontconfig1-dev, libqt5webkit5-dev, libhdf4-dev, chrpath, libxinerama-dev, libxmu-dev, libxi-dev, libhpdf-dev, mpi-default-dev, swig3.0, cmake, libxft-dev, liboctave-dev, fluid Standards-Version: 4.1.3 @@ -217,16 +217,16 @@ Description: library for scientific graphs (development files) . This package contains the development files. -Package: python-mathgl +Package: python3-mathgl Architecture: any Section: python -Depends: ${shlibs:Depends}, ${misc:Depends}, ${python:Depends}, python, - python-numpy -Description: library for scientific graphs (Python module) +Depends: ${shlibs:Depends}, ${misc:Depends}, ${python3:Depends}, python3, + python3-numpy +Description: library for scientific graphs (Python v.3 module) A free cross-platform library of fast C++ routines for plotting data in up to 3 dimensions. It can export plots to bitmaps and vector EPS, SVG, IDTF files. There are simple window interfaces based on GLUT, FLTK and/or Qt. MathGL can also be used in the console. There are interfaces to a set of languages, such as, C, Fortran, Pascal, Forth, Python, Octave. . - This package provides the Python module for mathgl. + This package provides the Python v.3 module for mathgl. diff --git a/debian/patches/CMakeLists.patch b/debian/patches/CMakeLists.patch index d8bcc63..be33c4a 100644 --- a/debian/patches/CMakeLists.patch +++ b/debian/patches/CMakeLists.patch @@ -66,7 +66,7 @@ Adjust enablement of several features # msvc fwprintf print char* for the specifier of "%s" format if(MSVC AND MSVC_VERSION GREATER 1899) -@@ -245,11 +245,11 @@ +@@ -245,11 +245,12 @@ # endif(NOT enable-opengl) endif(enable-qt4 OR enable-qt5) @@ -75,7 +75,8 @@ Adjust enablement of several features -MGL_DEPENDENT_OPTION(enable-python "Enable python interface" OFF "NOT enable-lgpl" ON "NOT enable-all-swig" ON) +CMAKE_DEPENDENT_OPTION(enable-json-sample "Enable JSON sample (WebKit variant is the default)." ON "QT_ENABLED" ON) +CMAKE_DEPENDENT_OPTION(enable-json-sample-we "Enable JSON sample (WebEngine variant)." ON "enable-json-sample" ON) -+MGL_DEPENDENT_OPTION(enable-python "Enable python interface" ON "NOT enable-lgpl" ON "NOT enable-all-swig" ON) ++#MGL_DEPENDENT_OPTION(enable-python "Enable python interface" ON "NOT enable-lgpl" ON "NOT enable-all-swig" ON) ++MGL_DEPENDENT_OPTION(enable-python3 "Enable python v.3 interface" ON "NOT enable-lgpl" ON "NOT enable-all-swig" ON) MGL_DEPENDENT_OPTION(enable-lua "Enable Lua (v.5.1) interface" OFF "NOT enable-lgpl" ON "NOT enable-all-swig" ON) -MGL_DEPENDENT_OPTION(enable-octave "Enable octave interface" OFF "NOT enable-lgpl" ON "NOT enable-all-swig" ON) +MGL_DEPENDENT_OPTION(enable-octave "Enable octave interface" ON "NOT enable-lgpl" ON "NOT enable-all-swig" ON) diff --git a/debian/patches/lang_CMakeLists.patch b/debian/patches/lang_CMakeLists.patch new file mode 100644 index 0000000..5bc39ce --- /dev/null +++ b/debian/patches/lang_CMakeLists.patch @@ -0,0 +1,63 @@ +--- a/lang/CMakeLists.txt ++++ b/lang/CMakeLists.txt +@@ -9,7 +9,7 @@ + + set(mgl_clean_files "") + +-SET_SOURCE_FILES_PROPERTIES(mathgl.i numpy.i PROPERTIES CPLUSPLUS ON) ++SET_SOURCE_FILES_PROPERTIES(mathgl.i numpy.i numpy_python3.i mathgl_python3.i PROPERTIES CPLUSPLUS ON) + + FIND_PACKAGE(SWIG) + if(NOT SWIG_FOUND) +@@ -17,8 +17,8 @@ + endif(NOT SWIG_FOUND) + INCLUDE(${SWIG_USE_FILE}) + +-if(enable-python) +- set(Python_ADDITIONAL_VERSIONS 2.7) ++if(enable-python3) ++ set(Python_ADDITIONAL_VERSIONS 3.6) + FIND_PACKAGE(PythonInterp) + if(NOT PYTHONINTERP_FOUND) + message(SEND_ERROR "Couldn't find python interpreter.") +@@ -28,7 +28,7 @@ + message(SEND_ERROR "Couldn't find python development libraries.") + endif(NOT PYTHONLIBS_FOUND) + execute_process( +- COMMAND ${PYTHON_EXECUTABLE} -c "import numpy; print numpy.get_include()" ++ COMMAND ${PYTHON_EXECUTABLE} -c "import numpy; print (numpy.get_include())" + OUTPUT_VARIABLE NUMPY_INCLUDE_PATH + RESULT_VARIABLE NUMPY_ERR + OUTPUT_STRIP_TRAILING_WHITESPACE +@@ -39,14 +39,14 @@ + + include_directories(${PYTHON_INCLUDE_DIR} ${NUMPY_INCLUDE_PATH}) + execute_process( +- COMMAND ${PYTHON_EXECUTABLE} -c "from distutils.sysconfig import get_python_lib; print get_python_lib(prefix='${CMAKE_INSTALL_PREFIX}')" ++ COMMAND ${PYTHON_EXECUTABLE} -c "from distutils.sysconfig import get_python_lib; print (get_python_lib(prefix='${CMAKE_INSTALL_PREFIX}'))" + OUTPUT_VARIABLE MGL_PYTHON_SITE_PACKAGES + OUTPUT_STRIP_TRAILING_WHITESPACE) +- set(SWIG_MODULE_mathgl_EXTRA_DEPS numpy.i ${src_imp_dep}) ++ set(SWIG_MODULE_mathgl_EXTRA_DEPS numpy_python3.i ${src_imp_dep}) + if(${CMAKE_VERSION} VERSION_LESS "3.8.0") +- SWIG_ADD_MODULE(mathgl python mathgl.i) ++ SWIG_ADD_MODULE(mathgl python mathgl_python3.i) + else(${CMAKE_VERSION} VERSION_LESS "3.8.0") +- SWIG_ADD_LIBRARY(mathgl LANGUAGE python SOURCES mathgl.i) ++ SWIG_ADD_LIBRARY(mathgl LANGUAGE python SOURCES mathgl_python3.i) + endif(${CMAKE_VERSION} VERSION_LESS "3.8.0") + SWIG_LINK_LIBRARIES(mathgl mgl ${PYTHON_LIBRARIES}) + set_target_properties(_mathgl PROPERTIES BUILD_WITH_INSTALL_RPATH ON) +@@ -58,10 +58,10 @@ + ) + add_custom_target(mgl_python_module ALL DEPENDS _mathgl mathgl.pyc) + +- install(FILES ${MathGL2_BINARY_DIR}/lang/mathgl.py ${MathGL2_BINARY_DIR}/lang/mathgl.pyc DESTINATION ${MGL_PYTHON_SITE_PACKAGES}) ++ install(FILES ${MathGL2_BINARY_DIR}/lang/mathgl.py ${MathGL2_BINARY_DIR}/lang/__pycache__/mathgl.cpython-36.pyc DESTINATION ${MGL_PYTHON_SITE_PACKAGES}) + install (TARGETS _mathgl LIBRARY DESTINATION ${MGL_PYTHON_SITE_PACKAGES}) + set(mgl_clean_files ${mgl_clean_files} mathgl.py) +-endif(enable-python) ++endif(enable-python3) + + if(enable-lua) + INCLUDE(FindLua51) diff --git a/debian/patches/lang_mathgl.patch b/debian/patches/lang_mathgl.patch new file mode 100644 index 0000000..f6b8889 --- /dev/null +++ b/debian/patches/lang_mathgl.patch @@ -0,0 +1,103 @@ +--- /dev/null ++++ b/lang/mathgl_python3.i +@@ -0,0 +1,100 @@ ++/*************************************************************************** ++ * mgl.i is part of Math Graphic Library ++ * Copyright (C) 2007 Alexey Balakin , ++ * Xavier Delacour , ++ * Alexander Filov * ++ * * ++ * This program is free software; you can redistribute it and/or modify * ++ * it under the terms of the GNU General Public License as published by * ++ * the Free Software Foundation; either version 2 of the License, or * ++ * (at your option) any later version. * ++ * * ++ * This program is distributed in the hope that it will be useful, * ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of * ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * ++ * GNU General Public License for more details. * ++ * * ++ * You should have received a copy of the GNU General Public License * ++ * along with this program; if not, write to the * ++ * Free Software Foundation, Inc., * ++ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ++ ***************************************************************************/ ++ ++ ++%module mathgl ++#ifdef SWIGOCTAVE ++%feature("autodoc", 1); ++#endif // SWIGOCTAVE ++ ++%ignore operator!; ++%ignore operator=; ++%ignore *::operator=; ++%ignore *::operator+=; ++%ignore *::operator-=; ++%ignore *::operator*=; ++%ignore *::operator/=; ++//%ignore mglDataA ++ ++%{ ++#define SWIG_FILE_WITH_INIT ++#include "mgl2/type.h" ++#include "mgl2/data.h" ++#include "mgl2/mgl.h" ++const double All = -1; ++const double Pi = M_PI; ++const double NaN = NAN; ++const double Inf = INFINITY; ++%} ++ ++#if MGL_USE_DOUBLE ++typedef double mreal; ++#else ++typedef float mreal; ++#endif ++ ++ ++#ifdef SWIGOCTAVE ++%rename(__add) operator+; ++%rename(__sub) operator-; ++%rename(__mul) operator*; ++%rename(__div) operator/; ++%rename(__eq) operator==; ++%rename(__ne) operator!=; ++%typemap(in,noblock=1) (double* d, int rows, int cols) (Matrix tmp) { ++ if (!$input.is_matrix_type()) { error("A must be a matrix"); SWIG_fail; } ++ tmp=$input.matrix_value(); ++ $1=tmp.data(); ++ $2=tmp.rows(); ++ $3=tmp.columns(); ++} ++#endif ++ ++#ifdef SWIGPYTHON ++%rename(__add__) *::operator+(const mglData&, const mglData&); ++%rename(__sub__) *::operator-(const mglData&, const mglData &); ++%rename(__mul__) *::operator*(const mglData &, float); ++%rename(__div__) *::operator/(const mglData &, float); ++ ++// Get the NumPy typemaps ++%include "numpy_python3.i" ++%init %{ ++import_array(); ++%} ++%apply (double* IN_ARRAY1, int DIM1) {(const double* d, int size)}; ++%apply (int DIM1, double* IN_ARRAY1) {(int size, const double* d)}; ++%apply (double* IN_ARRAY2, int DIM1, int DIM2) {(const double* d, int rows, int cols)}; ++%apply (int DIM1, int DIM2, double* IN_ARRAY2) {(int rows, int cols, const double* d)}; ++%apply (double* IN_ARRAY3, int DIM1, int DIM2, int DIM3) {(const double* d, int rows, int cols, int slc)}; ++%apply (int DIM1, int DIM2, int DIM3, double* IN_ARRAY3) {(int rows, int cols, int slc, const double* d)}; ++#endif ++ ++%include "type.i" ++%include "data.i" ++%include "mgl.i" ++%extend mglData ++{ ++ mreal __getitem__( int i) { return self->GetVal(i); }; ++ mreal __paren( int i) { return self->GetVal(i); }; ++ void __setitem__( int i, mreal y) { self->SetVal(y,i); }; ++ void __paren_asgn( int i, mreal y) { self->SetVal(y,i); }; ++}; diff --git a/debian/patches/lang_numpy.patch b/debian/patches/lang_numpy.patch new file mode 100644 index 0000000..9f5e235 --- /dev/null +++ b/debian/patches/lang_numpy.patch @@ -0,0 +1,1637 @@ +--- /dev/null ++++ b/lang/numpy_python3.i +@@ -0,0 +1,1634 @@ ++/* -*- C -*- (not really, but good for syntax highlighting) */ ++#ifdef SWIGPYTHON ++ ++%{ ++#ifndef SWIG_FILE_WITH_INIT ++# define NO_IMPORT_ARRAY ++#endif ++#include "stdio.h" ++#include ++%} ++ ++/**********************************************************************/ ++ ++%fragment("NumPy_Backward_Compatibility", "header") ++{ ++/* Support older NumPy data type names ++*/ ++%#if NDARRAY_VERSION < 0x01000000 ++%#define NPY_BOOL PyArray_BOOL ++%#define NPY_BYTE PyArray_BYTE ++%#define NPY_UBYTE PyArray_UBYTE ++%#define NPY_SHORT PyArray_SHORT ++%#define NPY_USHORT PyArray_USHORT ++%#define NPY_INT PyArray_INT ++%#define NPY_UINT PyArray_UINT ++%#define NPY_LONG PyArray_LONG ++%#define NPY_ULONG PyArray_ULONG ++%#define NPY_LONGLONG PyArray_LONGLONG ++%#define NPY_ULONGLONG PyArray_ULONGLONG ++%#define NPY_FLOAT PyArray_FLOAT ++%#define NPY_DOUBLE PyArray_DOUBLE ++%#define NPY_LONGDOUBLE PyArray_LONGDOUBLE ++%#define NPY_CFLOAT PyArray_CFLOAT ++%#define NPY_CDOUBLE PyArray_CDOUBLE ++%#define NPY_CLONGDOUBLE PyArray_CLONGDOUBLE ++%#define NPY_OBJECT PyArray_OBJECT ++%#define NPY_STRING PyArray_STRING ++%#define NPY_UNICODE PyArray_UNICODE ++%#define NPY_VOID PyArray_VOID ++%#define NPY_NTYPES PyArray_NTYPES ++%#define NPY_NOTYPE PyArray_NOTYPE ++%#define NPY_CHAR PyArray_CHAR ++%#define NPY_USERDEF PyArray_USERDEF ++%#define npy_intp intp ++ ++%#define NPY_MAX_BYTE MAX_BYTE ++%#define NPY_MIN_BYTE MIN_BYTE ++%#define NPY_MAX_UBYTE MAX_UBYTE ++%#define NPY_MAX_SHORT MAX_SHORT ++%#define NPY_MIN_SHORT MIN_SHORT ++%#define NPY_MAX_USHORT MAX_USHORT ++%#define NPY_MAX_INT MAX_INT ++%#define NPY_MIN_INT MIN_INT ++%#define NPY_MAX_UINT MAX_UINT ++%#define NPY_MAX_LONG MAX_LONG ++%#define NPY_MIN_LONG MIN_LONG ++%#define NPY_MAX_ULONG MAX_ULONG ++%#define NPY_MAX_LONGLONG MAX_LONGLONG ++%#define NPY_MIN_LONGLONG MIN_LONGLONG ++%#define NPY_MAX_ULONGLONG MAX_ULONGLONG ++%#define NPY_MAX_INTP MAX_INTP ++%#define NPY_MIN_INTP MIN_INTP ++ ++%#define NPY_FARRAY FARRAY ++%#define NPY_F_CONTIGUOUS F_CONTIGUOUS ++%#endif ++} ++ ++/**********************************************************************/ ++ ++/* The following code originally appeared in ++ * enthought/kiva/agg/src/numeric.i written by Eric Jones. It was ++ * translated from C++ to C by John Hunter. Bill Spotz has modified ++ * it to fix some minor bugs, upgrade from Numeric to numpy (all ++ * versions), add some comments and functionality, and convert from ++ * direct code insertion to SWIG fragments. ++ */ ++ ++%fragment("NumPy_Macros", "header") ++{ ++/* Macros to extract array attributes. ++ */ ++%#define is_array(a) ((a) && PyArray_Check((PyArrayObject *)a)) ++%#define array_type(a) (int)(PyArray_TYPE(a)) ++%#define array_numdims(a) (((PyArrayObject *)a)->nd) ++%#define array_dimensions(a) (((PyArrayObject *)a)->dimensions) ++%#define array_size(a,i) (((PyArrayObject *)a)->dimensions[i]) ++%#define array_data(a) (((PyArrayObject *)a)->data) ++%#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS(a)) ++%#define array_is_native(a) (PyArray_ISNOTSWAPPED(a)) ++%#define array_is_fortran(a) (PyArray_ISFORTRAN(a)) ++} ++ ++/**********************************************************************/ ++ ++%fragment("NumPy_Utilities", "header") ++{ ++ /* Given a PyObject, return a string describing its type. ++ */ ++ char* pytype_string(PyObject* py_obj) { ++ if (py_obj == NULL ) return "C NULL value"; ++ if (py_obj == Py_None ) return "Python None" ; ++ if (PyCallable_Check(py_obj)) return "callable" ; ++ if (PyString_Check( py_obj)) return "string" ; ++ if (PyInt_Check( py_obj)) return "int" ; ++ if (PyFloat_Check( py_obj)) return "float" ; ++ if (PyDict_Check( py_obj)) return "dict" ; ++ if (PyList_Check( py_obj)) return "list" ; ++ if (PyTuple_Check( py_obj)) return "tuple" ; ++ if (PyTuple_Check( py_obj)) return "file" ; ++ if (PyModule_Check( py_obj)) return "module" ; ++ if (PySequence_Check(py_obj)) return "instance" ; ++ ++ return "unknow type"; ++ } ++ ++ /* Given a NumPy typecode, return a string describing the type. ++ */ ++ char* typecode_string(int typecode) { ++ static char* type_names[25] = {"bool", "byte", "unsigned byte", ++ "short", "unsigned short", "int", ++ "unsigned int", "long", "unsigned long", ++ "long long", "unsigned long long", ++ "float", "double", "long double", ++ "complex float", "complex double", ++ "complex long double", "object", ++ "string", "unicode", "void", "ntypes", ++ "notype", "char", "unknown"}; ++ return typecode < 24 ? type_names[typecode] : type_names[24]; ++ } ++ ++ /* Make sure input has correct numpy type. Allow character and byte ++ * to match. Also allow int and long to match. This is deprecated. ++ * You should use PyArray_EquivTypenums() instead. ++ */ ++ int type_match(int actual_type, int desired_type) { ++ return PyArray_EquivTypenums(actual_type, desired_type); ++ } ++} ++ ++/**********************************************************************/ ++ ++%fragment("NumPy_Object_to_Array", "header", ++ fragment="NumPy_Backward_Compatibility", ++ fragment="NumPy_Macros", ++ fragment="NumPy_Utilities") ++{ ++ /* Given a PyObject pointer, cast it to a PyArrayObject pointer if ++ * legal. If not, set the python error string appropriately and ++ * return NULL. ++ */ ++ PyArrayObject* obj_to_array_no_conversion(PyObject* input, int typecode) ++ { ++ PyArrayObject* ary = NULL; ++ if (is_array(input) && (typecode == NPY_NOTYPE || ++ PyArray_EquivTypenums(array_type(input), typecode))) ++ { ++ ary = (PyArrayObject*) input; ++ } ++ else if is_array(input) ++ { ++ char* desired_type = typecode_string(typecode); ++ char* actual_type = typecode_string(array_type(input)); ++ PyErr_Format(PyExc_TypeError, ++ "Array of type '%s' required. Array of type '%s' given", ++ desired_type, actual_type); ++ ary = NULL; ++ } ++ else ++ { ++ char * desired_type = typecode_string(typecode); ++ char * actual_type = pytype_string(input); ++ PyErr_Format(PyExc_TypeError, ++ "Array of type '%s' required. A '%s' was given", ++ desired_type, actual_type); ++ ary = NULL; ++ } ++ return ary; ++ } ++ ++ /* Convert the given PyObject to a NumPy array with the given ++ * typecode. On success, return a valid PyArrayObject* with the ++ * correct type. On failure, the python error string will be set and ++ * the routine returns NULL. ++ */ ++ PyArrayObject* obj_to_array_allow_conversion(PyObject* input, int typecode, ++ int* is_new_object) ++ { ++ PyArrayObject* ary = NULL; ++ PyObject* py_obj; ++ if (is_array(input) && (typecode == NPY_NOTYPE || ++ PyArray_EquivTypenums(array_type(input),typecode))) ++ { ++ ary = (PyArrayObject*) input; ++ *is_new_object = 0; ++ } ++ else ++ { ++ py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_DEFAULT); ++ /* If NULL, PyArray_FromObject will have set python error value.*/ ++ ary = (PyArrayObject*) py_obj; ++ *is_new_object = 1; ++ } ++ return ary; ++ } ++ ++ /* Given a PyArrayObject, check to see if it is contiguous. If so, ++ * return the input pointer and flag it as not a new object. If it is ++ * not contiguous, create a new PyArrayObject using the original data, ++ * flag it as a new object and return the pointer. ++ */ ++ PyArrayObject* make_contiguous(PyArrayObject* ary, int* is_new_object, ++ int min_dims, int max_dims) ++ { ++ PyArrayObject* result; ++ if (array_is_contiguous(ary)) ++ { ++ result = ary; ++ *is_new_object = 0; ++ } ++ else ++ { ++ result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary, ++ array_type(ary), ++ min_dims, ++ max_dims); ++ *is_new_object = 1; ++ } ++ return result; ++ } ++ ++ /* Given a PyArrayObject, check to see if it is Fortran-contiguous. ++ * If so, return the input pointer, but do not flag it as not a new ++ * object. If it is not Fortran-contiguous, create a new ++ * PyArrayObject using the original data, flag it as a new object ++ * and return the pointer. ++ */ ++ PyArrayObject* make_fortran(PyArrayObject* ary, int* is_new_object, ++ int min_dims, int max_dims) ++ { ++ PyArrayObject* result; ++ if (array_is_fortran(ary)) ++ { ++ result = ary; ++ *is_new_object = 0; ++ } ++ else ++ { ++ Py_INCREF(ary->descr); ++ result = (PyArrayObject*) PyArray_FromArray(ary, ary->descr, NPY_FORTRAN); ++ *is_new_object = 1; ++ } ++ return result; ++ } ++ ++ /* Convert a given PyObject to a contiguous PyArrayObject of the ++ * specified type. If the input object is not a contiguous ++ * PyArrayObject, a new one will be created and the new object flag ++ * will be set. ++ */ ++ PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input, ++ int typecode, ++ int* is_new_object) ++ { ++ int is_new1 = 0; ++ int is_new2 = 0; ++ PyArrayObject* ary2; ++ PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode, ++ &is_new1); ++ if (ary1) ++ { ++ ary2 = make_contiguous(ary1, &is_new2, 0, 0); ++ if ( is_new1 && is_new2) ++ { ++ Py_DECREF(ary1); ++ } ++ ary1 = ary2; ++ } ++ *is_new_object = is_new1 || is_new2; ++ return ary1; ++ } ++ ++ /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the ++ * specified type. If the input object is not a Fortran-ordered ++ * PyArrayObject, a new one will be created and the new object flag ++ * will be set. ++ */ ++ PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input, ++ int typecode, ++ int* is_new_object) ++ { ++ int is_new1 = 0; ++ int is_new2 = 0; ++ PyArrayObject* ary2; ++ PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode, ++ &is_new1); ++ if (ary1) ++ { ++ ary2 = make_fortran(ary1, &is_new2, 0, 0); ++ if (is_new1 && is_new2) ++ { ++ Py_DECREF(ary1); ++ } ++ ary1 = ary2; ++ } ++ *is_new_object = is_new1 || is_new2; ++ return ary1; ++ } ++ ++} /* end fragment */ ++ ++ ++/**********************************************************************/ ++ ++%fragment("NumPy_Array_Requirements", "header", ++ fragment="NumPy_Backward_Compatibility", ++ fragment="NumPy_Macros") ++{ ++ /* Test whether a python object is contiguous. If array is ++ * contiguous, return 1. Otherwise, set the python error string and ++ * return 0. ++ */ ++ int require_contiguous(PyArrayObject* ary) ++ { ++ int contiguous = 1; ++ if (!array_is_contiguous(ary)) ++ { ++ PyErr_SetString(PyExc_TypeError, ++ "Array must be contiguous. A non-contiguous array was given"); ++ contiguous = 0; ++ } ++ return contiguous; ++ } ++ ++ /* Require that a numpy array is not byte-swapped. If the array is ++ * not byte-swapped, return 1. Otherwise, set the python error string ++ * and return 0. ++ */ ++ int require_native(PyArrayObject* ary) ++ { ++ int native = 1; ++ if (!array_is_native(ary)) ++ { ++ PyErr_SetString(PyExc_TypeError, ++ "Array must have native byteorder. " ++ "A byte-swapped array was given"); ++ native = 0; ++ } ++ return native; ++ } ++ ++ /* Require the given PyArrayObject to have a specified number of ++ * dimensions. If the array has the specified number of dimensions, ++ * return 1. Otherwise, set the python error string and return 0. ++ */ ++ int require_dimensions(PyArrayObject* ary, int exact_dimensions) ++ { ++ int success = 1; ++ if (array_numdims(ary) != exact_dimensions) ++ { ++ PyErr_Format(PyExc_TypeError, ++ "Array must have %d dimensions. Given array has %d dimensions", ++ exact_dimensions, array_numdims(ary)); ++ success = 0; ++ } ++ return success; ++ } ++ ++ /* Require the given PyArrayObject to have one of a list of specified ++ * number of dimensions. If the array has one of the specified number ++ * of dimensions, return 1. Otherwise, set the python error string ++ * and return 0. ++ */ ++ int require_dimensions_n(PyArrayObject* ary, int* exact_dimensions, int n) ++ { ++ int success = 0; ++ int i; ++ char dims_str[255] = ""; ++ char s[255]; ++ for (i = 0; i < n && !success; i++) ++ { ++ if (array_numdims(ary) == exact_dimensions[i]) ++ { ++ success = 1; ++ } ++ } ++ if (!success) ++ { ++ for (i = 0; i < n-1; i++) ++ { ++ sprintf(s, "%d, ", exact_dimensions[i]); ++ strcat(dims_str,s); ++ } ++ sprintf(s, " or %d", exact_dimensions[n-1]); ++ strcat(dims_str,s); ++ PyErr_Format(PyExc_TypeError, ++ "Array must have %s dimensions. Given array has %d dimensions", ++ dims_str, array_numdims(ary)); ++ } ++ return success; ++ } ++ ++ /* Require the given PyArrayObject to have a specified shape. If the ++ * array has the specified shape, return 1. Otherwise, set the python ++ * error string and return 0. ++ */ ++ int require_size(PyArrayObject* ary, npy_intp* size, int n) ++ { ++ int i; ++ int success = 1; ++ int len; ++ char desired_dims[255] = "["; ++ char s[255]; ++ char actual_dims[255] = "["; ++ for(i=0; i < n;i++) ++ { ++ if (size[i] != -1 && size[i] != array_size(ary,i)) ++ { ++ success = 0; ++ } ++ } ++ if (!success) ++ { ++ for (i = 0; i < n; i++) ++ { ++ if (size[i] == -1) ++ { ++ sprintf(s, "*,"); ++ } ++ else ++ { ++ sprintf(s, "%ld,", (long int)size[i]); ++ } ++ strcat(desired_dims,s); ++ } ++ len = strlen(desired_dims); ++ desired_dims[len-1] = ']'; ++ for (i = 0; i < n; i++) ++ { ++ sprintf(s, "%ld,", (long int)array_size(ary,i)); ++ strcat(actual_dims,s); ++ } ++ len = strlen(actual_dims); ++ actual_dims[len-1] = ']'; ++ PyErr_Format(PyExc_TypeError, ++ "Array must have shape of %s. Given array has shape of %s", ++ desired_dims, actual_dims); ++ } ++ return success; ++ } ++ ++ /* Require the given PyArrayObject to to be FORTRAN ordered. If the ++ * the PyArrayObject is already FORTRAN ordered, do nothing. Else, ++ * set the FORTRAN ordering flag and recompute the strides. ++ */ ++ int require_fortran(PyArrayObject* ary) ++ { ++ int success = 1; ++ int nd = array_numdims(ary); ++ int i; ++ if (array_is_fortran(ary)) return success; ++ /* Set the FORTRAN ordered flag */ ++ ary->flags = NPY_FARRAY; ++ /* Recompute the strides */ ++ ary->strides[0] = ary->strides[nd-1]; ++ for (i=1; i < nd; ++i) ++ ary->strides[i] = ary->strides[i-1] * array_size(ary,i-1); ++ return success; ++ } ++} ++ ++/* Combine all NumPy fragments into one for convenience */ ++%fragment("NumPy_Fragments", "header", ++ fragment="NumPy_Backward_Compatibility", ++ fragment="NumPy_Macros", ++ fragment="NumPy_Utilities", ++ fragment="NumPy_Object_to_Array", ++ fragment="NumPy_Array_Requirements") { } ++ ++/* End John Hunter translation (with modifications by Bill Spotz) ++ */ ++ ++/* %numpy_typemaps() macro ++ * ++ * This macro defines a family of 41 typemaps that allow C arguments ++ * of the form ++ * ++ * (DATA_TYPE IN_ARRAY1[ANY]) ++ * (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) ++ * (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) ++ * ++ * (DATA_TYPE IN_ARRAY2[ANY][ANY]) ++ * (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) ++ * (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) ++ * ++ * (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) ++ * (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) ++ * (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) ++ * ++ * (DATA_TYPE INPLACE_ARRAY1[ANY]) ++ * (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) ++ * (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) ++ * ++ * (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) ++ * (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) ++ * (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) ++ * ++ * (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) ++ * (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) ++ * (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++ * (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) ++ * ++ * (DATA_TYPE ARGOUT_ARRAY1[ANY]) ++ * (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) ++ * (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) ++ * ++ * (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) ++ * ++ * (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) ++ * ++ * (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) ++ * (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) ++ * ++ * (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) ++ * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) ++ * (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) ++ * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) ++ * ++ * (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) ++ * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) ++ * (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) ++ * (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3) ++ * ++ * where "DATA_TYPE" is any type supported by the NumPy module, and ++ * "DIM_TYPE" is any int-like type suitable for specifying dimensions. ++ * The difference between "ARRAY" typemaps and "FARRAY" typemaps is ++ * that the "FARRAY" typemaps expect FORTRAN ordering of ++ * multidimensional arrays. In python, the dimensions will not need ++ * to be specified (except for the "DATA_TYPE* ARGOUT_ARRAY1" ++ * typemaps). The IN_ARRAYs can be a numpy array or any sequence that ++ * can be converted to a numpy array of the specified type. The ++ * INPLACE_ARRAYs must be numpy arrays of the appropriate type. The ++ * ARGOUT_ARRAYs will be returned as new numpy arrays of the ++ * appropriate type. ++ * ++ * These typemaps can be applied to existing functions using the ++ * %apply directive. For example: ++ * ++ * %apply (double* IN_ARRAY1, int DIM1) {(double* series, int length)}; ++ * double prod(double* series, int length); ++ * ++ * %apply (int DIM1, int DIM2, double* INPLACE_ARRAY2) ++ * {(int rows, int cols, double* matrix )}; ++ * void floor(int rows, int cols, double* matrix, double f); ++ * ++ * %apply (double IN_ARRAY3[ANY][ANY][ANY]) ++ * {(double tensor[2][2][2] )}; ++ * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY]) ++ * {(double low[2][2][2] )}; ++ * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY]) ++ * {(double upp[2][2][2] )}; ++ * void luSplit(double tensor[2][2][2], ++ * double low[2][2][2], ++ * double upp[2][2][2] ); ++ * ++ * or directly with ++ * ++ * double prod(double* IN_ARRAY1, int DIM1); ++ * ++ * void floor(int DIM1, int DIM2, double* INPLACE_ARRAY2, double f); ++ * ++ * void luSplit(double IN_ARRAY3[ANY][ANY][ANY], ++ * double ARGOUT_ARRAY3[ANY][ANY][ANY], ++ * double ARGOUT_ARRAY3[ANY][ANY][ANY]); ++ */ ++ ++%define %numpy_typemaps(DATA_TYPE, DATA_TYPECODE, DIM_TYPE) ++ ++/************************/ ++/* Input Array Typemaps */ ++/************************/ ++ ++/* Typemap suite for (DATA_TYPE IN_ARRAY1[ANY]) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE IN_ARRAY1[ANY]) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE IN_ARRAY1[ANY]) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[1] = { $1_dim0 }; ++ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 1) || ++ !require_size(array, size, 1)) SWIG_fail; ++ $1 = ($1_ltype) array_data(array); ++} ++%typemap(freearg) ++ (DATA_TYPE IN_ARRAY1[ANY]) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[1] = { -1 }; ++ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 1) || ++ !require_size(array, size, 1)) SWIG_fail; ++ $1 = (DATA_TYPE*) array_data(array); ++ $2 = (DIM_TYPE) array_size(array,0); ++} ++%typemap(freearg) ++ (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[1] = {-1}; ++ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 1) || ++ !require_size(array, size, 1)) SWIG_fail; ++ $1 = (DIM_TYPE) array_size(array,0); ++ $2 = (DATA_TYPE*) array_data(array); ++} ++%typemap(freearg) ++ (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DATA_TYPE IN_ARRAY2[ANY][ANY]) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE IN_ARRAY2[ANY][ANY]) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE IN_ARRAY2[ANY][ANY]) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[2] = { $1_dim0, $1_dim1 }; ++ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 2) || ++ !require_size(array, size, 2)) SWIG_fail; ++ $1 = ($1_ltype) array_data(array); ++} ++%typemap(freearg) ++ (DATA_TYPE IN_ARRAY2[ANY][ANY]) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[2] = { -1, -1 }; ++ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 2) || ++ !require_size(array, size, 2)) SWIG_fail; ++ $1 = (DATA_TYPE*) array_data(array); ++ $2 = (DIM_TYPE) array_size(array,0); ++ $3 = (DIM_TYPE) array_size(array,1); ++} ++%typemap(freearg) ++ (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[2] = { -1, -1 }; ++ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 2) || ++ !require_size(array, size, 2)) SWIG_fail; ++ $1 = (DIM_TYPE) array_size(array,0); ++ $2 = (DIM_TYPE) array_size(array,1); ++ $3 = (DATA_TYPE*) array_data(array); ++} ++%typemap(freearg) ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[2] = { -1, -1 }; ++ array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 2) || ++ !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail; ++ $1 = (DATA_TYPE*) array_data(array); ++ $2 = (DIM_TYPE) array_size(array,0); ++ $3 = (DIM_TYPE) array_size(array,1); ++} ++%typemap(freearg) ++ (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[2] = { -1, -1 }; ++ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 2) || ++ !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail; ++ $1 = (DIM_TYPE) array_size(array,0); ++ $2 = (DIM_TYPE) array_size(array,1); ++ $3 = (DATA_TYPE*) array_data(array); ++} ++%typemap(freearg) ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 }; ++ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 3) || ++ !require_size(array, size, 3)) SWIG_fail; ++ $1 = ($1_ltype) array_data(array); ++} ++%typemap(freearg) ++ (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, ++ * DIM_TYPE DIM3) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[3] = { -1, -1, -1 }; ++ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 3) || ++ !require_size(array, size, 3)) SWIG_fail; ++ $1 = (DATA_TYPE*) array_data(array); ++ $2 = (DIM_TYPE) array_size(array,0); ++ $3 = (DIM_TYPE) array_size(array,1); ++ $4 = (DIM_TYPE) array_size(array,2); ++} ++%typemap(freearg) ++ (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, ++ * DATA_TYPE* IN_ARRAY3) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[3] = { -1, -1, -1 }; ++ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 3) || ++ !require_size(array, size, 3)) SWIG_fail; ++ $1 = (DIM_TYPE) array_size(array,0); ++ $2 = (DIM_TYPE) array_size(array,1); ++ $3 = (DIM_TYPE) array_size(array,2); ++ $4 = (DATA_TYPE*) array_data(array); ++} ++%typemap(freearg) ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, ++ * DIM_TYPE DIM3) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[3] = { -1, -1, -1 }; ++ array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 3) || ++ !require_size(array, size, 3) | !require_fortran(array)) SWIG_fail; ++ $1 = (DATA_TYPE*) array_data(array); ++ $2 = (DIM_TYPE) array_size(array,0); ++ $3 = (DIM_TYPE) array_size(array,1); ++ $4 = (DIM_TYPE) array_size(array,2); ++} ++%typemap(freearg) ++ (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, ++ * DATA_TYPE* IN_FARRAY3) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) ++{ ++ $1 = is_array($input) || PySequence_Check($input); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) ++ (PyArrayObject* array=NULL, int is_new_object=0) ++{ ++ npy_intp size[3] = { -1, -1, -1 }; ++ array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, ++ &is_new_object); ++ if (!array || !require_dimensions(array, 3) || ++ !require_size(array, size, 3) || !require_fortran(array)) SWIG_fail; ++ $1 = (DIM_TYPE) array_size(array,0); ++ $2 = (DIM_TYPE) array_size(array,1); ++ $3 = (DIM_TYPE) array_size(array,2); ++ $4 = (DATA_TYPE*) array_data(array); ++} ++%typemap(freearg) ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) ++{ ++ if (is_new_object$argnum && array$argnum) ++ { Py_DECREF(array$argnum); } ++} ++ ++/***************************/ ++/* In-Place Array Typemaps */ ++/***************************/ ++ ++/* Typemap suite for (DATA_TYPE INPLACE_ARRAY1[ANY]) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE INPLACE_ARRAY1[ANY]) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE INPLACE_ARRAY1[ANY]) ++ (PyArrayObject* array=NULL) ++{ ++ npy_intp size[1] = { $1_dim0 }; ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,1) || !require_size(array, size, 1) || ++ !require_contiguous(array) || !require_native(array)) SWIG_fail; ++ $1 = ($1_ltype) array_data(array); ++} ++ ++/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) ++ (PyArrayObject* array=NULL, int i=1) ++{ ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,1) || !require_contiguous(array) ++ || !require_native(array)) SWIG_fail; ++ $1 = (DATA_TYPE*) array_data(array); ++ $2 = 1; ++ for (i=0; i < array_numdims(array); ++i) $2 *= array_size(array,i); ++} ++ ++/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) ++ (PyArrayObject* array=NULL, int i=0) ++{ ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,1) || !require_contiguous(array) ++ || !require_native(array)) SWIG_fail; ++ $1 = 1; ++ for (i=0; i < array_numdims(array); ++i) $1 *= array_size(array,i); ++ $2 = (DATA_TYPE*) array_data(array); ++} ++ ++/* Typemap suite for (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) ++ (PyArrayObject* array=NULL) ++{ ++ npy_intp size[2] = { $1_dim0, $1_dim1 }; ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,2) || !require_size(array, size, 2) || ++ !require_contiguous(array) || !require_native(array)) SWIG_fail; ++ $1 = ($1_ltype) array_data(array); ++} ++ ++/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ (PyArrayObject* array=NULL) ++{ ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,2) || !require_contiguous(array) ++ || !require_native(array)) SWIG_fail; ++ $1 = (DATA_TYPE*) array_data(array); ++ $2 = (DIM_TYPE) array_size(array,0); ++ $3 = (DIM_TYPE) array_size(array,1); ++} ++ ++/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) ++ (PyArrayObject* array=NULL) ++{ ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,2) || !require_contiguous(array) || ++ !require_native(array)) SWIG_fail; ++ $1 = (DIM_TYPE) array_size(array,0); ++ $2 = (DIM_TYPE) array_size(array,1); ++ $3 = (DATA_TYPE*) array_data(array); ++} ++ ++/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) ++ (PyArrayObject* array=NULL) ++{ ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,2) || !require_contiguous(array) ++ || !require_native(array) || !require_fortran(array)) SWIG_fail; ++ $1 = (DATA_TYPE*) array_data(array); ++ $2 = (DIM_TYPE) array_size(array,0); ++ $3 = (DIM_TYPE) array_size(array,1); ++} ++ ++/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) ++ (PyArrayObject* array=NULL) ++{ ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,2) || !require_contiguous(array) || ++ !require_native(array) || !require_fortran(array)) SWIG_fail; ++ $1 = (DIM_TYPE) array_size(array,0); ++ $2 = (DIM_TYPE) array_size(array,1); ++ $3 = (DATA_TYPE*) array_data(array); ++} ++ ++/* Typemap suite for (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) ++ (PyArrayObject* array=NULL) ++{ ++ npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 }; ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,3) || !require_size(array, size, 3) || ++ !require_contiguous(array) || !require_native(array)) SWIG_fail; ++ $1 = ($1_ltype) array_data(array); ++} ++ ++/* Typemap suite for (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, ++ * DIM_TYPE DIM3) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++ (PyArrayObject* array=NULL) ++{ ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,3) || !require_contiguous(array) || ++ !require_native(array)) SWIG_fail; ++ $1 = (DATA_TYPE*) array_data(array); ++ $2 = (DIM_TYPE) array_size(array,0); ++ $3 = (DIM_TYPE) array_size(array,1); ++ $4 = (DIM_TYPE) array_size(array,2); ++} ++ ++/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, ++ * DATA_TYPE* INPLACE_ARRAY3) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) ++ (PyArrayObject* array=NULL) ++{ ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,3) || !require_contiguous(array) ++ || !require_native(array)) SWIG_fail; ++ $1 = (DIM_TYPE) array_size(array,0); ++ $2 = (DIM_TYPE) array_size(array,1); ++ $3 = (DIM_TYPE) array_size(array,2); ++ $4 = (DATA_TYPE*) array_data(array); ++} ++ ++/* Typemap suite for (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, ++ * DIM_TYPE DIM3) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) ++ (PyArrayObject* array=NULL) ++{ ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,3) || !require_contiguous(array) || ++ !require_native(array) || !require_fortran(array)) SWIG_fail; ++ $1 = (DATA_TYPE*) array_data(array); ++ $2 = (DIM_TYPE) array_size(array,0); ++ $3 = (DIM_TYPE) array_size(array,1); ++ $4 = (DIM_TYPE) array_size(array,2); ++} ++ ++/* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, ++ * DATA_TYPE* INPLACE_FARRAY3) ++ */ ++%typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, ++ fragment="NumPy_Macros") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) ++{ ++ $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), ++ DATA_TYPECODE); ++} ++%typemap(in, ++ fragment="NumPy_Fragments") ++ (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) ++ (PyArrayObject* array=NULL) ++{ ++ array = obj_to_array_no_conversion($input, DATA_TYPECODE); ++ if (!array || !require_dimensions(array,3) || !require_contiguous(array) ++ || !require_native(array) || !require_fortran(array)) SWIG_fail; ++ $1 = (DIM_TYPE) array_size(array,0); ++ $2 = (DIM_TYPE) array_size(array,1); ++ $3 = (DIM_TYPE) array_size(array,2); ++ $4 = (DATA_TYPE*) array_data(array); ++} ++ ++/*************************/ ++/* Argout Array Typemaps */ ++/*************************/ ++ ++/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY1[ANY]) ++ */ ++%typemap(in,numinputs=0, ++ fragment="NumPy_Backward_Compatibility,NumPy_Macros") ++ (DATA_TYPE ARGOUT_ARRAY1[ANY]) ++ (PyObject * array = NULL) ++{ ++ npy_intp dims[1] = { $1_dim0 }; ++ array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); ++ if (!array) SWIG_fail; ++ $1 = ($1_ltype) array_data(array); ++} ++%typemap(argout) ++ (DATA_TYPE ARGOUT_ARRAY1[ANY]) ++{ ++ $result = SWIG_Python_AppendOutput($result,array$argnum); ++} ++ ++/* Typemap suite for (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) ++ */ ++%typemap(in,numinputs=1, ++ fragment="NumPy_Fragments") ++ (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) ++ (PyObject * array = NULL) ++{ ++ npy_intp dims[1]; ++ if (!PyInt_Check($input)) ++ { ++ char* typestring = pytype_string($input); ++ PyErr_Format(PyExc_TypeError, ++ "Int dimension expected. '%s' given.", ++ typestring); ++ SWIG_fail; ++ } ++ $2 = (DIM_TYPE) PyInt_AsLong($input); ++ dims[0] = (npy_intp) $2; ++ array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); ++ if (!array) SWIG_fail; ++ $1 = (DATA_TYPE*) array_data(array); ++} ++%typemap(argout) ++ (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) ++{ ++ $result = SWIG_Python_AppendOutput($result,array$argnum); ++} ++ ++/* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) ++ */ ++%typemap(in,numinputs=1, ++ fragment="NumPy_Fragments") ++ (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) ++ (PyObject * array = NULL) ++{ ++ npy_intp dims[1]; ++ if (!PyInt_Check($input)) ++ { ++ char* typestring = pytype_string($input); ++ PyErr_Format(PyExc_TypeError, ++ "Int dimension expected. '%s' given.", ++ typestring); ++ SWIG_fail; ++ } ++ $1 = (DIM_TYPE) PyInt_AsLong($input); ++ dims[0] = (npy_intp) $1; ++ array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); ++ if (!array) SWIG_fail; ++ $2 = (DATA_TYPE*) array_data(array); ++} ++%typemap(argout) ++ (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) ++{ ++ $result = SWIG_Python_AppendOutput($result,array$argnum); ++} ++ ++/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) ++ */ ++%typemap(in,numinputs=0, ++ fragment="NumPy_Backward_Compatibility,NumPy_Macros") ++ (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) ++ (PyObject * array = NULL) ++{ ++ npy_intp dims[2] = { $1_dim0, $1_dim1 }; ++ array = PyArray_SimpleNew(2, dims, DATA_TYPECODE); ++ if (!array) SWIG_fail; ++ $1 = ($1_ltype) array_data(array); ++} ++%typemap(argout) ++ (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) ++{ ++ $result = SWIG_Python_AppendOutput($result,array$argnum); ++} ++ ++/* Typemap suite for (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) ++ */ ++%typemap(in,numinputs=0, ++ fragment="NumPy_Backward_Compatibility,NumPy_Macros") ++ (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) ++ (PyObject * array = NULL) ++{ ++ npy_intp dims[3] = { $1_dim0, $1_dim1, $1_dim2 }; ++ array = PyArray_SimpleNew(3, dims, DATA_TYPECODE); ++ if (!array) SWIG_fail; ++ $1 = ($1_ltype) array_data(array); ++} ++%typemap(argout) ++ (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) ++{ ++ $result = SWIG_Python_AppendOutput($result,array$argnum); ++} ++ ++/*****************************/ ++/* Argoutview Array Typemaps */ ++/*****************************/ ++ ++/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) ++ */ ++%typemap(in,numinputs=0) ++ (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1 ) ++ (DATA_TYPE* data_temp , DIM_TYPE dim_temp) ++{ ++ $1 = &data_temp; ++ $2 = &dim_temp; ++} ++%typemap(argout, ++ fragment="NumPy_Backward_Compatibility") ++ (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) ++{ ++ npy_intp dims[1] = { *$2 }; ++ PyObject * array = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1)); ++ if (!array) SWIG_fail; ++ $result = SWIG_Python_AppendOutput($result,array); ++} ++ ++/* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) ++ */ ++%typemap(in,numinputs=0) ++ (DIM_TYPE* DIM1 , DATA_TYPE** ARGOUTVIEW_ARRAY1) ++ (DIM_TYPE dim_temp, DATA_TYPE* data_temp ) ++{ ++ $1 = &dim_temp; ++ $2 = &data_temp; ++} ++%typemap(argout, ++ fragment="NumPy_Backward_Compatibility") ++ (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) ++{ ++ npy_intp dims[1] = { *$1 }; ++ PyObject * array = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2)); ++ if (!array) SWIG_fail; ++ $result = SWIG_Python_AppendOutput($result,array); ++} ++ ++/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) ++ */ ++%typemap(in,numinputs=0) ++ (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) ++ (DATA_TYPE* data_temp , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) ++{ ++ $1 = &data_temp; ++ $2 = &dim1_temp; ++ $3 = &dim2_temp; ++} ++%typemap(argout, ++ fragment="NumPy_Backward_Compatibility") ++ (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) ++{ ++ npy_intp dims[2] = { *$2, *$3 }; ++ PyObject * array = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); ++ if (!array) SWIG_fail; ++ $result = SWIG_Python_AppendOutput($result,array); ++} ++ ++/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) ++ */ ++%typemap(in,numinputs=0) ++ (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_ARRAY2) ++ (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp ) ++{ ++ $1 = &dim1_temp; ++ $2 = &dim2_temp; ++ $3 = &data_temp; ++} ++%typemap(argout, ++ fragment="NumPy_Backward_Compatibility") ++ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) ++{ ++ npy_intp dims[2] = { *$1, *$2 }; ++ PyObject * array = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); ++ if (!array) SWIG_fail; ++ $result = SWIG_Python_AppendOutput($result,array); ++} ++ ++/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) ++ */ ++%typemap(in,numinputs=0) ++ (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) ++ (DATA_TYPE* data_temp , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) ++{ ++ $1 = &data_temp; ++ $2 = &dim1_temp; ++ $3 = &dim2_temp; ++} ++%typemap(argout, ++ fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") ++ (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) ++{ ++ npy_intp dims[2] = { *$2, *$3 }; ++ PyObject * obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); ++ PyArrayObject * array = (PyArrayObject*) obj; ++ if (!array || !require_fortran(array)) SWIG_fail; ++ $result = SWIG_Python_AppendOutput($result,obj); ++} ++ ++/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) ++ */ ++%typemap(in,numinputs=0) ++ (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_FARRAY2) ++ (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp ) ++{ ++ $1 = &dim1_temp; ++ $2 = &dim2_temp; ++ $3 = &data_temp; ++} ++%typemap(argout, ++ fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") ++ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) ++{ ++ npy_intp dims[2] = { *$1, *$2 }; ++ PyObject * obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); ++ PyArrayObject * array = (PyArrayObject*) obj; ++ if (!array || !require_fortran(array)) SWIG_fail; ++ $result = SWIG_Python_AppendOutput($result,obj); ++} ++ ++/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, ++ DIM_TYPE* DIM3) ++ */ ++%typemap(in,numinputs=0) ++ (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) ++ (DATA_TYPE* data_temp, DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) ++{ ++ $1 = &data_temp; ++ $2 = &dim1_temp; ++ $3 = &dim2_temp; ++ $4 = &dim3_temp; ++} ++%typemap(argout, ++ fragment="NumPy_Backward_Compatibility") ++ (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) ++{ ++ npy_intp dims[3] = { *$2, *$3, *$4 }; ++ PyObject * array = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); ++ if (!array) SWIG_fail; ++ $result = SWIG_Python_AppendOutput($result,array); ++} ++ ++/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, ++ DATA_TYPE** ARGOUTVIEW_ARRAY3) ++ */ ++%typemap(in,numinputs=0) ++ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) ++ (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp) ++{ ++ $1 = &dim1_temp; ++ $2 = &dim2_temp; ++ $3 = &dim3_temp; ++ $4 = &data_temp; ++} ++%typemap(argout, ++ fragment="NumPy_Backward_Compatibility") ++ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) ++{ ++ npy_intp dims[3] = { *$1, *$2, *$3 }; ++ PyObject * array = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$3)); ++ if (!array) SWIG_fail; ++ $result = SWIG_Python_AppendOutput($result,array); ++} ++ ++/* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, ++ DIM_TYPE* DIM3) ++ */ ++%typemap(in,numinputs=0) ++ (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) ++ (DATA_TYPE* data_temp, DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) ++{ ++ $1 = &data_temp; ++ $2 = &dim1_temp; ++ $3 = &dim2_temp; ++ $4 = &dim3_temp; ++} ++%typemap(argout, ++ fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") ++ (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) ++{ ++ npy_intp dims[3] = { *$2, *$3, *$4 }; ++ PyObject * obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); ++ PyArrayObject * array = (PyArrayObject*) obj; ++ if (!array || require_fortran(array)) SWIG_fail; ++ $result = SWIG_Python_AppendOutput($result,obj); ++} ++ ++/* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, ++ DATA_TYPE** ARGOUTVIEW_FARRAY3) ++ */ ++%typemap(in,numinputs=0) ++ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3) ++ (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp) ++{ ++ $1 = &dim1_temp; ++ $2 = &dim2_temp; ++ $3 = &dim3_temp; ++ $4 = &data_temp; ++} ++%typemap(argout, ++ fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") ++ (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3) ++{ ++ npy_intp dims[3] = { *$1, *$2, *$3 }; ++ PyObject * obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$3)); ++ PyArrayObject * array = (PyArrayObject*) obj; ++ if (!array || require_fortran(array)) SWIG_fail; ++ $result = SWIG_Python_AppendOutput($result,obj); ++} ++ ++%enddef /* %numpy_typemaps() macro */ ++/* *************************************************************** */ ++ ++/* Concrete instances of the %numpy_typemaps() macro: Each invocation ++ * below applies all of the typemaps above to the specified data type. ++ */ ++%numpy_typemaps(signed char , NPY_BYTE , int) ++%numpy_typemaps(unsigned char , NPY_UBYTE , int) ++%numpy_typemaps(short , NPY_SHORT , int) ++%numpy_typemaps(unsigned short , NPY_USHORT , int) ++%numpy_typemaps(int , NPY_INT , int) ++%numpy_typemaps(unsigned int , NPY_UINT , int) ++%numpy_typemaps(long , NPY_LONG , int) ++%numpy_typemaps(unsigned long , NPY_ULONG , int) ++%numpy_typemaps(long long , NPY_LONGLONG , int) ++%numpy_typemaps(unsigned long long, NPY_ULONGLONG, int) ++%numpy_typemaps(float , NPY_FLOAT , int) ++%numpy_typemaps(double , NPY_DOUBLE , int) ++ ++/* *************************************************************** ++ * The follow macro expansion does not work, because C++ bool is 4 ++ * bytes and NPY_BOOL is 1 byte ++ * ++ * %numpy_typemaps(bool, NPY_BOOL, int) ++ */ ++ ++/* *************************************************************** ++ * On my Mac, I get the following warning for this macro expansion: ++ * 'swig/python detected a memory leak of type 'long double *', no destructor found.' ++ * ++ * %numpy_typemaps(long double, NPY_LONGDOUBLE, int) ++ */ ++ ++/* *************************************************************** ++ * Swig complains about a syntax error for the following macro ++ * expansions: ++ * ++ * %numpy_typemaps(complex float, NPY_CFLOAT , int) ++ * ++ * %numpy_typemaps(complex double, NPY_CDOUBLE, int) ++ * ++ * %numpy_typemaps(complex long double, NPY_CLONGDOUBLE, int) ++ */ ++ ++#endif /* SWIGPYTHON */ diff --git a/debian/patches/series b/debian/patches/series index 879efc6..71328c3 100644 --- a/debian/patches/series +++ b/debian/patches/series @@ -1 +1,4 @@ +lang_CMakeLists.patch CMakeLists.patch +lang_numpy.patch +lang_mathgl.patch diff --git a/debian/python-mathgl.install b/debian/python-mathgl.install deleted file mode 100644 index 430c254..0000000 --- a/debian/python-mathgl.install +++ /dev/null @@ -1,2 +0,0 @@ -debian/tmp/usr/lib/python*/dist-packages/*.so -debian/tmp/usr/lib/python*/dist-packages/*.py \ No newline at end of file diff --git a/debian/python3-mathgl.install b/debian/python3-mathgl.install new file mode 100644 index 0000000..430c254 --- /dev/null +++ b/debian/python3-mathgl.install @@ -0,0 +1,2 @@ +debian/tmp/usr/lib/python*/dist-packages/*.so +debian/tmp/usr/lib/python*/dist-packages/*.py \ No newline at end of file diff --git a/debian/rules b/debian/rules index c1d31b7..bd2e45e 100755 --- a/debian/rules +++ b/debian/rules @@ -11,7 +11,7 @@ export DH_VERBOSE=1 export DH_OPTIONS=-v %: - dh $@ --buildsystem=cmake --with python2 + dh $@ --buildsystem=cmake --with python3 -override_dh_python2: - dh_numpy +override_dh_python3: + dh_numpy3