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 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION 10 #include <numpy/arrayobject.h> 11 %} 12 13 /**********************************************************************/ 14 15 %fragment("NumPy_Backward_Compatibility", "header") 16 { 17 %#if NPY_API_VERSION < 0x00000007 18 %#define NPY_ARRAY_DEFAULT NPY_DEFAULT 19 %#define NPY_ARRAY_FARRAY NPY_FARRAY 20 %#define NPY_FORTRANORDER NPY_FORTRAN 21 %#endif 22 } 23 24 /**********************************************************************/ 25 26 /* The following code originally appeared in 27 * enthought/kiva/agg/src/numeric.i written by Eric Jones. It was 28 * translated from C++ to C by John Hunter. Bill Spotz has modified 29 * it to fix some minor bugs, upgrade from Numeric to numpy (all 30 * versions), add some comments and functionality, and convert from 31 * direct code insertion to SWIG fragments. 32 */ 33 34 %fragment("NumPy_Macros", "header") 35 { 36 /* Macros to extract array attributes. 37 */ 38 %#if NPY_API_VERSION < 0x00000007 39 %#define is_array(a) ((a) && PyArray_Check((PyArrayObject*)a)) 40 %#define array_type(a) (int)(PyArray_TYPE((PyArrayObject*)a)) 41 %#define array_numdims(a) (((PyArrayObject*)a)->nd) 42 %#define array_dimensions(a) (((PyArrayObject*)a)->dimensions) 43 %#define array_size(a,i) (((PyArrayObject*)a)->dimensions[i]) 44 %#define array_strides(a) (((PyArrayObject*)a)->strides) 45 %#define array_stride(a,i) (((PyArrayObject*)a)->strides[i]) 46 %#define array_data(a) (((PyArrayObject*)a)->data) 47 %#define array_descr(a) (((PyArrayObject*)a)->descr) 48 %#define array_flags(a) (((PyArrayObject*)a)->flags) 49 %#define array_enableflags(a,f) (((PyArrayObject*)a)->flags) = f 50 %#else 51 %#define is_array(a) ((a) && PyArray_Check(a)) 52 %#define array_type(a) PyArray_TYPE((PyArrayObject*)a) 53 %#define array_numdims(a) PyArray_NDIM((PyArrayObject*)a) 54 %#define array_dimensions(a) PyArray_DIMS((PyArrayObject*)a) 55 %#define array_strides(a) PyArray_STRIDES((PyArrayObject*)a) 56 %#define array_stride(a,i) PyArray_STRIDE((PyArrayObject*)a,i) 57 %#define array_size(a,i) PyArray_DIM((PyArrayObject*)a,i) 58 %#define array_data(a) PyArray_DATA((PyArrayObject*)a) 59 %#define array_descr(a) PyArray_DESCR((PyArrayObject*)a) 60 %#define array_flags(a) PyArray_FLAGS((PyArrayObject*)a) 61 %#define array_enableflags(a,f) PyArray_ENABLEFLAGS((PyArrayObject*)a,f) 62 %#endif 63 %#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS((PyArrayObject*)a)) 64 %#define array_is_native(a) (PyArray_ISNOTSWAPPED((PyArrayObject*)a)) 65 %#define array_is_fortran(a) (PyArray_ISFORTRAN((PyArrayObject*)a)) 66 } 67 68 /**********************************************************************/ 69 70 %fragment("NumPy_Utilities", 71 "header") 72 { 73 /* Given a PyObject, return a string describing its type. 74 */ 75 const char* pytype_string(PyObject* py_obj) 76 { 77 if (py_obj == NULL ) return "C NULL value"; 78 if (py_obj == Py_None ) return "Python None" ; 79 if (PyCallable_Check(py_obj)) return "callable" ; 80 if (PyString_Check( py_obj)) return "string" ; 81 if (PyInt_Check( py_obj)) return "int" ; 82 if (PyFloat_Check( py_obj)) return "float" ; 83 if (PyDict_Check( py_obj)) return "dict" ; 84 if (PyList_Check( py_obj)) return "list" ; 85 if (PyTuple_Check( py_obj)) return "tuple" ; 86 %#if PY_MAJOR_VERSION < 3 87 if (PyFile_Check( py_obj)) return "file" ; 88 if (PyModule_Check( py_obj)) return "module" ; 89 if (PyInstance_Check(py_obj)) return "instance" ; 90 %#endif 91 92 return "unkown type"; 93 } 94 95 /* Given a NumPy typecode, return a string describing the type. 96 */ 97 const char* typecode_string(int typecode) 98 { 99 static const char* type_names[25] = {"bool", 100 "byte", 101 "unsigned byte", 102 "short", 103 "unsigned short", 104 "int", 105 "unsigned int", 106 "long", 107 "unsigned long", 108 "long long", 109 "unsigned long long", 110 "float", 111 "double", 112 "long double", 113 "complex float", 114 "complex double", 115 "complex long double", 116 "object", 117 "string", 118 "unicode", 119 "void", 120 "ntypes", 121 "notype", 122 "char", 123 "unknown"}; 124 return typecode < 24 ? type_names[typecode] : type_names[24]; 125 } 126 127 /* Make sure input has correct numpy type. This now just calls 128 PyArray_EquivTypenums(). 129 */ 130 int type_match(int actual_type, 131 int desired_type) 132 { 133 return PyArray_EquivTypenums(actual_type, desired_type); 134 } 135 136 %#ifdef SWIGPY_USE_CAPSULE 137 void free_cap(PyObject * cap) 138 { 139 void* array = (void*) PyCapsule_GetPointer(cap,SWIGPY_CAPSULE_NAME); 140 if (array != NULL) free(array); 141 } 142 %#endif 143 144 145 } 146 147 /**********************************************************************/ 148 149 %fragment("NumPy_Object_to_Array", 150 "header", 151 fragment="NumPy_Backward_Compatibility", 152 fragment="NumPy_Macros", 153 fragment="NumPy_Utilities") 154 { 155 /* Given a PyObject pointer, cast it to a PyArrayObject pointer if 156 * legal. If not, set the python error string appropriately and 157 * return NULL. 158 */ 159 PyArrayObject* obj_to_array_no_conversion(PyObject* input, 160 int typecode) 161 { 162 PyArrayObject* ary = NULL; 163 if (is_array(input) && (typecode == NPY_NOTYPE || 164 PyArray_EquivTypenums(array_type(input), typecode))) 165 { 166 ary = (PyArrayObject*) input; 167 } 168 else if is_array(input) 169 { 170 const char* desired_type = typecode_string(typecode); 171 const char* actual_type = typecode_string(array_type(input)); 172 PyErr_Format(PyExc_TypeError, 173 "Array of type '%s' required. Array of type '%s' given", 174 desired_type, actual_type); 175 ary = NULL; 176 } 177 else 178 { 179 const char* desired_type = typecode_string(typecode); 180 const char* actual_type = pytype_string(input); 181 PyErr_Format(PyExc_TypeError, 182 "Array of type '%s' required. A '%s' was given", 183 desired_type, 184 actual_type); 185 ary = NULL; 186 } 187 return ary; 188 } 189 190 /* Convert the given PyObject to a NumPy array with the given 191 * typecode. On success, return a valid PyArrayObject* with the 192 * correct type. On failure, the python error string will be set and 193 * the routine returns NULL. 194 */ 195 PyArrayObject* obj_to_array_allow_conversion(PyObject* input, 196 int typecode, 197 int* is_new_object) 198 { 199 PyArrayObject* ary = NULL; 200 PyObject* py_obj; 201 if (is_array(input) && (typecode == NPY_NOTYPE || 202 PyArray_EquivTypenums(array_type(input),typecode))) 203 { 204 ary = (PyArrayObject*) input; 205 *is_new_object = 0; 206 } 207 else 208 { 209 py_obj = PyArray_FROMANY(input, typecode, 0, 0, NPY_ARRAY_DEFAULT); 210 /* If NULL, PyArray_FromObject will have set python error value.*/ 211 ary = (PyArrayObject*) py_obj; 212 *is_new_object = 1; 213 } 214 return ary; 215 } 216 217 /* Given a PyArrayObject, check to see if it is contiguous. If so, 218 * return the input pointer and flag it as not a new object. If it is 219 * not contiguous, create a new PyArrayObject using the original data, 220 * flag it as a new object and return the pointer. 221 */ 222 PyArrayObject* make_contiguous(PyArrayObject* ary, 223 int* is_new_object, 224 int min_dims, 225 int max_dims) 226 { 227 PyArrayObject* result; 228 if (array_is_contiguous(ary)) 229 { 230 result = ary; 231 *is_new_object = 0; 232 } 233 else 234 { 235 result = (PyArrayObject*) PyArray_ContiguousFromObject((PyObject*)ary, 236 array_type(ary), 237 min_dims, 238 max_dims); 239 *is_new_object = 1; 240 } 241 return result; 242 } 243 244 /* Given a PyArrayObject, check to see if it is Fortran-contiguous. 245 * If so, return the input pointer, but do not flag it as not a new 246 * object. If it is not Fortran-contiguous, create a new 247 * PyArrayObject using the original data, flag it as a new object 248 * and return the pointer. 249 */ 250 PyArrayObject* make_fortran(PyArrayObject* ary, 251 int* is_new_object) 252 { 253 PyArrayObject* result; 254 if (array_is_fortran(ary)) 255 { 256 result = ary; 257 *is_new_object = 0; 258 } 259 else 260 { 261 Py_INCREF(array_descr(ary)); 262 result = (PyArrayObject*) PyArray_FromArray(ary, 263 array_descr(ary), 264 NPY_FORTRANORDER); 265 *is_new_object = 1; 266 } 267 return result; 268 } 269 270 /* Convert a given PyObject to a contiguous PyArrayObject of the 271 * specified type. If the input object is not a contiguous 272 * PyArrayObject, a new one will be created and the new object flag 273 * will be set. 274 */ 275 PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input, 276 int typecode, 277 int* is_new_object) 278 { 279 int is_new1 = 0; 280 int is_new2 = 0; 281 PyArrayObject* ary2; 282 PyArrayObject* ary1 = obj_to_array_allow_conversion(input, 283 typecode, 284 &is_new1); 285 if (ary1) 286 { 287 ary2 = make_contiguous(ary1, &is_new2, 0, 0); 288 if ( is_new1 && is_new2) 289 { 290 Py_DECREF(ary1); 291 } 292 ary1 = ary2; 293 } 294 *is_new_object = is_new1 || is_new2; 295 return ary1; 296 } 297 298 /* Convert a given PyObject to a Fortran-ordered PyArrayObject of the 299 * specified type. If the input object is not a Fortran-ordered 300 * PyArrayObject, a new one will be created and the new object flag 301 * will be set. 302 */ 303 PyArrayObject* obj_to_array_fortran_allow_conversion(PyObject* input, 304 int typecode, 305 int* is_new_object) 306 { 307 int is_new1 = 0; 308 int is_new2 = 0; 309 PyArrayObject* ary2; 310 PyArrayObject* ary1 = obj_to_array_allow_conversion(input, 311 typecode, 312 &is_new1); 313 if (ary1) 314 { 315 ary2 = make_fortran(ary1, &is_new2); 316 if (is_new1 && is_new2) 317 { 318 Py_DECREF(ary1); 319 } 320 ary1 = ary2; 321 } 322 *is_new_object = is_new1 || is_new2; 323 return ary1; 324 } 325 } /* end fragment */ 326 327 /**********************************************************************/ 328 329 %fragment("NumPy_Array_Requirements", 330 "header", 331 fragment="NumPy_Backward_Compatibility", 332 fragment="NumPy_Macros") 333 { 334 /* Test whether a python object is contiguous. If array is 335 * contiguous, return 1. Otherwise, set the python error string and 336 * return 0. 337 */ 338 int require_contiguous(PyArrayObject* ary) 339 { 340 int contiguous = 1; 341 if (!array_is_contiguous(ary)) 342 { 343 PyErr_SetString(PyExc_TypeError, 344 "Array must be contiguous. A non-contiguous array was given"); 345 contiguous = 0; 346 } 347 return contiguous; 348 } 349 350 /* Require that a numpy array is not byte-swapped. If the array is 351 * not byte-swapped, return 1. Otherwise, set the python error string 352 * and return 0. 353 */ 354 int require_native(PyArrayObject* ary) 355 { 356 int native = 1; 357 if (!array_is_native(ary)) 358 { 359 PyErr_SetString(PyExc_TypeError, 360 "Array must have native byteorder. " 361 "A byte-swapped array was given"); 362 native = 0; 363 } 364 return native; 365 } 366 367 /* Require the given PyArrayObject to have a specified number of 368 * dimensions. If the array has the specified number of dimensions, 369 * return 1. Otherwise, set the python error string and return 0. 370 */ 371 int require_dimensions(PyArrayObject* ary, 372 int exact_dimensions) 373 { 374 int success = 1; 375 if (array_numdims(ary) != exact_dimensions) 376 { 377 PyErr_Format(PyExc_TypeError, 378 "Array must have %d dimensions. Given array has %d dimensions", 379 exact_dimensions, 380 array_numdims(ary)); 381 success = 0; 382 } 383 return success; 384 } 385 386 /* Require the given PyArrayObject to have one of a list of specified 387 * number of dimensions. If the array has one of the specified number 388 * of dimensions, return 1. Otherwise, set the python error string 389 * and return 0. 390 */ 391 int require_dimensions_n(PyArrayObject* ary, 392 int* exact_dimensions, 393 int n) 394 { 395 int success = 0; 396 int i; 397 char dims_str[255] = ""; 398 char s[255]; 399 for (i = 0; i < n && !success; i++) 400 { 401 if (array_numdims(ary) == exact_dimensions[i]) 402 { 403 success = 1; 404 } 405 } 406 if (!success) 407 { 408 for (i = 0; i < n-1; i++) 409 { 410 sprintf(s, "%d, ", exact_dimensions[i]); 411 strcat(dims_str,s); 412 } 413 sprintf(s, " or %d", exact_dimensions[n-1]); 414 strcat(dims_str,s); 415 PyErr_Format(PyExc_TypeError, 416 "Array must have %s dimensions. Given array has %d dimensions", 417 dims_str, 418 array_numdims(ary)); 419 } 420 return success; 421 } 422 423 /* Require the given PyArrayObject to have a specified shape. If the 424 * array has the specified shape, return 1. Otherwise, set the python 425 * error string and return 0. 426 */ 427 int require_size(PyArrayObject* ary, 428 npy_intp* size, 429 int n) 430 { 431 int i; 432 int success = 1; 433 int len; 434 char desired_dims[255] = "["; 435 char s[255]; 436 char actual_dims[255] = "["; 437 for(i=0; i < n;i++) 438 { 439 if (size[i] != -1 && size[i] != array_size(ary,i)) 440 { 441 success = 0; 442 } 443 } 444 if (!success) 445 { 446 for (i = 0; i < n; i++) 447 { 448 if (size[i] == -1) 449 { 450 sprintf(s, "*,"); 451 } 452 else 453 { 454 sprintf(s, "%ld,", (long int)size[i]); 455 } 456 strcat(desired_dims,s); 457 } 458 len = strlen(desired_dims); 459 desired_dims[len-1] = ']'; 460 for (i = 0; i < n; i++) 461 { 462 sprintf(s, "%ld,", (long int)array_size(ary,i)); 463 strcat(actual_dims,s); 464 } 465 len = strlen(actual_dims); 466 actual_dims[len-1] = ']'; 467 PyErr_Format(PyExc_TypeError, 468 "Array must have shape of %s. Given array has shape of %s", 469 desired_dims, 470 actual_dims); 471 } 472 return success; 473 } 474 475 /* Require the given PyArrayObject to to be Fortran ordered. If the 476 * the PyArrayObject is already Fortran ordered, do nothing. Else, 477 * set the Fortran ordering flag and recompute the strides. 478 */ 479 int require_fortran(PyArrayObject* ary) 480 { 481 int success = 1; 482 int nd = array_numdims(ary); 483 int i; 484 npy_intp * strides = array_strides(ary); 485 if (array_is_fortran(ary)) return success; 486 /* Set the Fortran ordered flag */ 487 array_enableflags(ary,NPY_ARRAY_FARRAY); 488 /* Recompute the strides */ 489 strides[0] = strides[nd-1]; 490 for (i=1; i < nd; ++i) 491 strides[i] = strides[i-1] * array_size(ary,i-1); 492 return success; 493 } 494 } 495 496 /* Combine all NumPy fragments into one for convenience */ 497 %fragment("NumPy_Fragments", 498 "header", 499 fragment="NumPy_Backward_Compatibility", 500 fragment="NumPy_Macros", 501 fragment="NumPy_Utilities", 502 fragment="NumPy_Object_to_Array", 503 fragment="NumPy_Array_Requirements") 504 { 505 } 506 507 /* End John Hunter translation (with modifications by Bill Spotz) 508 */ 509 510 /* %numpy_typemaps() macro 511 * 512 * This macro defines a family of 74 typemaps that allow C arguments 513 * of the form 514 * 515 * 1. (DATA_TYPE IN_ARRAY1[ANY]) 516 * 2. (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) 517 * 3. (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) 518 * 519 * 4. (DATA_TYPE IN_ARRAY2[ANY][ANY]) 520 * 5. (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 521 * 6. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) 522 * 7. (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 523 * 8. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) 524 * 525 * 9. (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) 526 * 10. (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 527 * 11. (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 528 * 12. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) 529 * 13. (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 530 * 14. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) 531 * 532 * 15. (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) 533 * 16. (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 534 * 17. (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 535 * 18. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, , DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) 536 * 19. (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 537 * 20. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) 538 * 539 * 21. (DATA_TYPE INPLACE_ARRAY1[ANY]) 540 * 22. (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) 541 * 23. (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) 542 * 543 * 24. (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) 544 * 25. (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 545 * 26. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) 546 * 27. (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 547 * 28. (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) 548 * 549 * 29. (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) 550 * 30. (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 551 * 31. (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 552 * 32. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) 553 * 33. (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 554 * 34. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) 555 * 556 * 35. (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) 557 * 36. (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 558 * 37. (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 559 * 38. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4) 560 * 39. (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 561 * 40. (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4) 562 * 563 * 41. (DATA_TYPE ARGOUT_ARRAY1[ANY]) 564 * 42. (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) 565 * 43. (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) 566 * 567 * 44. (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) 568 * 569 * 45. (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) 570 * 571 * 46. (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) 572 * 573 * 47. (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) 574 * 48. (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) 575 * 576 * 49. (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 577 * 50. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) 578 * 51. (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 579 * 52. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) 580 * 581 * 53. (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) 582 * 54. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) 583 * 55. (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) 584 * 56. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3) 585 * 586 * 57. (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) 587 * 58. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_ARRAY4) 588 * 59. (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) 589 * 60. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_FARRAY4) 590 * 591 * 61. (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1) 592 * 62. (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1) 593 * 594 * 63. (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 595 * 64. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2) 596 * 65. (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 597 * 66. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2) 598 * 599 * 67. (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) 600 * 68. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_ARRAY3) 601 * 69. (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) 602 * 70. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_FARRAY3) 603 * 604 * 71. (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) 605 * 72. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4) 606 * 73. (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) 607 * 74. (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4) 608 * 609 * where "DATA_TYPE" is any type supported by the NumPy module, and 610 * "DIM_TYPE" is any int-like type suitable for specifying dimensions. 611 * The difference between "ARRAY" typemaps and "FARRAY" typemaps is 612 * that the "FARRAY" typemaps expect Fortran ordering of 613 * multidimensional arrays. In python, the dimensions will not need 614 * to be specified (except for the "DATA_TYPE* ARGOUT_ARRAY1" 615 * typemaps). The IN_ARRAYs can be a numpy array or any sequence that 616 * can be converted to a numpy array of the specified type. The 617 * INPLACE_ARRAYs must be numpy arrays of the appropriate type. The 618 * ARGOUT_ARRAYs will be returned as new numpy arrays of the 619 * appropriate type. 620 * 621 * These typemaps can be applied to existing functions using the 622 * %apply directive. For example: 623 * 624 * %apply (double* IN_ARRAY1, int DIM1) {(double* series, int length)}; 625 * double prod(double* series, int length); 626 * 627 * %apply (int DIM1, int DIM2, double* INPLACE_ARRAY2) 628 * {(int rows, int cols, double* matrix )}; 629 * void floor(int rows, int cols, double* matrix, double f); 630 * 631 * %apply (double IN_ARRAY3[ANY][ANY][ANY]) 632 * {(double tensor[2][2][2] )}; 633 * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY]) 634 * {(double low[2][2][2] )}; 635 * %apply (double ARGOUT_ARRAY3[ANY][ANY][ANY]) 636 * {(double upp[2][2][2] )}; 637 * void luSplit(double tensor[2][2][2], 638 * double low[2][2][2], 639 * double upp[2][2][2] ); 640 * 641 * or directly with 642 * 643 * double prod(double* IN_ARRAY1, int DIM1); 644 * 645 * void floor(int DIM1, int DIM2, double* INPLACE_ARRAY2, double f); 646 * 647 * void luSplit(double IN_ARRAY3[ANY][ANY][ANY], 648 * double ARGOUT_ARRAY3[ANY][ANY][ANY], 649 * double ARGOUT_ARRAY3[ANY][ANY][ANY]); 650 */ 651 652 %define %numpy_typemaps(DATA_TYPE, DATA_TYPECODE, DIM_TYPE) 653 654 /************************/ 655 /* Input Array Typemaps */ 656 /************************/ 657 658 /* Typemap suite for (DATA_TYPE IN_ARRAY1[ANY]) 659 */ 660 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 661 fragment="NumPy_Macros") 662 (DATA_TYPE IN_ARRAY1[ANY]) 663 { 664 $1 = is_array($input) || PySequence_Check($input); 665 } 666 %typemap(in, 667 fragment="NumPy_Fragments") 668 (DATA_TYPE IN_ARRAY1[ANY]) 669 (PyArrayObject* array=NULL, int is_new_object=0) 670 { 671 npy_intp size[1] = { $1_dim0 }; 672 array = obj_to_array_contiguous_allow_conversion($input, 673 DATA_TYPECODE, 674 &is_new_object); 675 if (!array || !require_dimensions(array, 1) || 676 !require_size(array, size, 1)) SWIG_fail; 677 $1 = ($1_ltype) array_data(array); 678 } 679 %typemap(freearg) 680 (DATA_TYPE IN_ARRAY1[ANY]) 681 { 682 if (is_new_object$argnum && array$argnum) 683 { Py_DECREF(array$argnum); } 684 } 685 686 /* Typemap suite for (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) 687 */ 688 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 689 fragment="NumPy_Macros") 690 (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) 691 { 692 $1 = is_array($input) || PySequence_Check($input); 693 } 694 %typemap(in, 695 fragment="NumPy_Fragments") 696 (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) 697 (PyArrayObject* array=NULL, int is_new_object=0) 698 { 699 npy_intp size[1] = { -1 }; 700 array = obj_to_array_contiguous_allow_conversion($input, 701 DATA_TYPECODE, 702 &is_new_object); 703 if (!array || !require_dimensions(array, 1) || 704 !require_size(array, size, 1)) SWIG_fail; 705 $1 = (DATA_TYPE*) array_data(array); 706 $2 = (DIM_TYPE) array_size(array,0); 707 } 708 %typemap(freearg) 709 (DATA_TYPE* IN_ARRAY1, DIM_TYPE DIM1) 710 { 711 if (is_new_object$argnum && array$argnum) 712 { Py_DECREF(array$argnum); } 713 } 714 715 /* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) 716 */ 717 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 718 fragment="NumPy_Macros") 719 (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) 720 { 721 $1 = is_array($input) || PySequence_Check($input); 722 } 723 %typemap(in, 724 fragment="NumPy_Fragments") 725 (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) 726 (PyArrayObject* array=NULL, int is_new_object=0) 727 { 728 npy_intp size[1] = {-1}; 729 array = obj_to_array_contiguous_allow_conversion($input, 730 DATA_TYPECODE, 731 &is_new_object); 732 if (!array || !require_dimensions(array, 1) || 733 !require_size(array, size, 1)) SWIG_fail; 734 $1 = (DIM_TYPE) array_size(array,0); 735 $2 = (DATA_TYPE*) array_data(array); 736 } 737 %typemap(freearg) 738 (DIM_TYPE DIM1, DATA_TYPE* IN_ARRAY1) 739 { 740 if (is_new_object$argnum && array$argnum) 741 { Py_DECREF(array$argnum); } 742 } 743 744 /* Typemap suite for (DATA_TYPE IN_ARRAY2[ANY][ANY]) 745 */ 746 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 747 fragment="NumPy_Macros") 748 (DATA_TYPE IN_ARRAY2[ANY][ANY]) 749 { 750 $1 = is_array($input) || PySequence_Check($input); 751 } 752 %typemap(in, 753 fragment="NumPy_Fragments") 754 (DATA_TYPE IN_ARRAY2[ANY][ANY]) 755 (PyArrayObject* array=NULL, int is_new_object=0) 756 { 757 npy_intp size[2] = { $1_dim0, $1_dim1 }; 758 array = obj_to_array_contiguous_allow_conversion($input, 759 DATA_TYPECODE, 760 &is_new_object); 761 if (!array || !require_dimensions(array, 2) || 762 !require_size(array, size, 2)) SWIG_fail; 763 $1 = ($1_ltype) array_data(array); 764 } 765 %typemap(freearg) 766 (DATA_TYPE IN_ARRAY2[ANY][ANY]) 767 { 768 if (is_new_object$argnum && array$argnum) 769 { Py_DECREF(array$argnum); } 770 } 771 772 /* Typemap suite for (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 773 */ 774 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 775 fragment="NumPy_Macros") 776 (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 777 { 778 $1 = is_array($input) || PySequence_Check($input); 779 } 780 %typemap(in, 781 fragment="NumPy_Fragments") 782 (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 783 (PyArrayObject* array=NULL, int is_new_object=0) 784 { 785 npy_intp size[2] = { -1, -1 }; 786 array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, 787 &is_new_object); 788 if (!array || !require_dimensions(array, 2) || 789 !require_size(array, size, 2)) SWIG_fail; 790 $1 = (DATA_TYPE*) array_data(array); 791 $2 = (DIM_TYPE) array_size(array,0); 792 $3 = (DIM_TYPE) array_size(array,1); 793 } 794 %typemap(freearg) 795 (DATA_TYPE* IN_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 796 { 797 if (is_new_object$argnum && array$argnum) 798 { Py_DECREF(array$argnum); } 799 } 800 801 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) 802 */ 803 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 804 fragment="NumPy_Macros") 805 (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) 806 { 807 $1 = is_array($input) || PySequence_Check($input); 808 } 809 %typemap(in, 810 fragment="NumPy_Fragments") 811 (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) 812 (PyArrayObject* array=NULL, int is_new_object=0) 813 { 814 npy_intp size[2] = { -1, -1 }; 815 array = obj_to_array_contiguous_allow_conversion($input, 816 DATA_TYPECODE, 817 &is_new_object); 818 if (!array || !require_dimensions(array, 2) || 819 !require_size(array, size, 2)) SWIG_fail; 820 $1 = (DIM_TYPE) array_size(array,0); 821 $2 = (DIM_TYPE) array_size(array,1); 822 $3 = (DATA_TYPE*) array_data(array); 823 } 824 %typemap(freearg) 825 (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_ARRAY2) 826 { 827 if (is_new_object$argnum && array$argnum) 828 { Py_DECREF(array$argnum); } 829 } 830 831 /* Typemap suite for (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 832 */ 833 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 834 fragment="NumPy_Macros") 835 (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 836 { 837 $1 = is_array($input) || PySequence_Check($input); 838 } 839 %typemap(in, 840 fragment="NumPy_Fragments") 841 (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 842 (PyArrayObject* array=NULL, int is_new_object=0) 843 { 844 npy_intp size[2] = { -1, -1 }; 845 array = obj_to_array_fortran_allow_conversion($input, 846 DATA_TYPECODE, 847 &is_new_object); 848 if (!array || !require_dimensions(array, 2) || 849 !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail; 850 $1 = (DATA_TYPE*) array_data(array); 851 $2 = (DIM_TYPE) array_size(array,0); 852 $3 = (DIM_TYPE) array_size(array,1); 853 } 854 %typemap(freearg) 855 (DATA_TYPE* IN_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 856 { 857 if (is_new_object$argnum && array$argnum) 858 { Py_DECREF(array$argnum); } 859 } 860 861 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) 862 */ 863 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 864 fragment="NumPy_Macros") 865 (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) 866 { 867 $1 = is_array($input) || PySequence_Check($input); 868 } 869 %typemap(in, 870 fragment="NumPy_Fragments") 871 (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) 872 (PyArrayObject* array=NULL, int is_new_object=0) 873 { 874 npy_intp size[2] = { -1, -1 }; 875 array = obj_to_array_contiguous_allow_conversion($input, 876 DATA_TYPECODE, 877 &is_new_object); 878 if (!array || !require_dimensions(array, 2) || 879 !require_size(array, size, 2) || !require_fortran(array)) SWIG_fail; 880 $1 = (DIM_TYPE) array_size(array,0); 881 $2 = (DIM_TYPE) array_size(array,1); 882 $3 = (DATA_TYPE*) array_data(array); 883 } 884 %typemap(freearg) 885 (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* IN_FARRAY2) 886 { 887 if (is_new_object$argnum && array$argnum) 888 { Py_DECREF(array$argnum); } 889 } 890 891 /* Typemap suite for (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) 892 */ 893 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 894 fragment="NumPy_Macros") 895 (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) 896 { 897 $1 = is_array($input) || PySequence_Check($input); 898 } 899 %typemap(in, 900 fragment="NumPy_Fragments") 901 (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) 902 (PyArrayObject* array=NULL, int is_new_object=0) 903 { 904 npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 }; 905 array = obj_to_array_contiguous_allow_conversion($input, 906 DATA_TYPECODE, 907 &is_new_object); 908 if (!array || !require_dimensions(array, 3) || 909 !require_size(array, size, 3)) SWIG_fail; 910 $1 = ($1_ltype) array_data(array); 911 } 912 %typemap(freearg) 913 (DATA_TYPE IN_ARRAY3[ANY][ANY][ANY]) 914 { 915 if (is_new_object$argnum && array$argnum) 916 { Py_DECREF(array$argnum); } 917 } 918 919 /* Typemap suite for (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, 920 * DIM_TYPE DIM3) 921 */ 922 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 923 fragment="NumPy_Macros") 924 (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 925 { 926 $1 = is_array($input) || PySequence_Check($input); 927 } 928 %typemap(in, 929 fragment="NumPy_Fragments") 930 (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 931 (PyArrayObject* array=NULL, int is_new_object=0) 932 { 933 npy_intp size[3] = { -1, -1, -1 }; 934 array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, 935 &is_new_object); 936 if (!array || !require_dimensions(array, 3) || 937 !require_size(array, size, 3)) SWIG_fail; 938 $1 = (DATA_TYPE*) array_data(array); 939 $2 = (DIM_TYPE) array_size(array,0); 940 $3 = (DIM_TYPE) array_size(array,1); 941 $4 = (DIM_TYPE) array_size(array,2); 942 } 943 %typemap(freearg) 944 (DATA_TYPE* IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 945 { 946 if (is_new_object$argnum && array$argnum) 947 { Py_DECREF(array$argnum); } 948 } 949 950 /* Typemap suite for (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, 951 * DIM_TYPE DIM3) 952 */ 953 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 954 fragment="NumPy_Macros") 955 (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 956 { 957 /* for now, only concerned with lists */ 958 $1 = PySequence_Check($input); 959 } 960 %typemap(in, 961 fragment="NumPy_Fragments") 962 (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 963 (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL, int* is_new_object_array=NULL) 964 { 965 npy_intp size[2] = { -1, -1 }; 966 PyArrayObject* temp_array; 967 Py_ssize_t i; 968 int is_new_object; 969 970 /* length of the list */ 971 $2 = PyList_Size($input); 972 973 /* the arrays */ 974 array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); 975 object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); 976 is_new_object_array = (int *)calloc($2,sizeof(int)); 977 978 if (array == NULL || object_array == NULL || is_new_object_array == NULL) 979 { 980 SWIG_fail; 981 } 982 983 for (i=0; i<$2; i++) 984 { 985 temp_array = obj_to_array_contiguous_allow_conversion(PySequence_GetItem($input,i), DATA_TYPECODE, &is_new_object); 986 987 /* the new array must be stored so that it can be destroyed in freearg */ 988 object_array[i] = temp_array; 989 is_new_object_array[i] = is_new_object; 990 991 if (!temp_array || !require_dimensions(temp_array, 2)) SWIG_fail; 992 993 /* store the size of the first array in the list, then use that for comparison. */ 994 if (i == 0) 995 { 996 size[0] = array_size(temp_array,0); 997 size[1] = array_size(temp_array,1); 998 } 999 1000 if (!require_size(temp_array, size, 2)) SWIG_fail; 1001 1002 array[i] = (DATA_TYPE*) array_data(temp_array); 1003 } 1004 1005 $1 = (DATA_TYPE**) array; 1006 $3 = (DIM_TYPE) size[0]; 1007 $4 = (DIM_TYPE) size[1]; 1008 } 1009 %typemap(freearg) 1010 (DATA_TYPE** IN_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 1011 { 1012 Py_ssize_t i; 1013 1014 if (array$argnum!=NULL) free(array$argnum); 1015 1016 /*freeing the individual arrays if needed */ 1017 if (object_array$argnum!=NULL) 1018 { 1019 if (is_new_object_array$argnum!=NULL) 1020 { 1021 for (i=0; i<$2; i++) 1022 { 1023 if (object_array$argnum[i] != NULL && is_new_object_array$argnum[i]) 1024 { Py_DECREF(object_array$argnum[i]); } 1025 } 1026 free(is_new_object_array$argnum); 1027 } 1028 free(object_array$argnum); 1029 } 1030 } 1031 1032 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, 1033 * DATA_TYPE* IN_ARRAY3) 1034 */ 1035 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1036 fragment="NumPy_Macros") 1037 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) 1038 { 1039 $1 = is_array($input) || PySequence_Check($input); 1040 } 1041 %typemap(in, 1042 fragment="NumPy_Fragments") 1043 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) 1044 (PyArrayObject* array=NULL, int is_new_object=0) 1045 { 1046 npy_intp size[3] = { -1, -1, -1 }; 1047 array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, 1048 &is_new_object); 1049 if (!array || !require_dimensions(array, 3) || 1050 !require_size(array, size, 3)) SWIG_fail; 1051 $1 = (DIM_TYPE) array_size(array,0); 1052 $2 = (DIM_TYPE) array_size(array,1); 1053 $3 = (DIM_TYPE) array_size(array,2); 1054 $4 = (DATA_TYPE*) array_data(array); 1055 } 1056 %typemap(freearg) 1057 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_ARRAY3) 1058 { 1059 if (is_new_object$argnum && array$argnum) 1060 { Py_DECREF(array$argnum); } 1061 } 1062 1063 /* Typemap suite for (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, 1064 * DIM_TYPE DIM3) 1065 */ 1066 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1067 fragment="NumPy_Macros") 1068 (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 1069 { 1070 $1 = is_array($input) || PySequence_Check($input); 1071 } 1072 %typemap(in, 1073 fragment="NumPy_Fragments") 1074 (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 1075 (PyArrayObject* array=NULL, int is_new_object=0) 1076 { 1077 npy_intp size[3] = { -1, -1, -1 }; 1078 array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, 1079 &is_new_object); 1080 if (!array || !require_dimensions(array, 3) || 1081 !require_size(array, size, 3) | !require_fortran(array)) SWIG_fail; 1082 $1 = (DATA_TYPE*) array_data(array); 1083 $2 = (DIM_TYPE) array_size(array,0); 1084 $3 = (DIM_TYPE) array_size(array,1); 1085 $4 = (DIM_TYPE) array_size(array,2); 1086 } 1087 %typemap(freearg) 1088 (DATA_TYPE* IN_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 1089 { 1090 if (is_new_object$argnum && array$argnum) 1091 { Py_DECREF(array$argnum); } 1092 } 1093 1094 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, 1095 * DATA_TYPE* IN_FARRAY3) 1096 */ 1097 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1098 fragment="NumPy_Macros") 1099 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) 1100 { 1101 $1 = is_array($input) || PySequence_Check($input); 1102 } 1103 %typemap(in, 1104 fragment="NumPy_Fragments") 1105 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) 1106 (PyArrayObject* array=NULL, int is_new_object=0) 1107 { 1108 npy_intp size[3] = { -1, -1, -1 }; 1109 array = obj_to_array_contiguous_allow_conversion($input, 1110 DATA_TYPECODE, 1111 &is_new_object); 1112 if (!array || !require_dimensions(array, 3) || 1113 !require_size(array, size, 3) || !require_fortran(array)) SWIG_fail; 1114 $1 = (DIM_TYPE) array_size(array,0); 1115 $2 = (DIM_TYPE) array_size(array,1); 1116 $3 = (DIM_TYPE) array_size(array,2); 1117 $4 = (DATA_TYPE*) array_data(array); 1118 } 1119 %typemap(freearg) 1120 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* IN_FARRAY3) 1121 { 1122 if (is_new_object$argnum && array$argnum) 1123 { Py_DECREF(array$argnum); } 1124 } 1125 1126 /* Typemap suite for (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) 1127 */ 1128 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1129 fragment="NumPy_Macros") 1130 (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) 1131 { 1132 $1 = is_array($input) || PySequence_Check($input); 1133 } 1134 %typemap(in, 1135 fragment="NumPy_Fragments") 1136 (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) 1137 (PyArrayObject* array=NULL, int is_new_object=0) 1138 { 1139 npy_intp size[4] = { $1_dim0, $1_dim1, $1_dim2 , $1_dim3}; 1140 array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, 1141 &is_new_object); 1142 if (!array || !require_dimensions(array, 4) || 1143 !require_size(array, size, 4)) SWIG_fail; 1144 $1 = ($1_ltype) array_data(array); 1145 } 1146 %typemap(freearg) 1147 (DATA_TYPE IN_ARRAY4[ANY][ANY][ANY][ANY]) 1148 { 1149 if (is_new_object$argnum && array$argnum) 1150 { Py_DECREF(array$argnum); } 1151 } 1152 1153 /* Typemap suite for (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, 1154 * DIM_TYPE DIM3, DIM_TYPE DIM4) 1155 */ 1156 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1157 fragment="NumPy_Macros") 1158 (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1159 { 1160 $1 = is_array($input) || PySequence_Check($input); 1161 } 1162 %typemap(in, 1163 fragment="NumPy_Fragments") 1164 (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1165 (PyArrayObject* array=NULL, int is_new_object=0) 1166 { 1167 npy_intp size[4] = { -1, -1, -1, -1 }; 1168 array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, 1169 &is_new_object); 1170 if (!array || !require_dimensions(array, 4) || 1171 !require_size(array, size, 4)) SWIG_fail; 1172 $1 = (DATA_TYPE*) array_data(array); 1173 $2 = (DIM_TYPE) array_size(array,0); 1174 $3 = (DIM_TYPE) array_size(array,1); 1175 $4 = (DIM_TYPE) array_size(array,2); 1176 $5 = (DIM_TYPE) array_size(array,3); 1177 } 1178 %typemap(freearg) 1179 (DATA_TYPE* IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1180 { 1181 if (is_new_object$argnum && array$argnum) 1182 { Py_DECREF(array$argnum); } 1183 } 1184 1185 /* Typemap suite for (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, 1186 * DIM_TYPE DIM3, DIM_TYPE DIM4) 1187 */ 1188 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1189 fragment="NumPy_Macros") 1190 (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1191 { 1192 /* for now, only concerned with lists */ 1193 $1 = PySequence_Check($input); 1194 } 1195 %typemap(in, 1196 fragment="NumPy_Fragments") 1197 (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1198 (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL, int* is_new_object_array=NULL) 1199 { 1200 npy_intp size[3] = { -1, -1, -1 }; 1201 PyArrayObject* temp_array; 1202 Py_ssize_t i; 1203 int is_new_object; 1204 1205 /* length of the list */ 1206 $2 = PyList_Size($input); 1207 1208 /* the arrays */ 1209 array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); 1210 object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); 1211 is_new_object_array = (int *)calloc($2,sizeof(int)); 1212 1213 if (array == NULL || object_array == NULL || is_new_object_array == NULL) 1214 { 1215 SWIG_fail; 1216 } 1217 1218 for (i=0; i<$2; i++) 1219 { 1220 temp_array = obj_to_array_contiguous_allow_conversion(PySequence_GetItem($input,i), DATA_TYPECODE, &is_new_object); 1221 1222 /* the new array must be stored so that it can be destroyed in freearg */ 1223 object_array[i] = temp_array; 1224 is_new_object_array[i] = is_new_object; 1225 1226 if (!temp_array || !require_dimensions(temp_array, 3)) SWIG_fail; 1227 1228 /* store the size of the first array in the list, then use that for comparison. */ 1229 if (i == 0) 1230 { 1231 size[0] = array_size(temp_array,0); 1232 size[1] = array_size(temp_array,1); 1233 size[2] = array_size(temp_array,2); 1234 } 1235 1236 if (!require_size(temp_array, size, 3)) SWIG_fail; 1237 1238 array[i] = (DATA_TYPE*) array_data(temp_array); 1239 } 1240 1241 $1 = (DATA_TYPE**) array; 1242 $3 = (DIM_TYPE) size[0]; 1243 $4 = (DIM_TYPE) size[1]; 1244 $5 = (DIM_TYPE) size[2]; 1245 } 1246 %typemap(freearg) 1247 (DATA_TYPE** IN_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1248 { 1249 Py_ssize_t i; 1250 1251 if (array$argnum!=NULL) free(array$argnum); 1252 1253 /*freeing the individual arrays if needed */ 1254 if (object_array$argnum!=NULL) 1255 { 1256 if (is_new_object_array$argnum!=NULL) 1257 { 1258 for (i=0; i<$2; i++) 1259 { 1260 if (object_array$argnum[i] != NULL && is_new_object_array$argnum[i]) 1261 { Py_DECREF(object_array$argnum[i]); } 1262 } 1263 free(is_new_object_array$argnum); 1264 } 1265 free(object_array$argnum); 1266 } 1267 } 1268 1269 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, 1270 * DATA_TYPE* IN_ARRAY4) 1271 */ 1272 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1273 fragment="NumPy_Macros") 1274 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) 1275 { 1276 $1 = is_array($input) || PySequence_Check($input); 1277 } 1278 %typemap(in, 1279 fragment="NumPy_Fragments") 1280 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) 1281 (PyArrayObject* array=NULL, int is_new_object=0) 1282 { 1283 npy_intp size[4] = { -1, -1, -1 , -1}; 1284 array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, 1285 &is_new_object); 1286 if (!array || !require_dimensions(array, 4) || 1287 !require_size(array, size, 4)) SWIG_fail; 1288 $1 = (DIM_TYPE) array_size(array,0); 1289 $2 = (DIM_TYPE) array_size(array,1); 1290 $3 = (DIM_TYPE) array_size(array,2); 1291 $4 = (DIM_TYPE) array_size(array,3); 1292 $5 = (DATA_TYPE*) array_data(array); 1293 } 1294 %typemap(freearg) 1295 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_ARRAY4) 1296 { 1297 if (is_new_object$argnum && array$argnum) 1298 { Py_DECREF(array$argnum); } 1299 } 1300 1301 /* Typemap suite for (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, 1302 * DIM_TYPE DIM3, DIM_TYPE DIM4) 1303 */ 1304 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1305 fragment="NumPy_Macros") 1306 (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1307 { 1308 $1 = is_array($input) || PySequence_Check($input); 1309 } 1310 %typemap(in, 1311 fragment="NumPy_Fragments") 1312 (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1313 (PyArrayObject* array=NULL, int is_new_object=0) 1314 { 1315 npy_intp size[4] = { -1, -1, -1, -1 }; 1316 array = obj_to_array_fortran_allow_conversion($input, DATA_TYPECODE, 1317 &is_new_object); 1318 if (!array || !require_dimensions(array, 4) || 1319 !require_size(array, size, 4) | !require_fortran(array)) SWIG_fail; 1320 $1 = (DATA_TYPE*) array_data(array); 1321 $2 = (DIM_TYPE) array_size(array,0); 1322 $3 = (DIM_TYPE) array_size(array,1); 1323 $4 = (DIM_TYPE) array_size(array,2); 1324 $5 = (DIM_TYPE) array_size(array,3); 1325 } 1326 %typemap(freearg) 1327 (DATA_TYPE* IN_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1328 { 1329 if (is_new_object$argnum && array$argnum) 1330 { Py_DECREF(array$argnum); } 1331 } 1332 1333 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, 1334 * DATA_TYPE* IN_FARRAY4) 1335 */ 1336 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1337 fragment="NumPy_Macros") 1338 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) 1339 { 1340 $1 = is_array($input) || PySequence_Check($input); 1341 } 1342 %typemap(in, 1343 fragment="NumPy_Fragments") 1344 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) 1345 (PyArrayObject* array=NULL, int is_new_object=0) 1346 { 1347 npy_intp size[4] = { -1, -1, -1 , -1 }; 1348 array = obj_to_array_contiguous_allow_conversion($input, DATA_TYPECODE, 1349 &is_new_object); 1350 if (!array || !require_dimensions(array, 4) || 1351 !require_size(array, size, 4) || !require_fortran(array)) SWIG_fail; 1352 $1 = (DIM_TYPE) array_size(array,0); 1353 $2 = (DIM_TYPE) array_size(array,1); 1354 $3 = (DIM_TYPE) array_size(array,2); 1355 $4 = (DIM_TYPE) array_size(array,3); 1356 $5 = (DATA_TYPE*) array_data(array); 1357 } 1358 %typemap(freearg) 1359 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* IN_FARRAY4) 1360 { 1361 if (is_new_object$argnum && array$argnum) 1362 { Py_DECREF(array$argnum); } 1363 } 1364 1365 /***************************/ 1366 /* In-Place Array Typemaps */ 1367 /***************************/ 1368 1369 /* Typemap suite for (DATA_TYPE INPLACE_ARRAY1[ANY]) 1370 */ 1371 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1372 fragment="NumPy_Macros") 1373 (DATA_TYPE INPLACE_ARRAY1[ANY]) 1374 { 1375 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1376 DATA_TYPECODE); 1377 } 1378 %typemap(in, 1379 fragment="NumPy_Fragments") 1380 (DATA_TYPE INPLACE_ARRAY1[ANY]) 1381 (PyArrayObject* array=NULL) 1382 { 1383 npy_intp size[1] = { $1_dim0 }; 1384 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1385 if (!array || !require_dimensions(array,1) || !require_size(array, size, 1) || 1386 !require_contiguous(array) || !require_native(array)) SWIG_fail; 1387 $1 = ($1_ltype) array_data(array); 1388 } 1389 1390 /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) 1391 */ 1392 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1393 fragment="NumPy_Macros") 1394 (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) 1395 { 1396 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1397 DATA_TYPECODE); 1398 } 1399 %typemap(in, 1400 fragment="NumPy_Fragments") 1401 (DATA_TYPE* INPLACE_ARRAY1, DIM_TYPE DIM1) 1402 (PyArrayObject* array=NULL, int i=1) 1403 { 1404 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1405 if (!array || !require_dimensions(array,1) || !require_contiguous(array) 1406 || !require_native(array)) SWIG_fail; 1407 $1 = (DATA_TYPE*) array_data(array); 1408 $2 = 1; 1409 for (i=0; i < array_numdims(array); ++i) $2 *= array_size(array,i); 1410 } 1411 1412 /* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) 1413 */ 1414 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1415 fragment="NumPy_Macros") 1416 (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) 1417 { 1418 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1419 DATA_TYPECODE); 1420 } 1421 %typemap(in, 1422 fragment="NumPy_Fragments") 1423 (DIM_TYPE DIM1, DATA_TYPE* INPLACE_ARRAY1) 1424 (PyArrayObject* array=NULL, int i=0) 1425 { 1426 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1427 if (!array || !require_dimensions(array,1) || !require_contiguous(array) 1428 || !require_native(array)) SWIG_fail; 1429 $1 = 1; 1430 for (i=0; i < array_numdims(array); ++i) $1 *= array_size(array,i); 1431 $2 = (DATA_TYPE*) array_data(array); 1432 } 1433 1434 /* Typemap suite for (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) 1435 */ 1436 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1437 fragment="NumPy_Macros") 1438 (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) 1439 { 1440 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1441 DATA_TYPECODE); 1442 } 1443 %typemap(in, 1444 fragment="NumPy_Fragments") 1445 (DATA_TYPE INPLACE_ARRAY2[ANY][ANY]) 1446 (PyArrayObject* array=NULL) 1447 { 1448 npy_intp size[2] = { $1_dim0, $1_dim1 }; 1449 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1450 if (!array || !require_dimensions(array,2) || !require_size(array, size, 2) || 1451 !require_contiguous(array) || !require_native(array)) SWIG_fail; 1452 $1 = ($1_ltype) array_data(array); 1453 } 1454 1455 /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 1456 */ 1457 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1458 fragment="NumPy_Macros") 1459 (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 1460 { 1461 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1462 DATA_TYPECODE); 1463 } 1464 %typemap(in, 1465 fragment="NumPy_Fragments") 1466 (DATA_TYPE* INPLACE_ARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 1467 (PyArrayObject* array=NULL) 1468 { 1469 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1470 if (!array || !require_dimensions(array,2) || !require_contiguous(array) 1471 || !require_native(array)) SWIG_fail; 1472 $1 = (DATA_TYPE*) array_data(array); 1473 $2 = (DIM_TYPE) array_size(array,0); 1474 $3 = (DIM_TYPE) array_size(array,1); 1475 } 1476 1477 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) 1478 */ 1479 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1480 fragment="NumPy_Macros") 1481 (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) 1482 { 1483 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1484 DATA_TYPECODE); 1485 } 1486 %typemap(in, 1487 fragment="NumPy_Fragments") 1488 (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_ARRAY2) 1489 (PyArrayObject* array=NULL) 1490 { 1491 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1492 if (!array || !require_dimensions(array,2) || !require_contiguous(array) || 1493 !require_native(array)) SWIG_fail; 1494 $1 = (DIM_TYPE) array_size(array,0); 1495 $2 = (DIM_TYPE) array_size(array,1); 1496 $3 = (DATA_TYPE*) array_data(array); 1497 } 1498 1499 /* Typemap suite for (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 1500 */ 1501 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1502 fragment="NumPy_Macros") 1503 (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 1504 { 1505 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1506 DATA_TYPECODE); 1507 } 1508 %typemap(in, 1509 fragment="NumPy_Fragments") 1510 (DATA_TYPE* INPLACE_FARRAY2, DIM_TYPE DIM1, DIM_TYPE DIM2) 1511 (PyArrayObject* array=NULL) 1512 { 1513 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1514 if (!array || !require_dimensions(array,2) || !require_contiguous(array) 1515 || !require_native(array) || !require_fortran(array)) SWIG_fail; 1516 $1 = (DATA_TYPE*) array_data(array); 1517 $2 = (DIM_TYPE) array_size(array,0); 1518 $3 = (DIM_TYPE) array_size(array,1); 1519 } 1520 1521 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) 1522 */ 1523 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1524 fragment="NumPy_Macros") 1525 (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) 1526 { 1527 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1528 DATA_TYPECODE); 1529 } 1530 %typemap(in, 1531 fragment="NumPy_Fragments") 1532 (DIM_TYPE DIM1, DIM_TYPE DIM2, DATA_TYPE* INPLACE_FARRAY2) 1533 (PyArrayObject* array=NULL) 1534 { 1535 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1536 if (!array || !require_dimensions(array,2) || !require_contiguous(array) || 1537 !require_native(array) || !require_fortran(array)) SWIG_fail; 1538 $1 = (DIM_TYPE) array_size(array,0); 1539 $2 = (DIM_TYPE) array_size(array,1); 1540 $3 = (DATA_TYPE*) array_data(array); 1541 } 1542 1543 /* Typemap suite for (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) 1544 */ 1545 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1546 fragment="NumPy_Macros") 1547 (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) 1548 { 1549 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1550 DATA_TYPECODE); 1551 } 1552 %typemap(in, 1553 fragment="NumPy_Fragments") 1554 (DATA_TYPE INPLACE_ARRAY3[ANY][ANY][ANY]) 1555 (PyArrayObject* array=NULL) 1556 { 1557 npy_intp size[3] = { $1_dim0, $1_dim1, $1_dim2 }; 1558 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1559 if (!array || !require_dimensions(array,3) || !require_size(array, size, 3) || 1560 !require_contiguous(array) || !require_native(array)) SWIG_fail; 1561 $1 = ($1_ltype) array_data(array); 1562 } 1563 1564 /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, 1565 * DIM_TYPE DIM3) 1566 */ 1567 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1568 fragment="NumPy_Macros") 1569 (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 1570 { 1571 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1572 DATA_TYPECODE); 1573 } 1574 %typemap(in, 1575 fragment="NumPy_Fragments") 1576 (DATA_TYPE* INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 1577 (PyArrayObject* array=NULL) 1578 { 1579 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1580 if (!array || !require_dimensions(array,3) || !require_contiguous(array) || 1581 !require_native(array)) SWIG_fail; 1582 $1 = (DATA_TYPE*) array_data(array); 1583 $2 = (DIM_TYPE) array_size(array,0); 1584 $3 = (DIM_TYPE) array_size(array,1); 1585 $4 = (DIM_TYPE) array_size(array,2); 1586 } 1587 1588 /* Typemap suite for (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, 1589 * DIM_TYPE DIM3) 1590 */ 1591 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1592 fragment="NumPy_Macros") 1593 (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 1594 { 1595 $1 = PySequence_Check($input); 1596 } 1597 %typemap(in, 1598 fragment="NumPy_Fragments") 1599 (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 1600 (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL) 1601 { 1602 npy_intp size[2] = { -1, -1 }; 1603 PyArrayObject* temp_array; 1604 Py_ssize_t i; 1605 1606 /* length of the list */ 1607 $2 = PyList_Size($input); 1608 1609 /* the arrays */ 1610 array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); 1611 object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); 1612 1613 if (array == NULL || object_array == NULL) 1614 { 1615 SWIG_fail; 1616 } 1617 1618 for (i=0; i<$2; i++) 1619 { 1620 temp_array = obj_to_array_no_conversion(PySequence_GetItem($input,i), DATA_TYPECODE); 1621 1622 /* the new array must be stored so that it can be destroyed in freearg */ 1623 object_array[i] = temp_array; 1624 1625 if ( !temp_array || !require_dimensions(temp_array, 2) || 1626 !require_contiguous(temp_array) || 1627 !require_native(temp_array) || 1628 !PyArray_EquivTypenums(array_type(temp_array), DATA_TYPECODE) 1629 ) SWIG_fail; 1630 1631 /* store the size of the first array in the list, then use that for comparison. */ 1632 if (i == 0) 1633 { 1634 size[0] = array_size(temp_array,0); 1635 size[1] = array_size(temp_array,1); 1636 } 1637 1638 if (!require_size(temp_array, size, 2)) SWIG_fail; 1639 1640 array[i] = (DATA_TYPE*) array_data(temp_array); 1641 } 1642 1643 $1 = (DATA_TYPE**) array; 1644 $3 = (DIM_TYPE) size[0]; 1645 $4 = (DIM_TYPE) size[1]; 1646 } 1647 %typemap(freearg) 1648 (DATA_TYPE** INPLACE_ARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 1649 { 1650 if (array$argnum!=NULL) free(array$argnum); 1651 if (object_array$argnum!=NULL) free(object_array$argnum); 1652 } 1653 1654 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, 1655 * DATA_TYPE* INPLACE_ARRAY3) 1656 */ 1657 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1658 fragment="NumPy_Macros") 1659 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) 1660 { 1661 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1662 DATA_TYPECODE); 1663 } 1664 %typemap(in, 1665 fragment="NumPy_Fragments") 1666 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_ARRAY3) 1667 (PyArrayObject* array=NULL) 1668 { 1669 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1670 if (!array || !require_dimensions(array,3) || !require_contiguous(array) 1671 || !require_native(array)) SWIG_fail; 1672 $1 = (DIM_TYPE) array_size(array,0); 1673 $2 = (DIM_TYPE) array_size(array,1); 1674 $3 = (DIM_TYPE) array_size(array,2); 1675 $4 = (DATA_TYPE*) array_data(array); 1676 } 1677 1678 /* Typemap suite for (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, 1679 * DIM_TYPE DIM3) 1680 */ 1681 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1682 fragment="NumPy_Macros") 1683 (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 1684 { 1685 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1686 DATA_TYPECODE); 1687 } 1688 %typemap(in, 1689 fragment="NumPy_Fragments") 1690 (DATA_TYPE* INPLACE_FARRAY3, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3) 1691 (PyArrayObject* array=NULL) 1692 { 1693 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1694 if (!array || !require_dimensions(array,3) || !require_contiguous(array) || 1695 !require_native(array) || !require_fortran(array)) SWIG_fail; 1696 $1 = (DATA_TYPE*) array_data(array); 1697 $2 = (DIM_TYPE) array_size(array,0); 1698 $3 = (DIM_TYPE) array_size(array,1); 1699 $4 = (DIM_TYPE) array_size(array,2); 1700 } 1701 1702 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, 1703 * DATA_TYPE* INPLACE_FARRAY3) 1704 */ 1705 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1706 fragment="NumPy_Macros") 1707 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) 1708 { 1709 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1710 DATA_TYPECODE); 1711 } 1712 %typemap(in, 1713 fragment="NumPy_Fragments") 1714 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DATA_TYPE* INPLACE_FARRAY3) 1715 (PyArrayObject* array=NULL) 1716 { 1717 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1718 if (!array || !require_dimensions(array,3) || !require_contiguous(array) 1719 || !require_native(array) || !require_fortran(array)) SWIG_fail; 1720 $1 = (DIM_TYPE) array_size(array,0); 1721 $2 = (DIM_TYPE) array_size(array,1); 1722 $3 = (DIM_TYPE) array_size(array,2); 1723 $4 = (DATA_TYPE*) array_data(array); 1724 } 1725 1726 /* Typemap suite for (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) 1727 */ 1728 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1729 fragment="NumPy_Macros") 1730 (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) 1731 { 1732 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1733 DATA_TYPECODE); 1734 } 1735 %typemap(in, 1736 fragment="NumPy_Fragments") 1737 (DATA_TYPE INPLACE_ARRAY4[ANY][ANY][ANY][ANY]) 1738 (PyArrayObject* array=NULL) 1739 { 1740 npy_intp size[4] = { $1_dim0, $1_dim1, $1_dim2 , $1_dim3 }; 1741 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1742 if (!array || !require_dimensions(array,4) || !require_size(array, size, 4) || 1743 !require_contiguous(array) || !require_native(array)) SWIG_fail; 1744 $1 = ($1_ltype) array_data(array); 1745 } 1746 1747 /* Typemap suite for (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, 1748 * DIM_TYPE DIM3, DIM_TYPE DIM4) 1749 */ 1750 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1751 fragment="NumPy_Macros") 1752 (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1753 { 1754 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1755 DATA_TYPECODE); 1756 } 1757 %typemap(in, 1758 fragment="NumPy_Fragments") 1759 (DATA_TYPE* INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1760 (PyArrayObject* array=NULL) 1761 { 1762 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1763 if (!array || !require_dimensions(array,4) || !require_contiguous(array) || 1764 !require_native(array)) SWIG_fail; 1765 $1 = (DATA_TYPE*) array_data(array); 1766 $2 = (DIM_TYPE) array_size(array,0); 1767 $3 = (DIM_TYPE) array_size(array,1); 1768 $4 = (DIM_TYPE) array_size(array,2); 1769 $5 = (DIM_TYPE) array_size(array,3); 1770 } 1771 1772 /* Typemap suite for (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, 1773 * DIM_TYPE DIM3, DIM_TYPE DIM4) 1774 */ 1775 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1776 fragment="NumPy_Macros") 1777 (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1778 { 1779 $1 = PySequence_Check($input); 1780 } 1781 %typemap(in, 1782 fragment="NumPy_Fragments") 1783 (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1784 (DATA_TYPE** array=NULL, PyArrayObject** object_array=NULL) 1785 { 1786 npy_intp size[3] = { -1, -1, -1 }; 1787 PyArrayObject* temp_array; 1788 Py_ssize_t i; 1789 1790 /* length of the list */ 1791 $2 = PyList_Size($input); 1792 1793 /* the arrays */ 1794 array = (DATA_TYPE **)malloc($2*sizeof(DATA_TYPE *)); 1795 object_array = (PyArrayObject **)calloc($2,sizeof(PyArrayObject *)); 1796 1797 if (array == NULL || object_array == NULL) 1798 { 1799 SWIG_fail; 1800 } 1801 1802 for (i=0; i<$2; i++) 1803 { 1804 temp_array = obj_to_array_no_conversion(PySequence_GetItem($input,i), DATA_TYPECODE); 1805 1806 /* the new array must be stored so that it can be destroyed in freearg */ 1807 object_array[i] = temp_array; 1808 1809 if ( !temp_array || !require_dimensions(temp_array, 3) || 1810 !require_contiguous(temp_array) || 1811 !require_native(temp_array) || 1812 !PyArray_EquivTypenums(array_type(temp_array), DATA_TYPECODE) 1813 ) SWIG_fail; 1814 1815 /* store the size of the first array in the list, then use that for comparison. */ 1816 if (i == 0) 1817 { 1818 size[0] = array_size(temp_array,0); 1819 size[1] = array_size(temp_array,1); 1820 size[2] = array_size(temp_array,2); 1821 } 1822 1823 if (!require_size(temp_array, size, 3)) SWIG_fail; 1824 1825 array[i] = (DATA_TYPE*) array_data(temp_array); 1826 } 1827 1828 $1 = (DATA_TYPE**) array; 1829 $3 = (DIM_TYPE) size[0]; 1830 $4 = (DIM_TYPE) size[1]; 1831 $5 = (DIM_TYPE) size[2]; 1832 } 1833 %typemap(freearg) 1834 (DATA_TYPE** INPLACE_ARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1835 { 1836 if (array$argnum!=NULL) free(array$argnum); 1837 if (object_array$argnum!=NULL) free(object_array$argnum); 1838 } 1839 1840 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, 1841 * DATA_TYPE* INPLACE_ARRAY4) 1842 */ 1843 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1844 fragment="NumPy_Macros") 1845 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4) 1846 { 1847 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1848 DATA_TYPECODE); 1849 } 1850 %typemap(in, 1851 fragment="NumPy_Fragments") 1852 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_ARRAY4) 1853 (PyArrayObject* array=NULL) 1854 { 1855 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1856 if (!array || !require_dimensions(array,4) || !require_contiguous(array) 1857 || !require_native(array)) SWIG_fail; 1858 $1 = (DIM_TYPE) array_size(array,0); 1859 $2 = (DIM_TYPE) array_size(array,1); 1860 $3 = (DIM_TYPE) array_size(array,2); 1861 $4 = (DIM_TYPE) array_size(array,3); 1862 $5 = (DATA_TYPE*) array_data(array); 1863 } 1864 1865 /* Typemap suite for (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, 1866 * DIM_TYPE DIM3, DIM_TYPE DIM4) 1867 */ 1868 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1869 fragment="NumPy_Macros") 1870 (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1871 { 1872 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1873 DATA_TYPECODE); 1874 } 1875 %typemap(in, 1876 fragment="NumPy_Fragments") 1877 (DATA_TYPE* INPLACE_FARRAY4, DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4) 1878 (PyArrayObject* array=NULL) 1879 { 1880 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1881 if (!array || !require_dimensions(array,4) || !require_contiguous(array) || 1882 !require_native(array) || !require_fortran(array)) SWIG_fail; 1883 $1 = (DATA_TYPE*) array_data(array); 1884 $2 = (DIM_TYPE) array_size(array,0); 1885 $3 = (DIM_TYPE) array_size(array,1); 1886 $4 = (DIM_TYPE) array_size(array,2); 1887 $5 = (DIM_TYPE) array_size(array,3); 1888 } 1889 1890 /* Typemap suite for (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, 1891 * DATA_TYPE* INPLACE_FARRAY4) 1892 */ 1893 %typecheck(SWIG_TYPECHECK_DOUBLE_ARRAY, 1894 fragment="NumPy_Macros") 1895 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4) 1896 { 1897 $1 = is_array($input) && PyArray_EquivTypenums(array_type($input), 1898 DATA_TYPECODE); 1899 } 1900 %typemap(in, 1901 fragment="NumPy_Fragments") 1902 (DIM_TYPE DIM1, DIM_TYPE DIM2, DIM_TYPE DIM3, DIM_TYPE DIM4, DATA_TYPE* INPLACE_FARRAY4) 1903 (PyArrayObject* array=NULL) 1904 { 1905 array = obj_to_array_no_conversion($input, DATA_TYPECODE); 1906 if (!array || !require_dimensions(array,4) || !require_contiguous(array) 1907 || !require_native(array) || !require_fortran(array)) SWIG_fail; 1908 $1 = (DIM_TYPE) array_size(array,0); 1909 $2 = (DIM_TYPE) array_size(array,1); 1910 $3 = (DIM_TYPE) array_size(array,2); 1911 $4 = (DIM_TYPE) array_size(array,3); 1912 $5 = (DATA_TYPE*) array_data(array); 1913 } 1914 1915 /*************************/ 1916 /* Argout Array Typemaps */ 1917 /*************************/ 1918 1919 /* Typemap suite for (DATA_TYPE ARGOUT_ARRAY1[ANY]) 1920 */ 1921 %typemap(in,numinputs=0, 1922 fragment="NumPy_Backward_Compatibility,NumPy_Macros") 1923 (DATA_TYPE ARGOUT_ARRAY1[ANY]) 1924 (PyObject* array = NULL) 1925 { 1926 npy_intp dims[1] = { $1_dim0 }; 1927 array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); 1928 if (!array) SWIG_fail; 1929 $1 = ($1_ltype) array_data(array); 1930 } 1931 %typemap(argout) 1932 (DATA_TYPE ARGOUT_ARRAY1[ANY]) 1933 { 1934 $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); 1935 } 1936 1937 /* Typemap suite for (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) 1938 */ 1939 %typemap(in,numinputs=1, 1940 fragment="NumPy_Fragments") 1941 (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) 1942 (PyObject* array = NULL) 1943 { 1944 npy_intp dims[1]; 1945 if (!PyInt_Check($input)) 1946 { 1947 const char* typestring = pytype_string($input); 1948 PyErr_Format(PyExc_TypeError, 1949 "Int dimension expected. '%s' given.", 1950 typestring); 1951 SWIG_fail; 1952 } 1953 $2 = (DIM_TYPE) PyInt_AsLong($input); 1954 dims[0] = (npy_intp) $2; 1955 array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); 1956 if (!array) SWIG_fail; 1957 $1 = (DATA_TYPE*) array_data(array); 1958 } 1959 %typemap(argout) 1960 (DATA_TYPE* ARGOUT_ARRAY1, DIM_TYPE DIM1) 1961 { 1962 $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); 1963 } 1964 1965 /* Typemap suite for (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) 1966 */ 1967 %typemap(in,numinputs=1, 1968 fragment="NumPy_Fragments") 1969 (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) 1970 (PyObject* array = NULL) 1971 { 1972 npy_intp dims[1]; 1973 if (!PyInt_Check($input)) 1974 { 1975 const char* typestring = pytype_string($input); 1976 PyErr_Format(PyExc_TypeError, 1977 "Int dimension expected. '%s' given.", 1978 typestring); 1979 SWIG_fail; 1980 } 1981 $1 = (DIM_TYPE) PyInt_AsLong($input); 1982 dims[0] = (npy_intp) $1; 1983 array = PyArray_SimpleNew(1, dims, DATA_TYPECODE); 1984 if (!array) SWIG_fail; 1985 $2 = (DATA_TYPE*) array_data(array); 1986 } 1987 %typemap(argout) 1988 (DIM_TYPE DIM1, DATA_TYPE* ARGOUT_ARRAY1) 1989 { 1990 $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); 1991 } 1992 1993 /* Typemap suite for (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) 1994 */ 1995 %typemap(in,numinputs=0, 1996 fragment="NumPy_Backward_Compatibility,NumPy_Macros") 1997 (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) 1998 (PyObject* array = NULL) 1999 { 2000 npy_intp dims[2] = { $1_dim0, $1_dim1 }; 2001 array = PyArray_SimpleNew(2, dims, DATA_TYPECODE); 2002 if (!array) SWIG_fail; 2003 $1 = ($1_ltype) array_data(array); 2004 } 2005 %typemap(argout) 2006 (DATA_TYPE ARGOUT_ARRAY2[ANY][ANY]) 2007 { 2008 $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); 2009 } 2010 2011 /* Typemap suite for (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) 2012 */ 2013 %typemap(in,numinputs=0, 2014 fragment="NumPy_Backward_Compatibility,NumPy_Macros") 2015 (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) 2016 (PyObject* array = NULL) 2017 { 2018 npy_intp dims[3] = { $1_dim0, $1_dim1, $1_dim2 }; 2019 array = PyArray_SimpleNew(3, dims, DATA_TYPECODE); 2020 if (!array) SWIG_fail; 2021 $1 = ($1_ltype) array_data(array); 2022 } 2023 %typemap(argout) 2024 (DATA_TYPE ARGOUT_ARRAY3[ANY][ANY][ANY]) 2025 { 2026 $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); 2027 } 2028 2029 /* Typemap suite for (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) 2030 */ 2031 %typemap(in,numinputs=0, 2032 fragment="NumPy_Backward_Compatibility,NumPy_Macros") 2033 (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) 2034 (PyObject* array = NULL) 2035 { 2036 npy_intp dims[4] = { $1_dim0, $1_dim1, $1_dim2, $1_dim3 }; 2037 array = PyArray_SimpleNew(4, dims, DATA_TYPECODE); 2038 if (!array) SWIG_fail; 2039 $1 = ($1_ltype) array_data(array); 2040 } 2041 %typemap(argout) 2042 (DATA_TYPE ARGOUT_ARRAY4[ANY][ANY][ANY][ANY]) 2043 { 2044 $result = SWIG_Python_AppendOutput($result,(PyObject*)array$argnum); 2045 } 2046 2047 /*****************************/ 2048 /* Argoutview Array Typemaps */ 2049 /*****************************/ 2050 2051 /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) 2052 */ 2053 %typemap(in,numinputs=0) 2054 (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1 ) 2055 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim_temp) 2056 { 2057 $1 = &data_temp; 2058 $2 = &dim_temp; 2059 } 2060 %typemap(argout, 2061 fragment="NumPy_Backward_Compatibility") 2062 (DATA_TYPE** ARGOUTVIEW_ARRAY1, DIM_TYPE* DIM1) 2063 { 2064 npy_intp dims[1] = { *$2 }; 2065 PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1)); 2066 PyArrayObject* array = (PyArrayObject*) obj; 2067 2068 if (!array) SWIG_fail; 2069 $result = SWIG_Python_AppendOutput($result,obj); 2070 } 2071 2072 /* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) 2073 */ 2074 %typemap(in,numinputs=0) 2075 (DIM_TYPE* DIM1 , DATA_TYPE** ARGOUTVIEW_ARRAY1) 2076 (DIM_TYPE dim_temp, DATA_TYPE* data_temp = NULL ) 2077 { 2078 $1 = &dim_temp; 2079 $2 = &data_temp; 2080 } 2081 %typemap(argout, 2082 fragment="NumPy_Backward_Compatibility") 2083 (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEW_ARRAY1) 2084 { 2085 npy_intp dims[1] = { *$1 }; 2086 PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2)); 2087 PyArrayObject* array = (PyArrayObject*) obj; 2088 2089 if (!array) SWIG_fail; 2090 $result = SWIG_Python_AppendOutput($result,obj); 2091 } 2092 2093 /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 2094 */ 2095 %typemap(in,numinputs=0) 2096 (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) 2097 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) 2098 { 2099 $1 = &data_temp; 2100 $2 = &dim1_temp; 2101 $3 = &dim2_temp; 2102 } 2103 %typemap(argout, 2104 fragment="NumPy_Backward_Compatibility") 2105 (DATA_TYPE** ARGOUTVIEW_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 2106 { 2107 npy_intp dims[2] = { *$2, *$3 }; 2108 PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); 2109 PyArrayObject* array = (PyArrayObject*) obj; 2110 2111 if (!array) SWIG_fail; 2112 $result = SWIG_Python_AppendOutput($result,obj); 2113 } 2114 2115 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) 2116 */ 2117 %typemap(in,numinputs=0) 2118 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_ARRAY2) 2119 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) 2120 { 2121 $1 = &dim1_temp; 2122 $2 = &dim2_temp; 2123 $3 = &data_temp; 2124 } 2125 %typemap(argout, 2126 fragment="NumPy_Backward_Compatibility") 2127 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_ARRAY2) 2128 { 2129 npy_intp dims[2] = { *$1, *$2 }; 2130 PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); 2131 PyArrayObject* array = (PyArrayObject*) obj; 2132 2133 if (!array) SWIG_fail; 2134 $result = SWIG_Python_AppendOutput($result,obj); 2135 } 2136 2137 /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 2138 */ 2139 %typemap(in,numinputs=0) 2140 (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) 2141 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) 2142 { 2143 $1 = &data_temp; 2144 $2 = &dim1_temp; 2145 $3 = &dim2_temp; 2146 } 2147 %typemap(argout, 2148 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2149 (DATA_TYPE** ARGOUTVIEW_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 2150 { 2151 npy_intp dims[2] = { *$2, *$3 }; 2152 PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); 2153 PyArrayObject* array = (PyArrayObject*) obj; 2154 2155 if (!array || !require_fortran(array)) SWIG_fail; 2156 $result = SWIG_Python_AppendOutput($result,obj); 2157 } 2158 2159 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) 2160 */ 2161 %typemap(in,numinputs=0) 2162 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEW_FARRAY2) 2163 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) 2164 { 2165 $1 = &dim1_temp; 2166 $2 = &dim2_temp; 2167 $3 = &data_temp; 2168 } 2169 %typemap(argout, 2170 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2171 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEW_FARRAY2) 2172 { 2173 npy_intp dims[2] = { *$1, *$2 }; 2174 PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); 2175 PyArrayObject* array = (PyArrayObject*) obj; 2176 2177 if (!array || !require_fortran(array)) SWIG_fail; 2178 $result = SWIG_Python_AppendOutput($result,obj); 2179 } 2180 2181 /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, 2182 DIM_TYPE* DIM3) 2183 */ 2184 %typemap(in,numinputs=0) 2185 (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) 2186 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) 2187 { 2188 $1 = &data_temp; 2189 $2 = &dim1_temp; 2190 $3 = &dim2_temp; 2191 $4 = &dim3_temp; 2192 } 2193 %typemap(argout, 2194 fragment="NumPy_Backward_Compatibility") 2195 (DATA_TYPE** ARGOUTVIEW_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) 2196 { 2197 npy_intp dims[3] = { *$2, *$3, *$4 }; 2198 PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); 2199 PyArrayObject* array = (PyArrayObject*) obj; 2200 2201 if (!array) SWIG_fail; 2202 $result = SWIG_Python_AppendOutput($result,obj); 2203 } 2204 2205 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, 2206 DATA_TYPE** ARGOUTVIEW_ARRAY3) 2207 */ 2208 %typemap(in,numinputs=0) 2209 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) 2210 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL) 2211 { 2212 $1 = &dim1_temp; 2213 $2 = &dim2_temp; 2214 $3 = &dim3_temp; 2215 $4 = &data_temp; 2216 } 2217 %typemap(argout, 2218 fragment="NumPy_Backward_Compatibility") 2219 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_ARRAY3) 2220 { 2221 npy_intp dims[3] = { *$1, *$2, *$3 }; 2222 PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); 2223 PyArrayObject* array = (PyArrayObject*) obj; 2224 2225 if (!array) SWIG_fail; 2226 $result = SWIG_Python_AppendOutput($result,obj); 2227 } 2228 2229 /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, 2230 DIM_TYPE* DIM3) 2231 */ 2232 %typemap(in,numinputs=0) 2233 (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) 2234 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) 2235 { 2236 $1 = &data_temp; 2237 $2 = &dim1_temp; 2238 $3 = &dim2_temp; 2239 $4 = &dim3_temp; 2240 } 2241 %typemap(argout, 2242 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2243 (DATA_TYPE** ARGOUTVIEW_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) 2244 { 2245 npy_intp dims[3] = { *$2, *$3, *$4 }; 2246 PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); 2247 PyArrayObject* array = (PyArrayObject*) obj; 2248 2249 if (!array || require_fortran(array)) SWIG_fail; 2250 $result = SWIG_Python_AppendOutput($result,obj); 2251 } 2252 2253 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, 2254 DATA_TYPE** ARGOUTVIEW_FARRAY3) 2255 */ 2256 %typemap(in,numinputs=0) 2257 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DATA_TYPE** ARGOUTVIEW_FARRAY3) 2258 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL ) 2259 { 2260 $1 = &dim1_temp; 2261 $2 = &dim2_temp; 2262 $3 = &dim3_temp; 2263 $4 = &data_temp; 2264 } 2265 %typemap(argout, 2266 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2267 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEW_FARRAY3) 2268 { 2269 npy_intp dims[3] = { *$1, *$2, *$3 }; 2270 PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); 2271 PyArrayObject* array = (PyArrayObject*) obj; 2272 2273 if (!array || require_fortran(array)) SWIG_fail; 2274 $result = SWIG_Python_AppendOutput($result,obj); 2275 } 2276 2277 /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, 2278 DIM_TYPE* DIM3, DIM_TYPE* DIM4) 2279 */ 2280 %typemap(in,numinputs=0) 2281 (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) 2282 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) 2283 { 2284 $1 = &data_temp; 2285 $2 = &dim1_temp; 2286 $3 = &dim2_temp; 2287 $4 = &dim3_temp; 2288 $5 = &dim4_temp; 2289 } 2290 %typemap(argout, 2291 fragment="NumPy_Backward_Compatibility") 2292 (DATA_TYPE** ARGOUTVIEW_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) 2293 { 2294 npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; 2295 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); 2296 PyArrayObject* array = (PyArrayObject*) obj; 2297 2298 if (!array) SWIG_fail; 2299 $result = SWIG_Python_AppendOutput($result,obj); 2300 } 2301 2302 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, 2303 DATA_TYPE** ARGOUTVIEW_ARRAY4) 2304 */ 2305 %typemap(in,numinputs=0) 2306 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEW_ARRAY4) 2307 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) 2308 { 2309 $1 = &dim1_temp; 2310 $2 = &dim2_temp; 2311 $3 = &dim3_temp; 2312 $4 = &dim4_temp; 2313 $5 = &data_temp; 2314 } 2315 %typemap(argout, 2316 fragment="NumPy_Backward_Compatibility") 2317 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_ARRAY4) 2318 { 2319 npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; 2320 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); 2321 PyArrayObject* array = (PyArrayObject*) obj; 2322 2323 if (!array) SWIG_fail; 2324 $result = SWIG_Python_AppendOutput($result,obj); 2325 } 2326 2327 /* Typemap suite for (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, 2328 DIM_TYPE* DIM3, DIM_TYPE* DIM4) 2329 */ 2330 %typemap(in,numinputs=0) 2331 (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) 2332 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) 2333 { 2334 $1 = &data_temp; 2335 $2 = &dim1_temp; 2336 $3 = &dim2_temp; 2337 $4 = &dim3_temp; 2338 $5 = &dim4_temp; 2339 } 2340 %typemap(argout, 2341 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2342 (DATA_TYPE** ARGOUTVIEW_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) 2343 { 2344 npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; 2345 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); 2346 PyArrayObject* array = (PyArrayObject*) obj; 2347 2348 if (!array || require_fortran(array)) SWIG_fail; 2349 $result = SWIG_Python_AppendOutput($result,obj); 2350 } 2351 2352 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, 2353 DATA_TYPE** ARGOUTVIEW_FARRAY4) 2354 */ 2355 %typemap(in,numinputs=0) 2356 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEW_FARRAY4) 2357 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) 2358 { 2359 $1 = &dim1_temp; 2360 $2 = &dim2_temp; 2361 $3 = &dim3_temp; 2362 $4 = &dim4_temp; 2363 $5 = &data_temp; 2364 } 2365 %typemap(argout, 2366 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2367 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEW_FARRAY4) 2368 { 2369 npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; 2370 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); 2371 PyArrayObject* array = (PyArrayObject*) obj; 2372 2373 if (!array || require_fortran(array)) SWIG_fail; 2374 $result = SWIG_Python_AppendOutput($result,obj); 2375 } 2376 2377 /*************************************/ 2378 /* Managed Argoutview Array Typemaps */ 2379 /*************************************/ 2380 2381 /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1) 2382 */ 2383 %typemap(in,numinputs=0) 2384 (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1 ) 2385 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim_temp) 2386 { 2387 $1 = &data_temp; 2388 $2 = &dim_temp; 2389 } 2390 %typemap(argout, 2391 fragment="NumPy_Backward_Compatibility") 2392 (DATA_TYPE** ARGOUTVIEWM_ARRAY1, DIM_TYPE* DIM1) 2393 { 2394 npy_intp dims[1] = { *$2 }; 2395 PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$1)); 2396 PyArrayObject* array = (PyArrayObject*) obj; 2397 2398 if (!array) SWIG_fail; 2399 2400 %#ifdef SWIGPY_USE_CAPSULE 2401 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2402 %#else 2403 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2404 %#endif 2405 2406 %#if NPY_API_VERSION < 0x00000007 2407 PyArray_BASE(array) = cap; 2408 %#else 2409 PyArray_SetBaseObject(array,cap); 2410 %#endif 2411 2412 $result = SWIG_Python_AppendOutput($result,obj); 2413 } 2414 2415 /* Typemap suite for (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1) 2416 */ 2417 %typemap(in,numinputs=0) 2418 (DIM_TYPE* DIM1 , DATA_TYPE** ARGOUTVIEWM_ARRAY1) 2419 (DIM_TYPE dim_temp, DATA_TYPE* data_temp = NULL ) 2420 { 2421 $1 = &dim_temp; 2422 $2 = &data_temp; 2423 } 2424 %typemap(argout, 2425 fragment="NumPy_Backward_Compatibility") 2426 (DIM_TYPE* DIM1, DATA_TYPE** ARGOUTVIEWM_ARRAY1) 2427 { 2428 npy_intp dims[1] = { *$1 }; 2429 PyObject* obj = PyArray_SimpleNewFromData(1, dims, DATA_TYPECODE, (void*)(*$2)); 2430 PyArrayObject* array = (PyArrayObject*) obj; 2431 2432 if (!array) SWIG_fail; 2433 2434 %#ifdef SWIGPY_USE_CAPSULE 2435 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2436 %#else 2437 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2438 %#endif 2439 2440 %#if NPY_API_VERSION < 0x00000007 2441 PyArray_BASE(array) = cap; 2442 %#else 2443 PyArray_SetBaseObject(array,cap); 2444 %#endif 2445 2446 $result = SWIG_Python_AppendOutput($result,obj); 2447 } 2448 2449 /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 2450 */ 2451 %typemap(in,numinputs=0) 2452 (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) 2453 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) 2454 { 2455 $1 = &data_temp; 2456 $2 = &dim1_temp; 2457 $3 = &dim2_temp; 2458 } 2459 %typemap(argout, 2460 fragment="NumPy_Backward_Compatibility") 2461 (DATA_TYPE** ARGOUTVIEWM_ARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 2462 { 2463 npy_intp dims[2] = { *$2, *$3 }; 2464 PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); 2465 PyArrayObject* array = (PyArrayObject*) obj; 2466 2467 if (!array) SWIG_fail; 2468 2469 %#ifdef SWIGPY_USE_CAPSULE 2470 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2471 %#else 2472 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2473 %#endif 2474 2475 %#if NPY_API_VERSION < 0x00000007 2476 PyArray_BASE(array) = cap; 2477 %#else 2478 PyArray_SetBaseObject(array,cap); 2479 %#endif 2480 2481 $result = SWIG_Python_AppendOutput($result,obj); 2482 } 2483 2484 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2) 2485 */ 2486 %typemap(in,numinputs=0) 2487 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEWM_ARRAY2) 2488 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) 2489 { 2490 $1 = &dim1_temp; 2491 $2 = &dim2_temp; 2492 $3 = &data_temp; 2493 } 2494 %typemap(argout, 2495 fragment="NumPy_Backward_Compatibility") 2496 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_ARRAY2) 2497 { 2498 npy_intp dims[2] = { *$1, *$2 }; 2499 PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); 2500 PyArrayObject* array = (PyArrayObject*) obj; 2501 2502 if (!array) SWIG_fail; 2503 2504 %#ifdef SWIGPY_USE_CAPSULE 2505 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2506 %#else 2507 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2508 %#endif 2509 2510 %#if NPY_API_VERSION < 0x00000007 2511 PyArray_BASE(array) = cap; 2512 %#else 2513 PyArray_SetBaseObject(array,cap); 2514 %#endif 2515 2516 $result = SWIG_Python_AppendOutput($result,obj); 2517 } 2518 2519 /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 2520 */ 2521 %typemap(in,numinputs=0) 2522 (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 ) 2523 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp) 2524 { 2525 $1 = &data_temp; 2526 $2 = &dim1_temp; 2527 $3 = &dim2_temp; 2528 } 2529 %typemap(argout, 2530 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2531 (DATA_TYPE** ARGOUTVIEWM_FARRAY2, DIM_TYPE* DIM1, DIM_TYPE* DIM2) 2532 { 2533 npy_intp dims[2] = { *$2, *$3 }; 2534 PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$1)); 2535 PyArrayObject* array = (PyArrayObject*) obj; 2536 2537 if (!array || !require_fortran(array)) SWIG_fail; 2538 2539 %#ifdef SWIGPY_USE_CAPSULE 2540 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2541 %#else 2542 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2543 %#endif 2544 2545 %#if NPY_API_VERSION < 0x00000007 2546 PyArray_BASE(array) = cap; 2547 %#else 2548 PyArray_SetBaseObject(array,cap); 2549 %#endif 2550 2551 $result = SWIG_Python_AppendOutput($result,obj); 2552 } 2553 2554 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2) 2555 */ 2556 %typemap(in,numinputs=0) 2557 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DATA_TYPE** ARGOUTVIEWM_FARRAY2) 2558 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DATA_TYPE* data_temp = NULL ) 2559 { 2560 $1 = &dim1_temp; 2561 $2 = &dim2_temp; 2562 $3 = &data_temp; 2563 } 2564 %typemap(argout, 2565 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2566 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DATA_TYPE** ARGOUTVIEWM_FARRAY2) 2567 { 2568 npy_intp dims[2] = { *$1, *$2 }; 2569 PyObject* obj = PyArray_SimpleNewFromData(2, dims, DATA_TYPECODE, (void*)(*$3)); 2570 PyArrayObject* array = (PyArrayObject*) obj; 2571 2572 if (!array || !require_fortran(array)) SWIG_fail; 2573 2574 %#ifdef SWIGPY_USE_CAPSULE 2575 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2576 %#else 2577 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2578 %#endif 2579 2580 %#if NPY_API_VERSION < 0x00000007 2581 PyArray_BASE(array) = cap; 2582 %#else 2583 PyArray_SetBaseObject(array,cap); 2584 %#endif 2585 2586 $result = SWIG_Python_AppendOutput($result,obj); 2587 } 2588 2589 /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, 2590 DIM_TYPE* DIM3) 2591 */ 2592 %typemap(in,numinputs=0) 2593 (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) 2594 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) 2595 { 2596 $1 = &data_temp; 2597 $2 = &dim1_temp; 2598 $3 = &dim2_temp; 2599 $4 = &dim3_temp; 2600 } 2601 %typemap(argout, 2602 fragment="NumPy_Backward_Compatibility") 2603 (DATA_TYPE** ARGOUTVIEWM_ARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) 2604 { 2605 npy_intp dims[3] = { *$2, *$3, *$4 }; 2606 PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); 2607 PyArrayObject* array = (PyArrayObject*) obj; 2608 2609 if (!array) SWIG_fail; 2610 2611 %#ifdef SWIGPY_USE_CAPSULE 2612 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2613 %#else 2614 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2615 %#endif 2616 2617 %#if NPY_API_VERSION < 0x00000007 2618 PyArray_BASE(array) = cap; 2619 %#else 2620 PyArray_SetBaseObject(array,cap); 2621 %#endif 2622 2623 $result = SWIG_Python_AppendOutput($result,obj); 2624 } 2625 2626 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, 2627 DATA_TYPE** ARGOUTVIEWM_ARRAY3) 2628 */ 2629 %typemap(in,numinputs=0) 2630 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DATA_TYPE** ARGOUTVIEWM_ARRAY3) 2631 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL ) 2632 { 2633 $1 = &dim1_temp; 2634 $2 = &dim2_temp; 2635 $3 = &dim3_temp; 2636 $4 = &data_temp; 2637 } 2638 %typemap(argout, 2639 fragment="NumPy_Backward_Compatibility") 2640 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_ARRAY3) 2641 { 2642 npy_intp dims[3] = { *$1, *$2, *$3 }; 2643 PyObject* obj= PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); 2644 PyArrayObject* array = (PyArrayObject*) obj; 2645 2646 if (!array) SWIG_fail; 2647 2648 %#ifdef SWIGPY_USE_CAPSULE 2649 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2650 %#else 2651 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2652 %#endif 2653 2654 %#if NPY_API_VERSION < 0x00000007 2655 PyArray_BASE(array) = cap; 2656 %#else 2657 PyArray_SetBaseObject(array,cap); 2658 %#endif 2659 2660 $result = SWIG_Python_AppendOutput($result,obj); 2661 } 2662 2663 /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, 2664 DIM_TYPE* DIM3) 2665 */ 2666 %typemap(in,numinputs=0) 2667 (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 ) 2668 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp) 2669 { 2670 $1 = &data_temp; 2671 $2 = &dim1_temp; 2672 $3 = &dim2_temp; 2673 $4 = &dim3_temp; 2674 } 2675 %typemap(argout, 2676 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2677 (DATA_TYPE** ARGOUTVIEWM_FARRAY3, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) 2678 { 2679 npy_intp dims[3] = { *$2, *$3, *$4 }; 2680 PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$1)); 2681 PyArrayObject* array = (PyArrayObject*) obj; 2682 2683 if (!array || require_fortran(array)) SWIG_fail; 2684 2685 %#ifdef SWIGPY_USE_CAPSULE 2686 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2687 %#else 2688 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2689 %#endif 2690 2691 %#if NPY_API_VERSION < 0x00000007 2692 PyArray_BASE(array) = cap; 2693 %#else 2694 PyArray_SetBaseObject(array,cap); 2695 %#endif 2696 2697 $result = SWIG_Python_AppendOutput($result,obj); 2698 } 2699 2700 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, 2701 DATA_TYPE** ARGOUTVIEWM_FARRAY3) 2702 */ 2703 %typemap(in,numinputs=0) 2704 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DATA_TYPE** ARGOUTVIEWM_FARRAY3) 2705 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DATA_TYPE* data_temp = NULL ) 2706 { 2707 $1 = &dim1_temp; 2708 $2 = &dim2_temp; 2709 $3 = &dim3_temp; 2710 $4 = &data_temp; 2711 } 2712 %typemap(argout, 2713 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2714 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DATA_TYPE** ARGOUTVIEWM_FARRAY3) 2715 { 2716 npy_intp dims[3] = { *$1, *$2, *$3 }; 2717 PyObject* obj = PyArray_SimpleNewFromData(3, dims, DATA_TYPECODE, (void*)(*$4)); 2718 PyArrayObject* array = (PyArrayObject*) obj; 2719 2720 if (!array || require_fortran(array)) SWIG_fail; 2721 2722 %#ifdef SWIGPY_USE_CAPSULE 2723 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2724 %#else 2725 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2726 %#endif 2727 2728 %#if NPY_API_VERSION < 0x00000007 2729 PyArray_BASE(array) = cap; 2730 %#else 2731 PyArray_SetBaseObject(array,cap); 2732 %#endif 2733 2734 $result = SWIG_Python_AppendOutput($result,obj); 2735 } 2736 2737 /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, 2738 DIM_TYPE* DIM3, DIM_TYPE* DIM4) 2739 */ 2740 %typemap(in,numinputs=0) 2741 (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) 2742 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) 2743 { 2744 $1 = &data_temp; 2745 $2 = &dim1_temp; 2746 $3 = &dim2_temp; 2747 $4 = &dim3_temp; 2748 $5 = &dim4_temp; 2749 } 2750 %typemap(argout, 2751 fragment="NumPy_Backward_Compatibility") 2752 (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) 2753 { 2754 npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; 2755 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); 2756 PyArrayObject* array = (PyArrayObject*) obj; 2757 2758 if (!array) SWIG_fail; 2759 2760 %#ifdef SWIGPY_USE_CAPSULE 2761 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2762 %#else 2763 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2764 %#endif 2765 2766 %#if NPY_API_VERSION < 0x00000007 2767 PyArray_BASE(array) = cap; 2768 %#else 2769 PyArray_SetBaseObject(array,cap); 2770 %#endif 2771 2772 $result = SWIG_Python_AppendOutput($result,obj); 2773 } 2774 2775 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, 2776 DATA_TYPE** ARGOUTVIEWM_ARRAY4) 2777 */ 2778 %typemap(in,numinputs=0) 2779 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_ARRAY4) 2780 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) 2781 { 2782 $1 = &dim1_temp; 2783 $2 = &dim2_temp; 2784 $3 = &dim3_temp; 2785 $4 = &dim4_temp; 2786 $5 = &data_temp; 2787 } 2788 %typemap(argout, 2789 fragment="NumPy_Backward_Compatibility") 2790 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4) 2791 { 2792 npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; 2793 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); 2794 PyArrayObject* array = (PyArrayObject*) obj; 2795 2796 if (!array) SWIG_fail; 2797 2798 %#ifdef SWIGPY_USE_CAPSULE 2799 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2800 %#else 2801 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2802 %#endif 2803 2804 %#if NPY_API_VERSION < 0x00000007 2805 PyArray_BASE(array) = cap; 2806 %#else 2807 PyArray_SetBaseObject(array,cap); 2808 %#endif 2809 2810 $result = SWIG_Python_AppendOutput($result,obj); 2811 } 2812 2813 /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, 2814 DIM_TYPE* DIM3, DIM_TYPE* DIM4) 2815 */ 2816 %typemap(in,numinputs=0) 2817 (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) 2818 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) 2819 { 2820 $1 = &data_temp; 2821 $2 = &dim1_temp; 2822 $3 = &dim2_temp; 2823 $4 = &dim3_temp; 2824 $5 = &dim4_temp; 2825 } 2826 %typemap(argout, 2827 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2828 (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3) 2829 { 2830 npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; 2831 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); 2832 PyArrayObject* array = (PyArrayObject*) obj; 2833 2834 if (!array || require_fortran(array)) SWIG_fail; 2835 2836 %#ifdef SWIGPY_USE_CAPSULE 2837 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2838 %#else 2839 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2840 %#endif 2841 2842 %#if NPY_API_VERSION < 0x00000007 2843 PyArray_BASE(array) = cap; 2844 %#else 2845 PyArray_SetBaseObject(array,cap); 2846 %#endif 2847 2848 $result = SWIG_Python_AppendOutput($result,obj); 2849 } 2850 2851 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, 2852 DATA_TYPE** ARGOUTVIEWM_FARRAY4) 2853 */ 2854 %typemap(in,numinputs=0) 2855 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_FARRAY4) 2856 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) 2857 { 2858 $1 = &dim1_temp; 2859 $2 = &dim2_temp; 2860 $3 = &dim3_temp; 2861 $4 = &dim4_temp; 2862 $5 = &data_temp; 2863 } 2864 %typemap(argout, 2865 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2866 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4) 2867 { 2868 npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; 2869 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); 2870 PyArrayObject* array = (PyArrayObject*) obj; 2871 2872 if (!array || require_fortran(array)) SWIG_fail; 2873 2874 %#ifdef SWIGPY_USE_CAPSULE 2875 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2876 %#else 2877 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2878 %#endif 2879 2880 %#if NPY_API_VERSION < 0x00000007 2881 PyArray_BASE(array) = cap; 2882 %#else 2883 PyArray_SetBaseObject(array,cap); 2884 %#endif 2885 2886 $result = SWIG_Python_AppendOutput($result,obj); 2887 } 2888 2889 /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, 2890 DIM_TYPE* DIM3, DIM_TYPE* DIM4) 2891 */ 2892 %typemap(in,numinputs=0) 2893 (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) 2894 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) 2895 { 2896 $1 = &data_temp; 2897 $2 = &dim1_temp; 2898 $3 = &dim2_temp; 2899 $4 = &dim3_temp; 2900 $5 = &dim4_temp; 2901 } 2902 %typemap(argout, 2903 fragment="NumPy_Backward_Compatibility") 2904 (DATA_TYPE** ARGOUTVIEWM_ARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) 2905 { 2906 npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; 2907 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); 2908 PyArrayObject* array = (PyArrayObject*) obj; 2909 2910 if (!array) SWIG_fail; 2911 2912 %#ifdef SWIGPY_USE_CAPSULE 2913 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2914 %#else 2915 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2916 %#endif 2917 2918 %#if NPY_API_VERSION < 0x00000007 2919 PyArray_BASE(array) = cap; 2920 %#else 2921 PyArray_SetBaseObject(array,cap); 2922 %#endif 2923 2924 $result = SWIG_Python_AppendOutput($result,obj); 2925 } 2926 2927 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, 2928 DATA_TYPE** ARGOUTVIEWM_ARRAY4) 2929 */ 2930 %typemap(in,numinputs=0) 2931 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_ARRAY4) 2932 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) 2933 { 2934 $1 = &dim1_temp; 2935 $2 = &dim2_temp; 2936 $3 = &dim3_temp; 2937 $4 = &dim4_temp; 2938 $5 = &data_temp; 2939 } 2940 %typemap(argout, 2941 fragment="NumPy_Backward_Compatibility") 2942 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_ARRAY4) 2943 { 2944 npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; 2945 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); 2946 PyArrayObject* array = (PyArrayObject*) obj; 2947 2948 if (!array) SWIG_fail; 2949 2950 %#ifdef SWIGPY_USE_CAPSULE 2951 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2952 %#else 2953 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2954 %#endif 2955 2956 %#if NPY_API_VERSION < 0x00000007 2957 PyArray_BASE(array) = cap; 2958 %#else 2959 PyArray_SetBaseObject(array,cap); 2960 %#endif 2961 2962 $result = SWIG_Python_AppendOutput($result,obj); 2963 } 2964 2965 /* Typemap suite for (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, 2966 DIM_TYPE* DIM3, DIM_TYPE* DIM4) 2967 */ 2968 %typemap(in,numinputs=0) 2969 (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 ) 2970 (DATA_TYPE* data_temp = NULL , DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp) 2971 { 2972 $1 = &data_temp; 2973 $2 = &dim1_temp; 2974 $3 = &dim2_temp; 2975 $4 = &dim3_temp; 2976 $5 = &dim4_temp; 2977 } 2978 %typemap(argout, 2979 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 2980 (DATA_TYPE** ARGOUTVIEWM_FARRAY4, DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4) 2981 { 2982 npy_intp dims[4] = { *$2, *$3, *$4 , *$5 }; 2983 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$1)); 2984 PyArrayObject* array = (PyArrayObject*) obj; 2985 2986 if (!array || require_fortran(array)) SWIG_fail; 2987 2988 %#ifdef SWIGPY_USE_CAPSULE 2989 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 2990 %#else 2991 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 2992 %#endif 2993 2994 %#if NPY_API_VERSION < 0x00000007 2995 PyArray_BASE(array) = cap; 2996 %#else 2997 PyArray_SetBaseObject(array,cap); 2998 %#endif 2999 3000 $result = SWIG_Python_AppendOutput($result,obj); 3001 } 3002 3003 /* Typemap suite for (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, 3004 DATA_TYPE** ARGOUTVIEWM_FARRAY4) 3005 */ 3006 %typemap(in,numinputs=0) 3007 (DIM_TYPE* DIM1 , DIM_TYPE* DIM2 , DIM_TYPE* DIM3 , DIM_TYPE* DIM4 , DATA_TYPE** ARGOUTVIEWM_FARRAY4) 3008 (DIM_TYPE dim1_temp, DIM_TYPE dim2_temp, DIM_TYPE dim3_temp, DIM_TYPE dim4_temp, DATA_TYPE* data_temp = NULL ) 3009 { 3010 $1 = &dim1_temp; 3011 $2 = &dim2_temp; 3012 $3 = &dim3_temp; 3013 $4 = &dim4_temp; 3014 $5 = &data_temp; 3015 } 3016 %typemap(argout, 3017 fragment="NumPy_Backward_Compatibility,NumPy_Array_Requirements") 3018 (DIM_TYPE* DIM1, DIM_TYPE* DIM2, DIM_TYPE* DIM3, DIM_TYPE* DIM4, DATA_TYPE** ARGOUTVIEWM_FARRAY4) 3019 { 3020 npy_intp dims[4] = { *$1, *$2, *$3 , *$4 }; 3021 PyObject* obj = PyArray_SimpleNewFromData(4, dims, DATA_TYPECODE, (void*)(*$5)); 3022 PyArrayObject* array = (PyArrayObject*) obj; 3023 3024 if (!array || require_fortran(array)) SWIG_fail; 3025 3026 %#ifdef SWIGPY_USE_CAPSULE 3027 PyObject* cap = PyCapsule_New((void*)(*$1), SWIGPY_CAPSULE_NAME, free_cap); 3028 %#else 3029 PyObject* cap = PyCObject_FromVoidPtr((void*)(*$1), free); 3030 %#endif 3031 3032 %#if NPY_API_VERSION < 0x00000007 3033 PyArray_BASE(array) = cap; 3034 %#else 3035 PyArray_SetBaseObject(array,cap); 3036 %#endif 3037 3038 $result = SWIG_Python_AppendOutput($result,obj); 3039 } 3040 3041 %enddef /* %numpy_typemaps() macro */ 3042 /* *************************************************************** */ 3043 3044 /* Concrete instances of the %numpy_typemaps() macro: Each invocation 3045 * below applies all of the typemaps above to the specified data type. 3046 */ 3047 %numpy_typemaps(signed char , NPY_BYTE , int) 3048 %numpy_typemaps(unsigned char , NPY_UBYTE , int) 3049 %numpy_typemaps(short , NPY_SHORT , int) 3050 %numpy_typemaps(unsigned short , NPY_USHORT , int) 3051 %numpy_typemaps(int , NPY_INT , int) 3052 %numpy_typemaps(unsigned int , NPY_UINT , int) 3053 %numpy_typemaps(long , NPY_LONG , int) 3054 %numpy_typemaps(unsigned long , NPY_ULONG , int) 3055 %numpy_typemaps(long long , NPY_LONGLONG , int) 3056 %numpy_typemaps(unsigned long long, NPY_ULONGLONG, int) 3057 %numpy_typemaps(float , NPY_FLOAT , int) 3058 %numpy_typemaps(double , NPY_DOUBLE , int) 3059 3060 /* *************************************************************** 3061 * The follow macro expansion does not work, because C++ bool is 4 3062 * bytes and NPY_BOOL is 1 byte 3063 * 3064 * %numpy_typemaps(bool, NPY_BOOL, int) 3065 */ 3066 3067 /* *************************************************************** 3068 * On my Mac, I get the following warning for this macro expansion: 3069 * 'swig/python detected a memory leak of type 'long double *', no destructor found.' 3070 * 3071 * %numpy_typemaps(long double, NPY_LONGDOUBLE, int) 3072 */ 3073 3074 /* *************************************************************** 3075 * Swig complains about a syntax error for the following macro 3076 * expansions: 3077 * 3078 * %numpy_typemaps(complex float, NPY_CFLOAT , int) 3079 * 3080 * %numpy_typemaps(complex double, NPY_CDOUBLE, int) 3081 * 3082 * %numpy_typemaps(complex long double, NPY_CLONGDOUBLE, int) 3083 */ 3084 3085 #endif /* SWIGPYTHON */ 3086