1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
|
/***********************************************************************
Helper functions from numpy.i, translated by John Hunter
************************************************************************/
#define is_array(a) ((a) && PyArray_Check((PyArrayObject *)a))
#define array_type(a) (int)(((PyArrayObject *)a)->descr->type_num)
#define array_dimensions(a) (((PyArrayObject *)a)->nd)
#define array_size(a,i) (((PyArrayObject *)a)->dimensions[i])
#define array_is_contiguous(a) (PyArray_ISCONTIGUOUS(a))
/* Given a PyObject, return a string describing its type.
*/
char* pytype_string(PyObject* py_obj)
/* Given a Numeric typecode, return a string describing the type.
*/
char* typecode_string(int typecode)
/* Make sure input has correct numeric type. Allow character and byte
* to match. Also allow int and long to match.
*/
int type_match(int actual_type, int desired_type)
/* Given a PyObject pointer, cast it to a PyArrayObject pointer if
* legal. If not, set the python error string appropriately and
* return NULL.
*/
PyArrayObject* obj_to_array_no_conversion(PyObject* input, int typecode)
/* Convert the given PyObject to a Numeric array with the given
* typecode. On Success, return a valid PyArrayObject* with the
* correct type. On failure, the python error string will be set and
* the routine returns NULL.
*/
PyArrayObject* obj_to_array_allow_conversion(PyObject* input, int typecode,
int* is_new_object)
/* Given a PyArrayObject, check to see if it is contiguous. If so,
* return the input pointer and flag it as not a new object. If it is
* not contiguous, create a new PyArrayObject using the original data,
* flag it as a new object and return the pointer.
*/
PyArrayObject* make_contiguous(PyArrayObject* ary, int* is_new_object,
int min_dims, int max_dims)
/* Convert a given PyObject to a contiguous PyArrayObject of the
* specified type. If the input object is not a contiguous
* PyArrayObject, a new one will be created and the new object flag
* will be set.
*/
PyArrayObject* obj_to_array_contiguous_allow_conversion(PyObject* input,
int typecode,
int* is_new_object)
/* Test whether a python object is contiguous. If array is
* contiguous, return 1. Otherwise, set the python error string and
* return 0.
*/
int require_contiguous(PyArrayObject* ary)
/* Require the given PyArrayObject to have a specified number of
* dimensions. If the array has the specified number of dimensions,
* return 1. Otherwise, set the python error string and return 0.
*/
int require_dimensions(PyArrayObject* ary, int exact_dimensions)
/* Require the given PyArrayObject to have one of a list of specified
* number of dimensions. If the array has one of the specified number
* of dimensions, return 1. Otherwise, set the python error string
* and return 0.
*/
int require_dimensions_n(PyArrayObject* ary, int* exact_dimensions, int n)
/* Require the given PyArrayObject to have a specified shape. If the
* array has the specified shape, return 1. Otherwise, set the python
* error string and return 0.
*/
int require_size(PyArrayObject* ary, int* size, int n)
/***********************************************************************
Helper functions from Anna Omelchenko and Michel Sanner
************************************************************************/
/********************************************************************
The following function tries to create a contiguous numeric array of type
typecode from a Python object. Works for list, tuples and numeric arrays.
obj: Numeric array , Python object
typecode: data type PyArray_{ CHAR, UBYTE, SBYTE, SHORT, INT, LONG, FLOAT,
DOUBLE, CFLOAT, CDOUBLE }
expectnd: required number of dimensions. Used for checking. Ignored if <=0.
expectdims: array of expected extends. Used for checking. Ignored if <=0.
Raises ValueError exceptions if:
- the PyArray_ContiguousFromObject fails
- the array has a bad shape
- the extent of a given dimension doesn't match the specified extent.
If obj is a contiguous PyArrayObject then a reference is returned;
If op is PyObject sequence object(list, tuple) then a new PyArrayObject is created
and returned.
********************************************************************/
static PyArrayObject *contiguous_typed_array(PyObject *obj, int typecode,
int expectnd, int *expectdims)
|
