falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2333 Commits
16 Branches
16GB
Tree: 03feae01ff
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '03feae01ff'
${ noResults }
Carla/source/modules/lilv/lilv-0.20.0/bindings/numpy.i

1745 lines
59KB
Raw Blame History 

  1. /* -*- C -*-  (not really, but good for syntax highlighting) */

  2. #ifdef SWIGPYTHON

  3. 

  4. %{

  5. #ifndef SWIG_FILE_WITH_INIT

  6. #  define NO_IMPORT_ARRAY

  7. #endif

  8. #include "stdio.h"

  9. #include <numpy/arrayobject.h>

  10. %}

  11. 

  12. /**********************************************************************/

  13. 

  14. %fragment("NumPy_Backward_Compatibility", "header")

  15. {

  16. /* Support older NumPy data type names

  17. */

  18. %#if NDARRAY_VERSION < 0x01000000

  19. %#define NPY_BOOL          PyArray_BOOL

  20. %#define NPY_BYTE          PyArray_BYTE

  21. %#define NPY_UBYTE         PyArray_UBYTE

  22. %#define NPY_SHORT         PyArray_SHORT

  23. %#define NPY_USHORT        PyArray_USHORT

  24. %#define NPY_INT           PyArray_INT

  25. %#define NPY_UINT          PyArray_UINT

  26. %#define NPY_LONG          PyArray_LONG

  27. %#define NPY_ULONG         PyArray_ULONG

  28. %#define NPY_LONGLONG      PyArray_LONGLONG

  29. %#define NPY_ULONGLONG     PyArray_ULONGLONG

  30. %#define NPY_FLOAT         PyArray_FLOAT

  31. %#define NPY_DOUBLE        PyArray_DOUBLE

  32. %#define NPY_LONGDOUBLE    PyArray_LONGDOUBLE

  33. %#define NPY_CFLOAT        PyArray_CFLOAT

  34. %#define NPY_CDOUBLE       PyArray_CDOUBLE

  35. %#define NPY_CLONGDOUBLE   PyArray_CLONGDOUBLE

  36. %#define NPY_OBJECT        PyArray_OBJECT

  37. %#define NPY_STRING        PyArray_STRING

  38. %#define NPY_UNICODE       PyArray_UNICODE

  39. %#define NPY_VOID          PyArray_VOID

  40. %#define NPY_NTYPES        PyArray_NTYPES

  41. %#define NPY_NOTYPE        PyArray_NOTYPE

  42. %#define NPY_CHAR          PyArray_CHAR

  43. %#define NPY_USERDEF       PyArray_USERDEF

  44. %#define npy_intp          intp

  45. 

  46. %#define NPY_MAX_BYTE      MAX_BYTE

  47. %#define NPY_MIN_BYTE      MIN_BYTE

  48. %#define NPY_MAX_UBYTE     MAX_UBYTE

  49. %#define NPY_MAX_SHORT     MAX_SHORT

  50. %#define NPY_MIN_SHORT     MIN_SHORT

  51. %#define NPY_MAX_USHORT    MAX_USHORT

  52. %#define NPY_MAX_INT       MAX_INT

  53. %#define NPY_MIN_INT       MIN_INT

  54. %#define NPY_MAX_UINT      MAX_UINT

  55. %#define NPY_MAX_LONG      MAX_LONG

  56. %#define NPY_MIN_LONG      MIN_LONG

  57. %#define NPY_MAX_ULONG     MAX_ULONG

  58. %#define NPY_MAX_LONGLONG  MAX_LONGLONG

  59. %#define NPY_MIN_LONGLONG  MIN_LONGLONG

  60. %#define NPY_MAX_ULONGLONG MAX_ULONGLONG

  61. %#define NPY_MAX_INTP      MAX_INTP

  62. %#define NPY_MIN_INTP      MIN_INTP

  63. 

  64. %#define NPY_FARRAY        FARRAY

  65. %#define NPY_F_CONTIGUOUS  F_CONTIGUOUS

  66. %#endif

  67. }

  68. 

  69. /**********************************************************************/

  70. 

  71. /* The following code originally appeared in

  72.  * enthought/kiva/agg/src/numeric.i written by Eric Jones.  It was

  73.  * translated from C++ to C by John Hunter.  Bill Spotz has modified

  74.  * it to fix some minor bugs, upgrade from Numeric to numpy (all

  75.  * versions), add some comments and functionality, and convert from

  76.  * direct code insertion to SWIG fragments.

  77.  */

  78. 

  79. %fragment("NumPy_Macros", "header")

  80. {

  81. /* Macros to extract array attributes.

  82.  */

  83. %#define is_array(a)            ((a) && PyArray_Check((PyArrayObject *)a))

  84. %#define array_type(a)          (int)(PyArray_TYPE(a))

  85. %#define array_numdims(a)       (((PyArrayObject *)a)->nd)

  86. %#define array_dimensions(a)    (((PyArrayObject *)a)->dimensions)

  87. %#define array_size(a,i)        (((PyArrayObject *)a)->dimensions[i])

  88. %#define array_data(a)          (((PyArrayObject *)a)->data)

  89. %#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS(a))

  90. %#define array_is_native(a)     (PyArray_ISNOTSWAPPED(a))

  91. %#define array_is_fortran(a)    (PyArray_ISFORTRAN(a))

  92. }

  93. 

  94. /**********************************************************************/

  95. 

  96. %fragment("NumPy_Utilities", "header")

  97. {

  98.   /* Given a PyObject, return a string describing its type.

  99.    */

  100.   const char* pytype_string(PyObject* py_obj) {

  101.     if (py_obj == NULL          ) return "C NULL value";

  102.     if (py_obj == Py_None       ) return "Python None" ;

  103.     if (PyCallable_Check(py_obj)) return "callable"    ;

  104.     if (PyString_Check(  py_obj)) return "string"      ;

  105.     if (PyInt_Check(     py_obj)) return "int"         ;

  106.     if (PyFloat_Check(   py_obj)) return "float"       ;

  107.     if (PyDict_Check(    py_obj)) return "dict"        ;

  108.     if (PyList_Check(    py_obj)) return "list"        ;

  109.     if (PyTuple_Check(   py_obj)) return "tuple"       ;

  110.     if (PyFile_Check(    py_obj)) return "file"        ;

  111.     if (PyModule_Check(  py_obj)) return "module"      ;

  112.     if (PyInstance_Check(py_obj)) return "instance"    ;

  113. 

  114.     return "unkown type";

  115.   }

  116. 

  117.   /* Given a NumPy typecode, return a string describing the type.

  118.    */

  119.   const char* typecode_string(int typecode) {

  120.     static const char* type_names[25] = {"bool", "byte", "unsigned byte",

  121.                                    "short", "unsigned short", "int",

  122.                                    "unsigned int", "long", "unsigned long",

  123.                                    "long long", "unsigned long long",

  124.                                    "float", "double", "long double",

  125.                                    "complex float", "complex double",

  126.                                    "complex long double", "object",

  127.                                    "string", "unicode", "void", "ntypes",

  128.                                    "notype", "char", "unknown"};

  129.     return typecode < 24 ? type_names[typecode] : type_names[24];

  130.   }

  131. 

  132.   /* Make sure input has correct numpy type.  Allow character and byte

  133.    * to match.  Also allow int and long to match.  This is deprecated.

  134.    * You should use PyArray_EquivTypenums() instead.

  135.    */

  136.   int type_match(int actual_type, int desired_type) {

  137.     return PyArray_EquivTypenums(actual_type, desired_type);

  138.   }

  139. }

  140. 

  141. /**********************************************************************/

  142. 

  143. %fragment("NumPy_Object_to_Array", "header",

  144.           fragment="NumPy_Backward_Compatibility",

  145.           fragment="NumPy_Macros",

  146.           fragment="NumPy_Utilities")

  147. {

  148.   /* Given a PyObject pointer, cast it to a PyArrayObject pointer if

  149.    * legal.  If not, set the python error string appropriately and

  150.    * return NULL.

  151.    */

  152.   PyArrayObject* obj_to_array_no_conversion(PyObject* input, int typecode)

  153.   {

  154.     PyArrayObject* ary = NULL;

  155.     if (is_array(input) && (typecode == NPY_NOTYPE ||

  156.                             PyArray_EquivTypenums(array_type(input), typecode)))

  157.     {

  158.       ary = (PyArrayObject*) input;

  159.     }

  160.     else if is_array(input)

  161.     {

  162.       const char* desired_type = typecode_string(typecode);

  163.       const char* actual_type  = typecode_string(array_type(input));

  164.       PyErr_Format(PyExc_TypeError,

  165.                    "Array of type '%s' required.  Array of type '%s' given",

  166.                    desired_type, actual_type);

  167.       ary = NULL;

  168.     }

  169.     else

  170.     {

  171.       const char * desired_type = typecode_string(typecode);

  172.       const char * actual_type  = pytype_string(input);

  173.       PyErr_Format(PyExc_TypeError,

  174.                    "Array of type '%s' required.  A '%s' was given",

  175.                    desired_type, actual_type);

  176.       ary = NULL;

  177.     }

  178.     return ary;

  179.   }

  180. 

  181.   /* Convert the given PyObject to a NumPy array with the given

  182.    * typecode.  On success, return a valid PyArrayObject* with the

  183.    * correct type.  On failure, the python error string will be set and

  184.    * the routine returns NULL.

  185.    */

  186.   PyArrayObject* obj_to_array_allow_conversion(PyObject* input, int typecode,

  187.                                                int* is_new_object)

  188.   {

  189.     PyArrayObject* ary = NULL;

  190.     PyObject* py_obj;

  191.     if (is_array(input) && (typecode == NPY_NOTYPE ||

  192.                             PyArray_EquivTypenums(array_type(input),typecode)))

  193.     {

  194.       ary = (PyArrayObject*) input;

  195.       *is_new_object = 0;

  196.     }

  197.     else

  198.     {

  199.       py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_DEFAULT);

  200.       /* If NULL, PyArray_FromObject will have set python error value.*/

  201.       ary = (PyArrayObject*) py_obj;

  202.       *is_new_object = 1;

  203.     }

  204.     return ary;

  205.   }

  206. 

  207.   /* Given a PyArrayObject, check to see if it is contiguous.  If so,

  208.    * return the input pointer and flag it as not a new object.  If it is

  209.    * not contiguous, create a new PyArrayObject using the original data,

  210.    * flag it as a new object and return the pointer.

  211.    */

  212.   PyArrayObject* make_contiguous(PyArrayObject* ary, int* is_new_object,

  213.                                  int min_dims, int max_dims)

  214.   {

  215.     PyArrayObject* result;

  216.     if (array_is_contiguous(ary))

  217.     {

  218.       result = ary;

  219.       *is_new_object = 0;

  220.     }

  221.     else

  222.     {

  223.       result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary,

  224.                                                              array_type(ary),

  225.                                                              min_dims,

  226.                                                              max_dims);

  227.       *is_new_object = 1;

  228.     }

  229.     return result;

  230.   }

  231. 

  232.   /* Given a PyArrayObject, check to see if it is Fortran-contiguous.

  233.    * If so, return the input pointer, but do not flag it as not a new

  234.    * object.  If it is not Fortran-contiguous, create a new

  235.    * PyArrayObject using the original data, flag it as a new object

  236.    * and return the pointer.

  237.    */

  238.   PyArrayObject* make_fortran(PyArrayObject* ary, int* is_new_object,

  239.                               int min_dims, int max_dims)

  240.   {

  241.     PyArrayObject* result;

  242.     if (array_is_fortran(ary))

  243.     {

  244.       result = ary;

  245.       *is_new_object = 0;

  246.     }

  247.     else

  248.     {

  249.       Py_INCREF(ary->descr);

  250.       result = (PyArrayObject*) PyArray_FromArray(ary, ary->descr, NPY_FORTRAN);

  251.       *is_new_object = 1;

  252.     }

  253.     return result;

  254.   }

  255. 

  256.   /* Convert a given PyObject to a contiguous PyArrayObject of the

  257.    * specified type.  If the input object is not a contiguous

  258.    * PyArrayObject, a new one will be created and the new object flag

  259.    * will be set.

  260.    */

  261.   PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input,

  262.                                                           int typecode,

  263.                                                           int* is_new_object)

  264.   {

  265.     int is_new1 = 0;

  266.     int is_new2 = 0;

  267.     PyArrayObject* ary2;

  268.     PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode,

  269.                                                         &is_new1);

  270.     if (ary1)

  271.     {

  272.       ary2 = make_contiguous(ary1, &is_new2, 0, 0);

  273.       if ( is_new1 && is_new2)

  274.       {

  275.         Py_DECREF(ary1);

  276.       }

  277.       ary1 = ary2;

  278.     }

  279.     *is_new_object = is_new1 || is_new2;

  280.     return ary1;

  281.   }

  282. 

  283.   /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the

  284.    * specified type.  If the input object is not a Fortran-ordered

  285.    * PyArrayObject, a new one will be created and the new object flag

  286.    * will be set.

  287.    */

  288.   PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input,

  289.                                                        int typecode,

  290.                                                        int* is_new_object)

  291.   {

  292.     int is_new1 = 0;

  293.     int is_new2 = 0;

  294.     PyArrayObject* ary2;

  295.     PyArrayObject* ary1 = obj_to_array_allow_conversion(input, typecode,

  296.                                                         &is_new1);

  297.     if (ary1)

  298.     {

  299.       ary2 = make_fortran(ary1, &is_new2, 0, 0);

  300.       if (is_new1 && is_new2)

  301.       {

  302.         Py_DECREF(ary1);

  303.       }

  304.       ary1 = ary2;

  305.     }

  306.     *is_new_object = is_new1 || is_new2;

  307.     return ary1;

  308.   }

  309. 

  310.   /* The following code was added by Ilmar M. Wilbers for forcing a copy of the

  311.    * object even when it is a NumPy array. This is meant for use with the

  312.    * IN_ARRAY typemaps, and allows the user to perform changes on an array

  313.    * without these chenges being reflected in the calling code.

  314.    */

  315. 

  316.   /* Convert the given PyObject to a NumPy array with the given

  317.    * typecode as a copy. On success, return a valid PyArrayObject* with the

  318.    * correct type.  On failure, the python error string will be set and

  319.    * the routine returns NULL.

  320.    */

  321.   PyArrayObject* obj_to_array_force_conversion(PyObject* input, int typecode,

  322.                                                int* is_new_object)

  323.   {

  324.     PyArrayObject* ary = NULL;

  325.     PyObject* py_obj;

  326.     if (is_array(input) && (typecode == NPY_NOTYPE ||

  327.                             PyArray_EquivTypenums(array_type(input),typecode)))

  328.     {

  329.       py_obj = PyArray_Copy((PyArrayObject*) input);

  330.       ary = (PyArrayObject*) py_obj;

  331.       *is_new_object = 1;

  332.     }

  333.     else

  334.     {

  335.       py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_DEFAULT);

  336.       /* If NULL, PyArray_FromObject will have set python error value.*/

  337.       ary = (PyArrayObject*) py_obj;

  338.       *is_new_object = 1;

  339.     }

  340.     return ary;

  341.   }

  342. 

  343.  /* Convert a given PyObject to a contiguous PyArrayObject of the

  344.    * specified type.  If the input object is not a contiguous

  345.    * PyArrayObject, a new one will be created and the new object flag

  346.    * will be set.

  347.    */

  348.   PyArrayObject* obj_to_array_contiguous_force_conversion(PyObject* input,

  349.                                                           int typecode,

  350.                                                           int* is_new_object)

  351.   {

  352.     int is_new1 = 0;

  353.     int is_new2 = 0;

  354.     PyArrayObject* ary2;

  355.     PyArrayObject* ary1 = obj_to_array_force_conversion(input, typecode,

  356.                                                         &is_new1);

  357.     if (ary1)

  358.     {

  359.       ary2 = make_contiguous(ary1, &is_new2, 0, 0);

  360.       if ( is_new1 && is_new2)

  361.       {

  362.         Py_DECREF(ary1);

  363.       }

  364.       ary1 = ary2;

  365.     }

  366.     *is_new_object = is_new1 || is_new2;

  367.     return ary1;

  368.   }

  369. 

  370.   /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the

  371.    * specified type.  If the input object is not a Fortran-ordered

  372.    * PyArrayObject, a new one will be created and the new object flag

  373.    * will be set.

  374.    */

  375.   PyArrayObject* obj_to_array_fortran_force_conversion(PyObject* input,

  376.                                                        int typecode,

  377.                                                        int* is_new_object)

  378.   {

  379.     int is_new1 = 0;

  380.     int is_new2 = 0;

  381.     PyArrayObject* ary2;

  382.     PyArrayObject* ary1 = obj_to_array_force_conversion(input, typecode,

  383.                                                         &is_new1);

  384.     if (ary1)

  385.     {

  386.       ary2 = make_fortran(ary1, &is_new2, 0, 0);

  387.       if (is_new1 && is_new2)

  388.       {

  389.         Py_DECREF(ary1);

  390.       }

  391.       ary1 = ary2;

  392.     }

  393.     *is_new_object = is_new1 || is_new2;

  394.     return ary1;

  395.   }

  396.   /* End modifications by Ilmar M. Wilbers

  397.    */

  398. 

  399. } /* end fragment */

  400. 

  401. 

  402. /**********************************************************************/

  403. 

  404. %fragment("NumPy_Array_Requirements", "header",

  405.           fragment="NumPy_Backward_Compatibility",

  406.           fragment="NumPy_Macros")

  407. {

  408.   /* Test whether a python object is contiguous.  If array is

  409.    * contiguous, return 1.  Otherwise, set the python error string and

  410.    * return 0.

  411.    */

  412.   int require_contiguous(PyArrayObject* ary)

  413.   {

  414.     int contiguous = 1;

  415.     if (!array_is_contiguous(ary))

  416.     {

  417.       PyErr_SetString(PyExc_TypeError,

  418.                       "Array must be contiguous.  A non-contiguous array was given");

  419.       contiguous = 0;

  420.     }

  421.     return contiguous;

  422.   }

  423. 

  424.   /* Require that a numpy array is not byte-swapped.  If the array is

  425.    * not byte-swapped, return 1.  Otherwise, set the python error string

  426.    * and return 0.

  427.    */

  428.   int require_native(PyArrayObject* ary)

  429.   {

  430.     int native = 1;

  431.     if (!array_is_native(ary))

  432.     {

  433.       PyErr_SetString(PyExc_TypeError,

  434.                       "Array must have native byteorder.  "

  435.                       "A byte-swapped array was given");

  436.       native = 0;

  437.     }

  438.     return native;

  439.   }

  440. 

  441.   /* Require the given PyArrayObject to have a specified number of

  442.    * dimensions.  If the array has the specified number of dimensions,

  443.    * return 1.  Otherwise, set the python error string and return 0.

  444.    */

  445.   int require_dimensions(PyArrayObject* ary, int exact_dimensions)

  446.   {

  447.     int success = 1;

  448.     if (array_numdims(ary) != exact_dimensions)

  449.     {

  450.       PyErr_Format(PyExc_TypeError,

  451.                    "Array must have %d dimensions.  Given array has %d dimensions",

  452.                    exact_dimensions, array_numdims(ary));

  453.       success = 0;

  454.     }

  455.     return success;

  456.   }

  457. 

  458.   /* Require the given PyArrayObject to have one of a list of specified

  459.    * number of dimensions.  If the array has one of the specified number

  460.    * of dimensions, return 1.  Otherwise, set the python error string

  461.    * and return 0.

  462.    */

  463.   int require_dimensions_n(PyArrayObject* ary, int* exact_dimensions, int n)

  464.   {

  465.     int success = 0;

  466.     int i;

  467.     char dims_str[255] = "";

  468.     char s[255];

  469.     for (i = 0; i < n && !success; i++)

  470.     {

  471.       if (array_numdims(ary) == exact_dimensions[i])

  472.       {

  473.         success = 1;

  474.       }

  475.     }

  476.     if (!success)

  477.     {

  478.       for (i = 0; i < n-1; i++)

  479.       {

  480.         sprintf(s, "%d, ", exact_dimensions[i]);

  481.         strcat(dims_str,s);

  482.       }

  483.       sprintf(s, " or %d", exact_dimensions[n-1]);

  484.       strcat(dims_str,s);

  485.       PyErr_Format(PyExc_TypeError,

  486.                    "Array must have %s dimensions.  Given array has %d dimensions",

  487.                    dims_str, array_numdims(ary));

  488.     }

  489.     return success;

  490.   }

  491. 

  492.   /* Require the given PyArrayObject to have a specified shape.  If the

  493.    * array has the specified shape, return 1.  Otherwise, set the python

  494.    * error string and return 0.

  495.    */

  496.   int require_size(PyArrayObject* ary, npy_intp* size, int n)

  497.   {

  498.     int i;

  499.     int success = 1;

  500.     int len;

  501.     char desired_dims[255] = "[";

  502.     char s[255];

  503.     char actual_dims[255] = "[";

  504.     for(i=0; i < n;i++)

  505.     {

  506.       if (size[i] != -1 &&  size[i] != array_size(ary,i))

  507.       {

  508.         success = 0;

  509.       }

  510.     }

  511.     if (!success)

  512.     {

  513.       for (i = 0; i < n; i++)

  514.       {

  515.         if (size[i] == -1)

  516.         {

  517.           sprintf(s, "*,");

  518.         }

  519.         else

  520.         {

  521.           sprintf(s, "%ld,", (long int)size[i]);

  522.         }

  523.         strcat(desired_dims,s);

  524.       }

  525.       len = strlen(desired_dims);

  526.       desired_dims[len-1] = ']';

  527.       for (i = 0; i < n; i++)

  528.       {

  529.         sprintf(s, "%ld,", (long int)array_size(ary,i));

  530.         strcat(actual_dims,s);

  531.       }

  532.       len = strlen(actual_dims);

  533.       actual_dims[len-1] = ']';

  534.       PyErr_Format(PyExc_TypeError,

  535.                    "Array must have shape of %s.  Given array has shape of %s",

  536.                    desired_dims, actual_dims);

  537.     }

  538.     return success;

  539.   }

  540. 

  541.   /* Require the given PyArrayObject to to be FORTRAN ordered.  If the

  542.    * the PyArrayObject is already FORTRAN ordered, do nothing.  Else,

  543.    * set the FORTRAN ordering flag and recompute the strides.

  544.    */

  545.   int require_fortran(PyArrayObject* ary)

  546.   {

  547.     int success = 1;

  548.     int nd = array_numdims(ary);

  549.     int i;

  550.     if (array_is_fortran(ary)) return success;

  551.     /* Set the FORTRAN ordered flag */

  552.     ary->flags = NPY_FARRAY;

  553.     /* Recompute the strides */

  554.     ary->strides[0] = ary->strides[nd-1];

  555.     for (i=1; i < nd; ++i)

  556.       ary->strides[i] = ary->strides[i-1] * array_size(ary,i-1);

  557.     return success;

  558.   }

  559. }

  560. 

  561. /* Combine all NumPy fragments into one for convenience */

  562. %fragment("NumPy_Fragments", "header",

  563.           fragment="NumPy_Backward_Compatibility",

  564.           fragment="NumPy_Macros",

  565.           fragment="NumPy_Utilities",

  566.           fragment="NumPy_Object_to_Array",

  567.           fragment="NumPy_Array_Requirements") { }

  568. 

  569. /* End John Hunter translation (with modifications by Bill Spotz)

  570.  */

  571. 

  572. /* %numpy_typemaps() macro

  573.  *

  574.  * This macro defines a family of 42 typemaps that allow C arguments

  575.  * of the form

  576.  *

  577.  *     (DATA_TYPE IN_ARRAY1[ANY])

  578.  *     (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)

  579.  *     (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)

  580.  *

  581.  *     (DATA_TYPE IN_ARRAY2[ANY][ANY])

  582.  *     (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  583.  *     (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)

  584.  *     (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  585.  *     (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)

  586.  *

  587.  *     (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])

  588.  *     (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  589.  *     (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)

  590.  *     (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  591.  *     (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)

  592.  *

  593.  *     (DATA_TYPE INPLACE_ARRAY1[ANY])

  594.  *     (DATA_TYPE* INPLACE_ARRAY1)

  595.  *     (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)

  596.  *     (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)

  597.  *

  598.  *     (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])

  599.  *     (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  600.  *     (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)

  601.  *     (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  602.  *     (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)

  603.  *

  604.  *     (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])

  605.  *     (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  606.  *     (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)

  607.  *     (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  608.  *     (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)

  609.  *

  610.  *     (DATA_TYPE ARGOUT_ARRAY1[ANY])

  611.  *     (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)

  612.  *     (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)

  613.  *

  614.  *     (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])

  615.  *

  616.  *     (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])

  617.  *

  618.  *     (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)

  619.  *     (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)

  620.  *

  621.  *     (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)

  622.  *     (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)

  623.  *     (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)

  624.  *     (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)

  625.  *

  626.  *     (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)

  627.  *     (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)

  628.  *     (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)

  629.  *     (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3)

  630.  *

  631.  * where "DATA_TYPE" is any type supported by the NumPy module, and

  632.  * "DIM_TYPE" is any int-like type suitable for specifying dimensions.

  633.  * The difference between "ARRAY" typemaps and "FARRAY" typemaps is

  634.  * that the "FARRAY" typemaps expect FORTRAN ordering of

  635.  * multidimensional arrays.  In python, the dimensions will not need

  636.  * to be specified (except for the "DATA_TYPE* ARGOUT_ARRAY1"

  637.  * typemaps).  The IN_ARRAYs can be a numpy array or any sequence that

  638.  * can be converted to a numpy array of the specified type.  The

  639.  * INPLACE_ARRAYs must be numpy arrays of the appropriate type.  The

  640.  * ARGOUT_ARRAYs will be returned as new numpy arrays of the

  641.  * appropriate type.

  642.  *

  643.  * These typemaps can be applied to existing functions using the

  644.  * %apply directive.  For example:

  645.  *

  646.  *     %apply (double* IN_ARRAY1, int DIM1) {(double* series, int length)};

  647.  *     double prod(double* series, int length);

  648.  *

  649.  *     %apply (int DIM1, int DIM2, double* INPLACE_ARRAY2)

  650.  *           {(int rows, int cols, double* matrix        )};

  651.  *     void floor(int rows, int cols, double* matrix, double f);

  652.  *

  653.  *     %apply (double IN_ARRAY3[ANY][ANY][ANY])

  654.  *           {(double tensor[2][2][2]         )};

  655.  *     %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY])

  656.  *           {(double low[2][2][2]                )};

  657.  *     %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY])

  658.  *           {(double upp[2][2][2]                )};

  659.  *     void luSplit(double tensor[2][2][2],

  660.  *                  double low[2][2][2],

  661.  *                  double upp[2][2][2]    );

  662.  *

  663.  * or directly with

  664.  *

  665.  *     double prod(double* IN_ARRAY1, int DIM1);

  666.  *

  667.  *     void floor(int DIM1, int DIM2, double* INPLACE_ARRAY2, double f);

  668.  *

  669.  *     void luSplit(double IN_ARRAY3[ANY][ANY][ANY],

  670.  *                  double ARGOUT_ARRAY3[ANY][ANY][ANY],

  671.  *                  double ARGOUT_ARRAY3[ANY][ANY][ANY]);

  672.  */

  673. 

  674. %define %numpy_typemaps(DATA_TYPE, DATA_TYPECODE, DIM_TYPE)

  675. 

  676. /************************/

  677. /* Input Array Typemaps */

  678. /************************/

  679. 

  680. /* Typemap suite for (DATA_TYPE IN_ARRAY1[ANY])

  681.  */

  682. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  683.            fragment="NumPy_Macros")

  684.   (DATA_TYPE IN_ARRAY1[ANY])

  685. {

  686.   $1 = is_array($input) || PySequence_Check($input);

  687. }

  688. %typemap(in,

  689.          fragment="NumPy_Fragments")

  690.   (DATA_TYPE IN_ARRAY1[ANY])

  691.   (PyArrayObject* array=NULL, int is_new_object=0)

  692. {

  693.   npy_intp size[1] = { $1_dim0 };

  694.   array = obj_to_array_contiguous_force_conversion($input, DATA_TYPECODE,

  695.                                                    &is_new_object);

  696.   if (!array || !require_dimensions(array, 1) ||

  697.       !require_size(array, size, 1)) SWIG_fail;

  698.   $1 = ($1_ltype) array_data(array);

  699. }

  700. %typemap(freearg)

  701.   (DATA_TYPE IN_ARRAY1[ANY])

  702. {

  703.   if (is_new_object$argnum && array$argnum)

  704.     { Py_DECREF(array$argnum); }

  705. }

  706. 

  707. /* Typemap suite for (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)

  708.  */

  709. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  710.            fragment="NumPy_Macros")

  711.   (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)

  712. {

  713.   $1 = is_array($input) || PySequence_Check($input);

  714. }

  715. %typemap(in,

  716.          fragment="NumPy_Fragments")

  717.   (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)

  718.   (PyArrayObject* array=NULL, int is_new_object=0)

  719. {

  720.   npy_intp size[1] = { -1 };

  721.   array = obj_to_array_contiguous_force_conversion($input, DATA_TYPECODE,

  722.                                                    &is_new_object);

  723.   if (!array || !require_dimensions(array, 1) ||

  724.       !require_size(array, size, 1)) SWIG_fail;

  725.   $1 = (DATA_TYPE*) array_data(array);

  726.   $2 = (DIM_TYPE) array_size(array,0);

  727. }

  728. %typemap(freearg)

  729.   (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1)

  730. {

  731.   if (is_new_object$argnum && array$argnum)

  732.     { Py_DECREF(array$argnum); }

  733. }

  734. 

  735. /* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)

  736.  */

  737. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  738.            fragment="NumPy_Macros")

  739.   (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)

  740. {

  741.   $1 = is_array($input) || PySequence_Check($input);

  742. }

  743. %typemap(in,

  744.          fragment="NumPy_Fragments")

  745.   (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)

  746.   (PyArrayObject* array=NULL, int is_new_object=0)

  747. {

  748.   npy_intp size[1] = {-1};

  749.   array = obj_to_array_contiguous_force_conversion($input, DATA_TYPECODE,

  750.                                                    &is_new_object);

  751.   if (!array || !require_dimensions(array, 1) ||

  752.       !require_size(array, size, 1)) SWIG_fail;

  753.   $1 = (DIM_TYPE) array_size(array,0);

  754.   $2 = (DATA_TYPE*) array_data(array);

  755. }

  756. %typemap(freearg)

  757.   (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1)

  758. {

  759.   if (is_new_object$argnum && array$argnum)

  760.     { Py_DECREF(array$argnum); }

  761. }

  762. 

  763. /* Typemap suite for (DATA_TYPE IN_ARRAY2[ANY][ANY])

  764.  */

  765. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  766.            fragment="NumPy_Macros")

  767.   (DATA_TYPE IN_ARRAY2[ANY][ANY])

  768. {

  769.   $1 = is_array($input) || PySequence_Check($input);

  770. }

  771. %typemap(in,

  772.          fragment="NumPy_Fragments")

  773.   (DATA_TYPE IN_ARRAY2[ANY][ANY])

  774.   (PyArrayObject* array=NULL, int is_new_object=0)

  775. {

  776.   npy_intp size[2] = { $1_dim0, $1_dim1 };

  777.   array = obj_to_array_contiguous_force_conversion($input, DATA_TYPECODE,

  778.                                                    &is_new_object);

  779.   if (!array || !require_dimensions(array, 2) ||

  780.       !require_size(array, size, 2)) SWIG_fail;

  781.   $1 = ($1_ltype) array_data(array);

  782. }

  783. %typemap(freearg)

  784.   (DATA_TYPE IN_ARRAY2[ANY][ANY])

  785. {

  786.   if (is_new_object$argnum && array$argnum)

  787.     { Py_DECREF(array$argnum); }

  788. }

  789. 

  790. /* Typemap suite for (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  791.  */

  792. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  793.            fragment="NumPy_Macros")

  794.   (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  795. {

  796.   $1 = is_array($input) || PySequence_Check($input);

  797. }

  798. %typemap(in,

  799.          fragment="NumPy_Fragments")

  800.   (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  801.   (PyArrayObject* array=NULL, int is_new_object=0)

  802. {

  803.   npy_intp size[2] = { -1, -1 };

  804.   array = obj_to_array_contiguous_force_conversion($input, DATA_TYPECODE,

  805.                                                    &is_new_object);

  806.   if (!array || !require_dimensions(array, 2) ||

  807.       !require_size(array, size, 2)) SWIG_fail;

  808.   $1 = (DATA_TYPE*) array_data(array);

  809.   $2 = (DIM_TYPE) array_size(array,0);

  810.   $3 = (DIM_TYPE) array_size(array,1);

  811. }

  812. %typemap(freearg)

  813.   (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  814. {

  815.   if (is_new_object$argnum && array$argnum)

  816.     { Py_DECREF(array$argnum); }

  817. }

  818. 

  819. /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)

  820.  */

  821. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  822.            fragment="NumPy_Macros")

  823.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)

  824. {

  825.   $1 = is_array($input) || PySequence_Check($input);

  826. }

  827. %typemap(in,

  828.          fragment="NumPy_Fragments")

  829.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)

  830.   (PyArrayObject* array=NULL, int is_new_object=0)

  831. {

  832.   npy_intp size[2] = { -1, -1 };

  833.   array = obj_to_array_contiguous_force_conversion($input, DATA_TYPECODE,

  834.                                                    &is_new_object);

  835.   if (!array || !require_dimensions(array, 2) ||

  836.       !require_size(array, size, 2)) SWIG_fail;

  837.   $1 = (DIM_TYPE) array_size(array,0);

  838.   $2 = (DIM_TYPE) array_size(array,1);

  839.   $3 = (DATA_TYPE*) array_data(array);

  840. }

  841. %typemap(freearg)

  842.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2)

  843. {

  844.   if (is_new_object$argnum && array$argnum)

  845.     { Py_DECREF(array$argnum); }

  846. }

  847. 

  848. /* Typemap suite for (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  849.  */

  850. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  851.            fragment="NumPy_Macros")

  852.   (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  853. {

  854.   $1 = is_array($input) || PySequence_Check($input);

  855. }

  856. %typemap(in,

  857.          fragment="NumPy_Fragments")

  858.   (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  859.   (PyArrayObject* array=NULL, int is_new_object=0)

  860. {

  861.   npy_intp size[2] = { -1, -1 };

  862.   array = obj_to_array_fortran_force_conversion($input, DATA_TYPECODE,

  863.                                                 &is_new_object);

  864.   if (!array || !require_dimensions(array, 2) ||

  865.       !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail;

  866.   $1 = (DATA_TYPE*) array_data(array);

  867.   $2 = (DIM_TYPE) array_size(array,0);

  868.   $3 = (DIM_TYPE) array_size(array,1);

  869. }

  870. %typemap(freearg)

  871.   (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  872. {

  873.   if (is_new_object$argnum && array$argnum)

  874.     { Py_DECREF(array$argnum); }

  875. }

  876. 

  877. /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)

  878.  */

  879. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  880.            fragment="NumPy_Macros")

  881.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)

  882. {

  883.   $1 = is_array($input) || PySequence_Check($input);

  884. }

  885. %typemap(in,

  886.          fragment="NumPy_Fragments")

  887.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)

  888.   (PyArrayObject* array=NULL, int is_new_object=0)

  889. {

  890.   npy_intp size[2] = { -1, -1 };

  891.   array = obj_to_array_contiguous_force_conversion($input, DATA_TYPECODE,

  892.                                                    &is_new_object);

  893.   if (!array || !require_dimensions(array, 2) ||

  894.       !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail;

  895.   $1 = (DIM_TYPE) array_size(array,0);

  896.   $2 = (DIM_TYPE) array_size(array,1);

  897.   $3 = (DATA_TYPE*) array_data(array);

  898. }

  899. %typemap(freearg)

  900.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2)

  901. {

  902.   if (is_new_object$argnum && array$argnum)

  903.     { Py_DECREF(array$argnum); }

  904. }

  905. 

  906. /* Typemap suite for (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])

  907.  */

  908. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  909.            fragment="NumPy_Macros")

  910.   (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])

  911. {

  912.   $1 = is_array($input) || PySequence_Check($input);

  913. }

  914. %typemap(in,

  915.          fragment="NumPy_Fragments")

  916.   (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])

  917.   (PyArrayObject* array=NULL, int is_new_object=0)

  918. {

  919.   npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 };

  920.   array = obj_to_array_contiguous_force_conversion($input, DATA_TYPECODE,

  921.                                                    &is_new_object);

  922.   if (!array || !require_dimensions(array, 3) ||

  923.       !require_size(array, size, 3)) SWIG_fail;

  924.   $1 = ($1_ltype) array_data(array);

  925. }

  926. %typemap(freearg)

  927.   (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY])

  928. {

  929.   if (is_new_object$argnum && array$argnum)

  930.     { Py_DECREF(array$argnum); }

  931. }

  932. 

  933. /* Typemap suite for (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,

  934.  *                    DIM_TYPE DIM3)

  935.  */

  936. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  937.            fragment="NumPy_Macros")

  938.   (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  939. {

  940.   $1 = is_array($input) || PySequence_Check($input);

  941. }

  942. %typemap(in,

  943.          fragment="NumPy_Fragments")

  944.   (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  945.   (PyArrayObject* array=NULL, int is_new_object=0)

  946. {

  947.   npy_intp size[3] = { -1, -1, -1 };

  948.   array = obj_to_array_contiguous_force_conversion($input, DATA_TYPECODE,

  949.                                                    &is_new_object);

  950.   if (!array || !require_dimensions(array, 3) ||

  951.       !require_size(array, size, 3)) SWIG_fail;

  952.   $1 = (DATA_TYPE*) array_data(array);

  953.   $2 = (DIM_TYPE) array_size(array,0);

  954.   $3 = (DIM_TYPE) array_size(array,1);

  955.   $4 = (DIM_TYPE) array_size(array,2);

  956. }

  957. %typemap(freearg)

  958.   (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  959. {

  960.   if (is_new_object$argnum && array$argnum)

  961.     { Py_DECREF(array$argnum); }

  962. }

  963. 

  964. /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,

  965.  *                    DATA_TYPE* IN_ARRAY3)

  966.  */

  967. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  968.            fragment="NumPy_Macros")

  969.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)

  970. {

  971.   $1 = is_array($input) || PySequence_Check($input);

  972. }

  973. %typemap(in,

  974.          fragment="NumPy_Fragments")

  975.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)

  976.   (PyArrayObject* array=NULL, int is_new_object=0)

  977. {

  978.   npy_intp size[3] = { -1, -1, -1 };

  979.   array = obj_to_array_contiguous_force_conversion($input, DATA_TYPECODE,

  980.                                                    &is_new_object);

  981.   if (!array || !require_dimensions(array, 3) ||

  982.       !require_size(array, size, 3)) SWIG_fail;

  983.   $1 = (DIM_TYPE) array_size(array,0);

  984.   $2 = (DIM_TYPE) array_size(array,1);

  985.   $3 = (DIM_TYPE) array_size(array,2);

  986.   $4 = (DATA_TYPE*) array_data(array);

  987. }

  988. %typemap(freearg)

  989.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3)

  990. {

  991.   if (is_new_object$argnum && array$argnum)

  992.     { Py_DECREF(array$argnum); }

  993. }

  994. 

  995. /* Typemap suite for (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,

  996.  *                    DIM_TYPE DIM3)

  997.  */

  998. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  999.            fragment="NumPy_Macros")

  1000.   (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  1001. {

  1002.   $1 = is_array($input) || PySequence_Check($input);

  1003. }

  1004. %typemap(in,

  1005.          fragment="NumPy_Fragments")

  1006.   (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  1007.   (PyArrayObject* array=NULL, int is_new_object=0)

  1008. {

  1009.   npy_intp size[3] = { -1, -1, -1 };

  1010.   array = obj_to_array_fortran_force_conversion($input, DATA_TYPECODE,

  1011.                                                 &is_new_object);

  1012.   if (!array || !require_dimensions(array, 3) ||

  1013.       !require_size(array, size, 3) | !require_fortran(array)) SWIG_fail;

  1014.   $1 = (DATA_TYPE*) array_data(array);

  1015.   $2 = (DIM_TYPE) array_size(array,0);

  1016.   $3 = (DIM_TYPE) array_size(array,1);

  1017.   $4 = (DIM_TYPE) array_size(array,2);

  1018. }

  1019. %typemap(freearg)

  1020.   (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  1021. {

  1022.   if (is_new_object$argnum && array$argnum)

  1023.     { Py_DECREF(array$argnum); }

  1024. }

  1025. 

  1026. /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,

  1027.  *                    DATA_TYPE* IN_FARRAY3)

  1028.  */

  1029. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1030.            fragment="NumPy_Macros")

  1031.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)

  1032. {

  1033.   $1 = is_array($input) || PySequence_Check($input);

  1034. }

  1035. %typemap(in,

  1036.          fragment="NumPy_Fragments")

  1037.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)

  1038.   (PyArrayObject* array=NULL, int is_new_object=0)

  1039. {

  1040.   npy_intp size[3] = { -1, -1, -1 };

  1041.   array = obj_to_array_contiguous_force_conversion($input, DATA_TYPECODE,

  1042.                                                    &is_new_object);

  1043.   if (!array || !require_dimensions(array, 3) ||

  1044.       !require_size(array, size, 3) || !require_fortran(array)) SWIG_fail;

  1045.   $1 = (DIM_TYPE) array_size(array,0);

  1046.   $2 = (DIM_TYPE) array_size(array,1);

  1047.   $3 = (DIM_TYPE) array_size(array,2);

  1048.   $4 = (DATA_TYPE*) array_data(array);

  1049. }

  1050. %typemap(freearg)

  1051.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3)

  1052. {

  1053.   if (is_new_object$argnum && array$argnum)

  1054.     { Py_DECREF(array$argnum); }

  1055. }

  1056. 

  1057. /***************************/

  1058. /* In-Place Array Typemaps */

  1059. /***************************/

  1060. 

  1061. /* Typemap suite for (DATA_TYPE INPLACE_ARRAY1[ANY])

  1062.  */

  1063. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1064.            fragment="NumPy_Macros")

  1065.   (DATA_TYPE INPLACE_ARRAY1[ANY])

  1066. {

  1067.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1068.                                                  DATA_TYPECODE);

  1069. }

  1070. %typemap(in,

  1071.          fragment="NumPy_Fragments")

  1072.   (DATA_TYPE INPLACE_ARRAY1[ANY])

  1073.   (PyArrayObject* array=NULL)

  1074. {

  1075.   npy_intp size[1] = { $1_dim0 };

  1076.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1077.   if (!array || !require_dimensions(array,1) || !require_size(array, size, 1) ||

  1078.       !require_contiguous(array) || !require_native(array)) SWIG_fail;

  1079.   $1 = ($1_ltype) array_data(array);

  1080. }

  1081. 

  1082. /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY1)

  1083.  */

  1084. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1085.            fragment="NumPy_Macros")

  1086.   (DATA_TYPE* INPLACE_ARRAY1)

  1087. {

  1088.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1089.                                                  DATA_TYPECODE);

  1090. }

  1091. %typemap(in,

  1092.          fragment="NumPy_Fragments")

  1093.   (DATA_TYPE* INPLACE_ARRAY1)

  1094.   (PyArrayObject* array=NULL)

  1095. {

  1096.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1097.   if (!array || !require_dimensions(array,1) || !require_contiguous(array)

  1098.       || !require_native(array)) SWIG_fail;

  1099.   $1 = (DATA_TYPE*) array_data(array);

  1100. }

  1101. 

  1102. /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)

  1103.  */

  1104. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1105.            fragment="NumPy_Macros")

  1106.   (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)

  1107. {

  1108.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1109.                                                  DATA_TYPECODE);

  1110. }

  1111. %typemap(in,

  1112.          fragment="NumPy_Fragments")

  1113.   (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1)

  1114.   (PyArrayObject* array=NULL, int i=1)

  1115. {

  1116.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1117.   if (!array || !require_dimensions(array,1) || !require_contiguous(array)

  1118.       || !require_native(array)) SWIG_fail;

  1119.   $1 = (DATA_TYPE*) array_data(array);

  1120.   $2 = 1;

  1121.   for (i=0; i < array_numdims(array); ++i) $2 *= array_size(array,i);

  1122. }

  1123. 

  1124. /* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)

  1125.  */

  1126. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1127.            fragment="NumPy_Macros")

  1128.   (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)

  1129. {

  1130.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1131.                                                  DATA_TYPECODE);

  1132. }

  1133. %typemap(in,

  1134.          fragment="NumPy_Fragments")

  1135.   (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1)

  1136.   (PyArrayObject* array=NULL, int i=0)

  1137. {

  1138.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1139.   if (!array || !require_dimensions(array,1) || !require_contiguous(array)

  1140.       || !require_native(array)) SWIG_fail;

  1141.   $1 = 1;

  1142.   for (i=0; i < array_numdims(array); ++i) $1 *= array_size(array,i);

  1143.   $2 = (DATA_TYPE*) array_data(array);

  1144. }

  1145. 

  1146. /* Typemap suite for (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])

  1147.  */

  1148. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1149.            fragment="NumPy_Macros")

  1150.   (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])

  1151. {

  1152.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1153.                                                  DATA_TYPECODE);

  1154. }

  1155. %typemap(in,

  1156.          fragment="NumPy_Fragments")

  1157.   (DATA_TYPE INPLACE_ARRAY2[ANY][ANY])

  1158.   (PyArrayObject* array=NULL)

  1159. {

  1160.   npy_intp size[2] = { $1_dim0, $1_dim1 };

  1161.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1162.   if (!array || !require_dimensions(array,2) || !require_size(array, size, 2) ||

  1163.       !require_contiguous(array) || !require_native(array)) SWIG_fail;

  1164.   $1 = ($1_ltype) array_data(array);

  1165. }

  1166. 

  1167. /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  1168.  */

  1169. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1170.            fragment="NumPy_Macros")

  1171.   (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  1172. {

  1173.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1174.                                                  DATA_TYPECODE);

  1175. }

  1176. %typemap(in,

  1177.          fragment="NumPy_Fragments")

  1178.   (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  1179.   (PyArrayObject* array=NULL)

  1180. {

  1181.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1182.   if (!array || !require_dimensions(array,2) || !require_contiguous(array)

  1183.       || !require_native(array)) SWIG_fail;

  1184.   $1 = (DATA_TYPE*) array_data(array);

  1185.   $2 = (DIM_TYPE) array_size(array,0);

  1186.   $3 = (DIM_TYPE) array_size(array,1);

  1187. }

  1188. 

  1189. /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)

  1190.  */

  1191. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1192.            fragment="NumPy_Macros")

  1193.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)

  1194. {

  1195.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1196.                                                  DATA_TYPECODE);

  1197. }

  1198. %typemap(in,

  1199.          fragment="NumPy_Fragments")

  1200.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2)

  1201.   (PyArrayObject* array=NULL)

  1202. {

  1203.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1204.   if (!array || !require_dimensions(array,2) || !require_contiguous(array) ||

  1205.       !require_native(array)) SWIG_fail;

  1206.   $1 = (DIM_TYPE) array_size(array,0);

  1207.   $2 = (DIM_TYPE) array_size(array,1);

  1208.   $3 = (DATA_TYPE*) array_data(array);

  1209. }

  1210. 

  1211. /* Typemap suite for (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  1212.  */

  1213. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1214.            fragment="NumPy_Macros")

  1215.   (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  1216. {

  1217.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1218.                                                  DATA_TYPECODE);

  1219. }

  1220. %typemap(in,

  1221.          fragment="NumPy_Fragments")

  1222.   (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2)

  1223.   (PyArrayObject* array=NULL)

  1224. {

  1225.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1226.   if (!array || !require_dimensions(array,2) || !require_contiguous(array)

  1227.       || !require_native(array) || !require_fortran(array)) SWIG_fail;

  1228.   $1 = (DATA_TYPE*) array_data(array);

  1229.   $2 = (DIM_TYPE) array_size(array,0);

  1230.   $3 = (DIM_TYPE) array_size(array,1);

  1231. }

  1232. 

  1233. /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)

  1234.  */

  1235. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1236.            fragment="NumPy_Macros")

  1237.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)

  1238. {

  1239.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1240.                                                  DATA_TYPECODE);

  1241. }

  1242. %typemap(in,

  1243.          fragment="NumPy_Fragments")

  1244.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2)

  1245.   (PyArrayObject* array=NULL)

  1246. {

  1247.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1248.   if (!array || !require_dimensions(array,2) || !require_contiguous(array) ||

  1249.       !require_native(array) || !require_fortran(array)) SWIG_fail;

  1250.   $1 = (DIM_TYPE) array_size(array,0);

  1251.   $2 = (DIM_TYPE) array_size(array,1);

  1252.   $3 = (DATA_TYPE*) array_data(array);

  1253. }

  1254. 

  1255. /* Typemap suite for (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])

  1256.  */

  1257. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1258.            fragment="NumPy_Macros")

  1259.   (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])

  1260. {

  1261.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1262.                                                  DATA_TYPECODE);

  1263. }

  1264. %typemap(in,

  1265.          fragment="NumPy_Fragments")

  1266.   (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY])

  1267.   (PyArrayObject* array=NULL)

  1268. {

  1269.   npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 };

  1270.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1271.   if (!array || !require_dimensions(array,3) || !require_size(array, size, 3) ||

  1272.       !require_contiguous(array) || !require_native(array)) SWIG_fail;

  1273.   $1 = ($1_ltype) array_data(array);

  1274. }

  1275. 

  1276. /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,

  1277.  *                    DIM_TYPE DIM3)

  1278.  */

  1279. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1280.            fragment="NumPy_Macros")

  1281.   (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  1282. {

  1283.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1284.                                                  DATA_TYPECODE);

  1285. }

  1286. %typemap(in,

  1287.          fragment="NumPy_Fragments")

  1288.   (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  1289.   (PyArrayObject* array=NULL)

  1290. {

  1291.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1292.   if (!array || !require_dimensions(array,3) || !require_contiguous(array) ||

  1293.       !require_native(array)) SWIG_fail;

  1294.   $1 = (DATA_TYPE*) array_data(array);

  1295.   $2 = (DIM_TYPE) array_size(array,0);

  1296.   $3 = (DIM_TYPE) array_size(array,1);

  1297.   $4 = (DIM_TYPE) array_size(array,2);

  1298. }

  1299. 

  1300. /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,

  1301.  *                    DATA_TYPE* INPLACE_ARRAY3)

  1302.  */

  1303. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1304.            fragment="NumPy_Macros")

  1305.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)

  1306. {

  1307.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1308.                                                  DATA_TYPECODE);

  1309. }

  1310. %typemap(in,

  1311.          fragment="NumPy_Fragments")

  1312.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3)

  1313.   (PyArrayObject* array=NULL)

  1314. {

  1315.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1316.   if (!array || !require_dimensions(array,3) || !require_contiguous(array)

  1317.       || !require_native(array)) SWIG_fail;

  1318.   $1 = (DIM_TYPE) array_size(array,0);

  1319.   $2 = (DIM_TYPE) array_size(array,1);

  1320.   $3 = (DIM_TYPE) array_size(array,2);

  1321.   $4 = (DATA_TYPE*) array_data(array);

  1322. }

  1323. 

  1324. /* Typemap suite for (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2,

  1325.  *                    DIM_TYPE DIM3)

  1326.  */

  1327. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1328.            fragment="NumPy_Macros")

  1329.   (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  1330. {

  1331.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1332.                                                  DATA_TYPECODE);

  1333. }

  1334. %typemap(in,

  1335.          fragment="NumPy_Fragments")

  1336.   (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3)

  1337.   (PyArrayObject* array=NULL)

  1338. {

  1339.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1340.   if (!array || !require_dimensions(array,3) || !require_contiguous(array) ||

  1341.       !require_native(array) || !require_fortran(array)) SWIG_fail;

  1342.   $1 = (DATA_TYPE*) array_data(array);

  1343.   $2 = (DIM_TYPE) array_size(array,0);

  1344.   $3 = (DIM_TYPE) array_size(array,1);

  1345.   $4 = (DIM_TYPE) array_size(array,2);

  1346. }

  1347. 

  1348. /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3,

  1349.  *                    DATA_TYPE* INPLACE_FARRAY3)

  1350.  */

  1351. %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY,

  1352.            fragment="NumPy_Macros")

  1353.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)

  1354. {

  1355.   $1 = is_array($input) && PyArray_EquivTypenums(array_type($input),

  1356.                                                  DATA_TYPECODE);

  1357. }

  1358. %typemap(in,

  1359.          fragment="NumPy_Fragments")

  1360.   (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3)

  1361.   (PyArrayObject* array=NULL)

  1362. {

  1363.   array = obj_to_array_no_conversion($input, DATA_TYPECODE);

  1364.   if (!array || !require_dimensions(array,3) || !require_contiguous(array)

  1365.       || !require_native(array) || !require_fortran(array)) SWIG_fail;

  1366.   $1 = (DIM_TYPE) array_size(array,0);

  1367.   $2 = (DIM_TYPE) array_size(array,1);

  1368.   $3 = (DIM_TYPE) array_size(array,2);

  1369.   $4 = (DATA_TYPE*) array_data(array);

  1370. }

  1371. 

  1372. /*************************/

  1373. /* Argout Array Typemaps */

  1374. /*************************/

  1375. 

  1376. /* Typemap suite for (DATA_TYPE ARGOUT_ARRAY1[ANY])

  1377.  */

  1378. %typemap(in,numinputs=0,

  1379.          fragment="NumPy_Backward_Compatibility,NumPy_Macros")

  1380.   (DATA_TYPE ARGOUT_ARRAY1[ANY])

  1381.   (PyObject * array = NULL)

  1382. {

  1383.   npy_intp dims[1] = { $1_dim0 };

  1384.   array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);

  1385.   if (!array) SWIG_fail;

  1386.   $1 = ($1_ltype) array_data(array);

  1387. }

  1388. %typemap(argout)

  1389.   (DATA_TYPE ARGOUT_ARRAY1[ANY])

  1390. {

  1391.   $result = SWIG_Python_AppendOutput($result,array$argnum);

  1392. }

  1393. 

  1394. /* Typemap suite for (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)

  1395.  */

  1396. %typemap(in,numinputs=1,

  1397.          fragment="NumPy_Fragments")

  1398.   (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)

  1399.   (PyObject * array = NULL)

  1400. {

  1401.   npy_intp dims[1];

  1402.   if (!PyInt_Check($input))

  1403.   {

  1404.     const char* typestring = pytype_string($input);

  1405.     PyErr_Format(PyExc_TypeError,

  1406.                  "Int dimension expected.  '%s' given.",

  1407.                  typestring);

  1408.     SWIG_fail;

  1409.   }

  1410.   $2 = (DIM_TYPE) PyInt_AsLong($input);

  1411.   dims[0] = (npy_intp) $2;

  1412.   array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);

  1413.   if (!array) SWIG_fail;

  1414.   $1 = (DATA_TYPE*) array_data(array);

  1415. }

  1416. %typemap(argout)

  1417.   (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1)

  1418. {

  1419.   $result = SWIG_Python_AppendOutput($result,array$argnum);

  1420. }

  1421. 

  1422. /* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)

  1423.  */

  1424. %typemap(in,numinputs=1,

  1425.          fragment="NumPy_Fragments")

  1426.   (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)

  1427.   (PyObject * array = NULL)

  1428. {

  1429.   npy_intp dims[1];

  1430.   if (!PyInt_Check($input))

  1431.   {

  1432.     const char* typestring = pytype_string($input);

  1433.     PyErr_Format(PyExc_TypeError,

  1434.                  "Int dimension expected.  '%s' given.",

  1435.                  typestring);

  1436.     SWIG_fail;

  1437.   }

  1438.   $1 = (DIM_TYPE) PyInt_AsLong($input);

  1439.   dims[0] = (npy_intp) $1;

  1440.   array = PyArray_SimpleNew(1, dims, DATA_TYPECODE);

  1441.   if (!array) SWIG_fail;

  1442.   $2 = (DATA_TYPE*) array_data(array);

  1443. }

  1444. %typemap(argout)

  1445.   (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1)

  1446. {

  1447.   $result = SWIG_Python_AppendOutput($result,array$argnum);

  1448. }

  1449. 

  1450. /* Typemap suite for (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])

  1451.  */

  1452. %typemap(in,numinputs=0,

  1453.          fragment="NumPy_Backward_Compatibility,NumPy_Macros")

  1454.   (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])

  1455.   (PyObject * array = NULL)

  1456. {

  1457.   npy_intp dims[2] = { $1_dim0, $1_dim1 };

  1458.   array = PyArray_SimpleNew(2, dims, DATA_TYPECODE);

  1459.   if (!array) SWIG_fail;

  1460.   $1 = ($1_ltype) array_data(array);

  1461. }

  1462. %typemap(argout)

  1463.   (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY])

  1464. {

  1465.   $result = SWIG_Python_AppendOutput($result,array$argnum);

  1466. }

  1467. 

  1468. /* Typemap suite for (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])

  1469.  */

  1470. %typemap(in,numinputs=0,

  1471.          fragment="NumPy_Backward_Compatibility,NumPy_Macros")

  1472.   (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])

  1473.   (PyObject * array = NULL)

  1474. {

  1475.   npy_intp dims[3] = { $1_dim0, $1_dim1, $1_dim2 };

  1476.   array = PyArray_SimpleNew(3, dims, DATA_TYPECODE);

  1477.   if (!array) SWIG_fail;

  1478.   $1 = ($1_ltype) array_data(array);

  1479. }

  1480. %typemap(argout)

  1481.   (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY])

  1482. {

  1483.   $result = SWIG_Python_AppendOutput($result,array$argnum);

  1484. }

  1485. 

  1486. /*****************************/

  1487. /* Argoutview Array Typemaps */

  1488. /*****************************/

  1489. 

  1490. /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)

  1491.  */

  1492. %typemap(in,numinputs=0)

  1493.   (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1    )

  1494.   (DATA_TYPE*  data_temp        , DIM_TYPE  dim_temp)

  1495. {

  1496.   $1 = &data_temp;

  1497.   $2 = &dim_temp;

  1498. }

  1499. %typemap(argout,

  1500.          fragment="NumPy_Backward_Compatibility")

  1501.   (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1)

  1502. {

  1503.   npy_intp dims[1] = { *$2 };

  1504.   PyObject * array = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1));

  1505.   if (!array) SWIG_fail;

  1506.   $result = SWIG_Python_AppendOutput($result,array);

  1507. }

  1508. 

  1509. /* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)

  1510.  */

  1511. %typemap(in,numinputs=0)

  1512.   (DIM_TYPE* DIM1    , DATA_TYPE** ARGOUTVIEW_ARRAY1)

  1513.   (DIM_TYPE  dim_temp, DATA_TYPE*  data_temp        )

  1514. {

  1515.   $1 = &dim_temp;

  1516.   $2 = &data_temp;

  1517. }

  1518. %typemap(argout,

  1519.          fragment="NumPy_Backward_Compatibility")

  1520.   (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1)

  1521. {

  1522.   npy_intp dims[1] = { *$1 };

  1523.   PyObject * array = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2));

  1524.   if (!array) SWIG_fail;

  1525.   $result = SWIG_Python_AppendOutput($result,array);

  1526. }

  1527. 

  1528. /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)

  1529.  */

  1530. %typemap(in,numinputs=0)

  1531.   (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1     , DIM_TYPE* DIM2     )

  1532.   (DATA_TYPE*  data_temp        , DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp)

  1533. {

  1534.   $1 = &data_temp;

  1535.   $2 = &dim1_temp;

  1536.   $3 = &dim2_temp;

  1537. }

  1538. %typemap(argout,

  1539.          fragment="NumPy_Backward_Compatibility")

  1540.   (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)

  1541. {

  1542.   npy_intp dims[2] = { *$2, *$3 };

  1543.   PyObject * array = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1));

  1544.   if (!array) SWIG_fail;

  1545.   $result = SWIG_Python_AppendOutput($result,array);

  1546. }

  1547. 

  1548. /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)

  1549.  */

  1550. %typemap(in,numinputs=0)

  1551.   (DIM_TYPE* DIM1     , DIM_TYPE* DIM2     , DATA_TYPE** ARGOUTVIEW_ARRAY2)

  1552.   (DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp, DATA_TYPE*  data_temp        )

  1553. {

  1554.   $1 = &dim1_temp;

  1555.   $2 = &dim2_temp;

  1556.   $3 = &data_temp;

  1557. }

  1558. %typemap(argout,

  1559.          fragment="NumPy_Backward_Compatibility")

  1560.   (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2)

  1561. {

  1562.   npy_intp dims[2] = { *$1, *$2 };

  1563.   PyObject * array = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3));

  1564.   if (!array) SWIG_fail;

  1565.   $result = SWIG_Python_AppendOutput($result,array);

  1566. }

  1567. 

  1568. /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)

  1569.  */

  1570. %typemap(in,numinputs=0)

  1571.   (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1     , DIM_TYPE* DIM2     )

  1572.   (DATA_TYPE*  data_temp        , DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp)

  1573. {

  1574.   $1 = &data_temp;

  1575.   $2 = &dim1_temp;

  1576.   $3 = &dim2_temp;

  1577. }

  1578. %typemap(argout,

  1579.          fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")

  1580.   (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2)

  1581. {

  1582.   npy_intp dims[2] = { *$2, *$3 };

  1583.   PyObject * obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1));

  1584.   PyArrayObject * array = (PyArrayObject*) obj;

  1585.   if (!array || !require_fortran(array)) SWIG_fail;

  1586.   $result = SWIG_Python_AppendOutput($result,obj);

  1587. }

  1588. 

  1589. /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)

  1590.  */

  1591. %typemap(in,numinputs=0)

  1592.   (DIM_TYPE* DIM1     , DIM_TYPE* DIM2     , DATA_TYPE** ARGOUTVIEW_FARRAY2)

  1593.   (DIM_TYPE  dim1_temp, DIM_TYPE  dim2_temp, DATA_TYPE*  data_temp        )

  1594. {

  1595.   $1 = &dim1_temp;

  1596.   $2 = &dim2_temp;

  1597.   $3 = &data_temp;

  1598. }

  1599. %typemap(argout,

  1600.          fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")

  1601.   (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2)

  1602. {

  1603.   npy_intp dims[2] = { *$1, *$2 };

  1604.   PyObject * obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3));

  1605.   PyArrayObject * array = (PyArrayObject*) obj;

  1606.   if (!array || !require_fortran(array)) SWIG_fail;

  1607.   $result = SWIG_Python_AppendOutput($result,obj);

  1608. }

  1609. 

  1610. /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2,

  1611.                       DIM_TYPE* DIM3)

  1612.  */

  1613. %typemap(in,numinputs=0)

  1614.   (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)

  1615.   (DATA_TYPE* data_temp, DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp)

  1616. {

  1617.   $1 = &data_temp;

  1618.   $2 = &dim1_temp;

  1619.   $3 = &dim2_temp;

  1620.   $4 = &dim3_temp;

  1621. }

  1622. %typemap(argout,

  1623.          fragment="NumPy_Backward_Compatibility")

  1624.   (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)

  1625. {

  1626.   npy_intp dims[3] = { *$2, *$3, *$4 };

  1627.   PyObject * array = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1));

  1628.   if (!array) SWIG_fail;

  1629.   $result = SWIG_Python_AppendOutput($result,array);

  1630. }

  1631. 

  1632. /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3,

  1633.                       DATA_TYPE** ARGOUTVIEW_ARRAY3)

  1634.  */

  1635. %typemap(in,numinputs=0)

  1636.   (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)

  1637.   (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp)

  1638. {

  1639.   $1 = &dim1_temp;

  1640.   $2 = &dim2_temp;

  1641.   $3 = &dim3_temp;

  1642.   $4 = &data_temp;

  1643. }

  1644. %typemap(argout,

  1645.          fragment="NumPy_Backward_Compatibility")

  1646.   (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3)

  1647. {

  1648.   npy_intp dims[3] = { *$1, *$2, *$3 };

  1649.   PyObject * array = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$3));

  1650.   if (!array) SWIG_fail;

  1651.   $result = SWIG_Python_AppendOutput($result,array);

  1652. }

  1653. 

  1654. /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2,

  1655.                       DIM_TYPE* DIM3)

  1656.  */

  1657. %typemap(in,numinputs=0)

  1658.   (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)

  1659.   (DATA_TYPE* data_temp, DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp)

  1660. {

  1661.   $1 = &data_temp;

  1662.   $2 = &dim1_temp;

  1663.   $3 = &dim2_temp;

  1664.   $4 = &dim3_temp;

  1665. }

  1666. %typemap(argout,

  1667.          fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")

  1668.   (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3)

  1669. {

  1670.   npy_intp dims[3] = { *$2, *$3, *$4 };

  1671.   PyObject * obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1));

  1672.   PyArrayObject * array = (PyArrayObject*) obj;

  1673.   if (!array || require_fortran(array)) SWIG_fail;

  1674.   $result = SWIG_Python_AppendOutput($result,obj);

  1675. }

  1676. 

  1677. /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3,

  1678.                       DATA_TYPE** ARGOUTVIEW_FARRAY3)

  1679.  */

  1680. %typemap(in,numinputs=0)

  1681.   (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3)

  1682.   (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp)

  1683. {

  1684.   $1 = &dim1_temp;

  1685.   $2 = &dim2_temp;

  1686.   $3 = &dim3_temp;

  1687.   $4 = &data_temp;

  1688. }

  1689. %typemap(argout,

  1690.          fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements")

  1691.   (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3)

  1692. {

  1693.   npy_intp dims[3] = { *$1, *$2, *$3 };

  1694.   PyObject * obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$3));

  1695.   PyArrayObject * array = (PyArrayObject*) obj;

  1696.   if (!array || require_fortran(array)) SWIG_fail;

  1697.   $result = SWIG_Python_AppendOutput($result,obj);

  1698. }

  1699. 

  1700. %enddef    /* %numpy_typemaps() macro */

  1701. /* *************************************************************** */

  1702. 

  1703. /* Concrete instances of the %numpy_typemaps() macro: Each invocation

  1704.  * below applies all of the typemaps above to the specified data type.

  1705.  */

  1706. %numpy_typemaps(signed char       , NPY_BYTE     , int)

  1707. %numpy_typemaps(unsigned char     , NPY_UBYTE    , int)

  1708. %numpy_typemaps(short             , NPY_SHORT    , int)

  1709. %numpy_typemaps(unsigned short    , NPY_USHORT   , int)

  1710. %numpy_typemaps(int               , NPY_INT      , int)

  1711. %numpy_typemaps(unsigned int      , NPY_UINT     , int)

  1712. %numpy_typemaps(long              , NPY_LONG     , int)

  1713. %numpy_typemaps(unsigned long     , NPY_ULONG    , int)

  1714. %numpy_typemaps(long long         , NPY_LONGLONG , int)

  1715. %numpy_typemaps(unsigned long long, NPY_ULONGLONG, int)

  1716. %numpy_typemaps(float             , NPY_FLOAT    , int)

  1717. %numpy_typemaps(double            , NPY_DOUBLE   , int)

  1718. 

  1719. /* ***************************************************************

  1720.  * The follow macro expansion does not work, because C++ bool is 4

  1721.  * bytes and NPY_BOOL is 1 byte

  1722.  *

  1723.  *    %numpy_typemaps(bool, NPY_BOOL, int)

  1724.  */

  1725. 

  1726. /* ***************************************************************

  1727.  * On my Mac, I get the following warning for this macro expansion:

  1728.  * 'swig/python detected a memory leak of type 'long double *', no destructor found.'

  1729.  *

  1730.  *    %numpy_typemaps(long double, NPY_LONGDOUBLE, int)

  1731.  */

  1732. 

  1733. /* ***************************************************************

  1734.  * Swig complains about a syntax error for the following macro

  1735.  * expansions:

  1736.  *

  1737.  *    %numpy_typemaps(complex float,  NPY_CFLOAT , int)

  1738.  *

  1739.  *    %numpy_typemaps(complex double, NPY_CDOUBLE, int)

  1740.  *

  1741.  *    %numpy_typemaps(complex long double, NPY_CLONGDOUBLE, int)

  1742.  */

  1743. 

  1744. #endif /* SWIGPYTHON */