diff options
| author | Mark Wiebe <mwiebe@enthought.com> | 2011-07-26 12:14:21 -0500 |
|---|---|---|
| committer | Mark Wiebe <mwiebe@enthought.com> | 2011-07-26 12:14:21 -0500 |
| commit | 9163993794f1bc56c279ab3d90796370d6b579c4 (patch) | |
| tree | f5a40b3c0ca60bf9d7a645073e0600e36ccdd60f | |
| parent | 1b62bdfb04e56f75fc61dbbd1f2600a72951b19d (diff) | |
| parent | affea42d886e8233fdd6f3c5760708e3a9e9b1b8 (diff) | |
| download | numpy-9163993794f1bc56c279ab3d90796370d6b579c4.tar.gz | |
Merge branch 'deprecate_array_field_access'
69 files changed, 3167 insertions, 2414 deletions
diff --git a/doc/neps/missing-data.rst b/doc/neps/missing-data.rst index 7a2c076cb..f983d0ce3 100644 --- a/doc/neps/missing-data.rst +++ b/doc/neps/missing-data.rst @@ -225,27 +225,30 @@ provides a starting point. For example,:: - >>> np.array([1.0, 2.0, np.NA, 7.0], namasked=True) - array([1., 2., NA, 7.], namasked=True) - >>> np.array([1.0, 2.0, np.NA, 7.0], dtype='NA[f8]') + >>> np.array([1.0, 2.0, np.NA, 7.0], maskna=True) + array([1., 2., NA, 7.], maskna=True) + >>> np.array([1.0, 2.0, np.NA, 7.0], dtype='NA') array([1., 2., NA, 7.], dtype='NA[<f8]') + >>> np.array([1.0, 2.0, np.NA, 7.0], dtype='NA[f4]') + array([1., 2., NA, 7.], dtype='NA[<f4]') produce arrays with values [1.0, 2.0, <inaccessible>, 7.0] / -mask [Unmasked, Unmasked, Masked, Unmasked], and -values [1.0, 2.0, <NA bitpattern>, 7.0] respectively. +mask [Exposed, Exposed, Hidden, Exposed], and +values [1.0, 2.0, <NA bitpattern>, 7.0] for the masked and +NA dtype versions respectively. It may be worth overloading the np.NA __call__ method to accept a dtype, returning a zero-dimensional array with a missing value of that dtype. Without doing this, NA printouts would look like:: - >>> np.sum(np.array([1.0, 2.0, np.NA, 7.0], namasked=True)) - array(NA, dtype='float64', namasked=True) + >>> np.sum(np.array([1.0, 2.0, np.NA, 7.0], maskna=True)) + array(NA, dtype='float64', maskna=True) >>> np.sum(np.array([1.0, 2.0, np.NA, 7.0], dtype='NA[f8]')) array(NA, dtype='NA[<f8]') but with this, they could be printed as:: - >>> np.sum(np.array([1.0, 2.0, np.NA, 7.0], namasked=True)) + >>> np.sum(np.array([1.0, 2.0, np.NA, 7.0], maskna=True)) NA('float64') >>> np.sum(np.array([1.0, 2.0, np.NA, 7.0], dtype='NA[f8]')) NA('NA[<f8]') @@ -274,12 +277,12 @@ from another view which doesn't have them masked. For example:: >>> a = np.array([1,2]) >>> b = a.view() - >>> b.flags.hasnamask = True + >>> b.flags.hasmaskna = True >>> b - array([1,2], namasked=True) + array([1,2], maskna=True) >>> b[0] = np.NA >>> b - array([NA,2], namasked=True) + array([NA,2], maskna=True) >>> a array([1,2]) >>> # The underlying number 1 value in 'a[0]' was untouched @@ -351,10 +354,10 @@ Creating Masked Arrays There are two flags which indicate and control the nature of the mask used in masked arrays. -First is 'arr.flags.hasnamask', which is True for all masked arrays and +First is 'arr.flags.hasmaskna', which is True for all masked arrays and may be set to True to add a mask to an array which does not have one. -Second is 'arr.flags.ownnamask', which is True if the array owns the +Second is 'arr.flags.ownmaskna', which is True if the array owns the memory to the mask, and False if the array has no mask, or has a view into the mask of another array. If this is set to False in a masked array, the array will create a copy of the mask so that further modifications @@ -402,8 +405,16 @@ New functions added to the ndarray are:: array is unmasked and has the 'NA' part stripped from the parameterized type ('NA[f8]' becomes just 'f8'). - arr.view(namasked=True) - This is a shortcut for 'a = arr.view(); a.flags.hasnamask=True'. + arr.view(maskna=True) + This is a shortcut for + >>> a = arr.view() + >>> a.flags.hasmaskna = True + + arr.view(ownmaskna=True) + This is a shortcut for + >>> a = arr.view() + >>> a.flags.hasmaskna = True + >>> a.flags.ownmaskna = True Element-wise UFuncs With Missing Values ======================================= @@ -461,9 +472,9 @@ will also use the unmasked value counts for their calculations if Some examples:: - >>> a = np.array([1., 3., np.NA, 7.], namasked=True) + >>> a = np.array([1., 3., np.NA, 7.], maskna=True) >>> np.sum(a) - array(NA, dtype='<f8', masked=True) + array(NA, dtype='<f8', maskna=True) >>> np.sum(a, skipna=True) 11.0 >>> np.mean(a) @@ -471,11 +482,11 @@ Some examples:: >>> np.mean(a, skipna=True) 3.6666666666666665 - >>> a = np.array([np.NA, np.NA], dtype='f8', namasked=True) + >>> a = np.array([np.NA, np.NA], dtype='f8', maskna=True) >>> np.sum(a, skipna=True) 0.0 >>> np.max(a, skipna=True) - array(NA, dtype='<f8', namasked=True) + array(NA, dtype='<f8', maskna=True) >>> np.mean(a) NA('<f8') >>> np.mean(a, skipna=True) @@ -487,20 +498,24 @@ The functions 'np.any' and 'np.all' require some special consideration, just as logical_and and logical_or do. Maybe the best way to describe their behavior is through a series of examples:: - >>> np.any(np.array([False, False, False], namasked=True)) + >>> np.any(np.array([False, False, False], maskna=True)) False - >>> np.any(np.array([False, NA, False], namasked=True)) + >>> np.any(np.array([False, np.NA, False], maskna=True)) NA - >>> np.any(np.array([False, NA, True], namasked=True)) + >>> np.any(np.array([False, np.NA, True], maskna=True)) True - >>> np.all(np.array([True, True, True], namasked=True)) + >>> np.all(np.array([True, True, True], maskna=True)) True - >>> np.all(np.array([True, NA, True], namasked=True)) + >>> np.all(np.array([True, np.NA, True], maskna=True)) NA - >>> np.all(np.array([False, NA, True], namasked=True)) + >>> np.all(np.array([False, np.NA, True], maskna=True)) False +Since 'np.any' is the reduction for 'np.logical_or', and 'np.all' +is the reduction for 'np.logical_and', it makes sense for them to +have a 'skipna=' parameter like the other similar reduction functions. + Parameterized NA Data Types =========================== @@ -609,14 +624,124 @@ The important part of future-proofing the design is making sure the C ABI-level choices and the Python API-level choices have a natural transition to multi-NA support. Here is one way multi-NA support could look:: - >>> a = np.array([np.NA(1), 3, np.NA(2)], namasked='multi') + >>> a = np.array([np.NA(1), 3, np.NA(2)], maskna='multi') >>> np.sum(a) - NA(1) + NA(1, dtype='<i4') >>> np.sum(a[1:]) - NA(2) - >>> b = np.array([np.NA, 2, 5], namasked=True) + NA(2, dtype='<i4') + >>> b = np.array([np.NA, 2, 5], maskna=True) >>> a + b - array([NA(0), 5, NA(2)], namasked='multi') + array([NA(0), 5, NA(2)], maskna='multi') + +The design of this NEP does not distinguish between NAs that come +from an NA mask or NAs that come from an NA dtype. Both of these get +treated equivalently in computations, with masks dominating over NA +dtypes.:: + + >>> a = np.array([np.NA, 2, 5], maskna=True) + >>> b = np.array([1, np.NA, 7], dtype='NA') + >>> a + b + array([NA, NA, 12], maskna=True) + +The multi-NA approach allows one to distinguish between these NAs, +through assigning different payloads to the different types. If we +extend the 'skipna=' parameter to accept a list of payloads in addition +to True/False, one could do this:: + + >>> a = np.array([np.NA(1), 2, 5], maskna='multi') + >>> b = np.array([1, np.NA(0), 7], dtype='NA[f4,multi]') + >>> a + b + array([NA(1), NA(0), 12], maskna='multi') + >>> np.sum(a, skipna=0) + NA(1, dtype='<i4') + >>> np.sum(a, skipna=1) + 7 + >>> np.sum(b, skipna=0) + 8 + >>> np.sum(b, skipna=1) + NA(0, dtype='<f4') + >>> np.sum(a+b, skipna=(0,1)) + 12 + +Differences with numpy.ma +========================= + +The computational model that numpy.ma uses does not strictly adhere to +either the NA or the IGNORE model. This section exhibits some examples +of how these differences affect simple computations. This information +will be very important for helping users navigate between the systems, +so a summary probably should be put in a table in the documentation.:: + + >>> a = np.random.random((3, 2)) + >>> mask = [[False, True], [True, True], [False, False]] + >>> b1 = np.ma.masked_array(a, mask=mask) + >>> b2 = a.view(maskna=True) + >>> b2[mask] = np.NA + + >>> b1 + masked_array(data = + [[0.110804969841 --] + [-- --] + [0.955128477746 0.440430735546]], + mask = + [[False True] + [ True True] + [False False]], + fill_value = 1e+20) + >>> b2 + array([[0.110804969841, NA], + [NA, NA], + [0.955128477746, 0.440430735546]], + maskna=True) + + >>> b1.mean(axis=0) + masked_array(data = [0.532966723794 0.440430735546], + mask = [False False], + fill_value = 1e+20) + + >>> b2.mean(axis=0) + array([NA, NA], dtype='<f8', maskna=True) + >>> b2.mean(axis=0, skipna=True) + array([0.532966723794 0.440430735546], maskna=True) + +For functions like np.mean, when 'skipna=True', the behavior +for all NAs is consistent with an empty array:: + + >>> b1.mean(axis=1) + masked_array(data = [0.110804969841 -- 0.697779606646], + mask = [False True False], + fill_value = 1e+20) + + >>> b2.mean(axis=1) + array([NA, NA, 0.697779606646], maskna=True) + >>> b2.mean(axis=1, skipna=True) + RuntimeWarning: invalid value encountered in double_scalars + array([0.110804969841, nan, 0.697779606646], maskna=True) + + >>> np.mean([]) + RuntimeWarning: invalid value encountered in double_scalars + nan + +In particular, note that numpy.ma generally skips masked values, +except returns masked when all the values are masked, while +the 'skipna=' parameter returns zero when all the values are NA, +to be consistent with the result of np.sum([]):: + + >>> b1[1] + masked_array(data = [-- --], + mask = [ True True], + fill_value = 1e+20) + >>> b2[1] + array([NA, NA], dtype='<f8', maskna=True) + >>> b1[1].sum() + masked + >>> b2[1].sum() + NA(dtype='<f8') + >>> b2[1].sum(skipna=True) + 0.0 + + >>> np.sum([]) + 0.0 PEP 3118 ======== @@ -696,28 +821,28 @@ This gives us the following additions to the PyArrayObject:: /* * Descriptor for the mask dtype. * If no mask: NULL - * If mask : bool/structured dtype of bools + * If mask : bool/uint8/structured dtype of mask dtypes */ - PyArray_Descr *maskdescr; + PyArray_Descr *maskna_descr; /* * Raw data buffer for mask. If the array has the flag - * NPY_ARRAY_OWNNAMASK enabled, it owns this memory and + * NPY_ARRAY_OWNMASKNA enabled, it owns this memory and * must call PyArray_free on it when destroyed. */ - npy_uint8 *maskdata; + npy_mask *maskna_data; /* * Just like dimensions and strides point into the same memory * buffer, we now just make the buffer 3x the nd instead of 2x * and use the same buffer. */ - npy_intp *maskstrides; + npy_intp *maskna_strides; There are 2 (or 3) flags which must be added to the array flags:: - NPY_ARRAY_HASNAMASK - NPY_ARRAY_OWNNAMASK + NPY_ARRAY_HASMASKNA + NPY_ARRAY_OWNMASKNA /* To possibly add in a later revision */ - NPY_ARRAY_HARDNAMASK + NPY_ARRAY_HARDMASKNA To allow the easy detection of NA support, and whether an array has any missing values, we add the following functions: @@ -807,7 +932,7 @@ NPY_ITER_ARRAYMASK can be only one such mask, and there cannot also be a virtual mask. - As a special case, if the flag NPY_ITER_USE_NAMASK is specified + As a special case, if the flag NPY_ITER_USE_MASKNA is specified at the same time, the mask for the operand is used instead of the operand itself. If the operand has no mask but is based on an NA dtype, that mask exposed by the iterator converts @@ -827,14 +952,14 @@ Iterator NA-array Features We add several new per-operand flags: -NPY_ITER_USE_NAMASK +NPY_ITER_USE_MASKNA If the operand has an NA dtype, an NA mask, or both, this adds a new virtual operand to the end of the operand list which iterates over the mask of the particular operand. -NPY_ITER_IGNORE_NAMASK +NPY_ITER_IGNORE_MASKNA If an operand has an NA mask, by default the iterator will raise - an exception unless NPY_ITER_USE_NAMASK is specified. This flag + an exception unless NPY_ITER_USE_MASKNA is specified. This flag disables that check, and is intended for cases where one has first checked that all the elements in the array are not NA using the PyArray_ContainsNA function. diff --git a/doc/source/reference/c-api.array.rst b/doc/source/reference/c-api.array.rst index 22a7b46fa..4b57945e9 100644 --- a/doc/source/reference/c-api.array.rst +++ b/doc/source/reference/c-api.array.rst @@ -50,6 +50,18 @@ sub-types). .. cfunction:: PyObject *PyArray_BASE(PyObject* arr) + This returns the base object of the array. In most cases, this + means the object which owns the memory the array is pointing at. + + If you are constructing an array using the C API, and specifying + your own memory, you should use the function :cfunc:`PyArray_SetBaseObject` + to set the base to an object which owns the memory. + + If the :cdata:`NPY_ARRAY_UPDATEIFCOPY` flag is set, it has a different + meaning, namely base is the array into which the current array will + be copied upon destruction. This overloading of the base property + for two functions is likely to change in a future version of NumPy. + .. cfunction:: PyArray_Descr *PyArray_DESCR(PyObject* arr) .. cfunction:: int PyArray_FLAGS(PyObject* arr) @@ -149,7 +161,7 @@ From scratch is not ``NULL``, then it is assumed to point to the memory to be used for the array and the *flags* argument is used as the new flags for the array (except the state of :cdata:`NPY_OWNDATA` and - :cdata:`UPDATEIFCOPY` flags of the new array will be reset). In + :cdata:`NPY_ARRAY_UPDATEIFCOPY` flags of the new array will be reset). In addition, if *data* is non-NULL, then *strides* can also be provided. If *strides* is ``NULL``, then the array strides are computed as C-style contiguous (default) or Fortran-style @@ -266,6 +278,19 @@ From scratch increments of ``step``. Equivalent to arange( ``start``, ``stop``, ``step``, ``typenum`` ). +.. cfunction:: int PyArray_SetBaseObject(PyArrayObject *arr, PyObject *obj) + + If you construct an array by passing in your own memory buffer as + a parameter, you need to set the array's `base` property to ensure + the lifetime of the memory buffer is appropriate. This function + accomplishes the task. + + The return value is 0 on success, -1 on failure. + + If the object provided is an array, this function traverses the + chain of `base` pointers so that each array points to the owner + of the memory directly. Once the base is set, it may not be changed + to another value. From other objects ^^^^^^^^^^^^^^^^^^ diff --git a/numpy/core/_internal.py b/numpy/core/_internal.py index e46e1441a..3d6702095 100644 --- a/numpy/core/_internal.py +++ b/numpy/core/_internal.py @@ -132,60 +132,42 @@ def _reconstruct(subtype, shape, dtype): return ndarray.__new__(subtype, shape, dtype) -# format_re and _split were taken from numarray by J. Todd Miller +# format_re was originally from numarray by J. Todd Miller -def _split(input): - """Split the input formats string into field formats without splitting - the tuple used to specify multi-dimensional arrays.""" - - newlist = [] - hold = asbytes('') - - listinput = input.split(asbytes(',')) - for element in listinput: - if hold != asbytes(''): - item = hold + asbytes(',') + element - else: - item = element - left = item.count(asbytes('(')) - right = item.count(asbytes(')')) - - # if the parenthesis is not balanced, hold the string - if left > right : - hold = item - - # when balanced, append to the output list and reset the hold - elif left == right: - newlist.append(item.strip()) - hold = asbytes('') - - # too many close parenthesis is unacceptable - else: - raise SyntaxError(item) - - # if there is string left over in hold - if hold != asbytes(''): - raise SyntaxError(hold) - - return newlist - -format_re = re.compile(asbytes(r'(?P<order1>[<>|=]?)(?P<repeats> *[(]?[ ,0-9]*[)]? *)(?P<order2>[<>|=]?)(?P<dtype>[A-Za-z0-9.]*)')) +format_re = re.compile(asbytes( + r'(?P<order1>[<>|=]?)' + r'(?P<repeats> *[(]?[ ,0-9]*[)]? *)' + r'(?P<order2>[<>|=]?)' + r'(?P<dtype>[A-Za-z0-9.]*(?:\[[a-zA-Z0-9,.]+\])?)')) +sep_re = re.compile(asbytes(r'\s*,\s*')) +space_re = re.compile(asbytes(r'\s+$')) # astr is a string (perhaps comma separated) _convorder = {asbytes('='): _nbo} def _commastring(astr): - res = _split(astr) - if (len(res)) < 1: - raise ValueError("unrecognized formant") + startindex = 0 result = [] - for k,item in enumerate(res): - # convert item + while startindex < len(astr): + mo = format_re.match(astr, pos=startindex) try: - (order1, repeats, order2, dtype) = format_re.match(item).groups() + (order1, repeats, order2, dtype) = mo.groups() except (TypeError, AttributeError): - raise ValueError('format %s is not recognized' % item) + raise ValueError('format number %d of "%s" is not recognized' % + (len(result)+1, astr)) + startindex = mo.end() + # Separator or ending padding + if startindex < len(astr): + if space_re.match(astr, pos=startindex): + startindex = len(astr) + else: + mo = sep_re.match(astr, pos=startindex) + if not mo: + raise ValueError( + 'format number %d of "%s" is not recognized' % + (len(result)+1, astr)) + startindex = mo.end() if order2 == asbytes(''): order = order1 @@ -195,7 +177,7 @@ def _commastring(astr): order1 = _convorder.get(order1, order1) order2 = _convorder.get(order2, order2) if (order1 != order2): - raise ValueError('in-consistent byte-order specification %s and %s' % (order1, order2)) + raise ValueError('inconsistent byte-order specification %s and %s' % (order1, order2)) order = order1 if order in [asbytes('|'), asbytes('='), _nbo]: diff --git a/numpy/core/code_generators/generate_numpy_api.py b/numpy/core/code_generators/generate_numpy_api.py index 2f4316d17..7cd4b9f6a 100644 --- a/numpy/core/code_generators/generate_numpy_api.py +++ b/numpy/core/code_generators/generate_numpy_api.py @@ -220,7 +220,9 @@ def do_generate_api(targets, sources): for name, index in types_api.items(): multiarray_api_dict[name] = TypeApi(name, index, 'PyTypeObject', api_name) - assert len(multiarray_api_dict) == len(multiarray_api_index) + if len(multiarray_api_dict) != len(multiarray_api_index): + raise AssertionError, "Multiarray API size mismatch %d %d" % \ + (len(multiarray_api_dict), len(multiarray_api_index)) extension_list = [] for name, index in genapi.order_dict(multiarray_api_index): diff --git a/numpy/core/code_generators/generate_umath.py b/numpy/core/code_generators/generate_umath.py index 296f4683d..477cd122b 100644 --- a/numpy/core/code_generators/generate_umath.py +++ b/numpy/core/code_generators/generate_umath.py @@ -121,7 +121,7 @@ import string if sys.version_info[0] < 3: UPPER_TABLE = string.maketrans(string.ascii_lowercase, string.ascii_uppercase) else: - UPPER_TABLE = bytes.maketrans(bytes(string.ascii_lowercase, "ascii"), + UPPER_TABLE = bytes.maketrans(bytes(string.ascii_lowercase, "ascii"), bytes(string.ascii_uppercase, "ascii")) def english_upper(s): diff --git a/numpy/core/code_generators/numpy_api.py b/numpy/core/code_generators/numpy_api.py index d83371319..a256d849a 100644 --- a/numpy/core/code_generators/numpy_api.py +++ b/numpy/core/code_generators/numpy_api.py @@ -318,6 +318,7 @@ multiarray_funcs_api = { # End 1.6 API 'PyArray_MaskedCopyInto': 281, 'PyArray_MaskedMoveInto': 282, + 'PyArray_SetBaseObject': 283, } ufunc_types_api = { diff --git a/numpy/core/include/numpy/ndarrayobject.h b/numpy/core/include/numpy/ndarrayobject.h index 04aa8d0e3..03dfcd9cd 100644 --- a/numpy/core/include/numpy/ndarrayobject.h +++ b/numpy/core/include/numpy/ndarrayobject.h @@ -42,7 +42,8 @@ extern "C" CONFUSE_EMACS #define PyArray_HasArrayInterface(op, out) \ PyArray_HasArrayInterfaceType(op, NULL, NULL, out) -#define PyArray_IsZeroDim(op) (PyArray_Check(op) && (PyArray_NDIM(op) == 0)) +#define PyArray_IsZeroDim(op) (PyArray_Check(op) && \ + (PyArray_NDIM((PyArrayObject *)op) == 0)) #define PyArray_IsScalar(obj, cls) \ (PyObject_TypeCheck(obj, &Py##cls##ArrType_Type)) @@ -159,12 +160,18 @@ extern "C" CONFUSE_EMACS (k)*PyArray_STRIDES(obj)[2] + \ (l)*PyArray_STRIDES(obj)[3])) -#define PyArray_XDECREF_ERR(obj) \ - if (obj && (PyArray_FLAGS(obj) & NPY_ARRAY_UPDATEIFCOPY)) { \ - PyArray_FLAGS(PyArray_BASE(obj)) |= NPY_ARRAY_WRITEABLE; \ - PyArray_FLAGS(obj) &= ~NPY_ARRAY_UPDATEIFCOPY; \ - } \ - Py_XDECREF(obj) +static NPY_INLINE void +PyArray_XDECREF_ERR(PyArrayObject *arr) +{ + if (arr != NULL) { + if (PyArray_FLAGS(arr) & NPY_ARRAY_UPDATEIFCOPY) { + PyArrayObject *base = (PyArrayObject *)PyArray_BASE(arr); + PyArray_ENABLEFLAGS(base, NPY_ARRAY_WRITEABLE); + PyArray_CLEARFLAGS(arr, NPY_ARRAY_UPDATEIFCOPY); + } + Py_DECREF(arr); + } +} #define PyArray_DESCR_REPLACE(descr) do { \ PyArray_Descr *_new_; \ diff --git a/numpy/core/include/numpy/ndarraytypes.h b/numpy/core/include/numpy/ndarraytypes.h index 0f0673825..af705b936 100644 --- a/numpy/core/include/numpy/ndarraytypes.h +++ b/numpy/core/include/numpy/ndarraytypes.h @@ -74,7 +74,7 @@ enum NPY_TYPES { NPY_BOOL=0, * New 1.6 types appended, may be integrated * into the above in 2.0. */ - NPY_DATETIME, NPY_TIMEDELTA, NPY_HALF, + NPY_DATETIME, NPY_TIMEDELTA, NPY_HALF, NPY_NTYPES, NPY_NOTYPE, @@ -519,7 +519,7 @@ typedef struct { NPY_ITEM_IS_POINTER | NPY_ITEM_REFCOUNT | \ NPY_NEEDS_INIT | NPY_NEEDS_PYAPI) -#define PyDataType_FLAGCHK(dtype, flag) \ +#define PyDataType_FLAGCHK(dtype, flag) \ (((dtype)->flags & (flag)) == (flag)) #define PyDataType_REFCHK(dtype) \ @@ -573,12 +573,16 @@ typedef struct _arr_descr { } PyArray_ArrayDescr; /* - * The main array object structure. It is recommended to use the macros - * defined below (PyArray_DATA and friends) access fields here, instead - * of the members themselves. + * The main array object structure. + * + * It has been recommended to use the inline functions defined below + * (PyArray_DATA and friends) to access fields here for a number of + * releases. Direct access to the members themselves is deprecated. + * To ensure that your code does not use deprecated access, + * #define NPY_NO_DEPRECATED_API. */ - -typedef struct PyArrayObject { +/* This struct will be moved to a private header in a future release */ +typedef struct tagPyArrayObject_fieldaccess { PyObject_HEAD char *data; /* pointer to raw data buffer */ int nd; /* number of dimensions, also called ndim */ @@ -605,7 +609,25 @@ typedef struct PyArrayObject { PyArray_Descr *descr; /* Pointer to type structure */ int flags; /* Flags describing array -- see below */ PyObject *weakreflist; /* For weakreferences */ +} PyArrayObject_fieldaccess; + +/* + * To hide the implementation details, we only expose + * the Python struct HEAD. + */ +#ifdef NPY_NO_DEPRECATED_API +typedef struct tagPyArrayObject { + PyObject_HEAD } PyArrayObject; +#else +/* + * Can't put this in npy_deprecated_api.h like the others. + * PyArrayObject field access is deprecated as of NumPy 1.7. + */ +typedef PyArrayObject_fieldaccess PyArrayObject; +#endif + +#define NPY_SIZEOF_PYARRAYOBJECT (sizeof(PyArrayObject_fieldaccess)) /* Array Flags Object */ typedef struct PyArrayFlagsObject { @@ -785,9 +807,6 @@ typedef int (PyArray_FinalizeFunc)(PyArrayObject *, PyObject *); */ -#define PyArray_CHKFLAGS(m, FLAGS) \ - ((((PyArrayObject *)(m))->flags & (FLAGS)) == (FLAGS)) - #define PyArray_ISCONTIGUOUS(m) PyArray_CHKFLAGS(m, NPY_ARRAY_C_CONTIGUOUS) #define PyArray_ISWRITEABLE(m) PyArray_CHKFLAGS(m, NPY_ARRAY_WRITEABLE) #define PyArray_ISALIGNED(m) PyArray_CHKFLAGS(m, NPY_ARRAY_ALIGNED) @@ -939,122 +958,122 @@ struct PyArrayIterObject_tag { #define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type) #define _PyAIT(it) ((PyArrayIterObject *)(it)) -#define PyArray_ITER_RESET(it) { \ - _PyAIT(it)->index = 0; \ - _PyAIT(it)->dataptr = _PyAIT(it)->ao->data; \ - memset(_PyAIT(it)->coordinates, 0, \ - (_PyAIT(it)->nd_m1+1)*sizeof(npy_intp)); \ +#define PyArray_ITER_RESET(it) { \ + _PyAIT(it)->index = 0; \ + _PyAIT(it)->dataptr = PyArray_BYTES(_PyAIT(it)->ao); \ + memset(_PyAIT(it)->coordinates, 0, \ + (_PyAIT(it)->nd_m1+1)*sizeof(npy_intp)); \ } -#define _PyArray_ITER_NEXT1(it) { \ - (it)->dataptr += _PyAIT(it)->strides[0]; \ - (it)->coordinates[0]++; \ +#define _PyArray_ITER_NEXT1(it) { \ + (it)->dataptr += _PyAIT(it)->strides[0]; \ + (it)->coordinates[0]++; \ } -#define _PyArray_ITER_NEXT2(it) { \ - if ((it)->coordinates[1] < (it)->dims_m1[1]) { \ - (it)->coordinates[1]++; \ - (it)->dataptr += (it)->strides[1]; \ - } \ - else { \ - (it)->coordinates[1] = 0; \ - (it)->coordinates[0]++; \ - (it)->dataptr += (it)->strides[0] - \ - (it)->backstrides[1]; \ - } \ +#define _PyArray_ITER_NEXT2(it) { \ + if ((it)->coordinates[1] < (it)->dims_m1[1]) { \ + (it)->coordinates[1]++; \ + (it)->dataptr += (it)->strides[1]; \ + } \ + else { \ + (it)->coordinates[1] = 0; \ + (it)->coordinates[0]++; \ + (it)->dataptr += (it)->strides[0] - \ + (it)->backstrides[1]; \ + } \ } -#define _PyArray_ITER_NEXT3(it) { \ - if ((it)->coordinates[2] < (it)->dims_m1[2]) { \ - (it)->coordinates[2]++; \ - (it)->dataptr += (it)->strides[2]; \ - } \ - else { \ - (it)->coordinates[2] = 0; \ - (it)->dataptr -= (it)->backstrides[2]; \ - if ((it)->coordinates[1] < (it)->dims_m1[1]) { \ - (it)->coordinates[1]++; \ - (it)->dataptr += (it)->strides[1]; \ - } \ - else { \ - (it)->coordinates[1] = 0; \ - (it)->coordinates[0]++; \ - (it)->dataptr += (it)->strides[0] - \ - (it)->backstrides[1]; \ - } \ - } \ +#define _PyArray_ITER_NEXT3(it) { \ + if ((it)->coordinates[2] < (it)->dims_m1[2]) { \ + (it)->coordinates[2]++; \ + (it)->dataptr += (it)->strides[2]; \ + } \ + else { \ + (it)->coordinates[2] = 0; \ + (it)->dataptr -= (it)->backstrides[2]; \ + if ((it)->coordinates[1] < (it)->dims_m1[1]) { \ + (it)->coordinates[1]++; \ + (it)->dataptr += (it)->strides[1]; \ + } \ + else { \ + (it)->coordinates[1] = 0; \ + (it)->coordinates[0]++; \ + (it)->dataptr += (it)->strides[0] \ + (it)->backstrides[1]; \ + } \ + } \ } -#define PyArray_ITER_NEXT(it) { \ - _PyAIT(it)->index++; \ - if (_PyAIT(it)->nd_m1 == 0) { \ - _PyArray_ITER_NEXT1(_PyAIT(it)); \ - } \ - else if (_PyAIT(it)->contiguous) \ - _PyAIT(it)->dataptr += _PyAIT(it)->ao->descr->elsize; \ - else if (_PyAIT(it)->nd_m1 == 1) { \ - _PyArray_ITER_NEXT2(_PyAIT(it)); \ - } \ - else { \ - int __npy_i; \ +#define PyArray_ITER_NEXT(it) { \ + _PyAIT(it)->index++; \ + if (_PyAIT(it)->nd_m1 == 0) { \ + _PyArray_ITER_NEXT1(_PyAIT(it)); \ + } \ + else if (_PyAIT(it)->contiguous) \ + _PyAIT(it)->dataptr += PyArray_DESCR(_PyAIT(it)->ao)->elsize; \ + else if (_PyAIT(it)->nd_m1 == 1) { \ + _PyArray_ITER_NEXT2(_PyAIT(it)); \ + } \ + else { \ + int __npy_i; \ for (__npy_i=_PyAIT(it)->nd_m1; __npy_i >= 0; __npy_i--) { \ - if (_PyAIT(it)->coordinates[__npy_i] < \ - _PyAIT(it)->dims_m1[__npy_i]) { \ - _PyAIT(it)->coordinates[__npy_i]++; \ - _PyAIT(it)->dataptr += \ - _PyAIT(it)->strides[__npy_i]; \ - break; \ - } \ - else { \ - _PyAIT(it)->coordinates[__npy_i] = 0; \ - _PyAIT(it)->dataptr -= \ - _PyAIT(it)->backstrides[__npy_i]; \ - } \ - } \ - } \ + if (_PyAIT(it)->coordinates[__npy_i] < \ + _PyAIT(it)->dims_m1[__npy_i]) { \ + _PyAIT(it)->coordinates[__npy_i]++; \ + _PyAIT(it)->dataptr += \ + _PyAIT(it)->strides[__npy_i]; \ + break; \ + } \ + else { \ + _PyAIT(it)->coordinates[__npy_i] = 0; \ + _PyAIT(it)->dataptr -= \ + _PyAIT(it)->backstrides[__npy_i]; \ + } \ + } \ + } \ } -#define PyArray_ITER_GOTO(it, destination) { \ - int __npy_i; \ - _PyAIT(it)->index = 0; \ - _PyAIT(it)->dataptr = _PyAIT(it)->ao->data; \ - for (__npy_i = _PyAIT(it)->nd_m1; __npy_i>=0; __npy_i--) { \ - if (destination[__npy_i] < 0) { \ - destination[__npy_i] += \ - _PyAIT(it)->dims_m1[__npy_i]+1; \ - } \ - _PyAIT(it)->dataptr += destination[__npy_i] * \ - _PyAIT(it)->strides[__npy_i]; \ - _PyAIT(it)->coordinates[__npy_i] = \ - destination[__npy_i]; \ - _PyAIT(it)->index += destination[__npy_i] * \ - ( __npy_i==_PyAIT(it)->nd_m1 ? 1 : \ - _PyAIT(it)->dims_m1[__npy_i+1]+1) ; \ - } \ +#define PyArray_ITER_GOTO(it, destination) { \ + int __npy_i; \ + _PyAIT(it)->index = 0; \ + _PyAIT(it)->dataptr = PyArray_BYTES(_PyAIT(it)->ao); \ + for (__npy_i = _PyAIT(it)->nd_m1; __npy_i>=0; __npy_i--) { \ + if (destination[__npy_i] < 0) { \ + destination[__npy_i] += \ + _PyAIT(it)->dims_m1[__npy_i]+1; \ + } \ + _PyAIT(it)->dataptr += destination[__npy_i] * \ + _PyAIT(it)->strides[__npy_i]; \ + _PyAIT(it)->coordinates[__npy_i] = \ + destination[__npy_i]; \ + _PyAIT(it)->index += destination[__npy_i] * \ + ( __npy_i==_PyAIT(it)->nd_m1 ? 1 : \ + _PyAIT(it)->dims_m1[__npy_i+1]+1) ; \ + } \ } -#define PyArray_ITER_GOTO1D(it, ind) { \ - int __npy_i; \ - npy_intp __npy_ind = (npy_intp) (ind); \ - if (__npy_ind < 0) __npy_ind += _PyAIT(it)->size; \ - _PyAIT(it)->index = __npy_ind; \ - if (_PyAIT(it)->nd_m1 == 0) { \ - _PyAIT(it)->dataptr = _PyAIT(it)->ao->data + \ - __npy_ind * _PyAIT(it)->strides[0]; \ - } \ - else if (_PyAIT(it)->contiguous) \ - _PyAIT(it)->dataptr = _PyAIT(it)->ao->data + \ - __npy_ind * _PyAIT(it)->ao->descr->elsize; \ - else { \ - _PyAIT(it)->dataptr = _PyAIT(it)->ao->data; \ - for (__npy_i = 0; __npy_i<=_PyAIT(it)->nd_m1; \ - __npy_i++) { \ - _PyAIT(it)->dataptr += \ +#define PyArray_ITER_GOTO1D(it, ind) { \ + int __npy_i; \ + npy_intp __npy_ind = (npy_intp) (ind); \ + if (__npy_ind < 0) __npy_ind += _PyAIT(it)->size; \ + _PyAIT(it)->index = __npy_ind; \ + if (_PyAIT(it)->nd_m1 == 0) { \ + _PyAIT(it)->dataptr = PyArray_BYTES(_PyAIT(it)->ao) + \ + __npy_ind * _PyAIT(it)->strides[0]; \ + } \ + else if (_PyAIT(it)->contiguous) \ + _PyAIT(it)->dataptr = PyArray_BYTES(_PyAIT(it)->ao) + \ + __npy_ind * PyArray_DESCR(_PyAIT(it)->ao)->elsize; \ + else { \ + _PyAIT(it)->dataptr = PyArray_BYTES(_PyAIT(it)->ao); \ + for (__npy_i = 0; __npy_i<=_PyAIT(it)->nd_m1; \ + __npy_i++) { \ + _PyAIT(it)->dataptr += \ (__npy_ind / _PyAIT(it)->factors[__npy_i]) \ - * _PyAIT(it)->strides[__npy_i]; \ - __npy_ind %= _PyAIT(it)->factors[__npy_i]; \ - } \ - } \ + * _PyAIT(it)->strides[__npy_i]; \ + __npy_ind %= _PyAIT(it)->factors[__npy_i]; \ + } \ + } \ } #define PyArray_ITER_DATA(it) ((void *)(_PyAIT(it)->dataptr)) @@ -1238,12 +1257,17 @@ PyArrayNeighborhoodIter_Next2D(PyArrayNeighborhoodIterObject* iter); #define NPY_DEFAULT_TYPE NPY_DOUBLE /* - * All sorts of useful ways to look into a PyArrayObject. These are - * the recommended over casting to PyArrayObject and accessing the - * members directly. + * All sorts of useful ways to look into a PyArrayObject. It is recommended + * to use PyArrayObject * objects instead of always casting from PyObject *, + * for improved type checking. + * + * In many cases here the macro versions of the accessors are deprecated, + * but can't be immediately changed to inline functions because the + * preexisting macros accept PyObject * and do automatic casts. Inline + * functions accepting PyArrayObject * provides for some compile-time + * checking of correctness when working with these objects in C. */ -#define PyArray_NDIM(obj) (((PyArrayObject *)(obj))->nd) #define PyArray_ISONESEGMENT(m) (PyArray_NDIM(m) == 0 || \ PyArray_CHKFLAGS(m, NPY_ARRAY_C_CONTIGUOUS) || \ PyArray_CHKFLAGS(m, NPY_ARRAY_F_CONTIGUOUS)) @@ -1255,27 +1279,154 @@ PyArrayNeighborhoodIter_Next2D(PyArrayNeighborhoodIterObject* iter); NPY_ARRAY_F_CONTIGUOUS : 0)) #define FORTRAN_IF PyArray_FORTRAN_IF -#define PyArray_DATA(obj) ((void *)(((PyArrayObject *)(obj))->data)) -#define PyArray_BYTES(obj) (((PyArrayObject *)(obj))->data) -#define PyArray_DIMS(obj) (((PyArrayObject *)(obj))->dimensions) -#define PyArray_STRIDES(obj) (((PyArrayObject *)(obj))->strides) + +#ifdef NPY_NO_DEPRECATED_API +/* + * Changing access macros into functions, to allow for future hiding + * of the internal memory layout. This later hiding will allow the 2.x series + * to change the internal representation of arrays without affecting + * ABI compatibility. + */ + +static NPY_INLINE int +PyArray_NDIM(PyArrayObject *arr) +{ + return ((PyArrayObject_fieldaccess *)arr)->nd; +} + +static NPY_INLINE char * +PyArray_DATA(PyArrayObject *arr) +{ + return ((PyArrayObject_fieldaccess *)arr)->data; +} + +static NPY_INLINE npy_intp * +PyArray_DIMS(PyArrayObject *arr) +{ + return ((PyArrayObject_fieldaccess *)arr)->dimensions; +} + +static NPY_INLINE npy_intp * +PyArray_STRIDES(PyArrayObject *arr) +{ + return ((PyArrayObject_fieldaccess *)arr)->strides; +} + +static NPY_INLINE npy_intp +PyArray_DIM(PyArrayObject *arr, int idim) +{ + return ((PyArrayObject_fieldaccess *)arr)->dimensions[idim]; +} + +static NPY_INLINE npy_intp +PyArray_STRIDE(PyArrayObject *arr, int istride) +{ + return ((PyArrayObject_fieldaccess *)arr)->strides[istride]; +} + +static NPY_INLINE PyObject * +PyArray_BASE(PyArrayObject *arr) +{ + return ((PyArrayObject_fieldaccess *)arr)->base; +} + +static NPY_INLINE PyArray_Descr * +PyArray_DESCR(PyArrayObject *arr) +{ + return ((PyArrayObject_fieldaccess *)arr)->descr; +} + +static NPY_INLINE int +PyArray_FLAGS(PyArrayObject *arr) +{ + return ((PyArrayObject_fieldaccess *)arr)->flags; +} + +static NPY_INLINE npy_intp +PyArray_ITEMSIZE(PyArrayObject *arr) +{ + return ((PyArrayObject_fieldaccess *)arr)->descr->elsize; +} + +static NPY_INLINE int +PyArray_TYPE(PyArrayObject *arr) +{ + return ((PyArrayObject_fieldaccess *)arr)->descr->type_num; +} + +static NPY_INLINE int +PyArray_CHKFLAGS(PyArrayObject *arr, int flags) +{ + return (PyArray_FLAGS(arr) & flags) == flags; +} + +static NPY_INLINE PyObject * +PyArray_GETITEM(PyArrayObject *arr, char *itemptr) +{ + return ((PyArrayObject_fieldaccess *)arr)->descr->f->getitem( + itemptr, + arr); +} + +static NPY_INLINE int +PyArray_SETITEM(PyArrayObject *arr, char *itemptr, PyObject *v) +{ + return ((PyArrayObject_fieldaccess *)arr)->descr->f->setitem( + v, + itemptr, + arr); +} + +#else + +/* Macros are deprecated as of NumPy 1.7. */ +#define PyArray_NDIM(obj) (((PyArrayObject_fieldaccess *)(obj))->nd) +#define PyArray_DATA(obj) ((void *)(((PyArrayObject_fieldaccess *)(obj))->data)) +#define PyArray_DIMS(obj) (((PyArrayObject_fieldaccess *)(obj))->dimensions) +#define PyArray_STRIDES(obj) (((PyArrayObject_fieldaccess *)(obj))->strides) #define PyArray_DIM(obj,n) (PyArray_DIMS(obj)[n]) #define PyArray_STRIDE(obj,n) (PyArray_STRIDES(obj)[n]) -#define PyArray_BASE(obj) (((PyArrayObject *)(obj))->base) -#define PyArray_DESCR(obj) (((PyArrayObject *)(obj))->descr) -#define PyArray_FLAGS(obj) (((PyArrayObject *)(obj))->flags) -#define PyArray_ITEMSIZE(obj) (((PyArrayObject *)(obj))->descr->elsize) -#define PyArray_TYPE(obj) (((PyArrayObject *)(obj))->descr->type_num) +#define PyArray_BASE(obj) (((PyArrayObject_fieldaccess *)(obj))->base) +#define PyArray_DESCR(obj) (((PyArrayObject_fieldaccess *)(obj))->descr) +#define PyArray_FLAGS(obj) (((PyArrayObject_fieldaccess *)(obj))->flags) +#define PyArray_CHKFLAGS(m, FLAGS) \ + ((((PyArrayObject_fieldaccess *)(m))->flags & (FLAGS)) == (FLAGS)) +#define PyArray_ITEMSIZE(obj) \ + (((PyArrayObject_fieldaccess *)(obj))->descr->elsize) +#define PyArray_TYPE(obj) \ + (((PyArrayObject_fieldaccess *)(obj))->descr->type_num) +#define PyArray_GETITEM(obj,itemptr) \ + PyArray_DESCR(obj)->f->getitem((char *)(itemptr), \ + (PyArrayObject *)(obj)) + +#define PyArray_SETITEM(obj,itemptr,v) \ + PyArray_DESCR(obj)->f->setitem((PyObject *)(v), \ + (char *)(itemptr), \ + (PyArrayObject *)(obj)) +#endif -#define PyArray_GETITEM(obj,itemptr) \ - ((PyArrayObject *)(obj))->descr->f->getitem((char *)(itemptr), \ - (PyArrayObject *)(obj)) +/* Same as PyArray_DATA */ +#define PyArray_BYTES(arr) PyArray_DATA(arr) -#define PyArray_SETITEM(obj,itemptr,v) \ - ((PyArrayObject *)(obj))->descr->f->setitem((PyObject *)(v), \ - (char *)(itemptr), \ - (PyArrayObject *)(obj)) +/* + * Enables the specified array flags. Does no checking, + * assumes you know what you're doing. + */ +static NPY_INLINE void +PyArray_ENABLEFLAGS(PyArrayObject *arr, int flags) +{ + ((PyArrayObject_fieldaccess *)arr)->flags |= flags; +} +/* + * Clears the specified array flags. Does no checking, + * assumes you know what you're doing. + */ +static NPY_INLINE void +PyArray_CLEARFLAGS(PyArrayObject *arr, int flags) +{ + ((PyArrayObject_fieldaccess *)arr)->flags &= ~flags; +} #define PyTypeNum_ISBOOL(type) ((type) == NPY_BOOL) diff --git a/numpy/core/include/numpy/npy_common.h b/numpy/core/include/numpy/npy_common.h index ad326da68..118850541 100644 --- a/numpy/core/include/numpy/npy_common.h +++ b/numpy/core/include/numpy/npy_common.h @@ -135,7 +135,7 @@ typedef unsigned PY_LONG_LONG npy_ulonglong; /* "%Ld" only parses 4 bytes -- "L" is floating modifier on MacOS X/BSD */ # define NPY_LONGLONG_FMT "lld" # define NPY_ULONGLONG_FMT "llu" -/* +/* another possible variant -- *quad_t works on *BSD, but is deprecated: #define LONGLONG_FMT "qd" #define ULONGLONG_FMT "qu" diff --git a/numpy/core/include/numpy/numpyconfig.h b/numpy/core/include/numpy/numpyconfig.h index ff7938cd9..19685b3dc 100644 --- a/numpy/core/include/numpy/numpyconfig.h +++ b/numpy/core/include/numpy/numpyconfig.h @@ -3,7 +3,7 @@ #include "_numpyconfig.h" -/* +/* * On Mac OS X, because there is only one configuration stage for all the archs * in universal builds, any macro which depends on the arch needs to be * harcoded diff --git a/numpy/core/include/numpy/ufuncobject.h b/numpy/core/include/numpy/ufuncobject.h index c7096371d..d00fe10ea 100644 --- a/numpy/core/include/numpy/ufuncobject.h +++ b/numpy/core/include/numpy/ufuncobject.h @@ -108,14 +108,14 @@ typedef struct _tagPyUFuncObject { void *ptr; PyObject *obj; PyObject *userloops; - + /* generalized ufunc parameters */ /* 0 for scalar ufunc; 1 for generalized ufunc */ int core_enabled; /* number of distinct dimension names in signature */ int core_num_dim_ix; - + /* * dimension indices of input/output argument k are stored in * core_dim_ixs[core_offsets[k]..core_offsets[k]+core_num_dims[k]-1] diff --git a/numpy/core/memmap.py b/numpy/core/memmap.py index 5a7aaba1c..1ab9f87fc 100644 --- a/numpy/core/memmap.py +++ b/numpy/core/memmap.py @@ -26,6 +26,15 @@ class memmap(ndarray): memmap's are array-like objects. This differs from Python's ``mmap`` module, which uses file-like objects. + This subclass of ndarray has some unpleasant interactions with + some operations, because it doesn't quite fit properly as a subclass. + An alternative to using this subclass is to create the ``mmap`` + object yourself, then create an ndarray with ndarray.__new__ directly, + passing the object created in its 'buffer=' parameter. + + This class may at some point be turned into a factory function + which returns a view into an mmap buffer. + Parameters ---------- filename : str or file-like object @@ -275,27 +284,5 @@ class memmap(ndarray): memmap """ - if self._mmap is not None: - self._mmap.flush() - - def _close(self): - """Close the memmap file. Only do this when deleting the object.""" - if self.base is self._mmap: - # The python mmap probably causes flush on close, but - # we put this here for safety - self._mmap.flush() - self._mmap.close() - self._mmap = None - - def __del__(self): - # We first check if we are the owner of the mmap, rather than - # a view, so deleting a view does not call _close - # on the parent mmap - if self._mmap is self.base: - try: - # First run tell() to see whether file is open - self._mmap.tell() - except ValueError: - pass - else: - self._close() + if self.base is not None and hasattr(self.base, 'flush'): + self.base.flush() diff --git a/numpy/core/src/multiarray/arrayobject.c b/numpy/core/src/multiarray/arrayobject.c index a1dc4399a..cd2060133 100644 --- a/numpy/core/src/multiarray/arrayobject.c +++ b/numpy/core/src/multiarray/arrayobject.c @@ -65,6 +65,57 @@ PyArray_Size(PyObject *op) } } +/*NUMPY_API + * Sets the 'base' attribute of the array. This steals a reference + * to 'obj'. + * + * Returns 0 on success, -1 on failure. + */ +NPY_NO_EXPORT int +PyArray_SetBaseObject(PyArrayObject *arr, PyObject *obj) +{ + if (obj == NULL) { + PyErr_SetString(PyExc_ValueError, + "Cannot set the NumPy array 'base' " + "dependency to NULL after initialization"); + return -1; + } + /* + * Allow the base to be set only once. Once the object which + * owns the data is set, it doesn't make sense to change it. + */ + if (PyArray_BASE(arr) != NULL) { + Py_DECREF(obj); + PyErr_SetString(PyExc_ValueError, + "Cannot set the NumPy array 'base' " + "dependency more than once"); + return -1; + } + /* + * Don't allow chains of views, always set the base + * to the owner of the data + */ + while (PyArray_Check(obj) && + (PyObject *)arr != obj && + PyArray_BASE((PyArrayObject *)obj) != NULL) { + PyObject *tmp = PyArray_BASE((PyArrayObject *)obj); + Py_INCREF(tmp); + Py_DECREF(obj); + obj = tmp; + } + /* Disallow circular references */ + if ((PyObject *)arr == obj) { + Py_DECREF(obj); + PyErr_SetString(PyExc_ValueError, + "Cannot create a circular NumPy array 'base' dependency"); + return -1; + } + ((PyArrayObject_fieldaccess *)arr)->base = obj; + + return 0; +} + + /*NUMPY_API*/ NPY_NO_EXPORT int PyArray_CopyObject(PyArrayObject *dest, PyObject *src_object) @@ -80,13 +131,14 @@ PyArray_CopyObject(PyArrayObject *dest, PyObject *src_object) * Special code to mimic Numeric behavior for * character arrays. */ - if (dest->descr->type == PyArray_CHARLTR && dest->nd > 0 \ - && PyString_Check(src_object)) { + if (PyArray_DESCR(dest)->type == PyArray_CHARLTR && + PyArray_NDIM(dest) > 0 && + PyString_Check(src_object)) { npy_intp n_new, n_old; char *new_string; PyObject *tmp; - n_new = dest->dimensions[dest->nd-1]; + n_new = PyArray_DIMS(dest)[PyArray_NDIM(dest)-1]; n_old = PyString_Size(src_object); if (n_new > n_old) { new_string = (char *)malloc(n_new); @@ -220,26 +272,29 @@ PyArray_TypeNumFromName(char *str) /* array object functions */ static void -array_dealloc(PyArrayObject *self) { +array_dealloc(PyArrayObject *self) +{ + PyArrayObject_fieldaccess *fa = (PyArrayObject_fieldaccess *)self; _array_dealloc_buffer_info(self); - if (self->weakreflist != NULL) { + if (fa->weakreflist != NULL) { PyObject_ClearWeakRefs((PyObject *)self); } - if (self->base) { + if (fa->base) { /* * UPDATEIFCOPY means that base points to an * array that should be updated with the contents * of this array upon destruction. - * self->base->flags must have been WRITEABLE + * fa->base->flags must have been WRITEABLE * (checked previously) and it was locked here * thus, unlock it. */ - if (self->flags & NPY_ARRAY_UPDATEIFCOPY) { - ((PyArrayObject *)self->base)->flags |= NPY_ARRAY_WRITEABLE; + if (fa->flags & NPY_ARRAY_UPDATEIFCOPY) { + PyArray_ENABLEFLAGS(((PyArrayObject *)fa->base), + NPY_ARRAY_WRITEABLE); Py_INCREF(self); /* hold on to self in next call */ - if (PyArray_CopyAnyInto((PyArrayObject *)self->base, self) < 0) { + if (PyArray_CopyAnyInto((PyArrayObject *)fa->base, self) < 0) { PyErr_Print(); PyErr_Clear(); } @@ -252,12 +307,12 @@ array_dealloc(PyArrayObject *self) { * In any case base is pointing to something that we need * to DECREF -- either a view or a buffer object */ - Py_DECREF(self->base); + Py_DECREF(fa->base); } - if ((self->flags & NPY_ARRAY_OWNDATA) && self->data) { + if ((fa->flags & NPY_ARRAY_OWNDATA) && fa->data) { /* Free internal references if an Object array */ - if (PyDataType_FLAGCHK(self->descr, NPY_ITEM_REFCOUNT)) { + if (PyDataType_FLAGCHK(fa->descr, NPY_ITEM_REFCOUNT)) { Py_INCREF(self); /*hold on to self */ PyArray_XDECREF(self); /* @@ -265,11 +320,11 @@ array_dealloc(PyArrayObject *self) { * self already... */ } - PyDataMem_FREE(self->data); + //PyDataMem_FREE(fa->data); } - PyDimMem_FREE(self->dimensions); - Py_DECREF(self->descr); + PyDimMem_FREE(fa->dimensions); + Py_DECREF(fa->descr); Py_TYPE(self)->tp_free((PyObject *)self); } @@ -277,7 +332,7 @@ static int dump_data(char **string, int *n, int *max_n, char *data, int nd, npy_intp *dimensions, npy_intp *strides, PyArrayObject* self) { - PyArray_Descr *descr=self->descr; + PyArray_Descr *descr=PyArray_DESCR(self); PyObject *op, *sp; char *ostring; npy_intp i, N; @@ -352,9 +407,9 @@ array_repr_builtin(PyArrayObject *self, int repr) else { n = 0; } - if (dump_data(&string, &n, &max_n, self->data, - self->nd, self->dimensions, - self->strides, self) < 0) { + if (dump_data(&string, &n, &max_n, PyArray_DATA(self), + PyArray_NDIM(self), PyArray_DIMS(self), + PyArray_STRIDES(self), self) < 0) { _pya_free(string); return NULL; } @@ -362,12 +417,12 @@ array_repr_builtin(PyArrayObject *self, int repr) if (repr) { if (PyArray_ISEXTENDED(self)) { char buf[100]; - PyOS_snprintf(buf, sizeof(buf), "%d", self->descr->elsize); - sprintf(string+n, ", '%c%s')", self->descr->type, buf); + PyOS_snprintf(buf, sizeof(buf), "%d", PyArray_DESCR(self)->elsize); + sprintf(string+n, ", '%c%s')", PyArray_DESCR(self)->type, buf); ret = PyUString_FromStringAndSize(string, n + 6 + strlen(buf)); } else { - sprintf(string+n, ", '%c')", self->descr->type); + sprintf(string+n, ", '%c')", PyArray_DESCR(self)->type); ret = PyUString_FromStringAndSize(string, n+6); } } @@ -702,11 +757,8 @@ _uni_release(char *ptr, int nc) } \ } -#define _loop(CMP) if (rstrip) _rstrip_loop(CMP) \ - else _reg_loop(CMP) - static int -_compare_strings(PyObject *result, PyArrayMultiIterObject *multi, +_compare_strings(PyArrayObject *result, PyArrayMultiIterObject *multi, int cmp_op, void *func, int rstrip) { PyArrayIterObject *iself, *iother; @@ -723,8 +775,8 @@ _compare_strings(PyObject *result, PyArrayMultiIterObject *multi, iself = multi->iters[0]; iother = multi->iters[1]; size = multi->size; - N1 = iself->ao->descr->elsize; - N2 = iother->ao->descr->elsize; + N1 = PyArray_DESCR(iself->ao)->elsize; + N2 = PyArray_DESCR(iother->ao)->elsize; if ((void *)compfunc == (void *)_myunincmp) { N1 >>= 2; N2 >>= 2; @@ -737,23 +789,47 @@ _compare_strings(PyObject *result, PyArrayMultiIterObject *multi, } switch (cmp_op) { case Py_EQ: - _loop(==) - break; + if (rstrip) { + _rstrip_loop(==); + } else { + _reg_loop(==); + } + break; case Py_NE: - _loop(!=) - break; + if (rstrip) { + _rstrip_loop(!=); + } else { + _reg_loop(!=); + } + break; case Py_LT: - _loop(<) - break; + if (rstrip) { + _rstrip_loop(<); + } else { + _reg_loop(<); + } + break; case Py_LE: - _loop(<=) - break; + if (rstrip) { + _rstrip_loop(<=); + } else { + _reg_loop(<=); + } + break; case Py_GT: - _loop(>) - break; + if (rstrip) { + _rstrip_loop(>); + } else { + _reg_loop(>); + } + break; case Py_GE: - _loop(>=) - break; + if (rstrip) { + _rstrip_loop(>=); + } else { + _reg_loop(>=); + } + break; default: PyErr_SetString(PyExc_RuntimeError, "bad comparison operator"); return -1; @@ -761,7 +837,6 @@ _compare_strings(PyObject *result, PyArrayMultiIterObject *multi, return 0; } -#undef _loop #undef _reg_loop #undef _rstrip_loop #undef SMALL_STRING @@ -770,26 +845,25 @@ NPY_NO_EXPORT PyObject * _strings_richcompare(PyArrayObject *self, PyArrayObject *other, int cmp_op, int rstrip) { - PyObject *result; + PyArrayObject *result; PyArrayMultiIterObject *mit; int val; /* Cast arrays to a common type */ - if (self->descr->type_num != other->descr->type_num) { + if (PyArray_DESCR(self)->type_num != PyArray_DESCR(other)->type_num) { #if defined(NPY_PY3K) /* * Comparison between Bytes and Unicode is not defined in Py3K; * we follow. */ - result = Py_NotImplemented; - Py_INCREF(result); - return result; + Py_INCREF(Py_NotImplemented); + return Py_NotImplemented; #else PyObject *new; - if (self->descr->type_num == PyArray_STRING && - other->descr->type_num == PyArray_UNICODE) { - PyArray_Descr* unicode = PyArray_DescrNew(other->descr); - unicode->elsize = self->descr->elsize << 2; + if (PyArray_DESCR(self)->type_num == PyArray_STRING && + PyArray_DESCR(other)->type_num == PyArray_UNICODE) { + PyArray_Descr* unicode = PyArray_DescrNew(PyArray_DESCR(other)); + unicode->elsize = PyArray_DESCR(self)->elsize << 2; new = PyArray_FromAny((PyObject *)self, unicode, 0, 0, 0, NULL); if (new == NULL) { @@ -798,10 +872,10 @@ _strings_richcompare(PyArrayObject *self, PyArrayObject *other, int cmp_op, Py_INCREF(other); self = (PyArrayObject *)new; } - else if (self->descr->type_num == PyArray_UNICODE && - other->descr->type_num == PyArray_STRING) { - PyArray_Descr* unicode = PyArray_DescrNew(self->descr); - unicode->elsize = other->descr->elsize << 2; + else if (PyArray_DESCR(self)->type_num == PyArray_UNICODE && + PyArray_DESCR(other)->type_num == PyArray_STRING) { + PyArray_Descr* unicode = PyArray_DescrNew(PyArray_DESCR(self)); + unicode->elsize = PyArray_DESCR(other)->elsize << 2; new = PyArray_FromAny((PyObject *)other, unicode, 0, 0, 0, NULL); if (new == NULL) { @@ -831,7 +905,7 @@ _strings_richcompare(PyArrayObject *self, PyArrayObject *other, int cmp_op, return NULL; } - result = PyArray_NewFromDescr(&PyArray_Type, + result = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, PyArray_DescrFromType(PyArray_BOOL), mit->nd, mit->dimensions, @@ -841,7 +915,7 @@ _strings_richcompare(PyArrayObject *self, PyArrayObject *other, int cmp_op, goto finish; } - if (self->descr->type_num == PyArray_UNICODE) { + if (PyArray_DESCR(self)->type_num == NPY_UNICODE) { val = _compare_strings(result, mit, cmp_op, _myunincmp, rstrip); } else { @@ -849,12 +923,13 @@ _strings_richcompare(PyArrayObject *self, PyArrayObject *other, int cmp_op, } if (val < 0) { - Py_DECREF(result); result = NULL; + Py_DECREF(result); + result = NULL; } finish: Py_DECREF(mit); - return result; + return (PyObject *)result; } /* @@ -884,7 +959,7 @@ _void_compare(PyArrayObject *self, PyArrayObject *other, int cmp_op) PyArray_NDIM(self) : PyArray_NDIM(other); op = (cmp_op == Py_EQ ? n_ops.logical_and : n_ops.logical_or); - while (PyDict_Next(self->descr->fields, &pos, &key, &value)) { + while (PyDict_Next(PyArray_DESCR(self)->fields, &pos, &key, &value)) { if NPY_TITLE_KEY(key, value) { continue; } @@ -912,16 +987,17 @@ _void_compare(PyArrayObject *self, PyArrayObject *other, int cmp_op) * dimensions will have been appended to `a` and `b`. * In that case, reduce them using `op`. */ - if (PyArray_Check(temp) && PyArray_NDIM(temp) > result_ndim) { + if (PyArray_Check(temp) && + PyArray_NDIM((PyArrayObject *)temp) > result_ndim) { /* If the type was multidimensional, collapse that part to 1-D */ - if (PyArray_NDIM(temp) != result_ndim+1) { + if (PyArray_NDIM((PyArrayObject *)temp) != result_ndim+1) { npy_intp dimensions[NPY_MAXDIMS]; PyArray_Dims newdims; newdims.ptr = dimensions; newdims.len = result_ndim+1; - memcpy(dimensions, PyArray_DIMS(temp), + memcpy(dimensions, PyArray_DIMS((PyArrayObject *)temp), sizeof(intp)*result_ndim); dimensions[result_ndim] = -1; temp2 = PyArray_Newshape((PyArrayObject *)temp, @@ -977,7 +1053,8 @@ _void_compare(PyArrayObject *self, PyArrayObject *other, int cmp_op) NPY_NO_EXPORT PyObject * array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op) { - PyObject *array_other, *result = NULL; + PyArrayObject *array_other; + PyObject *result = NULL; int typenum; switch (cmp_op) { @@ -994,40 +1071,39 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op) Py_INCREF(Py_False); return Py_False; } - /* Try to convert other to an array */ - if (!PyArray_Check(other)) { - typenum = self->descr->type_num; + /* Make sure 'other' is an array */ + if (PyArray_Check(other)) { + Py_INCREF(other); + array_other = (PyArrayObject *)other; + } + else { + typenum = PyArray_DESCR(self)->type_num; if (typenum != PyArray_OBJECT) { typenum = PyArray_NOTYPE; } - array_other = PyArray_FromObject(other, typenum, 0, 0); + array_other = (PyArrayObject *)PyArray_FromObject(other, + typenum, 0, 0); /* * If not successful, indicate that the items cannot be compared * this way. */ - if ((array_other == NULL) || - (array_other == Py_None)) { + if (array_other == NULL) { Py_XDECREF(array_other); PyErr_Clear(); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } } - else { - Py_INCREF(other); - array_other = other; - } result = PyArray_GenericBinaryFunction(self, - array_other, + (PyObject *)array_other, n_ops.equal); if ((result == Py_NotImplemented) && - (self->descr->type_num == PyArray_VOID)) { + (PyArray_DESCR(self)->type_num == PyArray_VOID)) { int _res; _res = PyObject_RichCompareBool - ((PyObject *)self->descr, - (PyObject *)\ - PyArray_DESCR(array_other), + ((PyObject *)PyArray_DESCR(self), + (PyObject *)PyArray_DESCR(array_other), Py_EQ); if (_res < 0) { Py_DECREF(result); @@ -1036,10 +1112,7 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op) } if (_res) { Py_DECREF(result); - result = _void_compare - (self, - (PyArrayObject *)array_other, - cmp_op); + result = _void_compare(self, array_other, cmp_op); Py_DECREF(array_other); } return result; @@ -1061,39 +1134,38 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op) Py_INCREF(Py_True); return Py_True; } - /* Try to convert other to an array */ - if (!PyArray_Check(other)) { - typenum = self->descr->type_num; + /* Make sure 'other' is an array */ + if (PyArray_Check(other)) { + Py_INCREF(other); + array_other = (PyArrayObject *)other; + } + else { + typenum = PyArray_DESCR(self)->type_num; if (typenum != PyArray_OBJECT) { typenum = PyArray_NOTYPE; } - array_other = PyArray_FromObject(other, typenum, 0, 0); + array_other = (PyArrayObject *)PyArray_FromObject(other, + typenum, 0, 0); /* * If not successful, then objects cannot be * compared this way */ - if ((array_other == NULL) || (array_other == Py_None)) { + if (array_other == NULL || (PyObject *)array_other == Py_None) { Py_XDECREF(array_other); PyErr_Clear(); Py_INCREF(Py_NotImplemented); return Py_NotImplemented; } } - else { - Py_INCREF(other); - array_other = other; - } - result = PyArray_GenericBinaryFunction(self, - array_other, + result = PyArray_GenericBinaryFunction(self, (PyObject *)array_other, n_ops.not_equal); if ((result == Py_NotImplemented) && - (self->descr->type_num == PyArray_VOID)) { + (PyArray_DESCR(self)->type_num == PyArray_VOID)) { int _res; _res = PyObject_RichCompareBool( - (PyObject *)self->descr, - (PyObject *) - PyArray_DESCR(array_other), + (PyObject *)PyArray_DESCR(self), + (PyObject *)PyArray_DESCR(array_other), Py_EQ); if (_res < 0) { Py_DECREF(result); @@ -1102,10 +1174,7 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op) } if (_res) { Py_DECREF(result); - result = _void_compare( - self, - (PyArrayObject *)array_other, - cmp_op); + result = _void_compare(self, array_other, cmp_op); Py_DECREF(array_other); } return result; @@ -1132,10 +1201,11 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op) } if (result == Py_NotImplemented) { /* Try to handle string comparisons */ - if (self->descr->type_num == PyArray_OBJECT) { + if (PyArray_DESCR(self)->type_num == PyArray_OBJECT) { return result; } - array_other = PyArray_FromObject(other,PyArray_NOTYPE, 0, 0); + array_other = (PyArrayObject *)PyArray_FromObject(other, + PyArray_NOTYPE, 0, 0); if (PyArray_ISSTRING(self) && PyArray_ISSTRING(array_other)) { Py_DECREF(result); result = _strings_richcompare(self, (PyArrayObject *) @@ -1149,13 +1219,24 @@ array_richcompare(PyArrayObject *self, PyObject *other, int cmp_op) /*NUMPY_API */ NPY_NO_EXPORT int -PyArray_ElementStrides(PyObject *arr) +PyArray_ElementStrides(PyObject *obj) { - int itemsize = PyArray_ITEMSIZE(arr); - int i, N = PyArray_NDIM(arr); - npy_intp *strides = PyArray_STRIDES(arr); + PyArrayObject *arr; + int itemsize; + int i, ndim; + npy_intp *strides; + + if (!PyArray_Check(obj)) { + return 0; + } - for (i = 0; i < N; i++) { + arr = (PyArrayObject *)obj; + + itemsize = PyArray_ITEMSIZE(arr); + ndim = PyArray_NDIM(arr); + strides = PyArray_STRIDES(arr); + + for (i = 0; i < ndim; i++) { if ((strides[i] % itemsize) != 0) { return 0; } @@ -1332,8 +1413,12 @@ array_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) goto fail; } PyArray_UpdateFlags(ret, NPY_ARRAY_UPDATE_ALL); - ret->base = buffer.base; Py_INCREF(buffer.base); + if (PyArray_SetBaseObject(ret, buffer.base) < 0) { + Py_DECREF(ret); + ret = NULL; + goto fail; + } } PyDimMem_FREE(dims.ptr); @@ -1357,7 +1442,7 @@ array_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds) static PyObject * array_iter(PyArrayObject *arr) { - if (arr->nd == 0) { + if (PyArray_NDIM(arr) == 0) { PyErr_SetString(PyExc_TypeError, "iteration over a 0-d array"); return NULL; @@ -1370,7 +1455,7 @@ array_alloc(PyTypeObject *type, Py_ssize_t NPY_UNUSED(nitems)) { PyObject *obj; /* nitems will always be 0 */ - obj = (PyObject *)_pya_malloc(sizeof(PyArrayObject)); + obj = (PyObject *)_pya_malloc(NPY_SIZEOF_PYARRAYOBJECT); PyObject_Init(obj, type); return obj; } @@ -1384,7 +1469,7 @@ NPY_NO_EXPORT PyTypeObject PyArray_Type = { 0, /* ob_size */ #endif "numpy.ndarray", /* tp_name */ - sizeof(PyArrayObject), /* tp_basicsize */ + NPY_SIZEOF_PYARRAYOBJECT, /* tp_basicsize */ 0, /* tp_itemsize */ /* methods */ (destructor)array_dealloc, /* tp_dealloc */ @@ -1419,7 +1504,7 @@ NPY_NO_EXPORT PyTypeObject PyArray_Type = { (traverseproc)0, /* tp_traverse */ (inquiry)0, /* tp_clear */ (richcmpfunc)array_richcompare, /* tp_richcompare */ - offsetof(PyArrayObject, weakreflist), /* tp_weaklistoffset */ + offsetof(PyArrayObject_fieldaccess, weakreflist), /* tp_weaklistoffset */ (getiterfunc)array_iter, /* tp_iter */ (iternextfunc)0, /* tp_iternext */ array_methods, /* tp_methods */ diff --git a/numpy/core/src/multiarray/arraytypes.c.src b/numpy/core/src/multiarray/arraytypes.c.src index f8362b27f..cb76d5af9 100644 --- a/numpy/core/src/multiarray/arraytypes.c.src +++ b/numpy/core/src/multiarray/arraytypes.c.src @@ -130,7 +130,7 @@ static PyObject * return @func1@((@type1@)t1); } else { - ap->descr->f->copyswap(&t1, ip, !PyArray_ISNOTSWAPPED(ap), ap); + PyArray_DESCR(ap)->f->copyswap(&t1, ip, !PyArray_ISNOTSWAPPED(ap), ap); return @func1@((@type1@)t1); } } @@ -157,7 +157,7 @@ static int if (ap == NULL || PyArray_ISBEHAVED(ap)) *((@type@ *)ov)=temp; else { - ap->descr->f->copyswap(ov, &temp, !PyArray_ISNOTSWAPPED(ap), ap); + PyArray_DESCR(ap)->f->copyswap(ov, &temp, !PyArray_ISNOTSWAPPED(ap), ap); } return 0; } @@ -205,9 +205,10 @@ static int int rsize; if (!(PyArray_IsScalar(op, @kind@))) { - if (PyArray_Check(op) && (PyArray_NDIM(op) == 0)) { - op2 = ((PyArrayObject *)op)->descr->f->getitem - (((PyArrayObject *)op)->data, (PyArrayObject *)op); + if (PyArray_Check(op) && (PyArray_NDIM((PyArrayObject *)op) == 0)) { + op2 = PyArray_DESCR((PyArrayObject *)op)->f->getitem( + PyArray_BYTES((PyArrayObject *)op), + (PyArrayObject *)op); } else { op2 = op; Py_INCREF(op); @@ -229,7 +230,7 @@ static int else { temp = ((Py@kind@ScalarObject *)op)->obval; } - memcpy(ov, &temp, ap->descr->elsize); + memcpy(ov, &temp, PyArray_DESCR(ap)->elsize); if (!PyArray_ISNOTSWAPPED(ap)) { byte_swap_vector(ov, 2, sizeof(@type@)); } @@ -247,7 +248,7 @@ static int static PyObject * LONGDOUBLE_getitem(char *ip, PyArrayObject *ap) { - return PyArray_Scalar(ip, ap->descr, NULL); + return PyArray_Scalar(ip, PyArray_DESCR(ap), NULL); } static int @@ -268,7 +269,7 @@ LONGDOUBLE_setitem(PyObject *op, char *ov, PyArrayObject *ap) { *((longdouble *)ov) = temp; } else { - copy_and_swap(ov, &temp, ap->descr->elsize, 1, 0, + copy_and_swap(ov, &temp, PyArray_DESCR(ap)->elsize, 1, 0, !PyArray_ISNOTSWAPPED(ap)); } return 0; @@ -277,14 +278,14 @@ LONGDOUBLE_setitem(PyObject *op, char *ov, PyArrayObject *ap) { static PyObject * CLONGDOUBLE_getitem(char *ip, PyArrayObject *ap) { - return PyArray_Scalar(ip, ap->descr, NULL); + return PyArray_Scalar(ip, PyArray_DESCR(ap), NULL); } /* UNICODE */ static PyObject * UNICODE_getitem(char *ip, PyArrayObject *ap) { - intp elsize = ap->descr->elsize; + intp elsize = PyArray_DESCR(ap)->elsize; intp mysize = elsize/sizeof(PyArray_UCS4); int alloc = 0; PyArray_UCS4 *buffer = NULL; @@ -378,10 +379,10 @@ UNICODE_setitem(PyObject *op, char *ov, PyArrayObject *ap) datalen = PyUnicode_GET_DATA_SIZE(temp); #ifdef Py_UNICODE_WIDE - memcpy(ov, ptr, MIN(ap->descr->elsize, datalen)); + memcpy(ov, ptr, MIN(PyArray_DESCR(ap)->elsize, datalen)); #else if (!PyArray_ISALIGNED(ap)) { - buffer = PyArray_malloc(ap->descr->elsize); + buffer = PyArray_malloc(PyArray_DESCR(ap)->elsize); if (buffer == NULL) { Py_DECREF(temp); PyErr_NoMemory(); @@ -392,7 +393,7 @@ UNICODE_setitem(PyObject *op, char *ov, PyArrayObject *ap) buffer = ov; } datalen = PyUCS2Buffer_AsUCS4(ptr, (PyArray_UCS4 *)buffer, - datalen >> 1, ap->descr->elsize >> 2); + datalen >> 1, PyArray_DESCR(ap)->elsize >> 2); datalen <<= 2; if (!PyArray_ISALIGNED(ap)) { memcpy(ov, buffer, datalen); @@ -400,11 +401,11 @@ UNICODE_setitem(PyObject *op, char *ov, PyArrayObject *ap) } #endif /* Fill in the rest of the space with 0 */ - if (ap->descr->elsize > datalen) { - memset(ov + datalen, 0, (ap->descr->elsize - datalen)); + if (PyArray_DESCR(ap)->elsize > datalen) { + memset(ov + datalen, 0, (PyArray_DESCR(ap)->elsize - datalen)); } if (!PyArray_ISNOTSWAPPED(ap)) { - byte_swap_vector(ov, ap->descr->elsize >> 2, 4); + byte_swap_vector(ov, PyArray_DESCR(ap)->elsize >> 2, 4); } Py_DECREF(temp); return 0; @@ -420,7 +421,7 @@ STRING_getitem(char *ip, PyArrayObject *ap) { /* Will eliminate NULLs at the end */ char *ptr; - int size = ap->descr->elsize; + int size = PyArray_DESCR(ap)->elsize; ptr = ip + size - 1; while (*ptr-- == '\0' && size > 0) { @@ -437,8 +438,9 @@ STRING_setitem(PyObject *op, char *ov, PyArrayObject *ap) PyObject *temp = NULL; /* Handle case of assigning from an array scalar */ - if (PyArray_Check(op) && PyArray_NDIM(op) == 0) { - temp = PyArray_ToScalar(PyArray_DATA(op), op); + if (PyArray_Check(op) && PyArray_NDIM((PyArrayObject *)op) == 0) { + temp = PyArray_ToScalar(PyArray_BYTES((PyArrayObject *)op), + (PyArrayObject *)op); if (temp == NULL) { return -1; } @@ -489,13 +491,13 @@ STRING_setitem(PyObject *op, char *ov, PyArrayObject *ap) Py_DECREF(temp); return -1; } - memcpy(ov, ptr, MIN(ap->descr->elsize,len)); + memcpy(ov, ptr, MIN(PyArray_DESCR(ap)->elsize,len)); /* * If string lenth is smaller than room in array * Then fill the rest of the element size with NULL */ - if (ap->descr->elsize > len) { - memset(ov + len, 0, (ap->descr->elsize - len)); + if (PyArray_DESCR(ap)->elsize > len) { + memset(ov + len, 0, (PyArray_DESCR(ap)->elsize - len)); } Py_DECREF(temp); return 0; @@ -540,11 +542,11 @@ OBJECT_setitem(PyObject *op, char *ov, PyArrayObject *ap) static PyObject * VOID_getitem(char *ip, PyArrayObject *ap) { - PyObject *u = NULL; + PyArrayObject *u = NULL; PyArray_Descr* descr; int itemsize; - descr = ap->descr; + descr = PyArray_DESCR(ap); if (PyDataType_HASFIELDS(descr)) { PyObject *key; PyObject *names; @@ -559,35 +561,39 @@ VOID_getitem(char *ip, PyArrayObject *ap) names = descr->names; n = PyTuple_GET_SIZE(names); ret = PyTuple_New(n); - savedflags = ap->flags; + savedflags = PyArray_FLAGS(ap); for (i = 0; i < n; i++) { key = PyTuple_GET_ITEM(names, i); tup = PyDict_GetItem(descr->fields, key); if (!PyArg_ParseTuple(tup, "Oi|O", &new, &offset, &title)) { Py_DECREF(ret); - ap->descr = descr; + ((PyArrayObject_fieldaccess *)ap)->descr = descr; return NULL; } - ap->descr = new; + /* + * TODO: temporarily modifying the array like this + * is bad coding style, should be changed. + */ + ((PyArrayObject_fieldaccess *)ap)->descr = new; /* update alignment based on offset */ if ((new->alignment > 1) && ((((intp)(ip+offset)) % new->alignment) != 0)) { - ap->flags &= ~NPY_ARRAY_ALIGNED; + PyArray_CLEARFLAGS(ap, NPY_ARRAY_ALIGNED); } else { - ap->flags |= NPY_ARRAY_ALIGNED; + PyArray_ENABLEFLAGS(ap, NPY_ARRAY_ALIGNED); } PyTuple_SET_ITEM(ret, i, new->f->getitem(ip+offset, ap)); - ap->flags = savedflags; + ((PyArrayObject_fieldaccess *)ap)->flags = savedflags; } - ap->descr = descr; + ((PyArrayObject_fieldaccess *)ap)->descr = descr; return ret; } if (descr->subarray) { /* return an array of the basic type */ PyArray_Dims shape = {NULL, -1}; - PyObject *ret; + PyArrayObject *ret; if (!(PyArray_IntpConverter(descr->subarray->shape, &shape))) { PyDimMem_FREE(shape.ptr); @@ -596,17 +602,20 @@ VOID_getitem(char *ip, PyArrayObject *ap) return NULL; } Py_INCREF(descr->subarray->base); - ret = PyArray_NewFromDescr(&PyArray_Type, + ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, descr->subarray->base, shape.len, shape.ptr, - NULL, ip, ap->flags&(~NPY_ARRAY_F_CONTIGUOUS), NULL); + NULL, ip, PyArray_FLAGS(ap)&(~NPY_ARRAY_F_CONTIGUOUS), NULL); PyDimMem_FREE(shape.ptr); if (!ret) { return NULL; } - PyArray_BASE(ret) = (PyObject *)ap; Py_INCREF(ap); + if (PyArray_SetBaseObject(ret, (PyObject *)ap) < 0) { + Py_DECREF(ret); + return NULL; + } PyArray_UpdateFlags((PyArrayObject *)ret, NPY_ARRAY_UPDATE_ALL); - return ret; + return (PyObject *)ret; } if (PyDataType_FLAGCHK(descr, NPY_ITEM_HASOBJECT) @@ -615,7 +624,7 @@ VOID_getitem(char *ip, PyArrayObject *ap) "tried to get void-array with object members as buffer."); return NULL; } - itemsize = ap->descr->elsize; + itemsize = PyArray_DESCR(ap)->elsize; #if defined(NPY_PY3K) /* * Return a byte array; there are no plain buffer objects on Py3 @@ -625,13 +634,16 @@ VOID_getitem(char *ip, PyArrayObject *ap) PyArray_Descr *descr; dims[0] = itemsize; strides[0] = 1; - descr = PyArray_DescrNewFromType(PyArray_BYTE); - u = PyArray_NewFromDescr(&PyArray_Type, descr, 1, dims, strides, - ip, + descr = PyArray_DescrNewFromType(NPY_BYTE); + u = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, + descr, 1, dims, strides, ip, PyArray_ISWRITEABLE(ap) ? NPY_ARRAY_WRITEABLE : 0, NULL); - ((PyArrayObject*)u)->base = ap; Py_INCREF(ap); + if (PyArray_SetBaseObject(u, ap) < 0) { + Py_DECREF(u); + return NULL; + } } #else /* @@ -639,19 +651,16 @@ VOID_getitem(char *ip, PyArrayObject *ap) * current item a view of it */ if (PyArray_ISWRITEABLE(ap)) { - u = PyBuffer_FromReadWriteMemory(ip, itemsize); + u = (PyArrayObject *)PyBuffer_FromReadWriteMemory(ip, itemsize); } else { - u = PyBuffer_FromMemory(ip, itemsize); + u = (PyArrayObject *)PyBuffer_FromMemory(ip, itemsize); } #endif if (u == NULL) { - goto fail; + return NULL; } - return u; - -fail: - return NULL; + return (PyObject *)u; } @@ -661,10 +670,10 @@ static int VOID_setitem(PyObject *op, char *ip, PyArrayObject *ap) { PyArray_Descr* descr; - int itemsize=ap->descr->elsize; + int itemsize=PyArray_DESCR(ap)->elsize; int res; - descr = ap->descr; + descr = PyArray_DESCR(ap); if (descr->names && PyTuple_Check(op)) { PyObject *key; PyObject *names; @@ -683,37 +692,41 @@ VOID_setitem(PyObject *op, char *ip, PyArrayObject *ap) "size of tuple must match number of fields."); return -1; } - savedflags = ap->flags; + savedflags = PyArray_FLAGS(ap); for (i = 0; i < n; i++) { key = PyTuple_GET_ITEM(names, i); tup = PyDict_GetItem(descr->fields, key); if (!PyArg_ParseTuple(tup, "Oi|O", &new, &offset, &title)) { - ap->descr = descr; + ((PyArrayObject_fieldaccess *)ap)->descr = descr; return -1; } - ap->descr = new; + /* + * TODO: temporarily modifying the array like this + * is bad coding style, should be changed. + */ + ((PyArrayObject_fieldaccess *)ap)->descr = new; /* remember to update alignment flags */ if ((new->alignment > 1) && ((((intp)(ip+offset)) % new->alignment) != 0)) { - ap->flags &= ~NPY_ARRAY_ALIGNED; + PyArray_CLEARFLAGS(ap, NPY_ARRAY_ALIGNED); } else { - ap->flags |= NPY_ARRAY_ALIGNED; + PyArray_ENABLEFLAGS(ap, NPY_ARRAY_ALIGNED); } res = new->f->setitem(PyTuple_GET_ITEM(op, i), ip+offset, ap); - ap->flags = savedflags; + ((PyArrayObject_fieldaccess *)ap)->flags = savedflags; if (res < 0) { break; } } - ap->descr = descr; + ((PyArrayObject_fieldaccess *)ap)->descr = descr; return res; } if (descr->subarray) { /* copy into an array of the same basic type */ PyArray_Dims shape = {NULL, -1}; - PyObject *ret; + PyArrayObject *ret; if (!(PyArray_IntpConverter(descr->subarray->shape, &shape))) { PyDimMem_FREE(shape.ptr); PyErr_SetString(PyExc_ValueError, @@ -721,17 +734,20 @@ VOID_setitem(PyObject *op, char *ip, PyArrayObject *ap) return -1; } Py_INCREF(descr->subarray->base); - ret = PyArray_NewFromDescr(&PyArray_Type, - descr->subarray->base, shape.len, shape.ptr, - NULL, ip, ap->flags, NULL); + ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, + descr->subarray->base, shape.len, shape.ptr, + NULL, ip, PyArray_FLAGS(ap), NULL); PyDimMem_FREE(shape.ptr); if (!ret) { return -1; } - PyArray_BASE(ret) = (PyObject *)ap; Py_INCREF(ap); - PyArray_UpdateFlags((PyArrayObject *)ret, NPY_ARRAY_UPDATE_ALL); - res = PyArray_CopyObject((PyArrayObject *)ret, op); + if (PyArray_SetBaseObject(ret, (PyObject *)ap) < 0) { + Py_DECREF(ret); + return -1; + } + PyArray_UpdateFlags(ret, NPY_ARRAY_UPDATE_ALL); + res = PyArray_CopyObject(ret, op); Py_DECREF(ret); return res; } @@ -776,7 +792,7 @@ DATETIME_getitem(char *ip, PyArrayObject *ap) { dt = *((npy_datetime *)ip); } else { - ap->descr->f->copyswap(&dt, ip, !PyArray_ISNOTSWAPPED(ap), ap); + PyArray_DESCR(ap)->f->copyswap(&dt, ip, !PyArray_ISNOTSWAPPED(ap), ap); } return convert_datetime_to_pyobject(dt, meta); @@ -798,7 +814,7 @@ TIMEDELTA_getitem(char *ip, PyArrayObject *ap) { td = *((npy_timedelta *)ip); } else { - ap->descr->f->copyswap(&td, ip, !PyArray_ISNOTSWAPPED(ap), ap); + PyArray_DESCR(ap)->f->copyswap(&td, ip, !PyArray_ISNOTSWAPPED(ap), ap); } return convert_timedelta_to_pyobject(td, meta); @@ -827,7 +843,7 @@ DATETIME_setitem(PyObject *op, char *ov, PyArrayObject *ap) { *((npy_datetime *)ov)=temp; } else { - ap->descr->f->copyswap(ov, &temp, !PyArray_ISNOTSWAPPED(ap), ap); + PyArray_DESCR(ap)->f->copyswap(ov, &temp, !PyArray_ISNOTSWAPPED(ap), ap); } return 0; @@ -856,7 +872,7 @@ TIMEDELTA_setitem(PyObject *op, char *ov, PyArrayObject *ap) { *((npy_timedelta *)ov)=temp; } else { - ap->descr->f->copyswap(ov, &temp, !PyArray_ISNOTSWAPPED(ap), ap); + PyArray_DESCR(ap)->f->copyswap(ov, &temp, !PyArray_ISNOTSWAPPED(ap), ap); } return 0; @@ -1137,7 +1153,7 @@ static void * longlong, ulonglong, npy_half, float, double, longdouble, * cfloat, cdouble, clongdouble, char, char, char, PyObject *, * datetime, timedelta# - * #skip = 1*18, aip->descr->elsize*3, 1*3# + * #skip = 1*18, PyArray_DESCR(aip)->elsize*3, 1*3# */ static void @FROMTYPE@_to_OBJECT(@fromtype@ *ip, PyObject **op, intp n, PyArrayObject *aip, @@ -1187,7 +1203,7 @@ static void * longlong, ulonglong, npy_half, float, double, longdouble, * cfloat, cdouble, clongdouble, char, char, char, datetime, * timedelta# - * #skip = 1*18, aop->descr->elsize*3, 1*2# + * #skip = 1*18, PyArray_DESCR(aop)->elsize*3, 1*2# */ static void OBJECT_to_@TOTYPE@(PyObject **ip, @totype@ *op, intp n, @@ -1214,7 +1230,9 @@ OBJECT_to_@TOTYPE@(PyObject **ip, @totype@ *op, intp n, * #fromtyp = char*69# * #to = (BOOL, BYTE, UBYTE, SHORT, USHORT, INT, UINT, LONG, ULONG, LONGLONG, ULONGLONG, HALF, FLOAT, DOUBLE, LONGDOUBLE, CFLOAT, CDOUBLE, CLONGDOUBLE, STRING, UNICODE, VOID, DATETIME, TIMEDELTA)*3# * #totyp = (Bool, byte, ubyte, short, ushort, int, uint, long, ulong, longlong, ulonglong, npy_half, float, double, longdouble, cfloat, cdouble, clongdouble, char, char, char, datetime, timedelta)*3# - * #oskip = (1*18,aop->descr->elsize*3,1*2)*3# + * #oskip = 1*18,(PyArray_DESCR(aop)->elsize)*3,1*2, + * 1*18,(PyArray_DESCR(aop)->elsize)*3,1*2, + * 1*18,(PyArray_DESCR(aop)->elsize)*3,1*2# * #convert = 1*18, 0*3, 1*2, 1*18, 0*3, 1*2, 0*23# * #convstr = (Int*9, Long*2, Float*4, Complex*3, Tuple*3, Long*2)*3# */ @@ -1224,7 +1242,7 @@ static void { intp i; PyObject *temp = NULL; - int skip = aip->descr->elsize; + int skip = PyArray_DESCR(aip)->elsize; int oskip = @oskip@; for (i = 0; i < n; i++, ip+=skip, op+=oskip) { @@ -1280,7 +1298,7 @@ static void intp i; PyObject *temp = NULL; int skip = 1; - int oskip = aop->descr->elsize; + int oskip = PyArray_DESCR(aop)->elsize; for (i = 0; i < n; i++, ip += skip, op += oskip) { temp = @from@_getitem((char *)ip, aip); if (temp == NULL) { @@ -1793,7 +1811,7 @@ STRING_copyswapn (char *dst, intp dstride, char *src, intp sstride, intp n, int NPY_UNUSED(swap), PyArrayObject *arr) { if (src != NULL && arr != NULL) { - int itemsize = arr->descr->elsize; + int itemsize = PyArray_DESCR(arr)->elsize; if (dstride == itemsize && sstride == itemsize) { memcpy(dst, src, itemsize * n); @@ -1820,33 +1838,41 @@ VOID_copyswapn (char *dst, intp dstride, char *src, intp sstride, int offset; Py_ssize_t pos = 0; - descr = arr->descr; + descr = PyArray_DESCR(arr); while (PyDict_Next(descr->fields, &pos, &key, &value)) { if NPY_TITLE_KEY(key, value) { continue; } if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset, &title)) { - arr->descr = descr; + ((PyArrayObject_fieldaccess *)arr)->descr = descr; return; } - arr->descr = new; + /* + * TODO: temporarily modifying the array like this + * is bad coding style, should be changed. + */ + ((PyArrayObject_fieldaccess *)arr)->descr = new; new->f->copyswapn(dst+offset, dstride, (src != NULL ? src+offset : NULL), sstride, n, swap, arr); } - arr->descr = descr; + ((PyArrayObject_fieldaccess *)arr)->descr = descr; return; } - if (swap && arr->descr->subarray != NULL) { + if (swap && PyArray_DESCR(arr)->subarray != NULL) { PyArray_Descr *descr, *new; npy_intp num; npy_intp i; int subitemsize; char *dstptr, *srcptr; - descr = arr->descr; + descr = PyArray_DESCR(arr); new = descr->subarray->base; - arr->descr = new; + /* + * TODO: temporarily modifying the array like this + * is bad coding style, should be changed. + */ + ((PyArrayObject_fieldaccess *)arr)->descr = new; dstptr = dst; srcptr = src; subitemsize = new->elsize; @@ -1859,11 +1885,11 @@ VOID_copyswapn (char *dst, intp dstride, char *src, intp sstride, srcptr += sstride; } } - arr->descr = descr; + ((PyArrayObject_fieldaccess *)arr)->descr = descr; return; } if (src != NULL) { - memcpy(dst, src, arr->descr->elsize * n); + memcpy(dst, src, PyArray_DESCR(arr)->elsize * n); } return; } @@ -1880,40 +1906,48 @@ VOID_copyswap (char *dst, char *src, int swap, PyArrayObject *arr) int offset; Py_ssize_t pos = 0; - descr = arr->descr; + descr = PyArray_DESCR(arr); while (PyDict_Next(descr->fields, &pos, &key, &value)) { if NPY_TITLE_KEY(key, value) { continue; } if (!PyArg_ParseTuple(value, "Oi|O", &new, &offset, &title)) { - arr->descr = descr; + ((PyArrayObject_fieldaccess *)arr)->descr = descr; return; } - arr->descr = new; + /* + * TODO: temporarily modifying the array like this + * is bad coding style, should be changed. + */ + ((PyArrayObject_fieldaccess *)arr)->descr = new; new->f->copyswap(dst+offset, (src != NULL ? src+offset : NULL), swap, arr); } - arr->descr = descr; + ((PyArrayObject_fieldaccess *)arr)->descr = descr; return; } - if (swap && arr->descr->subarray != NULL) { + if (swap && PyArray_DESCR(arr)->subarray != NULL) { PyArray_Descr *descr, *new; npy_intp num; int itemsize; - descr = arr->descr; + descr = PyArray_DESCR(arr); new = descr->subarray->base; - arr->descr = new; + /* + * TODO: temporarily modifying the array like this + * is bad coding style, should be changed. + */ + ((PyArrayObject_fieldaccess *)arr)->descr = new; itemsize = new->elsize; num = descr->elsize / itemsize; new->f->copyswapn(dst, itemsize, src, itemsize, num, swap, arr); - arr->descr = descr; + ((PyArrayObject_fieldaccess *)arr)->descr = descr; return; } if (src != NULL) { - memcpy(dst, src, arr->descr->elsize); + memcpy(dst, src, PyArray_DESCR(arr)->elsize); } return; } @@ -1928,7 +1962,7 @@ UNICODE_copyswapn (char *dst, intp dstride, char *src, intp sstride, if (arr == NULL) { return; } - itemsize = arr->descr->elsize; + itemsize = PyArray_DESCR(arr)->elsize; if (src != NULL) { if (dstride == itemsize && sstride == itemsize) { memcpy(dst, src, n * itemsize); @@ -1963,7 +1997,7 @@ static void STRING_copyswap(char *dst, char *src, int NPY_UNUSED(swap), PyArrayObject *arr) { if (src != NULL && arr != NULL) { - memcpy(dst, src, arr->descr->elsize); + memcpy(dst, src, PyArray_DESCR(arr)->elsize); } } @@ -1975,7 +2009,7 @@ UNICODE_copyswap (char *dst, char *src, int swap, PyArrayObject *arr) if (arr == NULL) { return; } - itemsize = arr->descr->elsize; + itemsize = PyArray_DESCR(arr)->elsize; if (src != NULL) { memcpy(dst, src, itemsize); } @@ -2031,7 +2065,7 @@ static Bool */ @type@ tmp; #if @isfloat@ - ap->descr->f->copyswap(&tmp, ip, !PyArray_ISNOTSWAPPED(ap), ap); + PyArray_DESCR(ap)->f->copyswap(&tmp, ip, !PyArray_ISNOTSWAPPED(ap), ap); #else memcpy(&tmp, ip, sizeof(@type@)); #endif @@ -2054,7 +2088,7 @@ static Bool } else { @type@ tmp; - ap->descr->f->copyswap(&tmp, ip, !PyArray_ISNOTSWAPPED(ap), ap); + PyArray_DESCR(ap)->f->copyswap(&tmp, ip, !PyArray_ISNOTSWAPPED(ap), ap); return (Bool) ((tmp.real != 0) || (tmp.imag != 0)); } } @@ -2083,7 +2117,7 @@ Py_STRING_ISSPACE(char ch) static Bool STRING_nonzero (char *ip, PyArrayObject *ap) { - int len = ap->descr->elsize; + int len = PyArray_DESCR(ap)->elsize; int i; Bool nonz = FALSE; @@ -2106,17 +2140,17 @@ STRING_nonzero (char *ip, PyArrayObject *ap) static Bool UNICODE_nonzero (PyArray_UCS4 *ip, PyArrayObject *ap) { - int len = ap->descr->elsize >> 2; + int len = PyArray_DESCR(ap)->elsize >> 2; int i; Bool nonz = FALSE; char *buffer = NULL; if ((!PyArray_ISNOTSWAPPED(ap)) || (!PyArray_ISALIGNED(ap))) { - buffer = PyArray_malloc(ap->descr->elsize); + buffer = PyArray_malloc(PyArray_DESCR(ap)->elsize); if (buffer == NULL) { return nonz; } - memcpy(buffer, ip, ap->descr->elsize); + memcpy(buffer, ip, PyArray_DESCR(ap)->elsize); if (!PyArray_ISNOTSWAPPED(ap)) { byte_swap_vector(buffer, len, 4); } @@ -2170,8 +2204,8 @@ VOID_nonzero (char *ip, PyArrayObject *ap) int savedflags, offset; Py_ssize_t pos = 0; - descr = ap->descr; - savedflags = ap->flags; + descr = PyArray_DESCR(ap); + savedflags = PyArray_FLAGS(ap); while (PyDict_Next(descr->fields, &pos, &key, &value)) { if NPY_TITLE_KEY(key, value) { continue; @@ -2181,24 +2215,28 @@ VOID_nonzero (char *ip, PyArrayObject *ap) PyErr_Clear(); continue; } - ap->descr = new; - ap->flags = savedflags; + /* + * TODO: temporarily modifying the array like this + * is bad coding style, should be changed. + */ + ((PyArrayObject_fieldaccess *)ap)->descr = descr; + ((PyArrayObject_fieldaccess *)ap)->flags = savedflags; if ((new->alignment > 1) && !__ALIGNED(ip+offset, new->alignment)) { - ap->flags &= ~NPY_ARRAY_ALIGNED; + PyArray_CLEARFLAGS(ap, NPY_ARRAY_ALIGNED); } else { - ap->flags |= NPY_ARRAY_ALIGNED; + PyArray_ENABLEFLAGS(ap, NPY_ARRAY_ALIGNED); } if (new->f->nonzero(ip+offset, ap)) { nonz = TRUE; break; } } - ap->descr = descr; - ap->flags = savedflags; + ((PyArrayObject_fieldaccess *)ap)->descr = descr; + ((PyArrayObject_fieldaccess *)ap)->flags = savedflags; return nonz; } - len = ap->descr->elsize; + len = PyArray_DESCR(ap)->elsize; for (i = 0; i < len; i++) { if (*ip != '\0') { nonz = TRUE; @@ -2413,7 +2451,7 @@ STRING_compare(char *ip1, char *ip2, PyArrayObject *ap) { const unsigned char *c1 = (unsigned char *)ip1; const unsigned char *c2 = (unsigned char *)ip2; - const size_t len = ap->descr->elsize; + const size_t len = PyArray_DESCR(ap)->elsize; size_t i; for(i = 0; i < len; ++i) { @@ -2431,7 +2469,7 @@ static int UNICODE_compare(PyArray_UCS4 *ip1, PyArray_UCS4 *ip2, PyArrayObject *ap) { - int itemsize = ap->descr->elsize; + int itemsize = PyArray_DESCR(ap)->elsize; if (itemsize < 0) { return 0; @@ -2469,7 +2507,7 @@ VOID_compare(char *ip1, char *ip2, PyArrayObject *ap) if (!PyArray_HASFIELDS(ap)) { return STRING_compare(ip1, ip2, ap); } - descr = ap->descr; + descr = PyArray_DESCR(ap); /* * Compare on the first-field. If equal, then * compare on the second-field, etc. @@ -2481,7 +2519,11 @@ VOID_compare(char *ip1, char *ip2, PyArrayObject *ap) if (!PyArg_ParseTuple(tup, "Oi|O", &new, &offset, &title)) { goto finish; } - ap->descr = new; + /* + * TODO: temporarily modifying the array like this + * is bad coding style, should be changed. + */ + ((PyArrayObject_fieldaccess *)ap)->descr = new; swap = PyArray_ISBYTESWAPPED(ap); nip1 = ip1+offset; nip2 = ip2+offset; @@ -2525,7 +2567,7 @@ VOID_compare(char *ip1, char *ip2, PyArrayObject *ap) } finish: - ap->descr = descr; + ((PyArrayObject_fieldaccess *)ap)->descr = descr; return res; } @@ -2648,7 +2690,7 @@ static int @fname@_argmax(@type@ *ip, intp n, intp *max_ind, PyArrayObject *aip) { intp i; - int elsize = aip->descr->elsize; + int elsize = PyArray_DESCR(aip)->elsize; @type@ *mp = (@type@ *)PyArray_malloc(elsize); if (mp==NULL) return 0; diff --git a/numpy/core/src/multiarray/buffer.c b/numpy/core/src/multiarray/buffer.c index eb1c028a9..75c6b9ba1 100644 --- a/numpy/core/src/multiarray/buffer.c +++ b/numpy/core/src/multiarray/buffer.c @@ -45,7 +45,7 @@ array_getreadbuf(PyArrayObject *self, Py_ssize_t segment, void **ptrptr) return -1; } if (PyArray_ISONESEGMENT(self)) { - *ptrptr = self->data; + *ptrptr = PyArray_DATA(self); return PyArray_NBYTES(self); } PyErr_SetString(PyExc_ValueError, "array is not a single segment"); @@ -154,7 +154,7 @@ _is_natively_aligned_at(PyArray_Descr *descr, { int k; - if ((Py_ssize_t)(arr->data) % descr->alignment != 0) { + if ((Py_ssize_t)(PyArray_DATA(arr)) % descr->alignment != 0) { return 0; } @@ -166,9 +166,9 @@ _is_natively_aligned_at(PyArray_Descr *descr, return 0; } - for (k = 0; k < arr->nd; ++k) { - if (arr->dimensions[k] > 1) { - if (arr->strides[k] % descr->alignment != 0) { + for (k = 0; k < PyArray_NDIM(arr); ++k) { + if (PyArray_DIM(arr, k) > 1) { + if (PyArray_STRIDE(arr, k) % descr->alignment != 0) { return 0; } } diff --git a/numpy/core/src/multiarray/calculation.c b/numpy/core/src/multiarray/calculation.c index ddb68953d..a6cb82ecb 100644 --- a/numpy/core/src/multiarray/calculation.c +++ b/numpy/core/src/multiarray/calculation.c @@ -45,7 +45,6 @@ PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out) intp *rptr; intp i, n, m; int elsize; - int copyret = 0; NPY_BEGIN_THREADS_DEF; if ((ap=(PyArrayObject *)PyArray_CheckAxis(op, &axis, 0)) == NULL) { @@ -55,16 +54,16 @@ PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out) * We need to permute the array so that axis is placed at the end. * And all other dimensions are shifted left. */ - if (axis != ap->nd-1) { + if (axis != PyArray_NDIM(ap)-1) { PyArray_Dims newaxes; intp dims[MAX_DIMS]; int i; newaxes.ptr = dims; - newaxes.len = ap->nd; + newaxes.len = PyArray_NDIM(ap); for (i = 0; i < axis; i++) dims[i] = i; - for (i = axis; i < ap->nd - 1; i++) dims[i] = i + 1; - dims[ap->nd - 1] = axis; + for (i = axis; i < PyArray_NDIM(ap) - 1; i++) dims[i] = i + 1; + dims[PyArray_NDIM(ap) - 1] = axis; op = (PyArrayObject *)PyArray_Transpose(ap, &newaxes); Py_DECREF(ap); if (op == NULL) { @@ -76,20 +75,19 @@ PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out) } /* Will get native-byte order contiguous copy. */ - ap = (PyArrayObject *) - PyArray_ContiguousFromAny((PyObject *)op, - op->descr->type_num, 1, 0); + ap = (PyArrayObject *)PyArray_ContiguousFromAny((PyObject *)op, + PyArray_DESCR(op)->type_num, 1, 0); Py_DECREF(op); if (ap == NULL) { return NULL; } - arg_func = ap->descr->f->argmax; + arg_func = PyArray_DESCR(ap)->f->argmax; if (arg_func == NULL) { PyErr_SetString(PyExc_TypeError, "data type not ordered"); goto fail; } - elsize = ap->descr->elsize; - m = ap->dimensions[ap->nd-1]; + elsize = PyArray_DESCR(ap)->elsize; + m = PyArray_DIMS(ap)[PyArray_NDIM(ap)-1]; if (m == 0) { PyErr_SetString(PyExc_ValueError, "attempt to get argmax/argmin "\ @@ -98,8 +96,8 @@ PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out) } if (!out) { - rp = (PyArrayObject *)PyArray_New(Py_TYPE(ap), ap->nd-1, - ap->dimensions, PyArray_INTP, + rp = (PyArrayObject *)PyArray_New(Py_TYPE(ap), PyArray_NDIM(ap)-1, + PyArray_DIMS(ap), PyArray_INTP, NULL, NULL, 0, 0, (PyObject *)ap); if (rp == NULL) { @@ -108,38 +106,33 @@ PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out) } else { if (PyArray_SIZE(out) != - PyArray_MultiplyList(ap->dimensions, ap->nd - 1)) { + PyArray_MultiplyList(PyArray_DIMS(ap), PyArray_NDIM(ap) - 1)) { PyErr_SetString(PyExc_TypeError, "invalid shape for output array."); } - rp = (PyArrayObject *)\ - PyArray_FromArray(out, + rp = (PyArrayObject *)PyArray_FromArray(out, PyArray_DescrFromType(PyArray_INTP), NPY_ARRAY_CARRAY | NPY_ARRAY_UPDATEIFCOPY); if (rp == NULL) { goto fail; } - if (rp != out) { - copyret = 1; - } } - NPY_BEGIN_THREADS_DESCR(ap->descr); + NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(ap)); n = PyArray_SIZE(ap)/m; - rptr = (intp *)rp->data; - for (ip = ap->data, i = 0; i < n; i++, ip += elsize*m) { + rptr = (intp *)PyArray_DATA(rp); + for (ip = PyArray_DATA(ap), i = 0; i < n; i++, ip += elsize*m) { arg_func(ip, m, rptr, ap); rptr += 1; } - NPY_END_THREADS_DESCR(ap->descr); + NPY_END_THREADS_DESCR(PyArray_DESCR(ap)); Py_DECREF(ap); - if (copyret) { - PyArrayObject *obj; - obj = (PyArrayObject *)rp->base; - Py_INCREF(obj); + /* Trigger the UPDATEIFCOPY if necessary */ + if (out != NULL && out != rp) { Py_DECREF(rp); - rp = obj; + rp = out; + Py_INCREF(rp); } return (PyObject *)rp; @@ -194,7 +187,7 @@ PyArray_Max(PyArrayObject *ap, int axis, PyArrayObject *out) return NULL; } ret = PyArray_GenericReduceFunction(arr, n_ops.maximum, axis, - arr->descr->type_num, out); + PyArray_DESCR(arr)->type_num, out); Py_DECREF(arr); return ret; } @@ -212,7 +205,7 @@ PyArray_Min(PyArrayObject *ap, int axis, PyArrayObject *out) return NULL; } ret = PyArray_GenericReduceFunction(arr, n_ops.minimum, axis, - arr->descr->type_num, out); + PyArray_DESCR(arr)->type_num, out); Py_DECREF(arr); return ret; } @@ -273,24 +266,26 @@ NPY_NO_EXPORT PyObject * __New_PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject *out, int variance, int num) { - PyObject *obj1 = NULL, *obj2 = NULL, *obj3 = NULL, *new = NULL; + PyObject *obj1 = NULL, *obj2 = NULL, *obj3 = NULL; + PyArrayObject *arr1 = NULL, *arr2 = NULL, *new = NULL; PyObject *ret = NULL, *newshape = NULL; int i, n; intp val; - if ((new = PyArray_CheckAxis(self, &axis, 0)) == NULL) { + if ((new = (PyArrayObject *)PyArray_CheckAxis(self, &axis, 0)) == NULL) { return NULL; } /* Compute and reshape mean */ - obj1 = PyArray_EnsureAnyArray(PyArray_Mean((PyArrayObject *)new, axis, rtype, NULL)); - if (obj1 == NULL) { + arr1 = (PyArrayObject *)PyArray_EnsureAnyArray( + PyArray_Mean(new, axis, rtype, NULL)); + if (arr1 == NULL) { Py_DECREF(new); return NULL; } n = PyArray_NDIM(new); newshape = PyTuple_New(n); if (newshape == NULL) { - Py_DECREF(obj1); + Py_DECREF(arr1); Py_DECREF(new); return NULL; } @@ -303,43 +298,44 @@ __New_PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject *out, } PyTuple_SET_ITEM(newshape, i, PyInt_FromLong((long)val)); } - obj2 = PyArray_Reshape((PyArrayObject *)obj1, newshape); - Py_DECREF(obj1); + arr2 = (PyArrayObject *)PyArray_Reshape(arr1, newshape); + Py_DECREF(arr1); Py_DECREF(newshape); - if (obj2 == NULL) { + if (arr2 == NULL) { Py_DECREF(new); return NULL; } /* Compute x = x - mx */ - obj1 = PyArray_EnsureAnyArray(PyNumber_Subtract((PyObject *)new, obj2)); - Py_DECREF(obj2); - if (obj1 == NULL) { + arr1 = (PyArrayObject *)PyArray_EnsureAnyArray( + PyNumber_Subtract((PyObject *)new, (PyObject *)arr2)); + Py_DECREF(arr2); + if (arr1 == NULL) { Py_DECREF(new); return NULL; } /* Compute x * x */ - if (PyArray_ISCOMPLEX(obj1)) { - obj3 = PyArray_Conjugate((PyArrayObject *)obj1, NULL); + if (PyArray_ISCOMPLEX(arr1)) { + obj3 = PyArray_Conjugate(arr1, NULL); } else { - obj3 = obj1; - Py_INCREF(obj1); + obj3 = (PyObject *)arr1; + Py_INCREF(arr1); } if (obj3 == NULL) { Py_DECREF(new); return NULL; } - obj2 = PyArray_EnsureAnyArray \ - (PyArray_GenericBinaryFunction((PyArrayObject *)obj1, obj3, n_ops.multiply)); - Py_DECREF(obj1); + arr2 = (PyArrayObject *)PyArray_EnsureAnyArray( + PyArray_GenericBinaryFunction(arr1, obj3, n_ops.multiply)); + Py_DECREF(arr1); Py_DECREF(obj3); - if (obj2 == NULL) { + if (arr2 == NULL) { Py_DECREF(new); return NULL; } - if (PyArray_ISCOMPLEX(obj2)) { - obj3 = PyObject_GetAttrString(obj2, "real"); + if (PyArray_ISCOMPLEX(arr2)) { + obj3 = PyObject_GetAttrString((PyObject *)arr2, "real"); switch(rtype) { case NPY_CDOUBLE: rtype = NPY_DOUBLE; @@ -353,8 +349,8 @@ __New_PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject *out, } } else { - obj3 = obj2; - Py_INCREF(obj2); + obj3 = (PyObject *)arr2; + Py_INCREF(arr2); } if (obj3 == NULL) { Py_DECREF(new); @@ -364,7 +360,7 @@ __New_PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject *out, obj1 = PyArray_GenericReduceFunction((PyArrayObject *)obj3, n_ops.add, axis, rtype, NULL); Py_DECREF(obj3); - Py_DECREF(obj2); + Py_DECREF(arr2); if (obj1 == NULL) { Py_DECREF(new); return NULL; @@ -385,10 +381,10 @@ __New_PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject *out, Py_DECREF(obj2); if (!variance) { - obj1 = PyArray_EnsureAnyArray(ret); + arr1 = (PyArrayObject *)PyArray_EnsureAnyArray(ret); /* sqrt() */ - ret = PyArray_GenericUnaryFunction((PyArrayObject *)obj1, n_ops.sqrt); - Py_DECREF(obj1); + ret = PyArray_GenericUnaryFunction(arr1, n_ops.sqrt); + Py_DECREF(arr1); } if (ret == NULL) { return NULL; @@ -399,12 +395,12 @@ __New_PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject *out, if (PyArray_Check(self) && Py_TYPE(self) == Py_TYPE(ret)) { goto finish; } - obj1 = PyArray_EnsureArray(ret); - if (obj1 == NULL) { + arr1 = (PyArrayObject *)PyArray_EnsureArray(ret); + if (arr1 == NULL) { return NULL; } - ret = PyArray_View((PyArrayObject *)obj1, NULL, Py_TYPE(self)); - Py_DECREF(obj1); + ret = PyArray_View(arr1, NULL, Py_TYPE(self)); + Py_DECREF(arr1); finish: if (out) { @@ -599,10 +595,10 @@ PyArray_Round(PyArrayObject *a, int decimals, PyArrayObject *out) my_descr = PyArray_DescrFromType(NPY_DOUBLE); } else { - Py_INCREF(a->descr); - my_descr = a->descr; + Py_INCREF(PyArray_DESCR(a)); + my_descr = PyArray_DESCR(a); } - out = (PyArrayObject *)PyArray_Empty(a->nd, a->dimensions, + out = (PyArrayObject *)PyArray_Empty(PyArray_NDIM(a), PyArray_DIMS(a), my_descr, PyArray_ISFORTRAN(a)); if (out == NULL) { @@ -639,9 +635,9 @@ PyArray_Round(PyArrayObject *a, int decimals, PyArrayObject *out) Py_DECREF(f); Py_DECREF(out); if (ret_int) { - Py_INCREF(a->descr); + Py_INCREF(PyArray_DESCR(a)); tmp = PyArray_CastToType((PyArrayObject *)ret, - a->descr, PyArray_ISFORTRAN(a)); + PyArray_DESCR(a), PyArray_ISFORTRAN(a)); Py_DECREF(ret); return tmp; } @@ -655,13 +651,13 @@ PyArray_Round(PyArrayObject *a, int decimals, PyArrayObject *out) NPY_NO_EXPORT PyObject * PyArray_Mean(PyArrayObject *self, int axis, int rtype, PyArrayObject *out) { - PyObject *obj1 = NULL, *obj2 = NULL; - PyObject *new, *ret; + PyObject *obj1 = NULL, *obj2 = NULL, *ret; + PyArrayObject *new; - if ((new = PyArray_CheckAxis(self, &axis, 0)) == NULL) { + if ((new = (PyArrayObject *)PyArray_CheckAxis(self, &axis, 0)) == NULL) { return NULL; } - obj1 = PyArray_GenericReduceFunction((PyArrayObject *)new, n_ops.add, axis, + obj1 = PyArray_GenericReduceFunction(new, n_ops.add, axis, rtype, out); obj2 = PyFloat_FromDouble((double) PyArray_DIM(new,axis)); Py_DECREF(new); @@ -810,7 +806,7 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o return NULL; } - func = self->descr->f->fastclip; + func = PyArray_DESCR(self)->f->fastclip; if (func == NULL || (min != NULL && !PyArray_CheckAnyScalar(min)) || (max != NULL && !PyArray_CheckAnyScalar(max))) { return _slow_array_clip(self, min, max, out); @@ -844,15 +840,15 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o * type that matches both). */ if (PyArray_ScalarKind(newdescr->type_num, NULL) > - PyArray_ScalarKind(self->descr->type_num, NULL)) { - indescr = PyArray_PromoteTypes(newdescr, self->descr); + PyArray_ScalarKind(PyArray_DESCR(self)->type_num, NULL)) { + indescr = PyArray_PromoteTypes(newdescr, PyArray_DESCR(self)); func = indescr->f->fastclip; if (func == NULL) { return _slow_array_clip(self, min, max, out); } } else { - indescr = self->descr; + indescr = PyArray_DESCR(self); Py_INCREF(indescr); } Py_DECREF(newdescr); @@ -927,7 +923,7 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o if (PyArray_ISONESEGMENT(self) && PyArray_CHKFLAGS(self, NPY_ARRAY_ALIGNED) && PyArray_ISNOTSWAPPED(self) && - (self->descr == indescr)) { + (PyArray_DESCR(self) == indescr)) { ingood = 1; } if (!ingood) { @@ -974,8 +970,8 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o if (out == NULL) { Py_INCREF(indescr); out = (PyArrayObject*)PyArray_NewFromDescr(Py_TYPE(self), - indescr, self->nd, - self->dimensions, + indescr, PyArray_NDIM(self), + PyArray_DIMS(self), NULL, NULL, PyArray_ISFORTRAN(self), (PyObject *)self); @@ -992,7 +988,7 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o if (!outgood && PyArray_ISONESEGMENT(out) && PyArray_CHKFLAGS(out, NPY_ARRAY_ALIGNED) && PyArray_ISNOTSWAPPED(out) && - PyArray_EquivTypes(out->descr, indescr)) { + PyArray_EquivTypes(PyArray_DESCR(out), indescr)) { outgood = 1; } @@ -1024,19 +1020,19 @@ PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject *max, PyArrayObject *o "same shape as the input."); goto fail; } - if (newout->data != newin->data) { - memcpy(newout->data, newin->data, PyArray_NBYTES(newin)); + if (PyArray_DATA(newout) != PyArray_DATA(newin)) { + memcpy(PyArray_DATA(newout), PyArray_DATA(newin), PyArray_NBYTES(newin)); } /* Now we can call the fast-clip function */ min_data = max_data = NULL; if (mina != NULL) { - min_data = mina->data; + min_data = PyArray_DATA(mina); } if (maxa != NULL) { - max_data = maxa->data; + max_data = PyArray_DATA(maxa); } - func(newin->data, PyArray_SIZE(newin), min_data, max_data, newout->data); + func(PyArray_DATA(newin), PyArray_SIZE(newin), min_data, max_data, PyArray_DATA(newout)); /* Clean up temporary variables */ Py_XDECREF(mina); diff --git a/numpy/core/src/multiarray/common.c b/numpy/core/src/multiarray/common.c index 89d4c5f63..5b17ad28c 100644 --- a/numpy/core/src/multiarray/common.c +++ b/numpy/core/src/multiarray/common.c @@ -92,7 +92,7 @@ _array_find_type(PyObject *op, PyArray_Descr *minitype, int max) * is NULL. */ if (PyArray_Check(op)) { - chktype = PyArray_DESCR(op); + chktype = PyArray_DESCR((PyArrayObject *)op); Py_INCREF(chktype); if (minitype == NULL) { return chktype; @@ -211,7 +211,7 @@ _array_find_type(PyObject *op, PyArray_Descr *minitype, int max) if (PyObject_HasAttrString(op, "__array__")) { ip = PyObject_CallMethod(op, "__array__", NULL); if(ip && PyArray_Check(ip)) { - chktype = PyArray_DESCR(ip); + chktype = PyArray_DESCR((PyArrayObject *)ip); Py_INCREF(chktype); Py_DECREF(ip); goto finish; @@ -288,7 +288,7 @@ _array_find_type(PyObject *op, PyArray_Descr *minitype, int max) if (outtype->type_num == PyArray_VOID && minitype->type_num != PyArray_VOID) { Py_DECREF(outtype); - return PyArray_DescrFromType(PyArray_OBJECT); + return PyArray_DescrFromType(NPY_OBJECT); } return outtype; } @@ -448,19 +448,19 @@ index2ptr(PyArrayObject *mp, intp i) { intp dim0; - if (mp->nd == 0) { + if (PyArray_NDIM(mp) == 0) { PyErr_SetString(PyExc_IndexError, "0-d arrays can't be indexed"); return NULL; } - dim0 = mp->dimensions[0]; + dim0 = PyArray_DIMS(mp)[0]; if (i < 0) { i += dim0; } if (i == 0 && dim0 > 0) { - return mp->data; + return PyArray_DATA(mp); } if (i > 0 && i < dim0) { - return mp->data+i*mp->strides[0]; + return PyArray_DATA(mp)+i*PyArray_STRIDES(mp)[0]; } PyErr_SetString(PyExc_IndexError,"index out of bounds"); return NULL; @@ -469,7 +469,7 @@ index2ptr(PyArrayObject *mp, intp i) NPY_NO_EXPORT int _zerofill(PyArrayObject *ret) { - if (PyDataType_REFCHK(ret->descr)) { + if (PyDataType_REFCHK(PyArray_DESCR(ret))) { PyObject *zero = PyInt_FromLong(0); PyArray_FillObjectArray(ret, zero); Py_DECREF(zero); @@ -480,7 +480,7 @@ _zerofill(PyArrayObject *ret) } else { intp n = PyArray_NBYTES(ret); - memset(ret->data, 0, n); + memset(PyArray_DATA(ret), 0, n); } return 0; } @@ -498,14 +498,14 @@ _IsAligned(PyArrayObject *ap) * PyArray_DescrConverter(), but not necessarily when using * PyArray_DescrAlignConverter(). */ - alignment = ap->descr->alignment; + alignment = PyArray_DESCR(ap)->alignment; if (alignment == 1) { return 1; } - ptr = (intp) ap->data; + ptr = (intp) PyArray_DATA(ap); aligned = (ptr % alignment) == 0; - for (i = 0; i < ap->nd; i++) { - aligned &= ((ap->strides[i] % alignment) == 0); + for (i = 0; i < PyArray_NDIM(ap); i++) { + aligned &= ((PyArray_STRIDES(ap)[i] % alignment) == 0); } return aligned != 0; } @@ -513,12 +513,12 @@ _IsAligned(PyArrayObject *ap) NPY_NO_EXPORT Bool _IsWriteable(PyArrayObject *ap) { - PyObject *base=ap->base; + PyObject *base=PyArray_BASE(ap); void *dummy; Py_ssize_t n; /* If we own our own data, then no-problem */ - if ((base == NULL) || (ap->flags & NPY_ARRAY_OWNDATA)) { + if ((base == NULL) || (PyArray_FLAGS(ap) & NPY_ARRAY_OWNDATA)) { return TRUE; } /* @@ -529,13 +529,16 @@ _IsWriteable(PyArrayObject *ap) * or a string object (for pickling support memory savings). * - this last could be removed if a proper pickleable * buffer was added to Python. + * + * MW: I think it would better to disallow switching from READONLY + * to WRITEABLE like this... */ while(PyArray_Check(base)) { - if (PyArray_CHKFLAGS(base, NPY_ARRAY_OWNDATA)) { - return (Bool) (PyArray_ISWRITEABLE(base)); + if (PyArray_CHKFLAGS((PyArrayObject *)base, NPY_ARRAY_OWNDATA)) { + return (npy_bool) (PyArray_ISWRITEABLE((PyArrayObject *)base)); } - base = PyArray_BASE(base); + base = PyArray_BASE((PyArrayObject *)base); } /* diff --git a/numpy/core/src/multiarray/conversion_utils.c b/numpy/core/src/multiarray/conversion_utils.c index c709527a3..74d7e1192 100644 --- a/numpy/core/src/multiarray/conversion_utils.c +++ b/numpy/core/src/multiarray/conversion_utils.c @@ -360,7 +360,7 @@ PyArray_PyIntAsInt(PyObject *o) long long_value = -1; PyObject *obj; static char *msg = "an integer is required"; - PyObject *arr; + PyArrayObject *arr; PyArray_Descr *descr; int ret; @@ -380,16 +380,18 @@ PyArray_PyIntAsInt(PyObject *o) descr = &INT_Descr; arr = NULL; if (PyArray_Check(o)) { - if (PyArray_SIZE(o)!=1 || !PyArray_ISINTEGER(o)) { + if (PyArray_SIZE((PyArrayObject *)o)!=1 || + !PyArray_ISINTEGER((PyArrayObject *)o)) { PyErr_SetString(PyExc_TypeError, msg); return -1; } Py_INCREF(descr); - arr = PyArray_CastToType((PyArrayObject *)o, descr, 0); + arr = (PyArrayObject *)PyArray_CastToType((PyArrayObject *)o, + descr, 0); } if (PyArray_IsScalar(o, Integer)) { Py_INCREF(descr); - arr = PyArray_FromScalar(o, descr); + arr = (PyArrayObject *)PyArray_FromScalar(o, descr); } if (arr != NULL) { ret = *((int *)PyArray_DATA(arr)); @@ -449,7 +451,7 @@ PyArray_PyIntAsIntp(PyObject *o) longlong long_value = -1; PyObject *obj; static char *msg = "an integer is required"; - PyObject *arr; + PyArrayObject *arr; PyArray_Descr *descr; npy_intp ret; @@ -475,16 +477,18 @@ PyArray_PyIntAsIntp(PyObject *o) arr = NULL; if (PyArray_Check(o)) { - if (PyArray_SIZE(o)!=1 || !PyArray_ISINTEGER(o)) { + if (PyArray_SIZE((PyArrayObject *)o)!=1 || + !PyArray_ISINTEGER((PyArrayObject *)o)) { PyErr_SetString(PyExc_TypeError, msg); return -1; } Py_INCREF(descr); - arr = PyArray_CastToType((PyArrayObject *)o, descr, 0); + arr = (PyArrayObject *)PyArray_CastToType((PyArrayObject *)o, + descr, 0); } else if (PyArray_IsScalar(o, Integer)) { Py_INCREF(descr); - arr = PyArray_FromScalar(o, descr); + arr = (PyArrayObject *)PyArray_FromScalar(o, descr); } if (arr != NULL) { ret = *((npy_intp *)PyArray_DATA(arr)); diff --git a/numpy/core/src/multiarray/convert.c b/numpy/core/src/multiarray/convert.c index 57ad8c22f..d399912a6 100644 --- a/numpy/core/src/multiarray/convert.c +++ b/numpy/core/src/multiarray/convert.c @@ -86,7 +86,7 @@ PyArray_ToFile(PyArrayObject *self, FILE *fp, char *sep, char *format) n3 = (sep ? strlen((const char *)sep) : 0); if (n3 == 0) { /* binary data */ - if (PyDataType_FLAGCHK(self->descr, NPY_LIST_PICKLE)) { + if (PyDataType_FLAGCHK(PyArray_DESCR(self), NPY_LIST_PICKLE)) { PyErr_SetString(PyExc_ValueError, "cannot write " \ "object arrays to a file in " \ "binary mode"); @@ -100,15 +100,15 @@ PyArray_ToFile(PyArrayObject *self, FILE *fp, char *sep, char *format) #if defined (_MSC_VER) && defined(_WIN64) /* Workaround Win64 fwrite() bug. Ticket #1660 */ { - npy_intp maxsize = 2147483648 / self->descr->elsize; + npy_intp maxsize = 2147483648 / PyArray_DESCR(self)->elsize; npy_intp chunksize; n = 0; while (size > 0) { chunksize = (size > maxsize) ? maxsize : size; n2 = fwrite((const void *) - ((char *)self->data + (n * self->descr->elsize)), - (size_t) self->descr->elsize, + ((char *)PyArray_DATA(self) + (n * PyArray_DESCR(self)->elsize)), + (size_t) PyArray_DESCR(self)->elsize, (size_t) chunksize, fp); if (n2 < chunksize) { break; @@ -119,8 +119,8 @@ PyArray_ToFile(PyArrayObject *self, FILE *fp, char *sep, char *format) size = PyArray_SIZE(self); } #else - n = fwrite((const void *)self->data, - (size_t) self->descr->elsize, + n = fwrite((const void *)PyArray_DATA(self), + (size_t) PyArray_DESCR(self)->elsize, (size_t) size, fp); #endif NPY_END_ALLOW_THREADS; @@ -138,7 +138,7 @@ PyArray_ToFile(PyArrayObject *self, FILE *fp, char *sep, char *format) NPY_BEGIN_THREADS; while (it->index < it->size) { if (fwrite((const void *)it->dataptr, - (size_t) self->descr->elsize, + (size_t) PyArray_DESCR(self)->elsize, 1, fp) < 1) { NPY_END_THREADS; PyErr_Format(PyExc_IOError, @@ -163,7 +163,7 @@ PyArray_ToFile(PyArrayObject *self, FILE *fp, char *sep, char *format) PyArray_IterNew((PyObject *)self); n4 = (format ? strlen((const char *)format) : 0); while (it->index < it->size) { - obj = self->descr->f->getitem(it->dataptr, self); + obj = PyArray_DESCR(self)->f->getitem(it->dataptr, self); if (obj == NULL) { Py_DECREF(it); return -1; @@ -266,7 +266,7 @@ PyArray_ToString(PyArrayObject *self, NPY_ORDER order) numbytes = PyArray_NBYTES(self); if ((PyArray_ISCONTIGUOUS(self) && (order == NPY_CORDER)) || (PyArray_ISFORTRAN(self) && (order == NPY_FORTRANORDER))) { - ret = PyBytes_FromStringAndSize(self->data, (Py_ssize_t) numbytes); + ret = PyBytes_FromStringAndSize(PyArray_DATA(self), (Py_ssize_t) numbytes); } else { PyObject *new; @@ -293,7 +293,7 @@ PyArray_ToString(PyArrayObject *self, NPY_ORDER order) } dptr = PyBytes_AS_STRING(ret); index = it->size; - elsize = self->descr->elsize; + elsize = PyArray_DESCR(self)->elsize; while (index--) { memcpy(dptr, it->dataptr, elsize); dptr += elsize; @@ -308,14 +308,14 @@ PyArray_ToString(PyArrayObject *self, NPY_ORDER order) NPY_NO_EXPORT int PyArray_FillWithScalar(PyArrayObject *arr, PyObject *obj) { - PyObject *newarr; + PyArrayObject *newarr; int itemsize, swap; void *fromptr; PyArray_Descr *descr; intp size; PyArray_CopySwapFunc *copyswap; - itemsize = arr->descr->elsize; + itemsize = PyArray_DESCR(arr)->elsize; if (PyArray_ISOBJECT(arr)) { fromptr = &obj; swap = 0; @@ -324,7 +324,8 @@ PyArray_FillWithScalar(PyArrayObject *arr, PyObject *obj) else { descr = PyArray_DESCR(arr); Py_INCREF(descr); - newarr = PyArray_FromAny(obj, descr, 0,0, NPY_ARRAY_ALIGNED, NULL); + newarr = (PyArrayObject *)PyArray_FromAny(obj, descr, + 0,0, NPY_ARRAY_ALIGNED, NULL); if (newarr == NULL) { return -1; } @@ -332,11 +333,11 @@ PyArray_FillWithScalar(PyArrayObject *arr, PyObject *obj) swap = (PyArray_ISNOTSWAPPED(arr) != PyArray_ISNOTSWAPPED(newarr)); } size=PyArray_SIZE(arr); - copyswap = arr->descr->f->copyswap; + copyswap = PyArray_DESCR(arr)->f->copyswap; if (PyArray_ISONESEGMENT(arr)) { char *toptr=PyArray_DATA(arr); PyArray_FillWithScalarFunc* fillwithscalar = - arr->descr->f->fillwithscalar; + PyArray_DESCR(arr)->f->fillwithscalar; if (fillwithscalar && PyArray_ISALIGNED(arr)) { copyswap(fromptr, NULL, swap, newarr); fillwithscalar(toptr, size, fromptr, arr); @@ -489,7 +490,8 @@ PyArray_NewCopy(PyArrayObject *m1, NPY_ORDER order) NPY_NO_EXPORT PyObject * PyArray_View(PyArrayObject *self, PyArray_Descr *type, PyTypeObject *pytype) { - PyObject *new = NULL; + PyArrayObject *new = NULL; + PyArray_Descr *dtype; PyTypeObject *subtype; if (pytype) { @@ -498,21 +500,26 @@ PyArray_View(PyArrayObject *self, PyArray_Descr *type, PyTypeObject *pytype) else { subtype = Py_TYPE(self); } - Py_INCREF(self->descr); - new = PyArray_NewFromDescr(subtype, - self->descr, - self->nd, self->dimensions, - self->strides, - self->data, - self->flags, (PyObject *)self); + dtype = PyArray_DESCR(self); + Py_INCREF(dtype); + new = (PyArrayObject *)PyArray_NewFromDescr(subtype, + dtype, + PyArray_NDIM(self), PyArray_DIMS(self), + PyArray_STRIDES(self), + PyArray_DATA(self), + PyArray_FLAGS(self), (PyObject *)self); if (new == NULL) { return NULL; } Py_INCREF(self); - PyArray_BASE(new) = (PyObject *)self; + if (PyArray_SetBaseObject(new, (PyObject *)self) < 0) { + Py_DECREF(new); + Py_DECREF(type); + return NULL; + } if (type != NULL) { - if (PyObject_SetAttrString(new, "dtype", + if (PyObject_SetAttrString((PyObject *)new, "dtype", (PyObject *)type) < 0) { Py_DECREF(new); Py_DECREF(type); @@ -520,5 +527,5 @@ PyArray_View(PyArrayObject *self, PyArray_Descr *type, PyTypeObject *pytype) } Py_DECREF(type); } - return new; + return (PyObject *)new; } diff --git a/numpy/core/src/multiarray/convert_datatype.c b/numpy/core/src/multiarray/convert_datatype.c index da3f7205b..f4d3e8c57 100644 --- a/numpy/core/src/multiarray/convert_datatype.c +++ b/numpy/core/src/multiarray/convert_datatype.c @@ -41,8 +41,8 @@ PyArray_CastToType(PyArrayObject *arr, PyArray_Descr *dtype, int is_f_order) } out = PyArray_NewFromDescr(Py_TYPE(arr), dtype, - arr->nd, - arr->dimensions, + PyArray_NDIM(arr), + PyArray_DIMS(arr), NULL, NULL, is_f_order, (PyObject *)arr); @@ -1633,10 +1633,10 @@ PyArray_Zero(PyArrayObject *arr) int ret, storeflags; PyObject *obj; - if (_check_object_rec(arr->descr) < 0) { + if (_check_object_rec(PyArray_DESCR(arr)) < 0) { return NULL; } - zeroval = PyDataMem_NEW(arr->descr->elsize); + zeroval = PyDataMem_NEW(PyArray_DESCR(arr)->elsize); if (zeroval == NULL) { PyErr_SetNone(PyExc_MemoryError); return NULL; @@ -1648,10 +1648,10 @@ PyArray_Zero(PyArrayObject *arr) Py_DECREF(obj); return zeroval; } - storeflags = arr->flags; - arr->flags |= NPY_ARRAY_BEHAVED; - ret = arr->descr->f->setitem(obj, zeroval, arr); - arr->flags = storeflags; + storeflags = PyArray_FLAGS(arr); + PyArray_ENABLEFLAGS(arr, NPY_ARRAY_BEHAVED); + ret = PyArray_DESCR(arr)->f->setitem(obj, zeroval, arr); + ((PyArrayObject_fieldaccess *)arr)->flags = storeflags; Py_DECREF(obj); if (ret < 0) { PyDataMem_FREE(zeroval); @@ -1670,10 +1670,10 @@ PyArray_One(PyArrayObject *arr) int ret, storeflags; PyObject *obj; - if (_check_object_rec(arr->descr) < 0) { + if (_check_object_rec(PyArray_DESCR(arr)) < 0) { return NULL; } - oneval = PyDataMem_NEW(arr->descr->elsize); + oneval = PyDataMem_NEW(PyArray_DESCR(arr)->elsize); if (oneval == NULL) { PyErr_SetNone(PyExc_MemoryError); return NULL; @@ -1686,10 +1686,10 @@ PyArray_One(PyArrayObject *arr) return oneval; } - storeflags = arr->flags; - arr->flags |= NPY_ARRAY_BEHAVED; - ret = arr->descr->f->setitem(obj, oneval, arr); - arr->flags = storeflags; + storeflags = PyArray_FLAGS(arr); + PyArray_ENABLEFLAGS(arr, NPY_ARRAY_BEHAVED); + ret = PyArray_DESCR(arr)->f->setitem(obj, oneval, arr); + ((PyArrayObject_fieldaccess *)arr)->flags = storeflags; Py_DECREF(obj); if (ret < 0) { PyDataMem_FREE(oneval); @@ -1752,7 +1752,7 @@ PyArray_ConvertToCommonType(PyObject *op, int *retn) for (i = 0; i < n; i++) { mps[i] = (PyArrayObject *) array_big_item((PyArrayObject *)op, i); } - if (!PyArray_ISCARRAY(op)) { + if (!PyArray_ISCARRAY((PyArrayObject *)op)) { for (i = 0; i < n; i++) { PyObject *obj; obj = PyArray_NewCopy(mps[i], NPY_CORDER); diff --git a/numpy/core/src/multiarray/ctors.c b/numpy/core/src/multiarray/ctors.c index 6100fe7ee..b527a1074 100644 --- a/numpy/core/src/multiarray/ctors.c +++ b/numpy/core/src/multiarray/ctors.c @@ -409,7 +409,7 @@ _get_array_memory_extents(PyArrayObject *arr, /* Return a half-open range */ *out_start = start; - *out_end = end + arr->descr->elsize; + *out_end = end + PyArray_DESCR(arr)->elsize; } /* Returns 1 if the arrays have overlapping data, 0 otherwise */ @@ -621,7 +621,7 @@ setArrayFromSequence(PyArrayObject *a, PyObject *s, int dim, npy_intp offset) } } - if (dim > a->nd) { + if (dim > PyArray_NDIM(a)) { PyErr_Format(PyExc_ValueError, "setArrayFromSequence: sequence/array dimensions mismatch."); goto fail; @@ -635,34 +635,34 @@ setArrayFromSequence(PyArrayObject *a, PyObject *s, int dim, npy_intp offset) * Either the dimensions match, or the sequence has length 1 and can * be broadcast to the destination. */ - if (slen != a->dimensions[dim] && slen != 1) { + if (slen != PyArray_DIMS(a)[dim] && slen != 1) { PyErr_Format(PyExc_ValueError, "cannot copy sequence with size %d to array axis " - "with dimension %d", (int)slen, (int)a->dimensions[dim]); + "with dimension %d", (int)slen, (int)PyArray_DIMS(a)[dim]); goto fail; } /* Broadcast the one element from the sequence to all the outputs */ if (slen == 1) { PyObject *o; - npy_intp alen = a->dimensions[dim]; + npy_intp alen = PyArray_DIMS(a)[dim]; o = PySequence_GetItem(s, 0); if (o == NULL) { goto fail; } for (i = 0; i < alen; i++) { - if ((a->nd - dim) > 1) { + if ((PyArray_NDIM(a) - dim) > 1) { res = setArrayFromSequence(a, o, dim+1, offset); } else { - res = a->descr->f->setitem(o, (a->data + offset), a); + res = PyArray_DESCR(a)->f->setitem(o, (PyArray_DATA(a) + offset), a); } if (res < 0) { Py_DECREF(o); goto fail; } - offset += a->strides[dim]; + offset += PyArray_STRIDES(a)[dim]; } Py_DECREF(o); } @@ -673,17 +673,17 @@ setArrayFromSequence(PyArrayObject *a, PyObject *s, int dim, npy_intp offset) if (o == NULL) { goto fail; } - if ((a->nd - dim) > 1) { + if ((PyArray_NDIM(a) - dim) > 1) { res = setArrayFromSequence(a, o, dim+1, offset); } else { - res = a->descr->f->setitem(o, (a->data + offset), a); + res = PyArray_DESCR(a)->f->setitem(o, (PyArray_DATA(a) + offset), a); } Py_DECREF(o); if (res < 0) { goto fail; } - offset += a->strides[dim]; + offset += PyArray_STRIDES(a)[dim]; } } @@ -703,7 +703,7 @@ PyArray_AssignFromSequence(PyArrayObject *self, PyObject *v) "assignment from non-sequence"); return -1; } - if (self->nd == 0) { + if (PyArray_NDIM(self) == 0) { PyErr_SetString(PyExc_ValueError, "assignment to 0-d array"); return -1; @@ -722,7 +722,7 @@ discover_itemsize(PyObject *s, int nd, int *itemsize) int n, r, i; if (PyArray_Check(s)) { - *itemsize = MAX(*itemsize, PyArray_ITEMSIZE(s)); + *itemsize = MAX(*itemsize, PyArray_ITEMSIZE((PyArrayObject *)s)); return 0; } @@ -768,7 +768,7 @@ discover_itemsize(PyObject *s, int nd, int *itemsize) * has, filling in the dimensions as we go. */ static int -discover_dimensions(PyObject *s, int *maxndim, npy_intp *d, int check_it, +discover_dimensions(PyObject *obj, int *maxndim, npy_intp *d, int check_it, int stop_at_string, int stop_at_tuple, int *out_is_object) { @@ -782,66 +782,68 @@ discover_dimensions(PyObject *s, int *maxndim, npy_intp *d, int check_it, return 0; } - /* s is an Array */ - if (PyArray_Check(s)) { - if (PyArray_NDIM(s) < *maxndim) { - *maxndim = PyArray_NDIM(s); + /* obj is an Array */ + if (PyArray_Check(obj)) { + PyArrayObject *arr = (PyArrayObject *)obj; + + if (PyArray_NDIM(arr) < *maxndim) { + *maxndim = PyArray_NDIM(arr); } for (i=0; i<*maxndim; i++) { - d[i] = PyArray_DIM(s,i); + d[i] = PyArray_DIM(arr,i); } return 0; } - /* s is a Scalar */ - if (PyArray_IsScalar(s, Generic)) { + /* obj is a Scalar */ + if (PyArray_IsScalar(obj, Generic)) { *maxndim = 0; return 0; } - /* s is not a Sequence */ - if (!PySequence_Check(s) || + /* obj is not a Sequence */ + if (!PySequence_Check(obj) || #if defined(NPY_PY3K) /* FIXME: XXX -- what is the correct thing to do here? */ #else - PyInstance_Check(s) || + PyInstance_Check(obj) || #endif - PySequence_Length(s) < 0) { + PySequence_Length(obj) < 0) { *maxndim = 0; PyErr_Clear(); return 0; } - /* s is a String */ - if (PyString_Check(s) || + /* obj is a String */ + if (PyString_Check(obj) || #if defined(NPY_PY3K) #else - PyBuffer_Check(s) || + PyBuffer_Check(obj) || #endif - PyUnicode_Check(s)) { + PyUnicode_Check(obj)) { if (stop_at_string) { *maxndim = 0; } else { - d[0] = PySequence_Length(s); + d[0] = PySequence_Length(obj); *maxndim = 1; } return 0; } - /* s is a Tuple, but tuples aren't expanded */ - if (stop_at_tuple && PyTuple_Check(s)) { + /* obj is a Tuple, but tuples aren't expanded */ + if (stop_at_tuple && PyTuple_Check(obj)) { *maxndim = 0; return 0; } - /* s is a PEP 3118 buffer */ + /* obj is a PEP 3118 buffer */ #if PY_VERSION_HEX >= 0x02060000 /* PEP 3118 buffer interface */ memset(&buffer_view, 0, sizeof(Py_buffer)); - if (PyObject_GetBuffer(s, &buffer_view, PyBUF_STRIDES) == 0 || - PyObject_GetBuffer(s, &buffer_view, PyBUF_ND) == 0) { + if (PyObject_GetBuffer(obj, &buffer_view, PyBUF_STRIDES) == 0 || + PyObject_GetBuffer(obj, &buffer_view, PyBUF_ND) == 0) { int nd = buffer_view.ndim; if (nd < *maxndim) { *maxndim = nd; @@ -852,7 +854,7 @@ discover_dimensions(PyObject *s, int *maxndim, npy_intp *d, int check_it, PyBuffer_Release(&buffer_view); return 0; } - else if (PyObject_GetBuffer(s, &buffer_view, PyBUF_SIMPLE) == 0) { + else if (PyObject_GetBuffer(obj, &buffer_view, PyBUF_SIMPLE) == 0) { d[0] = buffer_view.len; *maxndim = 1; PyBuffer_Release(&buffer_view); @@ -863,8 +865,8 @@ discover_dimensions(PyObject *s, int *maxndim, npy_intp *d, int check_it, } #endif - /* s has the __array_struct__ interface */ - if ((e = PyObject_GetAttrString(s, "__array_struct__")) != NULL) { + /* obj has the __array_struct__ interface */ + if ((e = PyObject_GetAttrString(obj, "__array_struct__")) != NULL) { int nd = -1; if (NpyCapsule_Check(e)) { PyArrayInterface *inter; @@ -890,8 +892,8 @@ discover_dimensions(PyObject *s, int *maxndim, npy_intp *d, int check_it, PyErr_Clear(); } - /* s has the __array_interface__ interface */ - if ((e = PyObject_GetAttrString(s, "__array_interface__")) != NULL) { + /* obj has the __array_interface__ interface */ + if ((e = PyObject_GetAttrString(obj, "__array_interface__")) != NULL) { int nd = -1; if (PyDict_Check(e)) { PyObject *new; @@ -925,7 +927,7 @@ discover_dimensions(PyObject *s, int *maxndim, npy_intp *d, int check_it, PyErr_Clear(); } - n = PySequence_Size(s); + n = PySequence_Size(obj); if (n < 0) { return -1; @@ -942,7 +944,7 @@ discover_dimensions(PyObject *s, int *maxndim, npy_intp *d, int check_it, npy_intp dtmp[NPY_MAXDIMS]; int j, maxndim_m1 = *maxndim - 1; - if ((e = PySequence_GetItem(s, 0)) == NULL) { + if ((e = PySequence_GetItem(obj, 0)) == NULL) { /* * PySequence_Check detects whether an old type object is a * sequence by the presence of the __getitem__ attribute, and @@ -977,7 +979,7 @@ discover_dimensions(PyObject *s, int *maxndim, npy_intp *d, int check_it, *maxndim = maxndim_m1 + 1; for (i = 1; i < n; ++i) { /* Get the dimensions of the first item */ - if ((e = PySequence_GetItem(s, i)) == NULL) { + if ((e = PySequence_GetItem(obj, i)) == NULL) { /* see comment above */ if (PyErr_ExceptionMatches(PyExc_KeyError)) { PyErr_Clear(); @@ -1028,7 +1030,7 @@ PyArray_NewFromDescr(PyTypeObject *subtype, PyArray_Descr *descr, int nd, npy_intp *dims, npy_intp *strides, void *data, int flags, PyObject *obj) { - PyArrayObject *self; + PyArrayObject_fieldaccess *fa; int i; size_t sd; npy_intp largest; @@ -1116,55 +1118,55 @@ PyArray_NewFromDescr(PyTypeObject *subtype, PyArray_Descr *descr, int nd, largest /= dim; } - self = (PyArrayObject *) subtype->tp_alloc(subtype, 0); - if (self == NULL) { + fa = (PyArrayObject_fieldaccess *) subtype->tp_alloc(subtype, 0); + if (fa == NULL) { Py_DECREF(descr); return NULL; } - self->nd = nd; - self->dimensions = NULL; - self->data = NULL; + fa->nd = nd; + fa->dimensions = NULL; + fa->data = NULL; if (data == NULL) { - self->flags = NPY_ARRAY_DEFAULT; + fa->flags = NPY_ARRAY_DEFAULT; if (flags) { - self->flags |= NPY_ARRAY_F_CONTIGUOUS; + fa->flags |= NPY_ARRAY_F_CONTIGUOUS; if (nd > 1) { - self->flags &= ~NPY_ARRAY_C_CONTIGUOUS; + fa->flags &= ~NPY_ARRAY_C_CONTIGUOUS; } flags = NPY_ARRAY_F_CONTIGUOUS; } } else { - self->flags = (flags & ~NPY_ARRAY_UPDATEIFCOPY); + fa->flags = (flags & ~NPY_ARRAY_UPDATEIFCOPY); } - self->descr = descr; - self->base = (PyObject *)NULL; - self->weakreflist = (PyObject *)NULL; + fa->descr = descr; + fa->base = (PyObject *)NULL; + fa->weakreflist = (PyObject *)NULL; if (nd > 0) { - self->dimensions = PyDimMem_NEW(2*nd); - if (self->dimensions == NULL) { + fa->dimensions = PyDimMem_NEW(2*nd); + if (fa->dimensions == NULL) { PyErr_NoMemory(); goto fail; } - self->strides = self->dimensions + nd; - memcpy(self->dimensions, dims, sizeof(npy_intp)*nd); + fa->strides = fa->dimensions + nd; + memcpy(fa->dimensions, dims, sizeof(npy_intp)*nd); if (strides == NULL) { /* fill it in */ - sd = _array_fill_strides(self->strides, dims, nd, sd, - flags, &(self->flags)); + sd = _array_fill_strides(fa->strides, dims, nd, sd, + flags, &(fa->flags)); } else { /* * we allow strides even when we create * the memory, but be careful with this... */ - memcpy(self->strides, strides, sizeof(npy_intp)*nd); + memcpy(fa->strides, strides, sizeof(npy_intp)*nd); sd *= size; } } else { - self->dimensions = self->strides = NULL; - self->flags |= NPY_ARRAY_F_CONTIGUOUS; + fa->dimensions = fa->strides = NULL; + fa->flags |= NPY_ARRAY_F_CONTIGUOUS; } if (data == NULL) { @@ -1182,7 +1184,7 @@ PyArray_NewFromDescr(PyTypeObject *subtype, PyArray_Descr *descr, int nd, PyErr_NoMemory(); goto fail; } - self->flags |= NPY_ARRAY_OWNDATA; + fa->flags |= NPY_ARRAY_OWNDATA; /* * It is bad to have unitialized OBJECT pointers @@ -1197,16 +1199,16 @@ PyArray_NewFromDescr(PyTypeObject *subtype, PyArray_Descr *descr, int nd, * If data is passed in, this object won't own it by default. * Caller must arrange for this to be reset if truly desired */ - self->flags &= ~NPY_ARRAY_OWNDATA; + fa->flags &= ~NPY_ARRAY_OWNDATA; } - self->data = data; + fa->data = data; /* * If the strides were provided to the function, need to * update the flags to get the right CONTIGUOUS, ALIGN properties */ if (strides != NULL) { - PyArray_UpdateFlags(self, NPY_ARRAY_UPDATE_ALL); + PyArray_UpdateFlags((PyArrayObject *)fa, NPY_ARRAY_UPDATE_ALL); } /* @@ -1217,14 +1219,14 @@ PyArray_NewFromDescr(PyTypeObject *subtype, PyArray_Descr *descr, int nd, if ((subtype != &PyArray_Type)) { PyObject *res, *func, *args; - func = PyObject_GetAttrString((PyObject *)self, "__array_finalize__"); + func = PyObject_GetAttrString((PyObject *)fa, "__array_finalize__"); if (func && func != Py_None) { if (NpyCapsule_Check(func)) { /* A C-function is stored here */ PyArray_FinalizeFunc *cfunc; cfunc = NpyCapsule_AsVoidPtr(func); Py_DECREF(func); - if (cfunc(self, obj) < 0) { + if (cfunc((PyArrayObject *)fa, obj) < 0) { goto fail; } } @@ -1248,10 +1250,10 @@ PyArray_NewFromDescr(PyTypeObject *subtype, PyArray_Descr *descr, int nd, } else Py_XDECREF(func); } - return (PyObject *)self; + return (PyObject *)fa; fail: - Py_DECREF(self); + Py_DECREF(fa); return NULL; } @@ -1455,7 +1457,7 @@ _array_from_buffer_3118(PyObject *obj, PyObject **out) r = PyArray_NewFromDescr(&PyArray_Type, descr, nd, shape, strides, view->buf, flags, NULL); - ((PyArrayObject *)r)->base = memoryview; + ((PyArrayObject_fieldaccess *)r)->base = memoryview; PyArray_UpdateFlags((PyArrayObject *)r, NPY_ARRAY_UPDATE_ALL); *out = r; @@ -1593,11 +1595,17 @@ PyArray_GetArrayParamsFromObject(PyObject *op, /* If op supports the __array_struct__ or __array_interface__ interface */ tmp = PyArray_FromStructInterface(op); + if (tmp == NULL) { + return -1; + } if (tmp == Py_NotImplemented) { tmp = PyArray_FromInterface(op); + if (tmp == NULL) { + return -1; + } } if (tmp != Py_NotImplemented) { - if (writeable && !PyArray_ISWRITEABLE(tmp)) { + if (writeable && !PyArray_ISWRITEABLE((PyArrayObject *)tmp)) { PyErr_SetString(PyExc_RuntimeError, "cannot write to array interface object"); Py_DECREF(tmp); @@ -1619,7 +1627,7 @@ PyArray_GetArrayParamsFromObject(PyObject *op, if (!writeable) { tmp = PyArray_FromArrayAttr(op, requested_dtype, context); if (tmp != Py_NotImplemented) { - if (writeable && !PyArray_ISWRITEABLE(tmp)) { + if (writeable && !PyArray_ISWRITEABLE((PyArrayObject *)tmp)) { PyErr_SetString(PyExc_RuntimeError, "cannot write to array interface object"); Py_DECREF(tmp); @@ -1788,7 +1796,7 @@ PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int min_depth, /* If we got dimensions and dtype instead of an array */ if (arr == NULL) { - if (flags&NPY_ARRAY_UPDATEIFCOPY) { + if (flags & NPY_ARRAY_UPDATEIFCOPY) { Py_XDECREF(newtype); PyErr_SetString(PyExc_TypeError, "UPDATEIFCOPY used for non-array input."); @@ -1937,8 +1945,8 @@ PyArray_CheckFromAny(PyObject *op, PyArray_Descr *descr, int min_depth, PyObject *obj; if (requires & NPY_ARRAY_NOTSWAPPED) { if (!descr && PyArray_Check(op) && - !PyArray_ISNBO(PyArray_DESCR(op)->byteorder)) { - descr = PyArray_DescrNew(PyArray_DESCR(op)); + !PyArray_ISNBO(PyArray_DESCR((PyArrayObject *)op)->byteorder)) { + descr = PyArray_DescrNew(PyArray_DESCR((PyArrayObject *)op)); } else if (descr && !PyArray_ISNBO(descr->byteorder)) { PyArray_DESCR_REPLACE(descr); @@ -1974,8 +1982,8 @@ PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags) int copy = 0; int arrflags; PyArray_Descr *oldtype; - char *msg = "cannot copy back to a read-only array"; PyTypeObject *subtype; + NPY_CASTING casting = NPY_SAFE_CASTING; oldtype = PyArray_DESCR(arr); subtype = Py_TYPE(arr); @@ -1992,41 +2000,55 @@ PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags) itemsize = newtype->elsize; } - /* - * Can't cast unless ndim-0 array, NPY_ARRAY_FORCECAST is specified - * or the cast is safe. - */ - if (!(flags & NPY_ARRAY_FORCECAST) && !PyArray_NDIM(arr) == 0 && - !PyArray_CanCastTo(oldtype, newtype)) { + /* If the casting if forced, use the 'unsafe' casting rule */ + if (flags & NPY_ARRAY_FORCECAST) { + casting = NPY_UNSAFE_CASTING; + } + + /* Raise an error if the casting rule isn't followed */ + if (!PyArray_CanCastArrayTo(arr, newtype, casting)) { + PyObject *errmsg; + + errmsg = PyUString_FromString("Cannot cast array data from "); + PyUString_ConcatAndDel(&errmsg, + PyObject_Repr((PyObject *)PyArray_DESCR(arr))); + PyUString_ConcatAndDel(&errmsg, + PyUString_FromString(" to ")); + PyUString_ConcatAndDel(&errmsg, + PyObject_Repr((PyObject *)newtype)); + PyUString_ConcatAndDel(&errmsg, + PyUString_FromFormat(" according to the rule %s", + npy_casting_to_string(casting))); + PyErr_SetObject(PyExc_TypeError, errmsg); + Py_DECREF(newtype); - PyErr_SetString(PyExc_TypeError, - "array cannot be safely cast " \ - "to required type"); return NULL; } /* Don't copy if sizes are compatible */ if ((flags & NPY_ARRAY_ENSURECOPY) || PyArray_EquivTypes(oldtype, newtype)) { - arrflags = arr->flags; - if (arr->nd <= 1 && (flags & NPY_ARRAY_F_CONTIGUOUS)) { + arrflags = PyArray_FLAGS(arr); + if (PyArray_NDIM(arr) <= 1 && (flags & NPY_ARRAY_F_CONTIGUOUS)) { flags |= NPY_ARRAY_C_CONTIGUOUS; } copy = (flags & NPY_ARRAY_ENSURECOPY) || - ((flags & NPY_ARRAY_C_CONTIGUOUS) && (!(arrflags & NPY_ARRAY_C_CONTIGUOUS))) + ((flags & NPY_ARRAY_C_CONTIGUOUS) && + (!(arrflags & NPY_ARRAY_C_CONTIGUOUS))) || ((flags & NPY_ARRAY_ALIGNED) && - (!(arrflags & NPY_ARRAY_ALIGNED))) - || (arr->nd > 1 && - ((flags & NPY_ARRAY_F_CONTIGUOUS) && - (!(arrflags & NPY_ARRAY_F_CONTIGUOUS)))) + (!(arrflags & NPY_ARRAY_ALIGNED))) + || (PyArray_NDIM(arr) > 1 && + ((flags & NPY_ARRAY_F_CONTIGUOUS) && + (!(arrflags & NPY_ARRAY_F_CONTIGUOUS)))) || ((flags & NPY_ARRAY_WRITEABLE) && - (!(arrflags & NPY_ARRAY_WRITEABLE))); + (!(arrflags & NPY_ARRAY_WRITEABLE))); if (copy) { if ((flags & NPY_ARRAY_UPDATEIFCOPY) && - (!PyArray_ISWRITEABLE(arr))) { + (!PyArray_ISWRITEABLE(arr))) { Py_DECREF(newtype); - PyErr_SetString(PyExc_ValueError, msg); + PyErr_SetString(PyExc_ValueError, + "cannot copy back to a read-only array"); return NULL; } if ((flags & NPY_ARRAY_ENSUREARRAY)) { @@ -2034,23 +2056,27 @@ PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags) } ret = (PyArrayObject *) PyArray_NewFromDescr(subtype, newtype, - arr->nd, - arr->dimensions, + PyArray_NDIM(arr), + PyArray_DIMS(arr), NULL, NULL, flags & NPY_ARRAY_F_CONTIGUOUS, (PyObject *)arr); if (ret == NULL) { return NULL; } - if (PyArray_CopyInto(ret, arr) == -1) { + if (PyArray_CopyInto(ret, arr) < 0) { Py_DECREF(ret); return NULL; } if (flags & NPY_ARRAY_UPDATEIFCOPY) { - ret->flags |= NPY_ARRAY_UPDATEIFCOPY; - ret->base = (PyObject *)arr; - PyArray_FLAGS(ret->base) &= ~NPY_ARRAY_WRITEABLE; + /* + * Don't use PyArray_SetBaseObject, because that compresses + * the chain of bases. + */ Py_INCREF(arr); + ((PyArrayObject_fieldaccess *)ret)->base = (PyObject *)arr; + PyArray_ENABLEFLAGS(ret, NPY_ARRAY_UPDATEIFCOPY); + PyArray_CLEARFLAGS(arr, NPY_ARRAY_WRITEABLE); } } /* @@ -2060,20 +2086,25 @@ PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags) else { Py_DECREF(newtype); if ((flags & NPY_ARRAY_ENSUREARRAY) && - !PyArray_CheckExact(arr)) { - Py_INCREF(arr->descr); + !PyArray_CheckExact(arr)) { + PyArray_Descr *dtype = PyArray_DESCR(arr); + Py_INCREF(dtype); ret = (PyArrayObject *) PyArray_NewFromDescr(&PyArray_Type, - arr->descr, - arr->nd, - arr->dimensions, - arr->strides, - arr->data, - arr->flags,NULL); + dtype, + PyArray_NDIM(arr), + PyArray_DIMS(arr), + PyArray_STRIDES(arr), + PyArray_DATA(arr), + PyArray_FLAGS(arr), + NULL); if (ret == NULL) { return NULL; } - ret->base = (PyObject *)arr; + if (PyArray_SetBaseObject(ret, (PyObject *)arr)) { + Py_DECREF(ret); + return NULL; + } } else { ret = arr; @@ -2088,9 +2119,10 @@ PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags) */ else { if ((flags & NPY_ARRAY_UPDATEIFCOPY) && - (!PyArray_ISWRITEABLE(arr))) { + (!PyArray_ISWRITEABLE(arr))) { Py_DECREF(newtype); - PyErr_SetString(PyExc_ValueError, msg); + PyErr_SetString(PyExc_ValueError, + "cannot copy back to a read-only array B"); return NULL; } if ((flags & NPY_ARRAY_ENSUREARRAY)) { @@ -2098,7 +2130,7 @@ PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags) } ret = (PyArrayObject *) PyArray_NewFromDescr(subtype, newtype, - arr->nd, arr->dimensions, + PyArray_NDIM(arr), PyArray_DIMS(arr), NULL, NULL, flags & NPY_ARRAY_F_CONTIGUOUS, (PyObject *)arr); @@ -2110,10 +2142,14 @@ PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int flags) return NULL; } if (flags & NPY_ARRAY_UPDATEIFCOPY) { - ret->flags |= NPY_ARRAY_UPDATEIFCOPY; - ret->base = (PyObject *)arr; - PyArray_FLAGS(ret->base) &= ~NPY_ARRAY_WRITEABLE; + /* + * Don't use PyArray_SetBaseObject, because that compresses + * the chain of bases. + */ Py_INCREF(arr); + ((PyArrayObject_fieldaccess *)ret)->base = (PyObject *)arr; + PyArray_ENABLEFLAGS(ret, NPY_ARRAY_UPDATEIFCOPY); + PyArray_CLEARFLAGS(arr, NPY_ARRAY_WRITEABLE); } } return (PyObject *)ret; @@ -2126,7 +2162,8 @@ PyArray_FromStructInterface(PyObject *input) PyArray_Descr *thetype = NULL; char buf[40]; PyArrayInterface *inter; - PyObject *attr, *r; + PyObject *attr; + PyArrayObject *ret; char endian = PyArray_NATBYTE; attr = PyObject_GetAttrString(input, "__array_struct__"); @@ -2162,15 +2199,18 @@ PyArray_FromStructInterface(PyObject *input) } } - r = PyArray_NewFromDescr(&PyArray_Type, thetype, + ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, thetype, inter->nd, inter->shape, inter->strides, inter->data, inter->flags, NULL); Py_INCREF(input); - PyArray_BASE(r) = input; + if (PyArray_SetBaseObject(ret, input) < 0) { + Py_DECREF(ret); + return NULL; + } Py_DECREF(attr); - PyArray_UpdateFlags((PyArrayObject *)r, NPY_ARRAY_UPDATE_ALL); - return r; + PyArray_UpdateFlags(ret, NPY_ARRAY_UPDATE_ALL); + return (PyObject *)ret; fail: PyErr_SetString(PyExc_ValueError, "invalid __array_struct__"); @@ -2208,17 +2248,23 @@ PyArray_FromInterface(PyObject *input) } if (!PyDict_Check(inter)) { Py_DECREF(inter); - return Py_NotImplemented; + PyErr_SetString(PyExc_ValueError, + "Invalid __array_interface__ value, must be a dict"); + return NULL; } shape = PyDict_GetItemString(inter, "shape"); if (shape == NULL) { Py_DECREF(inter); - return Py_NotImplemented; + PyErr_SetString(PyExc_ValueError, + "Missing __array_interface__ shape"); + return NULL; } tstr = PyDict_GetItemString(inter, "typestr"); if (tstr == NULL) { Py_DECREF(inter); - return Py_NotImplemented; + PyErr_SetString(PyExc_ValueError, + "Missing __array_interface__ typestr"); + return NULL; } attr = PyDict_GetItemString(inter, "data"); @@ -2234,7 +2280,7 @@ PyArray_FromInterface(PyObject *input) if (res < 0) { PyErr_Clear(); res = PyObject_AsReadBuffer( - item, (const void **)&data, &buffer_len); + item, (const void **)&data, &buffer_len); if (res < 0) { goto fail; } @@ -2245,7 +2291,7 @@ PyArray_FromInterface(PyObject *input) longlong num = PyLong_AsLongLong(attr); if (error_converting(num)) { PyErr_SetString(PyExc_TypeError, - "offset "\ + "__array_interface__ offset " "must be an integer"); goto fail; } @@ -2257,7 +2303,7 @@ PyArray_FromInterface(PyObject *input) PyObject *dataptr; if (PyTuple_GET_SIZE(attr) != 2) { PyErr_SetString(PyExc_TypeError, - "data must return " \ + "__array_interface__ data must be " \ "a 2-tuple with (data pointer "\ "integer, read-only flag)"); goto fail; @@ -2268,7 +2314,7 @@ PyArray_FromInterface(PyObject *input) "%p", (void **)&data); if (res < 1) { PyErr_SetString(PyExc_TypeError, - "data string cannot be " \ + "__array_interface__ data string cannot be " \ "converted"); goto fail; } @@ -2277,9 +2323,9 @@ PyArray_FromInterface(PyObject *input) data = PyLong_AsVoidPtr(dataptr); } else { - PyErr_SetString(PyExc_TypeError, "first element " \ - "of data tuple must be integer" \ - " or string."); + PyErr_SetString(PyExc_TypeError, "first element " + "of __array_interface__ data tuple " + "must be integer or string."); goto fail; } if (PyObject_IsTrue(PyTuple_GET_ITEM(attr,1))) { @@ -2294,7 +2340,8 @@ PyArray_FromInterface(PyObject *input) } #endif if (!PyBytes_Check(attr)) { - PyErr_SetString(PyExc_TypeError, "typestr must be a string"); + PyErr_SetString(PyExc_TypeError, + "__array_interface__ typestr must be a string"); goto fail; } type = _array_typedescr_fromstr(PyString_AS_STRING(attr)); @@ -2329,7 +2376,10 @@ PyArray_FromInterface(PyObject *input) return NULL; } Py_INCREF(base); - ret->base = base; + if (PyArray_SetBaseObject(ret, base) < 0) { + Py_DECREF(ret); + return NULL; + } attr = PyDict_GetItemString(inter, "strides"); if (attr != NULL && attr != Py_None) { @@ -2356,7 +2406,7 @@ PyArray_FromInterface(PyObject *input) if (PyErr_Occurred()) { PyErr_Clear(); } - memcpy(ret->strides, strides, n*sizeof(npy_intp)); + memcpy(PyArray_STRIDES(ret), strides, n*sizeof(npy_intp)); } else PyErr_Clear(); PyArray_UpdateFlags(ret, NPY_ARRAY_UPDATE_ALL); @@ -2467,13 +2517,13 @@ PyArray_FromDimsAndDataAndDescr(int nd, int *d, NPY_NO_EXPORT PyObject * PyArray_FromDims(int nd, int *d, int type) { - PyObject *ret; + PyArrayObject *ret; char msg[] = "PyArray_FromDims: use PyArray_SimpleNew."; if (DEPRECATE(msg) < 0) { return NULL; } - ret = PyArray_FromDimsAndDataAndDescr(nd, d, + ret = (PyArrayObject *)PyArray_FromDimsAndDataAndDescr(nd, d, PyArray_DescrFromType(type), NULL); /* @@ -2481,10 +2531,10 @@ PyArray_FromDims(int nd, int *d, int type) * relied on that. Better keep it the same. If * Object type, then it's already been set to zero, though. */ - if (ret && (PyArray_DESCR(ret)->type_num != PyArray_OBJECT)) { + if (ret && (PyArray_DESCR(ret)->type_num != NPY_OBJECT)) { memset(PyArray_DATA(ret), 0, PyArray_NBYTES(ret)); } - return ret; + return (PyObject *)ret; } /* end old calls */ @@ -2531,7 +2581,7 @@ PyArray_EnsureAnyArray(PyObject *op) /* TODO: Put the order parameter in PyArray_CopyAnyInto and remove this */ NPY_NO_EXPORT int -PyArray_CopyAnyIntoOrdered(PyArrayObject *dst, PyArrayObject *src, +PyArray_CopyAsFlat(PyArrayObject *dst, PyArrayObject *src, NPY_ORDER order) { PyArray_StridedTransferFn *stransfer = NULL; @@ -2571,9 +2621,9 @@ PyArray_CopyAnyIntoOrdered(PyArrayObject *dst, PyArrayObject *src, dst_size = PyArray_SIZE(dst); src_size = PyArray_SIZE(src); if (dst_size != src_size) { - PyErr_SetString(PyExc_ValueError, - "arrays must have the same number of elements" - " for copy"); + PyErr_Format(PyExc_ValueError, + "cannot copy from array of size %d into an array " + "of size %d", (int)src_size, (int)dst_size); return -1; } @@ -2724,7 +2774,7 @@ PyArray_CopyAnyIntoOrdered(PyArrayObject *dst, PyArrayObject *src, NPY_NO_EXPORT int PyArray_CopyAnyInto(PyArrayObject *dst, PyArrayObject *src) { - return PyArray_CopyAnyIntoOrdered(dst, src, NPY_CORDER); + return PyArray_CopyAsFlat(dst, src, NPY_CORDER); } /*NUMPY_API @@ -3121,7 +3171,7 @@ NPY_NO_EXPORT PyObject * PyArray_CheckAxis(PyArrayObject *arr, int *axis, int flags) { PyObject *temp1, *temp2; - int n = arr->nd; + int n = PyArray_NDIM(arr); if (*axis == MAX_DIMS || n == 0) { if (n != 1) { @@ -3131,7 +3181,7 @@ PyArray_CheckAxis(PyArrayObject *arr, int *axis, int flags) return NULL; } if (*axis == MAX_DIMS) { - *axis = PyArray_NDIM(temp1)-1; + *axis = PyArray_NDIM((PyArrayObject *)temp1)-1; } } else { @@ -3158,7 +3208,7 @@ PyArray_CheckAxis(PyArrayObject *arr, int *axis, int flags) else { temp2 = (PyObject *)temp1; } - n = PyArray_NDIM(temp2); + n = PyArray_NDIM((PyArrayObject *)temp2); if (*axis < 0) { *axis += n; } @@ -3256,7 +3306,7 @@ NPY_NO_EXPORT PyObject * PyArray_Arange(double start, double stop, double step, int type_num) { npy_intp length; - PyObject *range; + PyArrayObject *range; PyArray_ArrFuncs *funcs; PyObject *obj; int ret; @@ -3271,7 +3321,7 @@ PyArray_Arange(double start, double stop, double step, int type_num) return PyArray_New(&PyArray_Type, 1, &length, type_num, NULL, NULL, 0, 0, NULL); } - range = PyArray_New(&PyArray_Type, 1, &length, type_num, + range = (PyArrayObject *)PyArray_New(&PyArray_Type, 1, &length, type_num, NULL, NULL, 0, 0, NULL); if (range == NULL) { return NULL; @@ -3283,34 +3333,34 @@ PyArray_Arange(double start, double stop, double step, int type_num) * if length > 2, then call the inner loop, otherwise stop */ obj = PyFloat_FromDouble(start); - ret = funcs->setitem(obj, PyArray_DATA(range), (PyArrayObject *)range); + ret = funcs->setitem(obj, PyArray_DATA(range), range); Py_DECREF(obj); if (ret < 0) { goto fail; } if (length == 1) { - return range; + return (PyObject *)range; } obj = PyFloat_FromDouble(start + step); ret = funcs->setitem(obj, PyArray_BYTES(range)+PyArray_ITEMSIZE(range), - (PyArrayObject *)range); + range); Py_DECREF(obj); if (ret < 0) { goto fail; } if (length == 2) { - return range; + return (PyObject *)range; } if (!funcs->fill) { PyErr_SetString(PyExc_ValueError, "no fill-function for data-type."); Py_DECREF(range); return NULL; } - funcs->fill(PyArray_DATA(range), length, (PyArrayObject *)range); + funcs->fill(PyArray_DATA(range), length, range); if (PyErr_Occurred()) { goto fail; } - return range; + return (PyObject *)range; fail: Py_DECREF(range); @@ -3397,7 +3447,7 @@ _calc_length(PyObject *start, PyObject *stop, PyObject *step, PyObject **next, i NPY_NO_EXPORT PyObject * PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr *dtype) { - PyObject *range; + PyArrayObject *range; PyArray_ArrFuncs *funcs; PyObject *next, *err; npy_intp length; @@ -3462,10 +3512,10 @@ PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr } if (length <= 0) { length = 0; - range = PyArray_SimpleNewFromDescr(1, &length, dtype); + range = (PyArrayObject *)PyArray_SimpleNewFromDescr(1, &length, dtype); Py_DECREF(step); Py_DECREF(start); - return range; + return (PyObject *)range; } /* @@ -3481,7 +3531,7 @@ PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr swap = 0; } - range = PyArray_SimpleNewFromDescr(1, &length, native); + range = (PyArrayObject *)PyArray_SimpleNewFromDescr(1, &length, native); if (range == NULL) { goto fail; } @@ -3491,15 +3541,14 @@ PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr * if length > 2, then call the inner loop, otherwise stop */ funcs = PyArray_DESCR(range)->f; - if (funcs->setitem( - start, PyArray_DATA(range), (PyArrayObject *)range) < 0) { + if (funcs->setitem(start, PyArray_DATA(range), range) < 0) { goto fail; } if (length == 1) { goto finish; } if (funcs->setitem(next, PyArray_BYTES(range)+PyArray_ITEMSIZE(range), - (PyArrayObject *)range) < 0) { + range) < 0) { goto fail; } if (length == 2) { @@ -3510,22 +3559,24 @@ PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject *step, PyArray_Descr Py_DECREF(range); goto fail; } - funcs->fill(PyArray_DATA(range), length, (PyArrayObject *)range); + funcs->fill(PyArray_DATA(range), length, range); if (PyErr_Occurred()) { goto fail; } finish: + /* TODO: This swapping could be handled on the fly by the nditer */ if (swap) { PyObject *new; - new = PyArray_Byteswap((PyArrayObject *)range, 1); + new = PyArray_Byteswap(range, 1); Py_DECREF(new); Py_DECREF(PyArray_DESCR(range)); - PyArray_DESCR(range) = dtype; /* steals the reference */ + /* steals the reference */ + ((PyArrayObject_fieldaccess *)range)->descr = dtype; } Py_DECREF(start); Py_DECREF(step); Py_DECREF(next); - return range; + return (PyObject *)range; fail: Py_DECREF(start); @@ -3594,7 +3645,7 @@ array_fromfile_binary(FILE *fp, PyArray_Descr *dtype, npy_intp num, size_t *nrea return NULL; } NPY_BEGIN_ALLOW_THREADS; - *nread = fread(r->data, dtype->elsize, num, fp); + *nread = fread(PyArray_DATA(r), dtype->elsize, num, fp); NPY_END_ALLOW_THREADS; return r; } @@ -3630,7 +3681,7 @@ array_from_text(PyArray_Descr *dtype, npy_intp num, char *sep, size_t *nread, clean_sep = swab_separator(sep); NPY_BEGIN_ALLOW_THREADS; totalbytes = bytes = size * dtype->elsize; - dptr = r->data; + dptr = PyArray_DATA(r); for (i= 0; num < 0 || i < num; i++) { if (next(&stream, dptr, dtype, stream_data) < 0) { break; @@ -3640,12 +3691,12 @@ array_from_text(PyArray_Descr *dtype, npy_intp num, char *sep, size_t *nread, dptr += dtype->elsize; if (num < 0 && thisbuf == size) { totalbytes += bytes; - tmp = PyDataMem_RENEW(r->data, totalbytes); + tmp = PyDataMem_RENEW(PyArray_DATA(r), totalbytes); if (tmp == NULL) { err = 1; break; } - r->data = tmp; + ((PyArrayObject_fieldaccess *)r)->data = tmp; dptr = tmp + (totalbytes - bytes); thisbuf = 0; } @@ -3654,13 +3705,13 @@ array_from_text(PyArray_Descr *dtype, npy_intp num, char *sep, size_t *nread, } } if (num < 0) { - tmp = PyDataMem_RENEW(r->data, NPY_MAX(*nread,1)*dtype->elsize); + tmp = PyDataMem_RENEW(PyArray_DATA(r), NPY_MAX(*nread,1)*dtype->elsize); if (tmp == NULL) { err = 1; } else { - PyArray_DIM(r,0) = *nread; - r->data = tmp; + PyArray_DIMS(r)[0] = *nread; + ((PyArrayObject_fieldaccess *)r)->data = tmp; } } NPY_END_ALLOW_THREADS; @@ -3733,15 +3784,15 @@ PyArray_FromFile(FILE *fp, PyArray_Descr *dtype, npy_intp num, char *sep) } if (((npy_intp) nread) < num) { /* Realloc memory for smaller number of elements */ - const size_t nsize = NPY_MAX(nread,1)*ret->descr->elsize; + const size_t nsize = NPY_MAX(nread,1)*PyArray_DESCR(ret)->elsize; char *tmp; - if((tmp = PyDataMem_RENEW(ret->data, nsize)) == NULL) { + if((tmp = PyDataMem_RENEW(PyArray_DATA(ret), nsize)) == NULL) { Py_DECREF(ret); return PyErr_NoMemory(); } - ret->data = tmp; - PyArray_DIM(ret,0) = nread; + ((PyArrayObject_fieldaccess *)ret)->data = tmp; + PyArray_DIMS(ret)[0] = nread; } return (PyObject *)ret; } @@ -3848,10 +3899,13 @@ PyArray_FromBuffer(PyObject *buf, PyArray_Descr *type, } if (!writeable) { - ret->flags &= ~NPY_ARRAY_WRITEABLE; + PyArray_CLEARFLAGS(ret, NPY_ARRAY_WRITEABLE); } /* Store a reference for decref on deallocation */ - ret->base = buf; + if (PyArray_SetBaseObject(ret, buf) < 0) { + Py_DECREF(ret); + return NULL; + } PyArray_UpdateFlags(ret, NPY_ARRAY_ALIGNED); return (PyObject *)ret; } @@ -3931,7 +3985,7 @@ PyArray_FromString(char *data, npy_intp slen, PyArray_Descr *dtype, if (ret == NULL) { return NULL; } - memcpy(ret->data, data, num*dtype->elsize); + memcpy(PyArray_DATA(ret), data, num*dtype->elsize); } else { /* read from character-based string */ @@ -4004,13 +4058,13 @@ PyArray_FromIter(PyObject *obj, PyArray_Descr *dtype, npy_intp count) (value = PyIter_Next(iter)); i++) { if (i >= elcount) { /* - Grow ret->data: + Grow PyArray_DATA(ret): this is similar for the strategy for PyListObject, but we use 50% overallocation => 0, 4, 8, 14, 23, 36, 56, 86 ... */ elcount = (i >> 1) + (i < 4 ? 4 : 2) + i; if (elcount <= NPY_MAX_INTP/elsize) { - new_data = PyDataMem_RENEW(ret->data, elcount * elsize); + new_data = PyDataMem_RENEW(PyArray_DATA(ret), elcount * elsize); } else { new_data = NULL; @@ -4021,12 +4075,12 @@ PyArray_FromIter(PyObject *obj, PyArray_Descr *dtype, npy_intp count) Py_DECREF(value); goto done; } - ret->data = new_data; + ((PyArrayObject_fieldaccess *)ret)->data = new_data; } - ret->dimensions[0] = i + 1; + PyArray_DIMS(ret)[0] = i + 1; if (((item = index2ptr(ret, i)) == NULL) - || (ret->descr->f->setitem(value, item, ret) == -1)) { + || (PyArray_DESCR(ret)->f->setitem(value, item, ret) == -1)) { Py_DECREF(value); goto done; } @@ -4045,12 +4099,12 @@ PyArray_FromIter(PyObject *obj, PyArray_Descr *dtype, npy_intp count) if (i == 0) { i = 1; } - new_data = PyDataMem_RENEW(ret->data, i * elsize); + new_data = PyDataMem_RENEW(PyArray_DATA(ret), i * elsize); if (new_data == NULL) { PyErr_SetString(PyExc_MemoryError, "cannot allocate array memory"); goto done; } - ret->data = new_data; + ((PyArrayObject_fieldaccess *)ret)->data = new_data; done: Py_XDECREF(iter); diff --git a/numpy/core/src/multiarray/ctors.h b/numpy/core/src/multiarray/ctors.h index 13f5d0da6..ed7b72980 100644 --- a/numpy/core/src/multiarray/ctors.h +++ b/numpy/core/src/multiarray/ctors.h @@ -47,7 +47,7 @@ PyArray_CheckAxis(PyArrayObject *arr, int *axis, int flags); /* TODO: Put the order parameter in PyArray_CopyAnyInto and remove this */ NPY_NO_EXPORT int -PyArray_CopyAnyIntoOrdered(PyArrayObject *dst, PyArrayObject *src, +PyArray_CopyAsFlat(PyArrayObject *dst, PyArrayObject *src, NPY_ORDER order); /* FIXME: remove those from here */ diff --git a/numpy/core/src/multiarray/datetime.c b/numpy/core/src/multiarray/datetime.c index 7a0bafbf2..cc4fc9d63 100644 --- a/numpy/core/src/multiarray/datetime.c +++ b/numpy/core/src/multiarray/datetime.c @@ -2573,23 +2573,24 @@ convert_pyobject_to_datetime(PyArray_DatetimeMetaData *meta, PyObject *obj, } /* Datetime zero-dimensional array */ else if (PyArray_Check(obj) && - PyArray_NDIM(obj) == 0 && - PyArray_DESCR(obj)->type_num == NPY_DATETIME) { - PyArray_DatetimeMetaData *obj_meta; + PyArray_NDIM((PyArrayObject *)obj) == 0 && + PyArray_DESCR((PyArrayObject *)obj)->type_num == NPY_DATETIME) { + PyArrayObject *arr = (PyArrayObject *)obj; + PyArray_DatetimeMetaData *arr_meta; npy_datetime dt = 0; - obj_meta = get_datetime_metadata_from_dtype(PyArray_DESCR(obj)); - if (obj_meta == NULL) { + arr_meta = get_datetime_metadata_from_dtype(PyArray_DESCR(arr)); + if (arr_meta == NULL) { return -1; } - PyArray_DESCR(obj)->f->copyswap(&dt, - PyArray_DATA(obj), - !PyArray_ISNOTSWAPPED(obj), - obj); + PyArray_DESCR(arr)->f->copyswap(&dt, + PyArray_DATA(arr), + !PyArray_ISNOTSWAPPED(arr), + obj); /* Copy the value directly if units weren't specified */ if (meta->base == -1) { - *meta = *obj_meta; + *meta = *arr_meta; *out = dt; return 0; @@ -2600,11 +2601,11 @@ convert_pyobject_to_datetime(PyArray_DatetimeMetaData *meta, PyObject *obj, if (dt != NPY_DATETIME_NAT && raise_if_datetime64_metadata_cast_error( "NumPy timedelta64 scalar", - obj_meta, meta, casting) < 0) { + arr_meta, meta, casting) < 0) { return -1; } else { - return cast_datetime_to_datetime(obj_meta, meta, dt, out); + return cast_datetime_to_datetime(arr_meta, meta, dt, out); } } } @@ -2769,23 +2770,24 @@ convert_pyobject_to_timedelta(PyArray_DatetimeMetaData *meta, PyObject *obj, } /* Timedelta zero-dimensional array */ else if (PyArray_Check(obj) && - PyArray_NDIM(obj) == 0 && - PyArray_DESCR(obj)->type_num == NPY_TIMEDELTA) { - PyArray_DatetimeMetaData *obj_meta; + PyArray_NDIM((PyArrayObject *)obj) == 0 && + PyArray_DESCR((PyArrayObject *)obj)->type_num == NPY_TIMEDELTA) { + PyArrayObject *arr = (PyArrayObject *)obj; + PyArray_DatetimeMetaData *arr_meta; npy_timedelta dt = 0; - obj_meta = get_datetime_metadata_from_dtype(PyArray_DESCR(obj)); - if (obj_meta == NULL) { + arr_meta = get_datetime_metadata_from_dtype(PyArray_DESCR(arr)); + if (arr_meta == NULL) { return -1; } - PyArray_DESCR(obj)->f->copyswap(&dt, - PyArray_DATA(obj), - !PyArray_ISNOTSWAPPED(obj), - obj); + PyArray_DESCR(arr)->f->copyswap(&dt, + PyArray_DATA(arr), + !PyArray_ISNOTSWAPPED(arr), + obj); /* Copy the value directly if units weren't specified */ if (meta->base == -1) { - *meta = *obj_meta; + *meta = *arr_meta; *out = dt; return 0; @@ -2796,11 +2798,11 @@ convert_pyobject_to_timedelta(PyArray_DatetimeMetaData *meta, PyObject *obj, if (dt != NPY_DATETIME_NAT && raise_if_timedelta64_metadata_cast_error( "NumPy timedelta64 scalar", - obj_meta, meta, casting) < 0) { + arr_meta, meta, casting) < 0) { return -1; } else { - return cast_timedelta_to_timedelta(obj_meta, meta, dt, out); + return cast_timedelta_to_timedelta(arr_meta, meta, dt, out); } } } @@ -3184,7 +3186,8 @@ is_any_numpy_datetime(PyObject *obj) { return (PyArray_IsScalar(obj, Datetime) || (PyArray_Check(obj) && ( - PyArray_DESCR(obj)->type_num == NPY_DATETIME)) || + PyArray_DESCR((PyArrayObject *)obj)->type_num == + NPY_DATETIME)) || PyDate_Check(obj) || PyDateTime_Check(obj)); } @@ -3197,9 +3200,9 @@ static npy_bool is_any_numpy_timedelta(PyObject *obj) { return (PyArray_IsScalar(obj, Timedelta) || - (PyArray_Check(obj) && ( - PyArray_DESCR(obj)->type_num == NPY_TIMEDELTA)) || - PyDelta_Check(obj)); + (PyArray_Check(obj) && ( + PyArray_DESCR((PyArrayObject *)obj)->type_num == NPY_TIMEDELTA)) || + PyDelta_Check(obj)); } /* @@ -3550,7 +3553,7 @@ datetime_arange(PyObject *start, PyObject *stop, PyObject *step, * Returns 0 on success, -1 on failure. */ static int -find_string_array_datetime64_type(PyObject *obj, +find_string_array_datetime64_type(PyArrayObject *arr, PyArray_DatetimeMetaData *meta) { NpyIter* iter; @@ -3565,7 +3568,7 @@ find_string_array_datetime64_type(PyObject *obj, PyArray_DatetimeMetaData tmp_meta; /* Handle zero-sized arrays specially */ - if (PyArray_SIZE(obj) == 0) { + if (PyArray_SIZE(arr) == 0) { return 0; } @@ -3575,7 +3578,7 @@ find_string_array_datetime64_type(PyObject *obj, } /* Use unsafe casting to allow unicode -> ascii string */ - iter = NpyIter_New((PyArrayObject *)obj, + iter = NpyIter_New((PyArrayObject *)arr, NPY_ITER_READONLY| NPY_ITER_EXTERNAL_LOOP| NPY_ITER_BUFFERED, @@ -3681,19 +3684,20 @@ recursive_find_object_datetime64_type(PyObject *obj, { /* Array -> use its metadata */ if (PyArray_Check(obj)) { - PyArray_Descr *obj_dtype = PyArray_DESCR(obj); + PyArrayObject *arr = (PyArrayObject *)obj; + PyArray_Descr *arr_dtype = PyArray_DESCR(arr); - if (obj_dtype->type_num == NPY_STRING || - obj_dtype->type_num == NPY_UNICODE) { - return find_string_array_datetime64_type(obj, meta); + if (arr_dtype->type_num == NPY_STRING || + arr_dtype->type_num == NPY_UNICODE) { + return find_string_array_datetime64_type(arr, meta); } /* If the array has metadata, use it */ - else if (obj_dtype->type_num == NPY_DATETIME || - obj_dtype->type_num == NPY_TIMEDELTA) { + else if (arr_dtype->type_num == NPY_DATETIME || + arr_dtype->type_num == NPY_TIMEDELTA) { PyArray_DatetimeMetaData *tmp_meta; /* Get the metadata from the type */ - tmp_meta = get_datetime_metadata_from_dtype(obj_dtype); + tmp_meta = get_datetime_metadata_from_dtype(arr_dtype); if (tmp_meta == NULL) { return -1; } @@ -3707,7 +3711,7 @@ recursive_find_object_datetime64_type(PyObject *obj, return 0; } /* If it's not an object array, stop looking */ - else if (obj_dtype->type_num != NPY_OBJECT) { + else if (arr_dtype->type_num != NPY_OBJECT) { return 0; } } @@ -3827,15 +3831,16 @@ recursive_find_object_timedelta64_type(PyObject *obj, { /* Array -> use its metadata */ if (PyArray_Check(obj)) { - PyArray_Descr *obj_dtype = PyArray_DESCR(obj); + PyArrayObject *arr = (PyArrayObject *)obj; + PyArray_Descr *arr_dtype = PyArray_DESCR(arr); /* If the array has metadata, use it */ - if (obj_dtype->type_num == NPY_DATETIME || - obj_dtype->type_num == NPY_TIMEDELTA) { + if (arr_dtype->type_num == NPY_DATETIME || + arr_dtype->type_num == NPY_TIMEDELTA) { PyArray_DatetimeMetaData *tmp_meta; /* Get the metadata from the type */ - tmp_meta = get_datetime_metadata_from_dtype(obj_dtype); + tmp_meta = get_datetime_metadata_from_dtype(arr_dtype); if (tmp_meta == NULL) { return -1; } @@ -3849,7 +3854,7 @@ recursive_find_object_timedelta64_type(PyObject *obj, return 0; } /* If it's not an object array, stop looking */ - else if (obj_dtype->type_num != NPY_OBJECT) { + else if (arr_dtype->type_num != NPY_OBJECT) { return 0; } } diff --git a/numpy/core/src/multiarray/datetime_busdaycal.c b/numpy/core/src/multiarray/datetime_busdaycal.c index 018912ee8..1d047a547 100644 --- a/numpy/core/src/multiarray/datetime_busdaycal.c +++ b/numpy/core/src/multiarray/datetime_busdaycal.c @@ -149,7 +149,8 @@ invalid_weekmask_string: /* Something like [1,1,1,1,1,0,0] */ else if (PySequence_Check(obj)) { if (PySequence_Size(obj) != 7 || - (PyArray_Check(obj) && PyArray_NDIM(obj) != 1)) { + (PyArray_Check(obj) && + PyArray_NDIM((PyArrayObject *)obj) != 1)) { PyErr_SetString(PyExc_ValueError, "A business day weekmask array must have length 7"); Py_DECREF(obj); diff --git a/numpy/core/src/multiarray/descriptor.c b/numpy/core/src/multiarray/descriptor.c index 8f3038bf2..4f832bd12 100644 --- a/numpy/core/src/multiarray/descriptor.c +++ b/numpy/core/src/multiarray/descriptor.c @@ -599,7 +599,7 @@ _convert_from_commastring(PyObject *obj, int align) } listobj = PyObject_CallMethod(_numpy_internal, "_commastring", "O", obj); Py_DECREF(_numpy_internal); - if (!listobj) { + if (listobj == NULL) { return NULL; } if (!PyList_Check(listobj) || PyList_GET_SIZE(listobj) < 1) { @@ -851,10 +851,28 @@ _convert_from_dict(PyObject *obj, int align) || (offsets && (n > PyObject_Length(offsets))) || (titles && (n > PyObject_Length(titles)))) { PyErr_SetString(PyExc_ValueError, - "all items in the dictionary must have the same length."); + "'names', 'formats', 'offsets', and 'titles' dicct " + "entries must have the same length"); goto fail; } + /* + * If a property 'aligned' is in the dict, it overrides the align flag + * to be True if it not already true. + */ + tmp = PyDict_GetItemString(obj, "aligned"); + if (tmp != NULL) { + if (tmp == Py_True) { + align = 1; + } + else if (tmp != Py_False) { + PyErr_SetString(PyExc_ValueError, + "NumPy dtype descriptor includes 'aligned' entry, " + "but its value is neither True nor False"); + return NULL; + } + } + totalsize = 0; for (i = 0; i < n; i++) { PyObject *tup, *descr, *index, *title, *name, *off; @@ -2748,14 +2766,14 @@ arraydescr_struct_list_str(PyArray_Descr *dtype) /* Special case subarray handling here */ if (PyDataType_HASSUBARRAY(fld_dtype)) { tmp = arraydescr_short_construction_repr( - fld_dtype->subarray->base); + fld_dtype->subarray->base, 0); PyUString_ConcatAndDel(&ret, tmp); PyUString_ConcatAndDel(&ret, PyUString_FromString(", ")); PyUString_ConcatAndDel(&ret, PyObject_Str(fld_dtype->subarray->shape)); } else { - tmp = arraydescr_short_construction_repr(fld_dtype); + tmp = arraydescr_short_construction_repr(fld_dtype, 0); PyUString_ConcatAndDel(&ret, tmp); } PyUString_ConcatAndDel(&ret, PyUString_FromString(")")); @@ -2773,7 +2791,7 @@ arraydescr_struct_list_str(PyArray_Descr *dtype) * in a dict format. */ static PyObject * -arraydescr_struct_dict_str(PyArray_Descr *dtype) +arraydescr_struct_dict_str(PyArray_Descr *dtype, int includealignedflag) { PyObject *names, *key, *fields, *ret, *tmp, *tup, *title; Py_ssize_t i, names_size; @@ -2813,7 +2831,7 @@ arraydescr_struct_dict_str(PyArray_Descr *dtype) if (title != NULL && title != Py_None) { has_titles = 1; } - tmp = arraydescr_short_construction_repr(fld_dtype); + tmp = arraydescr_short_construction_repr(fld_dtype, 0); PyUString_ConcatAndDel(&ret, tmp); if (i != names_size - 1) { PyUString_ConcatAndDel(&ret, PyUString_FromString(",")); @@ -2857,22 +2875,36 @@ arraydescr_struct_dict_str(PyArray_Descr *dtype) } } } - /* Finally, the itemsize */ - PyUString_ConcatAndDel(&ret, - PyUString_FromFormat("], 'itemsize':%d}", (int)dtype->elsize)); + if (includealignedflag && (dtype->flags&NPY_ALIGNED_STRUCT)) { + /* Finally, the itemsize/itemsize and aligned flag */ + PyUString_ConcatAndDel(&ret, + PyUString_FromFormat("], 'itemsize':%d, 'aligned':True}", + (int)dtype->elsize)); + } + else { + /* Finally, the itemsize/itemsize*/ + PyUString_ConcatAndDel(&ret, + PyUString_FromFormat("], 'itemsize':%d}", (int)dtype->elsize)); + } return ret; } /* Produces a string representation for a structured dtype */ static PyObject * -arraydescr_struct_str(PyArray_Descr *dtype) +arraydescr_struct_str(PyArray_Descr *dtype, int includealignflag) { - if (is_dtype_struct_simple_unaligned_layout(dtype)) { + /* + * The list str representation can't include the 'align=' flag, + * so if it is requested and the struct has the aligned flag set, + * we must use the dict str instead. + */ + if (!(includealignflag && (dtype->flags&NPY_ALIGNED_STRUCT)) && + is_dtype_struct_simple_unaligned_layout(dtype)) { return arraydescr_struct_list_str(dtype); } else { - return arraydescr_struct_dict_str(dtype); + return arraydescr_struct_dict_str(dtype, includealignflag); } } @@ -2883,7 +2915,7 @@ arraydescr_subarray_str(PyArray_Descr *dtype) PyObject *p, *ret; ret = PyUString_FromString("("); - p = arraydescr_short_construction_repr(dtype->subarray->base); + p = arraydescr_short_construction_repr(dtype->subarray->base, 0); PyUString_ConcatAndDel(&ret, p); PyUString_ConcatAndDel(&ret, PyUString_FromString(", ")); PyUString_ConcatAndDel(&ret, PyObject_Str(dtype->subarray->shape)); @@ -2898,7 +2930,7 @@ arraydescr_str(PyArray_Descr *dtype) PyObject *sub; if (PyDataType_HASFIELDS(dtype)) { - sub = arraydescr_struct_str(dtype); + sub = arraydescr_struct_str(dtype, 1); } else if (PyDataType_HASSUBARRAY(dtype)) { sub = arraydescr_subarray_str(dtype); @@ -2921,7 +2953,7 @@ arraydescr_struct_repr(PyArray_Descr *dtype) PyObject *sub, *s; s = PyUString_FromString("dtype("); - sub = arraydescr_struct_str(dtype); + sub = arraydescr_struct_str(dtype, 0); if (sub == NULL) { return NULL; } @@ -2944,20 +2976,26 @@ arraydescr_struct_repr(PyArray_Descr *dtype) * additional constructor parameters are given, will reproduce * the exact memory layout. * - * This does not preserve the 'align=True' parameter or sticky - * NPY_ALIGNED_STRUCT flag for struct arrays like the regular - * repr does, because the 'align' flag is not part of first - * dtype constructor parameter. + * If 'includealignflag' is true, this includes the 'align=True' parameter + * inside the struct dtype construction dict when needed. Use this flag + * if you want a proper repr string without the 'dtype()' part around it. + * + * If 'includealignflag' is false, this does not preserve the + * 'align=True' parameter or sticky NPY_ALIGNED_STRUCT flag for + * struct arrays like the regular repr does, because the 'align' + * flag is not part of first dtype constructor parameter. This + * mode is intended for a full 'repr', where the 'align=True' is + * provided as the second parameter. */ NPY_NO_EXPORT PyObject * -arraydescr_short_construction_repr(PyArray_Descr *dtype) +arraydescr_short_construction_repr(PyArray_Descr *dtype, int includealignflag) { PyObject *ret; PyArray_DatetimeMetaData *meta; char byteorder[2]; if (PyDataType_HASFIELDS(dtype)) { - return arraydescr_struct_str(dtype); + return arraydescr_struct_str(dtype, includealignflag); } else if (PyDataType_HASSUBARRAY(dtype)) { return arraydescr_subarray_str(dtype); @@ -3037,16 +3075,20 @@ arraydescr_short_construction_repr(PyArray_Descr *dtype) if (meta == NULL) { return NULL; } - ret = PyUString_FromFormat("%sM8", byteorder); - return append_metastr_to_string(meta, 0, ret); + ret = PyUString_FromFormat("'%sM8", byteorder); + ret = append_metastr_to_string(meta, 0, ret); + PyUString_ConcatAndDel(&ret, PyUString_FromString("'")); + return ret; case NPY_TIMEDELTA: meta = get_datetime_metadata_from_dtype(dtype); if (meta == NULL) { return NULL; } - ret = PyUString_FromFormat("%sm8", byteorder); - return append_metastr_to_string(meta, 0, ret); + ret = PyUString_FromFormat("'%sm8", byteorder); + ret = append_metastr_to_string(meta, 0, ret); + PyUString_ConcatAndDel(&ret, PyUString_FromString("'")); + return ret; default: PyErr_SetString(PyExc_RuntimeError, "Internal error: NumPy dtype " diff --git a/numpy/core/src/multiarray/descriptor.h b/numpy/core/src/multiarray/descriptor.h index 4f8a90582..d936d0b31 100644 --- a/numpy/core/src/multiarray/descriptor.h +++ b/numpy/core/src/multiarray/descriptor.h @@ -11,16 +11,25 @@ NPY_NO_EXPORT PyArray_Descr * _arraydescr_fromobj(PyObject *obj); /* - * This creates a shorter repr using the 'kind' and 'itemsize', - * instead of the longer type name. It also creates the input - * for constructing a dtype rather than the full dtype function - * call. + * This creates a shorter repr using 'kind' and 'itemsize', + * instead of the longer type name. This is the object passed + * as the first parameter to the dtype constructor, and if no + * additional constructor parameters are given, will reproduce + * the exact memory layout. * - * This does not preserve the 'align=True' parameter - * for structured arrays like the regular repr does. + * If 'includealignflag' is true, this includes the 'align=True' parameter + * inside the struct dtype construction dict when needed. Use this flag + * if you want a proper repr string without the 'dtype()' part around it. + * + * If 'includealignflag' is false, this does not preserve the + * 'align=True' parameter or sticky NPY_ALIGNED_STRUCT flag for + * struct arrays like the regular repr does, because the 'align' + * flag is not part of first dtype constructor parameter. This + * mode is intended for a full 'repr', where the 'align=True' is + * provided as the second parameter. */ NPY_NO_EXPORT PyObject * -arraydescr_short_construction_repr(PyArray_Descr *dtype); +arraydescr_short_construction_repr(PyArray_Descr *dtype, int includealignflag); #ifdef NPY_ENABLE_SEPARATE_COMPILATION extern NPY_NO_EXPORT char *_datetime_strings[]; diff --git a/numpy/core/src/multiarray/einsum.c.src b/numpy/core/src/multiarray/einsum.c.src index 9120ef59a..6447e9843 100644 --- a/numpy/core/src/multiarray/einsum.c.src +++ b/numpy/core/src/multiarray/einsum.c.src @@ -2207,7 +2207,11 @@ get_single_op_view(PyArrayObject *op, int iop, char *labels, NPY_ARRAY_ALIGNED| NPY_ARRAY_F_CONTIGUOUS); Py_INCREF(op); - PyArray_BASE(*ret) = (PyObject *)op; + if (PyArray_SetBaseObject(*ret, (PyObject *)op) < 0) { + Py_DECREF(*ret); + *ret = NULL; + return 0; + } return 1; } @@ -2308,7 +2312,10 @@ get_combined_dims_view(PyArrayObject *op, int iop, char *labels) NPY_ARRAY_ALIGNED| NPY_ARRAY_F_CONTIGUOUS); Py_INCREF(op); - PyArray_BASE(ret) = (PyObject *)op; + if (PyArray_SetBaseObject(ret, (PyObject *)op) < 0) { + Py_DECREF(ret); + return NULL; + } return ret; } diff --git a/numpy/core/src/multiarray/flagsobject.c b/numpy/core/src/multiarray/flagsobject.c index cdcf60d5c..31a7d041e 100644 --- a/numpy/core/src/multiarray/flagsobject.c +++ b/numpy/core/src/multiarray/flagsobject.c @@ -31,6 +31,7 @@ PyArray_NewFlagsObject(PyObject *obj) { PyObject *flagobj; int flags; + if (obj == NULL) { flags = NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_OWNDATA | @@ -38,7 +39,13 @@ PyArray_NewFlagsObject(PyObject *obj) NPY_ARRAY_ALIGNED; } else { - flags = PyArray_FLAGS(obj); + if (!PyArray_Check(obj)) { + PyErr_SetString(PyExc_ValueError, + "Need a NumPy array to create a flags object"); + return NULL; + } + + flags = PyArray_FLAGS((PyArrayObject *)obj); } flagobj = PyArrayFlags_Type.tp_alloc(&PyArrayFlags_Type, 0); if (flagobj == NULL) { @@ -59,32 +66,32 @@ PyArray_UpdateFlags(PyArrayObject *ret, int flagmask) if (flagmask & NPY_ARRAY_F_CONTIGUOUS) { if (_IsFortranContiguous(ret)) { - ret->flags |= NPY_ARRAY_F_CONTIGUOUS; - if (ret->nd > 1) { - ret->flags &= ~NPY_ARRAY_C_CONTIGUOUS; + PyArray_ENABLEFLAGS(ret, NPY_ARRAY_F_CONTIGUOUS); + if (PyArray_NDIM(ret) > 1) { + PyArray_CLEARFLAGS(ret, NPY_ARRAY_C_CONTIGUOUS); } } else { - ret->flags &= ~NPY_ARRAY_F_CONTIGUOUS; + PyArray_CLEARFLAGS(ret, NPY_ARRAY_F_CONTIGUOUS); } } if (flagmask & NPY_ARRAY_C_CONTIGUOUS) { if (_IsContiguous(ret)) { - ret->flags |= NPY_ARRAY_C_CONTIGUOUS; - if (ret->nd > 1) { - ret->flags &= ~NPY_ARRAY_F_CONTIGUOUS; + PyArray_ENABLEFLAGS(ret, NPY_ARRAY_C_CONTIGUOUS); + if (PyArray_NDIM(ret) > 1) { + PyArray_CLEARFLAGS(ret, NPY_ARRAY_F_CONTIGUOUS); } } else { - ret->flags &= ~NPY_ARRAY_C_CONTIGUOUS; + PyArray_CLEARFLAGS(ret, NPY_ARRAY_C_CONTIGUOUS); } } if (flagmask & NPY_ARRAY_ALIGNED) { if (_IsAligned(ret)) { - ret->flags |= NPY_ARRAY_ALIGNED; + PyArray_ENABLEFLAGS(ret, NPY_ARRAY_ALIGNED); } else { - ret->flags &= ~NPY_ARRAY_ALIGNED; + PyArray_CLEARFLAGS(ret, NPY_ARRAY_ALIGNED); } } /* @@ -93,10 +100,10 @@ PyArray_UpdateFlags(PyArrayObject *ret, int flagmask) */ if (flagmask & NPY_ARRAY_WRITEABLE) { if (_IsWriteable(ret)) { - ret->flags |= NPY_ARRAY_WRITEABLE; + PyArray_ENABLEFLAGS(ret, NPY_ARRAY_WRITEABLE); } else { - ret->flags &= ~NPY_ARRAY_WRITEABLE; + PyArray_CLEARFLAGS(ret, NPY_ARRAY_WRITEABLE); } } return; @@ -115,20 +122,20 @@ _IsContiguous(PyArrayObject *ap) intp dim; int i; - if (ap->nd == 0) { + if (PyArray_NDIM(ap) == 0) { return 1; } - sd = ap->descr->elsize; - if (ap->nd == 1) { - return ap->dimensions[0] == 1 || sd == ap->strides[0]; + sd = PyArray_DESCR(ap)->elsize; + if (PyArray_NDIM(ap) == 1) { + return PyArray_DIMS(ap)[0] == 1 || sd == PyArray_STRIDES(ap)[0]; } - for (i = ap->nd - 1; i >= 0; --i) { - dim = ap->dimensions[i]; + for (i = PyArray_NDIM(ap) - 1; i >= 0; --i) { + dim = PyArray_DIMS(ap)[i]; /* contiguous by definition */ if (dim == 0) { return 1; } - if (ap->strides[i] != sd) { + if (PyArray_STRIDES(ap)[i] != sd) { return 0; } sd *= dim; @@ -145,20 +152,20 @@ _IsFortranContiguous(PyArrayObject *ap) intp dim; int i; - if (ap->nd == 0) { + if (PyArray_NDIM(ap) == 0) { return 1; } - sd = ap->descr->elsize; - if (ap->nd == 1) { - return ap->dimensions[0] == 1 || sd == ap->strides[0]; + sd = PyArray_DESCR(ap)->elsize; + if (PyArray_NDIM(ap) == 1) { + return PyArray_DIMS(ap)[0] == 1 || sd == PyArray_STRIDES(ap)[0]; } - for (i = 0; i < ap->nd; ++i) { - dim = ap->dimensions[i]; + for (i = 0; i < PyArray_NDIM(ap); ++i) { + dim = PyArray_DIMS(ap)[i]; /* fortran contiguous by definition */ if (dim == 0) { return 1; } - if (ap->strides[i] != sd) { + if (PyArray_STRIDES(ap)[i] != sd) { return 0; } sd *= dim; diff --git a/numpy/core/src/multiarray/getset.c b/numpy/core/src/multiarray/getset.c index cbb7ce6e9..e9e052683 100644 --- a/numpy/core/src/multiarray/getset.c +++ b/numpy/core/src/multiarray/getset.c @@ -23,7 +23,7 @@ static PyObject * array_ndim_get(PyArrayObject *self) { - return PyInt_FromLong(self->nd); + return PyInt_FromLong(PyArray_NDIM(self)); } static PyObject * @@ -35,7 +35,7 @@ array_flags_get(PyArrayObject *self) static PyObject * array_shape_get(PyArrayObject *self) { - return PyArray_IntTupleFromIntp(self->nd, self->dimensions); + return PyArray_IntTupleFromIntp(PyArray_NDIM(self), PyArray_DIMS(self)); } @@ -43,10 +43,10 @@ static int array_shape_set(PyArrayObject *self, PyObject *val) { int nd; - PyObject *ret; + PyArrayObject *ret; /* Assumes C-order */ - ret = PyArray_Reshape(self, val); + ret = (PyArrayObject *)PyArray_Reshape(self, val); if (ret == NULL) { return -1; } @@ -59,24 +59,24 @@ array_shape_set(PyArrayObject *self, PyObject *val) } /* Free old dimensions and strides */ - PyDimMem_FREE(self->dimensions); + PyDimMem_FREE(PyArray_DIMS(self)); nd = PyArray_NDIM(ret); - self->nd = nd; + ((PyArrayObject_fieldaccess *)self)->nd = nd; if (nd > 0) { /* create new dimensions and strides */ - self->dimensions = PyDimMem_NEW(2*nd); - if (self->dimensions == NULL) { + ((PyArrayObject_fieldaccess *)self)->dimensions = PyDimMem_NEW(2*nd); + if (PyArray_DIMS(self) == NULL) { Py_DECREF(ret); PyErr_SetString(PyExc_MemoryError,""); return -1; } - self->strides = self->dimensions + nd; - memcpy(self->dimensions, PyArray_DIMS(ret), nd*sizeof(intp)); - memcpy(self->strides, PyArray_STRIDES(ret), nd*sizeof(intp)); + ((PyArrayObject_fieldaccess *)self)->strides = PyArray_DIMS(self) + nd; + memcpy(PyArray_DIMS(self), PyArray_DIMS(ret), nd*sizeof(intp)); + memcpy(PyArray_STRIDES(self), PyArray_STRIDES(ret), nd*sizeof(intp)); } else { - self->dimensions = NULL; - self->strides = NULL; + ((PyArrayObject_fieldaccess *)self)->dimensions = NULL; + ((PyArrayObject_fieldaccess *)self)->strides = NULL; } Py_DECREF(ret); PyArray_UpdateFlags(self, NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS); @@ -87,7 +87,7 @@ array_shape_set(PyArrayObject *self, PyObject *val) static PyObject * array_strides_get(PyArrayObject *self) { - return PyArray_IntTupleFromIntp(self->nd, self->strides); + return PyArray_IntTupleFromIntp(PyArray_NDIM(self), PyArray_STRIDES(self)); } static int @@ -105,40 +105,40 @@ array_strides_set(PyArrayObject *self, PyObject *obj) PyErr_SetString(PyExc_TypeError, "invalid strides"); return -1; } - if (newstrides.len != self->nd) { + if (newstrides.len != PyArray_NDIM(self)) { PyErr_Format(PyExc_ValueError, "strides must be " \ - " same length as shape (%d)", self->nd); + " same length as shape (%d)", PyArray_NDIM(self)); goto fail; } new = self; - while(new->base && PyArray_Check(new->base)) { - new = (PyArrayObject *)(new->base); + while(PyArray_BASE(new) && PyArray_Check(PyArray_BASE(new))) { + new = (PyArrayObject *)(PyArray_BASE(new)); } /* * Get the available memory through the buffer interface on - * new->base or if that fails from the current new + * PyArray_BASE(new) or if that fails from the current new */ - if (new->base && PyObject_AsReadBuffer(new->base, + if (PyArray_BASE(new) && PyObject_AsReadBuffer(PyArray_BASE(new), (const void **)&buf, &buf_len) >= 0) { - offset = self->data - buf; + offset = PyArray_DATA(self) - buf; numbytes = buf_len + offset; } else { PyErr_Clear(); - numbytes = PyArray_MultiplyList(new->dimensions, - new->nd)*new->descr->elsize; - offset = self->data - new->data; + numbytes = PyArray_MultiplyList(PyArray_DIMS(new), + PyArray_NDIM(new))*PyArray_DESCR(new)->elsize; + offset = PyArray_DATA(self) - PyArray_DATA(new); } - if (!PyArray_CheckStrides(self->descr->elsize, self->nd, numbytes, + if (!PyArray_CheckStrides(PyArray_DESCR(self)->elsize, PyArray_NDIM(self), numbytes, offset, - self->dimensions, newstrides.ptr)) { + PyArray_DIMS(self), newstrides.ptr)) { PyErr_SetString(PyExc_ValueError, "strides is not "\ "compatible with available memory"); goto fail; } - memcpy(self->strides, newstrides.ptr, sizeof(intp)*newstrides.len); + memcpy(PyArray_STRIDES(self), newstrides.ptr, sizeof(intp)*newstrides.len); PyArray_UpdateFlags(self, NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS); PyDimMem_FREE(newstrides.ptr); return 0; @@ -164,14 +164,14 @@ array_priority_get(PyArrayObject *self) static PyObject * array_typestr_get(PyArrayObject *self) { - return arraydescr_protocol_typestr_get(self->descr); + return arraydescr_protocol_typestr_get(PyArray_DESCR(self)); } static PyObject * array_descr_get(PyArrayObject *self) { - Py_INCREF(self->descr); - return (PyObject *)self->descr; + Py_INCREF(PyArray_DESCR(self)); + return (PyObject *)PyArray_DESCR(self); } static PyObject * @@ -180,7 +180,7 @@ array_protocol_descr_get(PyArrayObject *self) PyObject *res; PyObject *dobj; - res = arraydescr_protocol_descr_get(self->descr); + res = arraydescr_protocol_descr_get(PyArray_DESCR(self)); if (res) { return res; } @@ -205,11 +205,11 @@ array_protocol_descr_get(PyArrayObject *self) static PyObject * array_protocol_strides_get(PyArrayObject *self) { - if PyArray_ISCONTIGUOUS(self) { + if (PyArray_ISCONTIGUOUS(self)) { Py_INCREF(Py_None); return Py_None; } - return PyArray_IntTupleFromIntp(self->nd, self->strides); + return PyArray_IntTupleFromIntp(PyArray_NDIM(self), PyArray_STRIDES(self)); } @@ -218,8 +218,8 @@ static PyObject * array_dataptr_get(PyArrayObject *self) { return Py_BuildValue("NO", - PyLong_FromVoidPtr(self->data), - (self->flags & NPY_ARRAY_WRITEABLE ? Py_False : + PyLong_FromVoidPtr(PyArray_DATA(self)), + (PyArray_FLAGS(self) & NPY_ARRAY_WRITEABLE ? Py_False : Py_True)); } @@ -233,7 +233,7 @@ array_ctypes_get(PyArrayObject *self) return NULL; } ret = PyObject_CallMethod(_numpy_internal, "_ctypes", "ON", self, - PyLong_FromVoidPtr(self->data)); + PyLong_FromVoidPtr(PyArray_DATA(self))); Py_DECREF(_numpy_internal); return ret; } @@ -262,7 +262,7 @@ array_interface_get(PyArrayObject *self) PyDict_SetItemString(dict, "descr", obj); Py_DECREF(obj); - obj = arraydescr_protocol_typestr_get(self->descr); + obj = arraydescr_protocol_typestr_get(PyArray_DESCR(self)); PyDict_SetItemString(dict, "typestr", obj); Py_DECREF(obj); @@ -299,6 +299,10 @@ array_data_get(PyArrayObject *self) #endif } +/* + * TODO: Given view semantics, I think this function is a really + * bad idea, and should be removed! + */ static int array_data_set(PyArrayObject *self, PyObject *op) { @@ -324,23 +328,24 @@ array_data_set(PyArrayObject *self, PyObject *op) PyErr_SetString(PyExc_AttributeError, "not enough data for array"); return -1; } - if (self->flags & NPY_ARRAY_OWNDATA) { + if (PyArray_FLAGS(self) & NPY_ARRAY_OWNDATA) { PyArray_XDECREF(self); - PyDataMem_FREE(self->data); + PyDataMem_FREE(PyArray_DATA(self)); } - if (self->base) { - if (self->flags & NPY_ARRAY_UPDATEIFCOPY) { - ((PyArrayObject *)self->base)->flags |= NPY_ARRAY_WRITEABLE; - self->flags &= ~NPY_ARRAY_UPDATEIFCOPY; + if (PyArray_BASE(self)) { + if (PyArray_FLAGS(self) & NPY_ARRAY_UPDATEIFCOPY) { + PyArray_ENABLEFLAGS((PyArrayObject *)PyArray_BASE(self), + NPY_ARRAY_WRITEABLE); + PyArray_CLEARFLAGS(self, NPY_ARRAY_UPDATEIFCOPY); } - Py_DECREF(self->base); + Py_DECREF(PyArray_BASE(self)); } Py_INCREF(op); - self->base = op; - self->data = buf; - self->flags = NPY_ARRAY_CARRAY; + ((PyArrayObject_fieldaccess *)self)->base = op; + ((PyArrayObject_fieldaccess *)self)->data = buf; + ((PyArrayObject_fieldaccess *)self)->flags = NPY_ARRAY_CARRAY; if (!writeable) { - self->flags &= ~NPY_ARRAY_WRITEABLE; + PyArray_CLEARFLAGS(self, ~NPY_ARRAY_WRITEABLE); } return 0; } @@ -349,7 +354,7 @@ array_data_set(PyArrayObject *self, PyObject *op) static PyObject * array_itemsize_get(PyArrayObject *self) { - return PyInt_FromLong((long) self->descr->elsize); + return PyInt_FromLong((long) PyArray_DESCR(self)->elsize); } static PyObject * @@ -409,8 +414,8 @@ array_descr_set(PyArrayObject *self, PyObject *arg) } if (PyDataType_FLAGCHK(newtype, NPY_ITEM_HASOBJECT) || PyDataType_FLAGCHK(newtype, NPY_ITEM_IS_POINTER) || - PyDataType_FLAGCHK(self->descr, NPY_ITEM_HASOBJECT) || - PyDataType_FLAGCHK(self->descr, NPY_ITEM_IS_POINTER)) { + PyDataType_FLAGCHK(PyArray_DESCR(self), NPY_ITEM_HASOBJECT) || + PyDataType_FLAGCHK(PyArray_DESCR(self), NPY_ITEM_IS_POINTER)) { PyErr_SetString(PyExc_TypeError, \ "Cannot change data-type for object " \ "array."); @@ -425,7 +430,7 @@ array_descr_set(PyArrayObject *self, PyObject *arg) if (newtype == NULL) { return -1; } - newtype->elsize = self->descr->elsize; + newtype->elsize = PyArray_DESCR(self)->elsize; } /* But no other flexible types */ else { @@ -437,44 +442,44 @@ array_descr_set(PyArrayObject *self, PyObject *arg) } - if ((newtype->elsize != self->descr->elsize) && - (self->nd == 0 || !PyArray_ISONESEGMENT(self) || + if ((newtype->elsize != PyArray_DESCR(self)->elsize) && + (PyArray_NDIM(self) == 0 || !PyArray_ISONESEGMENT(self) || PyDataType_HASSUBARRAY(newtype))) { goto fail; } if (PyArray_ISCONTIGUOUS(self)) { - index = self->nd - 1; + index = PyArray_NDIM(self) - 1; } else { index = 0; } - if (newtype->elsize < self->descr->elsize) { + if (newtype->elsize < PyArray_DESCR(self)->elsize) { /* * if it is compatible increase the size of the * dimension at end (or at the front for NPY_ARRAY_F_CONTIGUOUS) */ - if (self->descr->elsize % newtype->elsize != 0) { + if (PyArray_DESCR(self)->elsize % newtype->elsize != 0) { goto fail; } - newdim = self->descr->elsize / newtype->elsize; - self->dimensions[index] *= newdim; - self->strides[index] = newtype->elsize; + newdim = PyArray_DESCR(self)->elsize / newtype->elsize; + PyArray_DIMS(self)[index] *= newdim; + PyArray_STRIDES(self)[index] = newtype->elsize; } - else if (newtype->elsize > self->descr->elsize) { + else if (newtype->elsize > PyArray_DESCR(self)->elsize) { /* * Determine if last (or first if NPY_ARRAY_F_CONTIGUOUS) dimension * is compatible */ - newdim = self->dimensions[index] * self->descr->elsize; + newdim = PyArray_DIMS(self)[index] * PyArray_DESCR(self)->elsize; if ((newdim % newtype->elsize) != 0) { goto fail; } - self->dimensions[index] = newdim / newtype->elsize; - self->strides[index] = newtype->elsize; + PyArray_DIMS(self)[index] = newdim / newtype->elsize; + PyArray_STRIDES(self)[index] = newtype->elsize; } /* fall through -- adjust type*/ - Py_DECREF(self->descr); + Py_DECREF(PyArray_DESCR(self)); if (PyDataType_HASSUBARRAY(newtype)) { /* * create new array object from data and update @@ -486,25 +491,25 @@ array_descr_set(PyArrayObject *self, PyObject *arg) * temp will steal a reference to it */ temp = (PyArrayObject *) - PyArray_NewFromDescr(&PyArray_Type, newtype, self->nd, - self->dimensions, self->strides, - self->data, self->flags, NULL); + PyArray_NewFromDescr(&PyArray_Type, newtype, PyArray_NDIM(self), + PyArray_DIMS(self), PyArray_STRIDES(self), + PyArray_DATA(self), PyArray_FLAGS(self), NULL); if (temp == NULL) { return -1; } - PyDimMem_FREE(self->dimensions); - self->dimensions = temp->dimensions; - self->nd = temp->nd; - self->strides = temp->strides; - newtype = temp->descr; - Py_INCREF(temp->descr); + PyDimMem_FREE(PyArray_DIMS(self)); + ((PyArrayObject_fieldaccess *)self)->dimensions = PyArray_DIMS(temp); + ((PyArrayObject_fieldaccess *)self)->nd = PyArray_NDIM(temp); + ((PyArrayObject_fieldaccess *)self)->strides = PyArray_STRIDES(temp); + newtype = PyArray_DESCR(temp); + Py_INCREF(PyArray_DESCR(temp)); /* Fool deallocator not to delete these*/ - temp->nd = 0; - temp->dimensions = NULL; + ((PyArrayObject_fieldaccess *)temp)->nd = 0; + ((PyArrayObject_fieldaccess *)temp)->dimensions = NULL; Py_DECREF(temp); } - self->descr = newtype; + ((PyArrayObject_fieldaccess *)self)->descr = newtype; PyArray_UpdateFlags(self, NPY_ARRAY_UPDATE_ALL); return 0; @@ -525,10 +530,10 @@ array_struct_get(PyArrayObject *self) return PyErr_NoMemory(); } inter->two = 2; - inter->nd = self->nd; - inter->typekind = self->descr->kind; - inter->itemsize = self->descr->elsize; - inter->flags = self->flags; + inter->nd = PyArray_NDIM(self); + inter->typekind = PyArray_DESCR(self)->kind; + inter->itemsize = PyArray_DESCR(self)->elsize; + inter->flags = PyArray_FLAGS(self); /* reset unused flags */ inter->flags &= ~(NPY_ARRAY_UPDATEIFCOPY | NPY_ARRAY_OWNDATA); if (PyArray_ISNOTSWAPPED(self)) inter->flags |= NPY_ARRAY_NOTSWAPPED; @@ -536,23 +541,23 @@ array_struct_get(PyArrayObject *self) * Copy shape and strides over since these can be reset *when the array is "reshaped". */ - if (self->nd > 0) { - inter->shape = (intp *)_pya_malloc(2*sizeof(intp)*self->nd); + if (PyArray_NDIM(self) > 0) { + inter->shape = (intp *)_pya_malloc(2*sizeof(intp)*PyArray_NDIM(self)); if (inter->shape == NULL) { _pya_free(inter); return PyErr_NoMemory(); } - inter->strides = inter->shape + self->nd; - memcpy(inter->shape, self->dimensions, sizeof(intp)*self->nd); - memcpy(inter->strides, self->strides, sizeof(intp)*self->nd); + inter->strides = inter->shape + PyArray_NDIM(self); + memcpy(inter->shape, PyArray_DIMS(self), sizeof(intp)*PyArray_NDIM(self)); + memcpy(inter->strides, PyArray_STRIDES(self), sizeof(intp)*PyArray_NDIM(self)); } else { inter->shape = NULL; inter->strides = NULL; } - inter->data = self->data; - if (PyDataType_HASFIELDS(self->descr)) { - inter->descr = arraydescr_protocol_descr_get(self->descr); + inter->data = PyArray_DATA(self); + if (PyDataType_HASFIELDS(PyArray_DESCR(self))) { + inter->descr = arraydescr_protocol_descr_get(PyArray_DESCR(self)); if (inter->descr == NULL) { PyErr_Clear(); } @@ -571,13 +576,13 @@ array_struct_get(PyArrayObject *self) static PyObject * array_base_get(PyArrayObject *self) { - if (self->base == NULL) { + if (PyArray_BASE(self) == NULL) { Py_INCREF(Py_None); return Py_None; } else { - Py_INCREF(self->base); - return self->base; + Py_INCREF(PyArray_BASE(self)); + return PyArray_BASE(self); } } @@ -593,7 +598,7 @@ _get_part(PyArrayObject *self, int imag) PyArrayObject *ret; int offset; - switch (self->descr->type_num) { + switch (PyArray_DESCR(self)->type_num) { case PyArray_CFLOAT: float_type_num = PyArray_FLOAT; break; @@ -606,7 +611,7 @@ _get_part(PyArrayObject *self, int imag) default: PyErr_Format(PyExc_ValueError, "Cannot convert complex type number %d to float", - self->descr->type_num); + PyArray_DESCR(self)->type_num); return NULL; } @@ -614,28 +619,30 @@ _get_part(PyArrayObject *self, int imag) offset = (imag ? type->elsize : 0); - if (!PyArray_ISNBO(self->descr->byteorder)) { + if (!PyArray_ISNBO(PyArray_DESCR(self)->byteorder)) { PyArray_Descr *new; new = PyArray_DescrNew(type); - new->byteorder = self->descr->byteorder; + new->byteorder = PyArray_DESCR(self)->byteorder; Py_DECREF(type); type = new; } ret = (PyArrayObject *) PyArray_NewFromDescr(Py_TYPE(self), type, - self->nd, - self->dimensions, - self->strides, - self->data + offset, - self->flags, (PyObject *)self); + PyArray_NDIM(self), + PyArray_DIMS(self), + PyArray_STRIDES(self), + PyArray_DATA(self) + offset, + PyArray_FLAGS(self), (PyObject *)self); if (ret == NULL) { return NULL; } - ret->flags &= ~NPY_ARRAY_C_CONTIGUOUS; - ret->flags &= ~NPY_ARRAY_F_CONTIGUOUS; Py_INCREF(self); - ret->base = (PyObject *)self; + if (PyArray_SetBaseObject(ret, (PyObject *)self) < 0) { + Py_DECREF(ret); + return NULL; + } + PyArray_CLEARFLAGS(ret, NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS); return ret; } @@ -701,11 +708,11 @@ array_imag_get(PyArrayObject *self) ret = _get_part(self, 1); } else { - Py_INCREF(self->descr); + Py_INCREF(PyArray_DESCR(self)); ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self), - self->descr, - self->nd, - self->dimensions, + PyArray_DESCR(self), + PyArray_NDIM(self), + PyArray_DIMS(self), NULL, NULL, PyArray_ISFORTRAN(self), (PyObject *)self); @@ -715,7 +722,7 @@ array_imag_get(PyArrayObject *self) if (_zerofill(ret) < 0) { return NULL; } - ret->flags &= ~NPY_ARRAY_WRITEABLE; + PyArray_CLEARFLAGS(ret, NPY_ARRAY_WRITEABLE); } return (PyObject *) ret; } @@ -758,21 +765,21 @@ array_flat_get(PyArrayObject *self) static int array_flat_set(PyArrayObject *self, PyObject *val) { - PyObject *arr = NULL; + PyArrayObject *arr = NULL; int retval = -1; PyArrayIterObject *selfit = NULL, *arrit = NULL; PyArray_Descr *typecode; int swap; PyArray_CopySwapFunc *copyswap; - typecode = self->descr; + typecode = PyArray_DESCR(self); Py_INCREF(typecode); - arr = PyArray_FromAny(val, typecode, + arr = (PyArrayObject *)PyArray_FromAny(val, typecode, 0, 0, NPY_ARRAY_FORCECAST | FORTRAN_IF(self), NULL); if (arr == NULL) { return -1; } - arrit = (PyArrayIterObject *)PyArray_IterNew(arr); + arrit = (PyArrayIterObject *)PyArray_IterNew((PyObject *)arr); if (arrit == NULL) { goto exit; } @@ -785,10 +792,10 @@ array_flat_set(PyArrayObject *self, PyObject *val) goto exit; } swap = PyArray_ISNOTSWAPPED(self) != PyArray_ISNOTSWAPPED(arr); - copyswap = self->descr->f->copyswap; - if (PyDataType_REFCHK(self->descr)) { + copyswap = PyArray_DESCR(self)->f->copyswap; + if (PyDataType_REFCHK(PyArray_DESCR(self))) { while (selfit->index < selfit->size) { - PyArray_Item_XDECREF(selfit->dataptr, self->descr); + PyArray_Item_XDECREF(selfit->dataptr, PyArray_DESCR(self)); PyArray_Item_INCREF(arrit->dataptr, PyArray_DESCR(arr)); memmove(selfit->dataptr, arrit->dataptr, sizeof(PyObject **)); if (swap) { @@ -805,7 +812,7 @@ array_flat_set(PyArrayObject *self, PyObject *val) } while(selfit->index < selfit->size) { - memmove(selfit->dataptr, arrit->dataptr, self->descr->elsize); + memmove(selfit->dataptr, arrit->dataptr, PyArray_DESCR(self)->elsize); if (swap) { copyswap(selfit->dataptr, NULL, swap, self); } diff --git a/numpy/core/src/multiarray/item_selection.c b/numpy/core/src/multiarray/item_selection.c index 74203774c..54de27e05 100644 --- a/numpy/core/src/multiarray/item_selection.c +++ b/numpy/core/src/multiarray/item_selection.c @@ -18,7 +18,6 @@ #include "ctors.h" #include "lowlevel_strided_loops.h" -#define PyAO PyArrayObject #define _check_axis PyArray_CheckAxis /*NUMPY_API @@ -26,18 +25,18 @@ */ NPY_NO_EXPORT PyObject * PyArray_TakeFrom(PyArrayObject *self0, PyObject *indices0, int axis, - PyArrayObject *ret, NPY_CLIPMODE clipmode) + PyArrayObject *out, NPY_CLIPMODE clipmode) { + PyArray_Descr *dtype; PyArray_FastTakeFunc *func; - PyArrayObject *self, *indices; + PyArrayObject *obj = NULL, *self, *indices; intp nd, i, j, n, m, max_item, tmp, chunk, nelem; intp shape[MAX_DIMS]; char *src, *dest; - int copyret = 0; int err; indices = NULL; - self = (PyAO *)_check_axis(self0, &axis, NPY_ARRAY_CARRAY); + self = (PyArrayObject *)_check_axis(self0, &axis, NPY_ARRAY_CARRAY); if (self == NULL) { return NULL; } @@ -45,49 +44,46 @@ PyArray_TakeFrom(PyArrayObject *self0, PyObject *indices0, int axis, PyArray_INTP, 1, 0); if (indices == NULL) { - Py_XINCREF(ret); goto fail; } n = m = chunk = 1; - nd = self->nd + indices->nd - 1; + nd = PyArray_NDIM(self) + PyArray_NDIM(indices) - 1; for (i = 0; i < nd; i++) { if (i < axis) { - shape[i] = self->dimensions[i]; + shape[i] = PyArray_DIMS(self)[i]; n *= shape[i]; } else { - if (i < axis+indices->nd) { - shape[i] = indices->dimensions[i-axis]; + if (i < axis+PyArray_NDIM(indices)) { + shape[i] = PyArray_DIMS(indices)[i-axis]; m *= shape[i]; } else { - shape[i] = self->dimensions[i-indices->nd+1]; + shape[i] = PyArray_DIMS(self)[i-PyArray_NDIM(indices)+1]; chunk *= shape[i]; } } } - Py_INCREF(self->descr); - if (!ret) { - ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self), - self->descr, + if (!out) { + dtype = PyArray_DESCR(self); + Py_INCREF(dtype); + obj = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self), + dtype, nd, shape, NULL, NULL, 0, (PyObject *)self); - if (ret == NULL) { + if (obj == NULL) { goto fail; } } else { - PyArrayObject *obj; int flags = NPY_ARRAY_CARRAY | NPY_ARRAY_UPDATEIFCOPY; - if ((ret->nd != nd) || - !PyArray_CompareLists(ret->dimensions, shape, nd)) { + if ((PyArray_NDIM(out) != nd) || + !PyArray_CompareLists(PyArray_DIMS(out), shape, nd)) { PyErr_SetString(PyExc_ValueError, "bad shape in output array"); - ret = NULL; - Py_DECREF(self->descr); goto fail; } @@ -99,30 +95,27 @@ PyArray_TakeFrom(PyArrayObject *self0, PyObject *indices0, int axis, */ flags |= NPY_ARRAY_ENSURECOPY; } - obj = (PyArrayObject *)PyArray_FromArray(ret, self->descr, - flags); - if (obj != ret) { - copyret = 1; - } - ret = obj; - if (ret == NULL) { + dtype = PyArray_DESCR(self); + Py_INCREF(dtype); + obj = (PyArrayObject *)PyArray_FromArray(out, dtype, flags); + if (obj == NULL) { goto fail; } } - max_item = self->dimensions[axis]; + max_item = PyArray_DIMS(self)[axis]; nelem = chunk; - chunk = chunk * ret->descr->elsize; - src = self->data; - dest = ret->data; + chunk = chunk * PyArray_DESCR(obj)->elsize; + src = PyArray_DATA(self); + dest = PyArray_DATA(obj); - func = self->descr->f->fasttake; + func = PyArray_DESCR(self)->f->fasttake; if (func == NULL) { switch(clipmode) { case NPY_RAISE: for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { - tmp = ((intp *)(indices->data))[j]; + tmp = ((intp *)(PyArray_DATA(indices)))[j]; if (tmp < 0) { tmp = tmp + max_item; } @@ -141,7 +134,7 @@ PyArray_TakeFrom(PyArrayObject *self0, PyObject *indices0, int axis, case NPY_WRAP: for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { - tmp = ((intp *)(indices->data))[j]; + tmp = ((intp *)(PyArray_DATA(indices)))[j]; if (tmp < 0) { while (tmp < 0) { tmp += max_item; @@ -161,7 +154,7 @@ PyArray_TakeFrom(PyArrayObject *self0, PyObject *indices0, int axis, case NPY_CLIP: for (i = 0; i < n; i++) { for (j = 0; j < m; j++) { - tmp = ((intp *)(indices->data))[j]; + tmp = ((intp *)(PyArray_DATA(indices)))[j]; if (tmp < 0) { tmp = 0; } @@ -177,27 +170,25 @@ PyArray_TakeFrom(PyArrayObject *self0, PyObject *indices0, int axis, } } else { - err = func(dest, src, (intp *)(indices->data), + err = func(dest, src, (intp *)(PyArray_DATA(indices)), max_item, n, m, nelem, clipmode); if (err) { goto fail; } } - PyArray_INCREF(ret); + PyArray_INCREF(obj); Py_XDECREF(indices); Py_XDECREF(self); - if (copyret) { - PyObject *obj; - obj = ret->base; - Py_INCREF(obj); - Py_DECREF(ret); - ret = (PyArrayObject *)obj; + if (out != NULL && out != obj) { + Py_INCREF(out); + Py_DECREF(obj); + obj = out; } - return (PyObject *)ret; + return (PyObject *)obj; fail: - PyArray_XDECREF_ERR(ret); + PyArray_XDECREF_ERR(obj); Py_XDECREF(indices); Py_XDECREF(self); return NULL; @@ -229,25 +220,25 @@ PyArray_PutTo(PyArrayObject *self, PyObject* values0, PyObject *indices0, if (clipmode == NPY_RAISE) { flags |= NPY_ARRAY_ENSURECOPY; } - Py_INCREF(self->descr); + Py_INCREF(PyArray_DESCR(self)); obj = (PyArrayObject *)PyArray_FromArray(self, - self->descr, flags); + PyArray_DESCR(self), flags); if (obj != self) { copied = 1; } self = obj; } max_item = PyArray_SIZE(self); - dest = self->data; - chunk = self->descr->elsize; + dest = PyArray_DATA(self); + chunk = PyArray_DESCR(self)->elsize; indices = (PyArrayObject *)PyArray_ContiguousFromAny(indices0, PyArray_INTP, 0, 0); if (indices == NULL) { goto fail; } ni = PyArray_SIZE(indices); - Py_INCREF(self->descr); - values = (PyArrayObject *)PyArray_FromAny(values0, self->descr, 0, 0, + Py_INCREF(PyArray_DESCR(self)); + values = (PyArrayObject *)PyArray_FromAny(values0, PyArray_DESCR(self), 0, 0, NPY_ARRAY_DEFAULT | NPY_ARRAY_FORCECAST, NULL); if (values == NULL) { goto fail; @@ -256,12 +247,12 @@ PyArray_PutTo(PyArrayObject *self, PyObject* values0, PyObject *indices0, if (nv <= 0) { goto finish; } - if (PyDataType_REFCHK(self->descr)) { + if (PyDataType_REFCHK(PyArray_DESCR(self))) { switch(clipmode) { case NPY_RAISE: for (i = 0; i < ni; i++) { - src = values->data + chunk*(i % nv); - tmp = ((intp *)(indices->data))[i]; + src = PyArray_DATA(values) + chunk*(i % nv); + tmp = ((intp *)(PyArray_DATA(indices)))[i]; if (tmp < 0) { tmp = tmp + max_item; } @@ -271,15 +262,15 @@ PyArray_PutTo(PyArrayObject *self, PyObject* values0, PyObject *indices0, "range for array"); goto fail; } - PyArray_Item_INCREF(src, self->descr); - PyArray_Item_XDECREF(dest+tmp*chunk, self->descr); + PyArray_Item_INCREF(src, PyArray_DESCR(self)); + PyArray_Item_XDECREF(dest+tmp*chunk, PyArray_DESCR(self)); memmove(dest + tmp*chunk, src, chunk); } break; case NPY_WRAP: for (i = 0; i < ni; i++) { - src = values->data + chunk * (i % nv); - tmp = ((intp *)(indices->data))[i]; + src = PyArray_DATA(values) + chunk * (i % nv); + tmp = ((intp *)(PyArray_DATA(indices)))[i]; if (tmp < 0) { while (tmp < 0) { tmp += max_item; @@ -290,23 +281,23 @@ PyArray_PutTo(PyArrayObject *self, PyObject* values0, PyObject *indices0, tmp -= max_item; } } - PyArray_Item_INCREF(src, self->descr); - PyArray_Item_XDECREF(dest+tmp*chunk, self->descr); + PyArray_Item_INCREF(src, PyArray_DESCR(self)); + PyArray_Item_XDECREF(dest+tmp*chunk, PyArray_DESCR(self)); memmove(dest + tmp * chunk, src, chunk); } break; case NPY_CLIP: for (i = 0; i < ni; i++) { - src = values->data + chunk * (i % nv); - tmp = ((intp *)(indices->data))[i]; + src = PyArray_DATA(values) + chunk * (i % nv); + tmp = ((intp *)(PyArray_DATA(indices)))[i]; if (tmp < 0) { tmp = 0; } else if (tmp >= max_item) { tmp = max_item - 1; } - PyArray_Item_INCREF(src, self->descr); - PyArray_Item_XDECREF(dest+tmp*chunk, self->descr); + PyArray_Item_INCREF(src, PyArray_DESCR(self)); + PyArray_Item_XDECREF(dest+tmp*chunk, PyArray_DESCR(self)); memmove(dest + tmp * chunk, src, chunk); } break; @@ -316,8 +307,8 @@ PyArray_PutTo(PyArrayObject *self, PyObject* values0, PyObject *indices0, switch(clipmode) { case NPY_RAISE: for (i = 0; i < ni; i++) { - src = values->data + chunk * (i % nv); - tmp = ((intp *)(indices->data))[i]; + src = PyArray_DATA(values) + chunk * (i % nv); + tmp = ((intp *)(PyArray_DATA(indices)))[i]; if (tmp < 0) { tmp = tmp + max_item; } @@ -332,8 +323,8 @@ PyArray_PutTo(PyArrayObject *self, PyObject* values0, PyObject *indices0, break; case NPY_WRAP: for (i = 0; i < ni; i++) { - src = values->data + chunk * (i % nv); - tmp = ((intp *)(indices->data))[i]; + src = PyArray_DATA(values) + chunk * (i % nv); + tmp = ((intp *)(PyArray_DATA(indices)))[i]; if (tmp < 0) { while (tmp < 0) { tmp += max_item; @@ -349,8 +340,8 @@ PyArray_PutTo(PyArrayObject *self, PyObject* values0, PyObject *indices0, break; case NPY_CLIP: for (i = 0; i < ni; i++) { - src = values->data + chunk * (i % nv); - tmp = ((intp *)(indices->data))[i]; + src = PyArray_DATA(values) + chunk * (i % nv); + tmp = ((intp *)(PyArray_DATA(indices)))[i]; if (tmp < 0) { tmp = 0; } @@ -389,6 +380,7 @@ PyArray_PutMask(PyArrayObject *self, PyObject* values0, PyObject* mask0) { PyArray_FastPutmaskFunc *func; PyArrayObject *mask, *values; + PyArray_Descr *dtype; intp i, chunk, ni, max_item, nv, tmp; char *src, *dest; int copied = 0; @@ -402,17 +394,17 @@ PyArray_PutMask(PyArrayObject *self, PyObject* values0, PyObject* mask0) values = NULL; if (!PyArray_Check(self)) { PyErr_SetString(PyExc_TypeError, - "putmask: first argument must "\ + "putmask: first argument must " "be an array"); return NULL; } if (!PyArray_ISCONTIGUOUS(self)) { PyArrayObject *obj; - int flags = NPY_ARRAY_CARRAY | NPY_ARRAY_UPDATEIFCOPY; - Py_INCREF(self->descr); - obj = (PyArrayObject *)PyArray_FromArray(self, - self->descr, flags); + dtype = PyArray_DESCR(self); + Py_INCREF(dtype); + obj = (PyArrayObject *)PyArray_FromArray(self, dtype, + NPY_ARRAY_CARRAY | NPY_ARRAY_UPDATEIFCOPY); if (obj != self) { copied = 1; } @@ -420,24 +412,24 @@ PyArray_PutMask(PyArrayObject *self, PyObject* values0, PyObject* mask0) } max_item = PyArray_SIZE(self); - dest = self->data; - chunk = self->descr->elsize; - mask = (PyArrayObject *)\ - PyArray_FROM_OTF(mask0, PyArray_BOOL, - NPY_ARRAY_CARRAY | NPY_ARRAY_FORCECAST); + dest = PyArray_DATA(self); + chunk = PyArray_DESCR(self)->elsize; + mask = (PyArrayObject *)PyArray_FROM_OTF(mask0, NPY_BOOL, + NPY_ARRAY_CARRAY | NPY_ARRAY_FORCECAST); if (mask == NULL) { goto fail; } ni = PyArray_SIZE(mask); if (ni != max_item) { PyErr_SetString(PyExc_ValueError, - "putmask: mask and data must be "\ + "putmask: mask and data must be " "the same size"); goto fail; } - Py_INCREF(self->descr); - values = (PyArrayObject *)\ - PyArray_FromAny(values0, self->descr, 0, 0, NPY_ARRAY_CARRAY, NULL); + dtype = PyArray_DESCR(self); + Py_INCREF(dtype); + values = (PyArrayObject *)PyArray_FromAny(values0, dtype, + 0, 0, NPY_ARRAY_CARRAY, NULL); if (values == NULL) { goto fail; } @@ -448,30 +440,30 @@ PyArray_PutMask(PyArrayObject *self, PyObject* values0, PyObject* mask0) Py_INCREF(Py_None); return Py_None; } - if (PyDataType_REFCHK(self->descr)) { + if (PyDataType_REFCHK(PyArray_DESCR(self))) { for (i = 0; i < ni; i++) { - tmp = ((Bool *)(mask->data))[i]; + tmp = ((npy_bool *)(PyArray_DATA(mask)))[i]; if (tmp) { - src = values->data + chunk * (i % nv); - PyArray_Item_INCREF(src, self->descr); - PyArray_Item_XDECREF(dest+i*chunk, self->descr); + src = PyArray_DATA(values) + chunk * (i % nv); + PyArray_Item_INCREF(src, PyArray_DESCR(self)); + PyArray_Item_XDECREF(dest+i*chunk, PyArray_DESCR(self)); memmove(dest + i * chunk, src, chunk); } } } else { - func = self->descr->f->fastputmask; + func = PyArray_DESCR(self)->f->fastputmask; if (func == NULL) { for (i = 0; i < ni; i++) { - tmp = ((Bool *)(mask->data))[i]; + tmp = ((npy_bool *)(PyArray_DATA(mask)))[i]; if (tmp) { - src = values->data + chunk*(i % nv); + src = PyArray_DATA(values) + chunk*(i % nv); memmove(dest + i*chunk, src, chunk); } } } else { - func(dest, mask->data, ni, values->data, nv); + func(dest, PyArray_DATA(mask), ni, PyArray_DATA(values), nv); } } @@ -507,27 +499,27 @@ PyArray_Repeat(PyArrayObject *aop, PyObject *op, int axis) PyArrayObject *ret = NULL; char *new_data, *old_data; - repeats = (PyAO *)PyArray_ContiguousFromAny(op, PyArray_INTP, 0, 1); + repeats = (PyArrayObject *)PyArray_ContiguousFromAny(op, PyArray_INTP, 0, 1); if (repeats == NULL) { return NULL; } - nd = repeats->nd; - counts = (intp *)repeats->data; + nd = PyArray_NDIM(repeats); + counts = (npy_intp *)PyArray_DATA(repeats); if ((ap=_check_axis(aop, &axis, NPY_ARRAY_CARRAY))==NULL) { Py_DECREF(repeats); return NULL; } - aop = (PyAO *)ap; + aop = (PyArrayObject *)ap; if (nd == 1) { - n = repeats->dimensions[0]; + n = PyArray_DIMS(repeats)[0]; } else { /* nd == 0 */ - n = aop->dimensions[axis]; + n = PyArray_DIMS(aop)[axis]; } - if (aop->dimensions[axis] != n) { + if (PyArray_DIMS(aop)[axis] != n) { PyErr_SetString(PyExc_ValueError, "a.shape[axis] != len(repeats)"); goto fail; @@ -550,29 +542,29 @@ PyArray_Repeat(PyArrayObject *aop, PyObject *op, int axis) /* Construct new array */ - aop->dimensions[axis] = total; - Py_INCREF(aop->descr); + PyArray_DIMS(aop)[axis] = total; + Py_INCREF(PyArray_DESCR(aop)); ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(aop), - aop->descr, - aop->nd, - aop->dimensions, + PyArray_DESCR(aop), + PyArray_NDIM(aop), + PyArray_DIMS(aop), NULL, NULL, 0, (PyObject *)aop); - aop->dimensions[axis] = n; + PyArray_DIMS(aop)[axis] = n; if (ret == NULL) { goto fail; } - new_data = ret->data; - old_data = aop->data; + new_data = PyArray_DATA(ret); + old_data = PyArray_DATA(aop); - chunk = aop->descr->elsize; - for(i = axis + 1; i < aop->nd; i++) { - chunk *= aop->dimensions[i]; + chunk = PyArray_DESCR(aop)->elsize; + for(i = axis + 1; i < PyArray_NDIM(aop); i++) { + chunk *= PyArray_DIMS(aop)[i]; } n_outer = 1; for (i = 0; i < axis; i++) { - n_outer *= aop->dimensions[i]; + n_outer *= PyArray_DIMS(aop)[i]; } for (i = 0; i < n_outer; i++) { for (j = 0; j < n; j++) { @@ -600,16 +592,17 @@ PyArray_Repeat(PyArrayObject *aop, PyObject *op, int axis) /*NUMPY_API */ NPY_NO_EXPORT PyObject * -PyArray_Choose(PyArrayObject *ip, PyObject *op, PyArrayObject *ret, +PyArray_Choose(PyArrayObject *ip, PyObject *op, PyArrayObject *out, NPY_CLIPMODE clipmode) { + PyArrayObject *obj = NULL; + PyArray_Descr *dtype; int n, elsize; intp i; char *ret_data; PyArrayObject **mps, *ap; PyArrayMultiIterObject *multi = NULL; intp mi; - int copyret = 0; ap = NULL; /* @@ -636,27 +629,27 @@ PyArray_Choose(PyArrayObject *ip, PyObject *op, PyArrayObject *ret, goto fail; } /* Set-up return array */ - if (!ret) { - Py_INCREF(mps[0]->descr); - ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(ap), - mps[0]->descr, + if (out == NULL) { + dtype = PyArray_DESCR(mps[0]); + Py_INCREF(dtype); + obj = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(ap), + dtype, multi->nd, multi->dimensions, NULL, NULL, 0, (PyObject *)ap); } else { - PyArrayObject *obj; int flags = NPY_ARRAY_CARRAY | NPY_ARRAY_UPDATEIFCOPY | NPY_ARRAY_FORCECAST; - if ((PyArray_NDIM(ret) != multi->nd) - || !PyArray_CompareLists( - PyArray_DIMS(ret), multi->dimensions, multi->nd)) { + if ((PyArray_NDIM(out) != multi->nd) + || !PyArray_CompareLists(PyArray_DIMS(out), + multi->dimensions, + multi->nd)) { PyErr_SetString(PyExc_TypeError, - "invalid shape for output array."); - ret = NULL; + "choose: invalid shape for output array."); goto fail; } if (clipmode == NPY_RAISE) { @@ -667,19 +660,16 @@ PyArray_Choose(PyArrayObject *ip, PyObject *op, PyArrayObject *ret, */ flags |= NPY_ARRAY_ENSURECOPY; } - Py_INCREF(mps[0]->descr); - obj = (PyArrayObject *)PyArray_FromArray(ret, mps[0]->descr, flags); - if (obj != ret) { - copyret = 1; - } - ret = obj; + dtype = PyArray_DESCR(mps[0]); + Py_INCREF(dtype); + obj = (PyArrayObject *)PyArray_FromArray(out, dtype, flags); } - if (ret == NULL) { + if (obj == NULL) { goto fail; } - elsize = ret->descr->elsize; - ret_data = ret->data; + elsize = PyArray_DESCR(obj)->elsize; + ret_data = PyArray_DATA(obj); while (PyArray_MultiIter_NOTDONE(multi)) { mi = *((intp *)PyArray_MultiIter_DATA(multi, n)); @@ -717,21 +707,19 @@ PyArray_Choose(PyArrayObject *ip, PyObject *op, PyArrayObject *ret, PyArray_MultiIter_NEXT(multi); } - PyArray_INCREF(ret); + PyArray_INCREF(obj); Py_DECREF(multi); for (i = 0; i < n; i++) { Py_XDECREF(mps[i]); } Py_DECREF(ap); PyDataMem_FREE(mps); - if (copyret) { - PyObject *obj; - obj = ret->base; - Py_INCREF(obj); - Py_DECREF(ret); - ret = (PyArrayObject *)obj; + if (out != NULL && out != obj) { + Py_INCREF(out); + Py_DECREF(obj); + obj = out; } - return (PyObject *)ret; + return (PyObject *)obj; fail: Py_XDECREF(multi); @@ -740,7 +728,7 @@ PyArray_Choose(PyArrayObject *ip, PyObject *op, PyArrayObject *ret, } Py_XDECREF(ap); PyDataMem_FREE(mps); - PyArray_XDECREF_ERR(ret); + PyArray_XDECREF_ERR(obj); return NULL; } @@ -769,14 +757,14 @@ _new_sort(PyArrayObject *op, int axis, NPY_SORTKIND which) return -1; } - NPY_BEGIN_THREADS_DESCR(op->descr); - sort = op->descr->f->sort[which]; + NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(op)); + sort = PyArray_DESCR(op)->f->sort[which]; size = it->size; - N = op->dimensions[axis]; - elsize = op->descr->elsize; - astride = op->strides[axis]; + N = PyArray_DIMS(op)[axis]; + elsize = PyArray_DESCR(op)->elsize; + astride = PyArray_STRIDES(op)[axis]; - needcopy = !(op->flags & NPY_ARRAY_ALIGNED) || + needcopy = !(PyArray_FLAGS(op) & NPY_ARRAY_ALIGNED) || (astride != (intp) elsize) || swap; if (needcopy) { char *buffer = PyDataMem_NEW(N*elsize); @@ -808,7 +796,7 @@ _new_sort(PyArrayObject *op, int axis, NPY_SORTKIND which) PyArray_ITER_NEXT(it); } } - NPY_END_THREADS_DESCR(op->descr); + NPY_END_THREADS_DESCR(PyArray_DESCR(op)); Py_DECREF(it); return 0; @@ -824,7 +812,7 @@ _new_argsort(PyArrayObject *op, int axis, NPY_SORTKIND which) PyArrayIterObject *it = NULL; PyArrayIterObject *rit = NULL; - PyObject *ret; + PyArrayObject *ret; int needcopy = 0, i; intp N, size; int elsize, swap; @@ -832,28 +820,30 @@ _new_argsort(PyArrayObject *op, int axis, NPY_SORTKIND which) PyArray_ArgSortFunc *argsort; BEGIN_THREADS_DEF; - ret = PyArray_New(Py_TYPE(op), op->nd, - op->dimensions, PyArray_INTP, - NULL, NULL, 0, 0, (PyObject *)op); + ret = (PyArrayObject *)PyArray_New(Py_TYPE(op), + PyArray_NDIM(op), + PyArray_DIMS(op), + NPY_INTP, + NULL, NULL, 0, 0, (PyObject *)op); if (ret == NULL) { return NULL; } it = (PyArrayIterObject *)PyArray_IterAllButAxis((PyObject *)op, &axis); - rit = (PyArrayIterObject *)PyArray_IterAllButAxis(ret, &axis); + rit = (PyArrayIterObject *)PyArray_IterAllButAxis((PyObject *)ret, &axis); if (rit == NULL || it == NULL) { goto fail; } swap = !PyArray_ISNOTSWAPPED(op); - NPY_BEGIN_THREADS_DESCR(op->descr); - argsort = op->descr->f->argsort[which]; + NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(op)); + argsort = PyArray_DESCR(op)->f->argsort[which]; size = it->size; - N = op->dimensions[axis]; - elsize = op->descr->elsize; - astride = op->strides[axis]; + N = PyArray_DIMS(op)[axis]; + elsize = PyArray_DESCR(op)->elsize; + astride = PyArray_STRIDES(op)[axis]; rstride = PyArray_STRIDE(ret,axis); - needcopy = swap || !(op->flags & NPY_ARRAY_ALIGNED) || + needcopy = swap || !(PyArray_FLAGS(op) & NPY_ARRAY_ALIGNED) || (astride != (intp) elsize) || (rstride != sizeof(intp)); if (needcopy) { @@ -898,11 +888,11 @@ _new_argsort(PyArrayObject *op, int axis, NPY_SORTKIND which) } } - NPY_END_THREADS_DESCR(op->descr); + NPY_END_THREADS_DESCR(PyArray_DESCR(op)); Py_DECREF(it); Py_DECREF(rit); - return ret; + return (PyObject *)ret; fail: NPY_END_THREADS; @@ -919,7 +909,7 @@ static PyArrayObject *global_obj; static int qsortCompare (const void *a, const void *b) { - return global_obj->descr->f->compare(a,b,global_obj); + return PyArray_DESCR(global_obj)->f->compare(a,b,global_obj); } /* @@ -927,14 +917,14 @@ qsortCompare (const void *a, const void *b) * the array with axes swapped if local variable axis is not the * last dimension. Origin must be defined locally. */ -#define SWAPAXES(op, ap) { \ - orign = (ap)->nd-1; \ - if (axis != orign) { \ - (op) = (PyAO *)PyArray_SwapAxes((ap), axis, orign); \ - Py_DECREF((ap)); \ - if ((op) == NULL) return NULL; \ - } \ - else (op) = (ap); \ +#define SWAPAXES(op, ap) { \ + orign = PyArray_NDIM(ap)-1; \ + if (axis != orign) { \ + (op) = (PyArrayObject *)PyArray_SwapAxes((ap), axis, orign); \ + Py_DECREF((ap)); \ + if ((op) == NULL) return NULL; \ + } \ + else (op) = (ap); \ } /* @@ -944,7 +934,7 @@ qsortCompare (const void *a, const void *b) */ #define SWAPBACK(op, ap) { \ if (axis != orign) { \ - (op) = (PyAO *)PyArray_SwapAxes((ap), axis, orign); \ + (op) = (PyArrayObject *)PyArray_SwapAxes((ap), axis, orign); \ Py_DECREF((ap)); \ if ((op) == NULL) return NULL; \ } \ @@ -954,10 +944,10 @@ qsortCompare (const void *a, const void *b) /* These swap axes in-place if necessary */ #define SWAPINTP(a,b) {intp c; c=(a); (a) = (b); (b) = c;} #define SWAPAXES2(ap) { \ - orign = (ap)->nd-1; \ + orign = PyArray_NDIM(ap)-1; \ if (axis != orign) { \ - SWAPINTP(ap->dimensions[axis], ap->dimensions[orign]); \ - SWAPINTP(ap->strides[axis], ap->strides[orign]); \ + SWAPINTP(PyArray_DIMS(ap)[axis], PyArray_DIMS(ap)[orign]); \ + SWAPINTP(PyArray_STRIDES(ap)[axis], PyArray_STRIDES(ap)[orign]); \ PyArray_UpdateFlags(ap, NPY_ARRAY_C_CONTIGUOUS | \ NPY_ARRAY_F_CONTIGUOUS); \ } \ @@ -965,8 +955,8 @@ qsortCompare (const void *a, const void *b) #define SWAPBACK2(ap) { \ if (axis != orign) { \ - SWAPINTP(ap->dimensions[axis], ap->dimensions[orign]); \ - SWAPINTP(ap->strides[axis], ap->strides[orign]); \ + SWAPINTP(PyArray_DIMS(ap)[axis], PyArray_DIMS(ap)[orign]); \ + SWAPINTP(PyArray_STRIDES(ap)[axis], PyArray_STRIDES(ap)[orign]); \ PyArray_UpdateFlags(ap, NPY_ARRAY_C_CONTIGUOUS | \ NPY_ARRAY_F_CONTIGUOUS); \ } \ @@ -982,7 +972,7 @@ PyArray_Sort(PyArrayObject *op, int axis, NPY_SORTKIND which) char *ip; int i, n, m, elsize, orign; - n = op->nd; + n = PyArray_NDIM(op); if ((n == 0) || (PyArray_SIZE(op) == 1)) { return 0; } @@ -1000,11 +990,11 @@ PyArray_Sort(PyArrayObject *op, int axis, NPY_SORTKIND which) } /* Determine if we should use type-specific algorithm or not */ - if (op->descr->f->sort[which] != NULL) { + if (PyArray_DESCR(op)->f->sort[which] != NULL) { return _new_sort(op, axis, which); } if ((which != PyArray_QUICKSORT) - || op->descr->f->compare == NULL) { + || PyArray_DESCR(op)->f->compare == NULL) { PyErr_SetString(PyExc_TypeError, "desired sort not supported for this type"); return -1; @@ -1018,8 +1008,8 @@ PyArray_Sort(PyArrayObject *op, int axis, NPY_SORTKIND which) if (ap == NULL) { goto fail; } - elsize = ap->descr->elsize; - m = ap->dimensions[ap->nd-1]; + elsize = PyArray_DESCR(ap)->elsize; + m = PyArray_DIMS(ap)[PyArray_NDIM(ap)-1]; if (m == 0) { goto finish; } @@ -1028,7 +1018,7 @@ PyArray_Sort(PyArrayObject *op, int axis, NPY_SORTKIND which) /* Store global -- allows re-entry -- restore before leaving*/ store_arr = global_obj; global_obj = ap; - for (ip = ap->data, i = 0; i < n; i++, ip += elsize*m) { + for (ip = PyArray_DATA(ap), i = 0; i < n; i++, ip += elsize*m) { qsort(ip, m, elsize, qsortCompare); } global_obj = store_arr; @@ -1054,10 +1044,10 @@ static char *global_data; static int argsort_static_compare(const void *ip1, const void *ip2) { - int isize = global_obj->descr->elsize; + int isize = PyArray_DESCR(global_obj)->elsize; const intp *ipa = ip1; const intp *ipb = ip2; - return global_obj->descr->f->compare(global_data + (isize * *ipa), + return PyArray_DESCR(global_obj)->f->compare(global_data + (isize * *ipa), global_data + (isize * *ipb), global_obj); } @@ -1074,32 +1064,32 @@ PyArray_ArgSort(PyArrayObject *op, int axis, NPY_SORTKIND which) int argsort_elsize; char *store_ptr; - n = op->nd; + n = PyArray_NDIM(op); if ((n == 0) || (PyArray_SIZE(op) == 1)) { - ret = (PyArrayObject *)PyArray_New(Py_TYPE(op), op->nd, - op->dimensions, + ret = (PyArrayObject *)PyArray_New(Py_TYPE(op), PyArray_NDIM(op), + PyArray_DIMS(op), PyArray_INTP, NULL, NULL, 0, 0, (PyObject *)op); if (ret == NULL) { return NULL; } - *((intp *)ret->data) = 0; + *((intp *)PyArray_DATA(ret)) = 0; return (PyObject *)ret; } /* Creates new reference op2 */ - if ((op2=(PyAO *)_check_axis(op, &axis, 0)) == NULL) { + if ((op2=(PyArrayObject *)_check_axis(op, &axis, 0)) == NULL) { return NULL; } /* Determine if we should use new algorithm or not */ - if (op2->descr->f->argsort[which] != NULL) { + if (PyArray_DESCR(op2)->f->argsort[which] != NULL) { ret = (PyArrayObject *)_new_argsort(op2, axis, which); Py_DECREF(op2); return (PyObject *)ret; } - if ((which != PyArray_QUICKSORT) || op2->descr->f->compare == NULL) { + if ((which != PyArray_QUICKSORT) || PyArray_DESCR(op2)->f->compare == NULL) { PyErr_SetString(PyExc_TypeError, "requested sort not available for type"); Py_DECREF(op2); @@ -1116,21 +1106,21 @@ PyArray_ArgSort(PyArrayObject *op, int axis, NPY_SORTKIND which) if (op == NULL) { return NULL; } - ret = (PyArrayObject *)PyArray_New(Py_TYPE(op), op->nd, - op->dimensions, PyArray_INTP, + ret = (PyArrayObject *)PyArray_New(Py_TYPE(op), PyArray_NDIM(op), + PyArray_DIMS(op), PyArray_INTP, NULL, NULL, 0, 0, (PyObject *)op); if (ret == NULL) { goto fail; } - ip = (intp *)ret->data; - argsort_elsize = op->descr->elsize; - m = op->dimensions[op->nd-1]; + ip = (intp *)PyArray_DATA(ret); + argsort_elsize = PyArray_DESCR(op)->elsize; + m = PyArray_DIMS(op)[PyArray_NDIM(op)-1]; if (m == 0) { goto finish; } n = PyArray_SIZE(op)/m; store_ptr = global_data; - global_data = op->data; + global_data = PyArray_DATA(op); store = global_obj; global_obj = op; for (i = 0; i < n; i++, ip += m, global_data += m*argsort_elsize) { @@ -1187,7 +1177,7 @@ PyArray_LexSort(PyObject *sort_keys, int axis) "need sequence of keys with len > 0 in lexsort"); return NULL; } - mps = (PyArrayObject **) _pya_malloc(n*sizeof(PyArrayObject)); + mps = (PyArrayObject **) _pya_malloc(n*NPY_SIZEOF_PYARRAYOBJECT); if (mps == NULL) { return PyErr_NoMemory(); } @@ -1209,22 +1199,22 @@ PyArray_LexSort(PyObject *sort_keys, int axis) goto fail; } if (i > 0) { - if ((mps[i]->nd != mps[0]->nd) - || (!PyArray_CompareLists(mps[i]->dimensions, - mps[0]->dimensions, - mps[0]->nd))) { + if ((PyArray_NDIM(mps[i]) != PyArray_NDIM(mps[0])) + || (!PyArray_CompareLists(PyArray_DIMS(mps[i]), + PyArray_DIMS(mps[0]), + PyArray_NDIM(mps[0])))) { PyErr_SetString(PyExc_ValueError, "all keys need to be the same shape"); goto fail; } } - if (!mps[i]->descr->f->argsort[PyArray_MERGESORT]) { + if (!PyArray_DESCR(mps[i])->f->argsort[PyArray_MERGESORT]) { PyErr_Format(PyExc_TypeError, "merge sort not available for item %d", i); goto fail; } if (!object - && PyDataType_FLAGCHK(mps[i]->descr, NPY_NEEDS_PYAPI)) { + && PyDataType_FLAGCHK(PyArray_DESCR(mps[i]), NPY_NEEDS_PYAPI)) { object = 1; } its[i] = (PyArrayIterObject *)PyArray_IterAllButAxis( @@ -1235,18 +1225,18 @@ PyArray_LexSort(PyObject *sort_keys, int axis) } /* Now we can check the axis */ - nd = mps[0]->nd; + nd = PyArray_NDIM(mps[0]); if ((nd == 0) || (PyArray_SIZE(mps[0]) == 1)) { /* single element case */ - ret = (PyArrayObject *)PyArray_New(&PyArray_Type, mps[0]->nd, - mps[0]->dimensions, + ret = (PyArrayObject *)PyArray_New(&PyArray_Type, PyArray_NDIM(mps[0]), + PyArray_DIMS(mps[0]), PyArray_INTP, NULL, NULL, 0, 0, NULL); if (ret == NULL) { goto fail; } - *((intp *)(ret->data)) = 0; + *((intp *)(PyArray_DATA(ret))) = 0; goto finish; } if (axis < 0) { @@ -1259,8 +1249,8 @@ PyArray_LexSort(PyObject *sort_keys, int axis) } /* Now do the sorting */ - ret = (PyArrayObject *)PyArray_New(&PyArray_Type, mps[0]->nd, - mps[0]->dimensions, PyArray_INTP, + ret = (PyArrayObject *)PyArray_New(&PyArray_Type, PyArray_NDIM(mps[0]), + PyArray_DIMS(mps[0]), PyArray_INTP, NULL, NULL, 0, 0, NULL); if (ret == NULL) { goto fail; @@ -1274,17 +1264,17 @@ PyArray_LexSort(PyObject *sort_keys, int axis) NPY_BEGIN_THREADS; } size = rit->size; - N = mps[0]->dimensions[axis]; + N = PyArray_DIMS(mps[0])[axis]; rstride = PyArray_STRIDE(ret, axis); - maxelsize = mps[0]->descr->elsize; + maxelsize = PyArray_DESCR(mps[0])->elsize; needcopy = (rstride != sizeof(intp)); for (j = 0; j < n; j++) { needcopy = needcopy || PyArray_ISBYTESWAPPED(mps[j]) - || !(mps[j]->flags & NPY_ARRAY_ALIGNED) - || (mps[j]->strides[axis] != (intp)mps[j]->descr->elsize); - if (mps[j]->descr->elsize > maxelsize) { - maxelsize = mps[j]->descr->elsize; + || !(PyArray_FLAGS(mps[j]) & NPY_ARRAY_ALIGNED) + || (PyArray_STRIDES(mps[j])[axis] != (intp)PyArray_DESCR(mps[j])->elsize); + if (PyArray_DESCR(mps[j])->elsize > maxelsize) { + maxelsize = PyArray_DESCR(mps[j])->elsize; } } @@ -1304,9 +1294,9 @@ PyArray_LexSort(PyObject *sort_keys, int axis) *iptr++ = i; } for (j = 0; j < n; j++) { - elsize = mps[j]->descr->elsize; - astride = mps[j]->strides[axis]; - argsort = mps[j]->descr->f->argsort[PyArray_MERGESORT]; + elsize = PyArray_DESCR(mps[j])->elsize; + astride = PyArray_STRIDES(mps[j])[axis]; + argsort = PyArray_DESCR(mps[j])->f->argsort[PyArray_MERGESORT]; _unaligned_strided_byte_copy(valbuffer, (intp) elsize, its[j]->dataptr, astride, N, elsize); if (swaps[j]) { @@ -1335,7 +1325,7 @@ PyArray_LexSort(PyObject *sort_keys, int axis) *iptr++ = i; } for (j = 0; j < n; j++) { - argsort = mps[j]->descr->f->argsort[PyArray_MERGESORT]; + argsort = PyArray_DESCR(mps[j])->f->argsort[PyArray_MERGESORT]; if (argsort(its[j]->dataptr, (intp *)rit->dataptr, N, mps[j]) < 0) { goto fail; @@ -1389,13 +1379,13 @@ PyArray_LexSort(PyObject *sort_keys, int axis) static void local_search_left(PyArrayObject *arr, PyArrayObject *key, PyArrayObject *ret) { - PyArray_CompareFunc *compare = key->descr->f->compare; - intp nelts = arr->dimensions[arr->nd - 1]; + PyArray_CompareFunc *compare = PyArray_DESCR(key)->f->compare; + intp nelts = PyArray_DIMS(arr)[PyArray_NDIM(arr) - 1]; intp nkeys = PyArray_SIZE(key); - char *parr = arr->data; - char *pkey = key->data; - intp *pret = (intp *)ret->data; - int elsize = arr->descr->elsize; + char *parr = PyArray_DATA(arr); + char *pkey = PyArray_DATA(key); + intp *pret = (intp *)PyArray_DATA(ret); + int elsize = PyArray_DESCR(arr)->elsize; intp i; for (i = 0; i < nkeys; ++i) { @@ -1432,13 +1422,13 @@ local_search_left(PyArrayObject *arr, PyArrayObject *key, PyArrayObject *ret) static void local_search_right(PyArrayObject *arr, PyArrayObject *key, PyArrayObject *ret) { - PyArray_CompareFunc *compare = key->descr->f->compare; - intp nelts = arr->dimensions[arr->nd - 1]; + PyArray_CompareFunc *compare = PyArray_DESCR(key)->f->compare; + intp nelts = PyArray_DIMS(arr)[PyArray_NDIM(arr) - 1]; intp nkeys = PyArray_SIZE(key); - char *parr = arr->data; - char *pkey = key->data; - intp *pret = (intp *)ret->data; - int elsize = arr->descr->elsize; + char *parr = PyArray_DATA(arr); + char *pkey = PyArray_DATA(key); + intp *pret = (intp *)PyArray_DATA(ret); + int elsize = PyArray_DESCR(arr)->elsize; intp i; for(i = 0; i < nkeys; ++i) { @@ -1471,7 +1461,7 @@ PyArray_SearchSorted(PyArrayObject *op1, PyObject *op2, NPY_SEARCHSIDE side) PyArray_Descr *dtype; NPY_BEGIN_THREADS_DEF; - dtype = PyArray_DescrFromObject((PyObject *)op2, op1->descr); + dtype = PyArray_DescrFromObject((PyObject *)op2, PyArray_DESCR(op1)); /* need ap1 as contiguous array and of right type */ Py_INCREF(dtype); ap1 = (PyArrayObject *)PyArray_CheckFromAny((PyObject *)op1, dtype, @@ -1490,28 +1480,28 @@ PyArray_SearchSorted(PyArrayObject *op1, PyObject *op2, NPY_SEARCHSIDE side) goto fail; } /* ret is a contiguous array of intp type to hold returned indices */ - ret = (PyArrayObject *)PyArray_New(Py_TYPE(ap2), ap2->nd, - ap2->dimensions, PyArray_INTP, + ret = (PyArrayObject *)PyArray_New(Py_TYPE(ap2), PyArray_NDIM(ap2), + PyArray_DIMS(ap2), PyArray_INTP, NULL, NULL, 0, 0, (PyObject *)ap2); if (ret == NULL) { goto fail; } /* check that comparison function exists */ - if (ap2->descr->f->compare == NULL) { + if (PyArray_DESCR(ap2)->f->compare == NULL) { PyErr_SetString(PyExc_TypeError, "compare not supported for type"); goto fail; } if (side == NPY_SEARCHLEFT) { - NPY_BEGIN_THREADS_DESCR(ap2->descr); + NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(ap2)); local_search_left(ap1, ap2, ret); - NPY_END_THREADS_DESCR(ap2->descr); + NPY_END_THREADS_DESCR(PyArray_DESCR(ap2)); } else if (side == NPY_SEARCHRIGHT) { - NPY_BEGIN_THREADS_DESCR(ap2->descr); + NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(ap2)); local_search_right(ap1, ap2, ret); - NPY_END_THREADS_DESCR(ap2->descr); + NPY_END_THREADS_DESCR(PyArray_DESCR(ap2)); } Py_DECREF(ap1); Py_DECREF(ap2); @@ -1530,7 +1520,7 @@ PyArray_SearchSorted(PyArrayObject *op1, PyObject *op2, NPY_SEARCHSIDE side) NPY_NO_EXPORT PyObject * PyArray_Diagonal(PyArrayObject *self, int offset, int axis1, int axis2) { - int n = self->nd; + int n = PyArray_NDIM(self); PyObject *new; PyArray_Dims newaxes; intp dims[MAX_DIMS]; @@ -1571,15 +1561,16 @@ PyArray_Diagonal(PyArrayObject *self, int offset, int axis1, int axis2) if (new == NULL) { return NULL; } - self = (PyAO *)new; + self = (PyArrayObject *)new; if (n == 2) { - PyObject *a = NULL, *indices= NULL, *ret = NULL; + PyObject *a = NULL, *ret = NULL; + PyArrayObject *indices = NULL; intp n1, n2, start, stop, step, count; intp *dptr; - n1 = self->dimensions[0]; - n2 = self->dimensions[1]; + n1 = PyArray_DIMS(self)[0]; + n2 = PyArray_DIMS(self)[1]; step = n2 + 1; if (offset < 0) { start = -n2 * offset; @@ -1592,7 +1583,7 @@ PyArray_Diagonal(PyArrayObject *self, int offset, int axis1, int axis2) /* count = ceil((stop-start)/step) */ count = ((stop-start) / step) + (((stop-start) % step) != 0); - indices = PyArray_New(&PyArray_Type, 1, &count, + indices = (PyArrayObject *)PyArray_New(&PyArray_Type, 1, &count, PyArray_INTP, NULL, NULL, 0, 0, NULL); if (indices == NULL) { Py_DECREF(self); @@ -1608,7 +1599,7 @@ PyArray_Diagonal(PyArrayObject *self, int offset, int axis1, int axis2) Py_DECREF(indices); return NULL; } - ret = PyObject_GetItem(a, indices); + ret = PyObject_GetItem(a, (PyObject *)indices); Py_DECREF(a); Py_DECREF(indices); return ret; @@ -1628,13 +1619,13 @@ PyArray_Diagonal(PyArrayObject *self, int offset, int axis1, int axis2) new = NULL; - typecode = self->descr; + typecode = PyArray_DESCR(self); mydiagonal = PyList_New(0); if (mydiagonal == NULL) { Py_DECREF(self); return NULL; } - n1 = self->dimensions[0]; + n1 = PyArray_DIMS(self)[0]; for (i = 0; i < n1; i++) { new = PyInt_FromLong((long) i); sel = PyArray_EnsureAnyArray(PyObject_GetItem((PyObject *)self, new)); @@ -1644,7 +1635,7 @@ PyArray_Diagonal(PyArrayObject *self, int offset, int axis1, int axis2) Py_DECREF(mydiagonal); return NULL; } - new = PyArray_Diagonal((PyAO *)sel, offset, n-3, n-2); + new = PyArray_Diagonal((PyArrayObject *)sel, offset, n-3, n-2); Py_DECREF(sel); if (new == NULL) { Py_DECREF(self); @@ -1677,11 +1668,11 @@ PyArray_Compress(PyArrayObject *self, PyObject *condition, int axis, PyArrayObject *cond; PyObject *res, *ret; - cond = (PyAO *)PyArray_FROM_O(condition); + cond = (PyArrayObject *)PyArray_FROM_O(condition); if (cond == NULL) { return NULL; } - if (cond->nd != 1) { + if (PyArray_NDIM(cond) != 1) { Py_DECREF(cond); PyErr_SetString(PyExc_ValueError, "condition must be 1-d array"); @@ -1707,7 +1698,7 @@ PyArray_Compress(PyArrayObject *self, PyObject *condition, int axis, NPY_NO_EXPORT npy_intp PyArray_CountNonzero(PyArrayObject *self) { - PyArray_NonzeroFunc *nonzero = self->descr->f->nonzero; + PyArray_NonzeroFunc *nonzero = PyArray_DESCR(self)->f->nonzero; char *data; npy_intp stride, count; npy_intp nonzero_count = 0; @@ -1791,7 +1782,7 @@ PyArray_Nonzero(PyArrayObject *self) PyArrayObject *ret = NULL; PyObject *ret_tuple; npy_intp ret_dims[2]; - PyArray_NonzeroFunc *nonzero = self->descr->f->nonzero; + PyArray_NonzeroFunc *nonzero = PyArray_DESCR(self)->f->nonzero; char *data; npy_intp stride, count; npy_intp nonzero_count = PyArray_CountNonzero(self); @@ -1888,7 +1879,7 @@ finish: /* Create views into ret, one for each dimension */ if (ndim == 1) { /* Directly switch to one dimensions (dimension 1 is 1 anyway) */ - ret->nd = 1; + ((PyArrayObject_fieldaccess *)ret)->nd = 1; PyTuple_SET_ITEM(ret_tuple, 0, (PyObject *)ret); } else { @@ -1907,7 +1898,10 @@ finish: return NULL; } Py_INCREF(ret); - view->base = (PyObject *)ret; + if (PyArray_SetBaseObject(view, (PyObject *)ret) < 0) { + Py_DECREF(ret); + Py_DECREF(ret_tuple); + } PyTuple_SET_ITEM(ret_tuple, i, (PyObject *)view); } diff --git a/numpy/core/src/multiarray/iterators.c b/numpy/core/src/multiarray/iterators.c index 3618febf2..e1d44740f 100644 --- a/numpy/core/src/multiarray/iterators.c +++ b/numpy/core/src/multiarray/iterators.c @@ -22,7 +22,8 @@ #define SingleIndex -3 NPY_NO_EXPORT npy_intp -parse_subindex(PyObject *op, npy_intp *step_size, npy_intp *n_steps, npy_intp max) +parse_subindex(PyObject *op, npy_intp *step_size, + npy_intp *n_steps, npy_intp max) { npy_intp index; @@ -116,8 +117,8 @@ parse_index(PyArrayObject *self, PyObject *op, } } start = parse_subindex(op1, &step_size, &n_steps, - nd_old < self->nd ? - self->dimensions[nd_old] : 0); + nd_old < PyArray_NDIM(self) ? + PyArray_DIMS(self)[nd_old] : 0); Py_DECREF(op1); if (start == -1) { break; @@ -135,7 +136,7 @@ parse_index(PyArrayObject *self, PyObject *op, } Py_DECREF(op1); } - n_add = self->nd-(n-i-n_pseudo-1+nd_old); + n_add = PyArray_NDIM(self)-(n-i-n_pseudo-1+nd_old); if (n_add < 0) { PyErr_SetString(PyExc_IndexError, "too many indices"); @@ -143,24 +144,24 @@ parse_index(PyArrayObject *self, PyObject *op, } for (j = 0; j < n_add; j++) { dimensions[nd_new] = \ - self->dimensions[nd_old]; + PyArray_DIMS(self)[nd_old]; strides[nd_new] = \ - self->strides[nd_old]; + PyArray_STRIDES(self)[nd_old]; nd_new++; nd_old++; } } else { - if (nd_old >= self->nd) { + if (nd_old >= PyArray_NDIM(self)) { PyErr_SetString(PyExc_IndexError, "too many indices"); return -1; } - offset += self->strides[nd_old]*start; + offset += PyArray_STRIDES(self)[nd_old]*start; nd_old++; if (n_steps != SingleIndex) { dimensions[nd_new] = n_steps; strides[nd_new] = step_size * \ - self->strides[nd_old-1]; + PyArray_STRIDES(self)[nd_old-1]; nd_new++; } } @@ -169,10 +170,10 @@ parse_index(PyArrayObject *self, PyObject *op, if (i < n) { return -1; } - n_add = self->nd-nd_old; + n_add = PyArray_NDIM(self)-nd_old; for (j = 0; j < n_add; j++) { - dimensions[nd_new] = self->dimensions[nd_old]; - strides[nd_new] = self->strides[nd_old]; + dimensions[nd_new] = PyArray_DIMS(self)[nd_old]; + strides[nd_new] = PyArray_STRIDES(self)[nd_old]; nd_new++; nd_old++; } @@ -276,9 +277,9 @@ get_ptr_simple(PyArrayIterObject* iter, npy_intp *coordinates) npy_intp i; char *ret; - ret = iter->ao->data; + ret = PyArray_DATA(iter->ao); - for(i = 0; i < iter->ao->nd; ++i) { + for(i = 0; i < PyArray_NDIM(iter->ao); ++i) { ret += coordinates[i] * iter->strides[i]; } @@ -296,7 +297,7 @@ array_iter_base_init(PyArrayIterObject *it, PyArrayObject *ao) { int nd, i; - nd = ao->nd; + nd = PyArray_NDIM(ao); PyArray_UpdateFlags(ao, NPY_ARRAY_C_CONTIGUOUS); if (PyArray_ISCONTIGUOUS(ao)) { it->contiguous = 1; @@ -310,16 +311,16 @@ array_iter_base_init(PyArrayIterObject *it, PyArrayObject *ao) it->nd_m1 = nd - 1; it->factors[nd-1] = 1; for (i = 0; i < nd; i++) { - it->dims_m1[i] = ao->dimensions[i] - 1; - it->strides[i] = ao->strides[i]; + it->dims_m1[i] = PyArray_DIMS(ao)[i] - 1; + it->strides[i] = PyArray_STRIDES(ao)[i]; it->backstrides[i] = it->strides[i] * it->dims_m1[i]; if (i > 0) { - it->factors[nd-i-1] = it->factors[nd-i] * ao->dimensions[nd-i]; + it->factors[nd-i-1] = it->factors[nd-i] * PyArray_DIMS(ao)[nd-i]; } it->bounds[i][0] = 0; - it->bounds[i][1] = ao->dimensions[i] - 1; + it->bounds[i][1] = PyArray_DIMS(ao)[i] - 1; it->limits[i][0] = 0; - it->limits[i][1] = ao->dimensions[i] - 1; + it->limits[i][1] = PyArray_DIMS(ao)[i] - 1; it->limits_sizes[i] = it->limits[i][1] - it->limits[i][0] + 1; } @@ -370,16 +371,16 @@ PyArray_BroadcastToShape(PyObject *obj, npy_intp *dims, int nd) int i, diff, j, compat, k; PyArrayObject *ao = (PyArrayObject *)obj; - if (ao->nd > nd) { + if (PyArray_NDIM(ao) > nd) { goto err; } compat = 1; - diff = j = nd - ao->nd; - for (i = 0; i < ao->nd; i++, j++) { - if (ao->dimensions[i] == 1) { + diff = j = nd - PyArray_NDIM(ao); + for (i = 0; i < PyArray_NDIM(ao); i++, j++) { + if (PyArray_DIMS(ao)[i] == 1) { continue; } - if (ao->dimensions[i] != dims[j]) { + if (PyArray_DIMS(ao)[i] != dims[j]) { compat = 0; break; } @@ -408,12 +409,12 @@ PyArray_BroadcastToShape(PyObject *obj, npy_intp *dims, int nd) for (i = 0; i < nd; i++) { it->dims_m1[i] = dims[i] - 1; k = i - diff; - if ((k < 0) || ao->dimensions[k] != dims[i]) { + if ((k < 0) || PyArray_DIMS(ao)[k] != dims[i]) { it->contiguous = 0; it->strides[i] = 0; } else { - it->strides[i] = ao->strides[k]; + it->strides[i] = PyArray_STRIDES(ao)[k]; } it->backstrides[i] = it->strides[i] * it->dims_m1[i]; if (i > 0) { @@ -441,28 +442,37 @@ PyArray_BroadcastToShape(PyObject *obj, npy_intp *dims, int nd) NPY_NO_EXPORT PyObject * PyArray_IterAllButAxis(PyObject *obj, int *inaxis) { + PyArrayObject *arr; PyArrayIterObject *it; int axis; - it = (PyArrayIterObject *)PyArray_IterNew(obj); + + if (!PyArray_Check(obj)) { + PyErr_SetString(PyExc_ValueError, + "Numpy IterAllButAxis requires an ndarray"); + return NULL; + } + arr = (PyArrayObject *)obj; + + it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)arr); if (it == NULL) { return NULL; } - if (PyArray_NDIM(obj)==0) { + if (PyArray_NDIM(arr)==0) { return (PyObject *)it; } if (*inaxis < 0) { int i, minaxis = 0; npy_intp minstride = 0; i = 0; - while (minstride == 0 && i < PyArray_NDIM(obj)) { - minstride = PyArray_STRIDE(obj,i); + while (minstride == 0 && i < PyArray_NDIM(arr)) { + minstride = PyArray_STRIDE(arr,i); i++; } - for (i = 1; i < PyArray_NDIM(obj); i++) { - if (PyArray_STRIDE(obj,i) > 0 && - PyArray_STRIDE(obj, i) < minstride) { + for (i = 1; i < PyArray_NDIM(arr); i++) { + if (PyArray_STRIDE(arr,i) > 0 && + PyArray_STRIDE(arr, i) < minstride) { minaxis = i; - minstride = PyArray_STRIDE(obj,i); + minstride = PyArray_STRIDE(arr,i); } } *inaxis = minaxis; @@ -471,7 +481,7 @@ PyArray_IterAllButAxis(PyObject *obj, int *inaxis) /* adjust so that will not iterate over axis */ it->contiguous = 0; if (it->size != 0) { - it->size /= PyArray_DIM(obj,axis); + it->size /= PyArray_DIM(arr,axis); } it->dims_m1[axis] = 0; it->backstrides[axis] = 0; @@ -560,32 +570,32 @@ iter_length(PyArrayIterObject *self) } -static PyObject * +static PyArrayObject * iter_subscript_Bool(PyArrayIterObject *self, PyArrayObject *ind) { npy_intp index, strides; int itemsize; npy_intp count = 0; char *dptr, *optr; - PyObject *r; + PyArrayObject *ret; int swap; PyArray_CopySwapFunc *copyswap; - if (ind->nd != 1) { + if (PyArray_NDIM(ind) != 1) { PyErr_SetString(PyExc_ValueError, "boolean index array should have 1 dimension"); return NULL; } - index = ind->dimensions[0]; + index = PyArray_DIMS(ind)[0]; if (index > self->size) { PyErr_SetString(PyExc_ValueError, "too many boolean indices"); return NULL; } - strides = ind->strides[0]; - dptr = ind->data; + strides = PyArray_STRIDES(ind)[0]; + dptr = PyArray_DATA(ind); /* Get size of return array */ while (index--) { if (*((Bool *)dptr) != 0) { @@ -593,22 +603,22 @@ iter_subscript_Bool(PyArrayIterObject *self, PyArrayObject *ind) } dptr += strides; } - itemsize = self->ao->descr->elsize; - Py_INCREF(self->ao->descr); - r = PyArray_NewFromDescr(Py_TYPE(self->ao), - self->ao->descr, 1, &count, + itemsize = PyArray_DESCR(self->ao)->elsize; + Py_INCREF(PyArray_DESCR(self->ao)); + ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self->ao), + PyArray_DESCR(self->ao), 1, &count, NULL, NULL, 0, (PyObject *)self->ao); - if (r == NULL) { + if (ret == NULL) { return NULL; } /* Set up loop */ - optr = PyArray_DATA(r); - index = ind->dimensions[0]; - dptr = ind->data; - copyswap = self->ao->descr->f->copyswap; + optr = PyArray_DATA(ret); + index = PyArray_DIMS(ind)[0]; + dptr = PyArray_DATA(ind); + copyswap = PyArray_DESCR(self->ao)->f->copyswap; /* Loop over Boolean array */ - swap = (PyArray_ISNOTSWAPPED(self->ao) != PyArray_ISNOTSWAPPED(r)); + swap = (PyArray_ISNOTSWAPPED(self->ao) != PyArray_ISNOTSWAPPED(ret)); while (index--) { if (*((Bool *)dptr) != 0) { copyswap(optr, self->dataptr, swap, self->ao); @@ -618,14 +628,14 @@ iter_subscript_Bool(PyArrayIterObject *self, PyArrayObject *ind) PyArray_ITER_NEXT(self); } PyArray_ITER_RESET(self); - return r; + return ret; } static PyObject * iter_subscript_int(PyArrayIterObject *self, PyArrayObject *ind) { npy_intp num; - PyObject *r; + PyArrayObject *ret; PyArrayIterObject *ind_it; int itemsize; int swap; @@ -633,9 +643,9 @@ iter_subscript_int(PyArrayIterObject *self, PyArrayObject *ind) npy_intp index; PyArray_CopySwapFunc *copyswap; - itemsize = self->ao->descr->elsize; - if (ind->nd == 0) { - num = *((npy_intp *)ind->data); + itemsize = PyArray_DESCR(self->ao)->elsize; + if (PyArray_NDIM(ind) == 0) { + num = *((npy_intp *)PyArray_DATA(ind)); if (num < 0) { num += self->size; } @@ -644,33 +654,37 @@ iter_subscript_int(PyArrayIterObject *self, PyArrayObject *ind) "index %"INTP_FMT" out of bounds" \ " 0<=index<%"INTP_FMT, num, self->size); - r = NULL; + PyArray_ITER_RESET(self); + return NULL; } else { + PyObject *tmp; PyArray_ITER_GOTO1D(self, num); - r = PyArray_ToScalar(self->dataptr, self->ao); + tmp = PyArray_ToScalar(self->dataptr, self->ao); + PyArray_ITER_RESET(self); + return tmp; } - PyArray_ITER_RESET(self); - return r; } - Py_INCREF(self->ao->descr); - r = PyArray_NewFromDescr(Py_TYPE(self->ao), self->ao->descr, - ind->nd, ind->dimensions, + Py_INCREF(PyArray_DESCR(self->ao)); + ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self->ao), + PyArray_DESCR(self->ao), + PyArray_NDIM(ind), + PyArray_DIMS(ind), NULL, NULL, 0, (PyObject *)self->ao); - if (r == NULL) { + if (ret == NULL) { return NULL; } - optr = PyArray_DATA(r); + optr = PyArray_DATA(ret); ind_it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)ind); if (ind_it == NULL) { - Py_DECREF(r); + Py_DECREF(ret); return NULL; } index = ind_it->size; - copyswap = PyArray_DESCR(r)->f->copyswap; - swap = (PyArray_ISNOTSWAPPED(r) != PyArray_ISNOTSWAPPED(self->ao)); + copyswap = PyArray_DESCR(ret)->f->copyswap; + swap = (PyArray_ISNOTSWAPPED(ret) != PyArray_ISNOTSWAPPED(self->ao)); while (index--) { num = *((npy_intp *)(ind_it->dataptr)); if (num < 0) { @@ -682,18 +696,18 @@ iter_subscript_int(PyArrayIterObject *self, PyArrayObject *ind) " 0<=index<%"INTP_FMT, num, self->size); Py_DECREF(ind_it); - Py_DECREF(r); + Py_DECREF(ret); PyArray_ITER_RESET(self); return NULL; } PyArray_ITER_GOTO1D(self, num); - copyswap(optr, self->dataptr, swap, r); + copyswap(optr, self->dataptr, swap, ret); optr += itemsize; PyArray_ITER_NEXT(ind_it); } Py_DECREF(ind_it); PyArray_ITER_RESET(self); - return r; + return (PyObject *)ret; } /* Always returns arrays */ @@ -701,9 +715,10 @@ NPY_NO_EXPORT PyObject * iter_subscript(PyArrayIterObject *self, PyObject *ind) { PyArray_Descr *indtype = NULL; + PyArray_Descr *dtype; npy_intp start, step_size; npy_intp n_steps; - PyObject *r; + PyArrayObject *ret; char *dptr; int size; PyObject *obj = NULL; @@ -731,7 +746,7 @@ iter_subscript(PyArrayIterObject *self, PyObject *ind) /* * Tuples >1d not accepted --- i.e. no newaxis * Could implement this with adjusted strides and dimensions in iterator - * Check for Boolean -- this is first becasue Bool is a subclass of Int + * Check for Boolean -- this is first because Bool is a subclass of Int */ PyArray_ITER_RESET(self); @@ -741,13 +756,14 @@ iter_subscript(PyArrayIterObject *self, PyObject *ind) } else { /* empty array */ npy_intp ii = 0; - Py_INCREF(self->ao->descr); - r = PyArray_NewFromDescr(Py_TYPE(self->ao), - self->ao->descr, + dtype = PyArray_DESCR(self->ao); + Py_INCREF(dtype); + ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self->ao), + dtype, 1, &ii, NULL, NULL, 0, (PyObject *)self->ao); - return r; + return (PyObject *)ret; } } @@ -765,30 +781,32 @@ iter_subscript(PyArrayIterObject *self, PyObject *ind) } PyArray_ITER_GOTO1D(self, start) if (n_steps == SingleIndex) { /* Integer */ - r = PyArray_ToScalar(self->dataptr, self->ao); + PyObject *tmp; + tmp = PyArray_ToScalar(self->dataptr, self->ao); PyArray_ITER_RESET(self); - return r; + return tmp; } - size = self->ao->descr->elsize; - Py_INCREF(self->ao->descr); - r = PyArray_NewFromDescr(Py_TYPE(self->ao), - self->ao->descr, + size = PyArray_DESCR(self->ao)->elsize; + dtype = PyArray_DESCR(self->ao); + Py_INCREF(dtype); + ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self->ao), + dtype, 1, &n_steps, NULL, NULL, 0, (PyObject *)self->ao); - if (r == NULL) { + if (ret == NULL) { goto fail; } - dptr = PyArray_DATA(r); - copyswap = PyArray_DESCR(r)->f->copyswap; + dptr = PyArray_DATA(ret); + copyswap = PyArray_DESCR(ret)->f->copyswap; while (n_steps--) { - copyswap(dptr, self->dataptr, 0, r); + copyswap(dptr, self->dataptr, 0, ret); start += step_size; PyArray_ITER_GOTO1D(self, start) dptr += size; } PyArray_ITER_RESET(self); - return r; + return (PyObject *)ret; } /* convert to INTP array if Integer array scalar or List */ @@ -807,12 +825,12 @@ iter_subscript(PyArrayIterObject *self, PyObject *ind) if (PyArray_Check(obj)) { /* Check for Boolean object */ - if (PyArray_TYPE(obj)==PyArray_BOOL) { - r = iter_subscript_Bool(self, (PyArrayObject *)obj); + if (PyArray_TYPE((PyArrayObject *)obj) == NPY_BOOL) { + ret = iter_subscript_Bool(self, (PyArrayObject *)obj); Py_DECREF(indtype); } /* Check for integer array */ - else if (PyArray_ISINTEGER(obj)) { + else if (PyArray_ISINTEGER((PyArrayObject *)obj)) { PyObject *new; new = PyArray_FromAny(obj, indtype, 0, 0, NPY_ARRAY_FORCECAST | NPY_ARRAY_ALIGNED, NULL); @@ -821,13 +839,15 @@ iter_subscript(PyArrayIterObject *self, PyObject *ind) } Py_DECREF(obj); obj = new; - r = iter_subscript_int(self, (PyArrayObject *)obj); + new = iter_subscript_int(self, (PyArrayObject *)obj); + Py_DECREF(obj); + return new; } else { goto fail; } Py_DECREF(obj); - return r; + return (PyObject *)ret; } else { Py_DECREF(indtype); @@ -853,24 +873,24 @@ iter_ass_sub_Bool(PyArrayIterObject *self, PyArrayObject *ind, char *dptr; PyArray_CopySwapFunc *copyswap; - if (ind->nd != 1) { + if (PyArray_NDIM(ind) != 1) { PyErr_SetString(PyExc_ValueError, "boolean index array should have 1 dimension"); return -1; } - index = ind->dimensions[0]; + index = PyArray_DIMS(ind)[0]; if (index > self->size) { PyErr_SetString(PyExc_ValueError, "boolean index array has too many values"); return -1; } - strides = ind->strides[0]; - dptr = ind->data; + strides = PyArray_STRIDES(ind)[0]; + dptr = PyArray_DATA(ind); PyArray_ITER_RESET(self); /* Loop over Boolean array */ - copyswap = self->ao->descr->f->copyswap; + copyswap = PyArray_DESCR(self->ao)->f->copyswap; while (index--) { if (*((Bool *)dptr) != 0) { copyswap(self->dataptr, val->dataptr, swap, self->ao); @@ -895,9 +915,9 @@ iter_ass_sub_int(PyArrayIterObject *self, PyArrayObject *ind, npy_intp index; PyArray_CopySwapFunc *copyswap; - copyswap = self->ao->descr->f->copyswap; - if (ind->nd == 0) { - num = *((npy_intp *)ind->data); + copyswap = PyArray_DESCR(self->ao)->f->copyswap; + if (PyArray_NDIM(ind) == 0) { + num = *((npy_intp *)PyArray_DATA(ind)); PyArray_ITER_GOTO1D(self, num); copyswap(self->dataptr, val->dataptr, swap, self->ao); return 0; @@ -935,7 +955,7 @@ iter_ass_sub_int(PyArrayIterObject *self, PyArrayObject *ind, NPY_NO_EXPORT int iter_ass_subscript(PyArrayIterObject *self, PyObject *ind, PyObject *val) { - PyObject *arrval = NULL; + PyArrayObject *arrval = NULL; PyArrayIterObject *val_it = NULL; PyArray_Descr *type; PyArray_Descr *indtype = NULL; @@ -962,7 +982,7 @@ iter_ass_subscript(PyArrayIterObject *self, PyObject *ind, PyObject *val) ind = PyTuple_GET_ITEM(ind, 0); } - type = self->ao->descr; + type = PyArray_DESCR(self->ao); /* * Check for Boolean -- this is first becasue @@ -1003,11 +1023,11 @@ iter_ass_subscript(PyArrayIterObject *self, PyObject *ind, PyObject *val) skip: Py_INCREF(type); - arrval = PyArray_FromAny(val, type, 0, 0, 0, NULL); + arrval = (PyArrayObject *)PyArray_FromAny(val, type, 0, 0, 0, NULL); if (arrval == NULL) { return -1; } - val_it = (PyArrayIterObject *)PyArray_IterNew(arrval); + val_it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)arrval); if (val_it == NULL) { goto finish; } @@ -1065,7 +1085,7 @@ iter_ass_subscript(PyArrayIterObject *self, PyObject *ind, PyObject *val) if (obj != NULL && PyArray_Check(obj)) { /* Check for Boolean object */ - if (PyArray_TYPE(obj)==PyArray_BOOL) { + if (PyArray_TYPE((PyArrayObject *)obj)==PyArray_BOOL) { if (iter_ass_sub_Bool(self, (PyArrayObject *)obj, val_it, swap) < 0) { goto finish; @@ -1073,7 +1093,7 @@ iter_ass_subscript(PyArrayIterObject *self, PyObject *ind, PyObject *val) retval=0; } /* Check for integer array */ - else if (PyArray_ISINTEGER(obj)) { + else if (PyArray_ISINTEGER((PyArrayObject *)obj)) { PyObject *new; Py_INCREF(indtype); new = PyArray_CheckFromAny(obj, indtype, 0, 0, @@ -1116,11 +1136,11 @@ static PyMappingMethods iter_as_mapping = { -static PyObject * +static PyArrayObject * iter_array(PyArrayIterObject *it, PyObject *NPY_UNUSED(op)) { - PyObject *r; + PyArrayObject *ret; npy_intp size; /* Any argument ignored */ @@ -1133,37 +1153,46 @@ iter_array(PyArrayIterObject *it, PyObject *NPY_UNUSED(op)) * to copy back to the old array */ size = PyArray_SIZE(it->ao); - Py_INCREF(it->ao->descr); + Py_INCREF(PyArray_DESCR(it->ao)); if (PyArray_ISCONTIGUOUS(it->ao)) { - r = PyArray_NewFromDescr(&PyArray_Type, - it->ao->descr, + ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, + PyArray_DESCR(it->ao), 1, &size, - NULL, it->ao->data, - it->ao->flags, + NULL, PyArray_DATA(it->ao), + PyArray_FLAGS(it->ao), (PyObject *)it->ao); - if (r == NULL) { + if (ret == NULL) { + return NULL; + } + Py_INCREF(it->ao); + if (PyArray_SetBaseObject(ret, (PyObject *)it->ao) < 0) { + Py_DECREF(ret); return NULL; } } else { - r = PyArray_NewFromDescr(&PyArray_Type, - it->ao->descr, + ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, + PyArray_DESCR(it->ao), 1, &size, NULL, NULL, 0, (PyObject *)it->ao); - if (r == NULL) { + if (ret == NULL) { return NULL; } - if (PyArray_CopyAnyInto((PyArrayObject *)r, it->ao) < 0) { - Py_DECREF(r); + if (PyArray_CopyAnyInto(ret, it->ao) < 0) { + Py_DECREF(ret); return NULL; } - PyArray_FLAGS(r) |= NPY_ARRAY_UPDATEIFCOPY; - it->ao->flags &= ~NPY_ARRAY_WRITEABLE; + /* + * Don't use PyArray_SetBaseObject, because that compresses + * the chain of bases. + */ + Py_INCREF(it->ao); + ((PyArrayObject_fieldaccess *)ret)->base = (PyObject *)it->ao; + PyArray_ENABLEFLAGS(ret, NPY_ARRAY_UPDATEIFCOPY); + PyArray_CLEARFLAGS(it->ao, NPY_ARRAY_WRITEABLE); } - Py_INCREF(it->ao); - PyArray_BASE(r) = (PyObject *)it->ao; - return r; + return ret; } @@ -1218,7 +1247,7 @@ static PyObject * iter_coords_get(PyArrayIterObject *self) { int nd; - nd = self->ao->nd; + nd = PyArray_NDIM(self->ao); if (self->contiguous) { /* * coordinates not kept track of --- @@ -1324,7 +1353,7 @@ PyArray_Broadcast(PyArrayMultiIterObject *mit) /* Discover the broadcast number of dimensions */ for (i = 0, nd = 0; i < mit->numiter; i++) { - nd = MAX(nd, mit->iters[i]->ao->nd); + nd = MAX(nd, PyArray_NDIM(mit->iters[i]->ao)); } mit->nd = nd; @@ -1334,9 +1363,9 @@ PyArray_Broadcast(PyArrayMultiIterObject *mit) for (j = 0; j < mit->numiter; j++) { it = mit->iters[j]; /* This prepends 1 to shapes not already equal to nd */ - k = i + it->ao->nd - nd; + k = i + PyArray_NDIM(it->ao) - nd; if (k >= 0) { - tmp = it->ao->dimensions[k]; + tmp = PyArray_DIMS(it->ao)[k]; if (tmp == 1) { continue; } @@ -1370,7 +1399,7 @@ PyArray_Broadcast(PyArrayMultiIterObject *mit) it = mit->iters[i]; it->nd_m1 = mit->nd - 1; it->size = tmp; - nd = it->ao->nd; + nd = PyArray_NDIM(it->ao); it->factors[mit->nd-1] = 1; for (j = 0; j < mit->nd; j++) { it->dims_m1[j] = mit->dimensions[j] - 1; @@ -1380,12 +1409,12 @@ PyArray_Broadcast(PyArrayMultiIterObject *mit) * underlying array was 1 */ if ((k < 0) || - it->ao->dimensions[k] != mit->dimensions[j]) { + PyArray_DIMS(it->ao)[k] != mit->dimensions[j]) { it->contiguous = 0; it->strides[j] = 0; } else { - it->strides[j] = it->ao->strides[k]; + it->strides[j] = PyArray_STRIDES(it->ao)[k]; } it->backstrides[j] = it->strides[j] * it->dims_m1[j]; if (j > 0) @@ -1796,22 +1825,22 @@ static char* _set_constant(PyArrayNeighborhoodIterObject* iter, PyArrayIterObject *ar = iter->_internal_iter; int storeflags, st; - ret = PyDataMem_NEW(ar->ao->descr->elsize); + ret = PyDataMem_NEW(PyArray_DESCR(ar->ao)->elsize); if (ret == NULL) { PyErr_SetNone(PyExc_MemoryError); return NULL; } if (PyArray_ISOBJECT(ar->ao)) { - memcpy(ret, fill->data, sizeof(PyObject*)); + memcpy(ret, PyArray_DATA(fill), sizeof(PyObject*)); Py_INCREF(*(PyObject**)ret); } else { /* Non-object types */ - storeflags = ar->ao->flags; - ar->ao->flags |= NPY_ARRAY_BEHAVED; - st = ar->ao->descr->f->setitem((PyObject*)fill, ret, ar->ao); - ar->ao->flags = storeflags; + storeflags = PyArray_FLAGS(ar->ao); + PyArray_ENABLEFLAGS(ar->ao, NPY_ARRAY_BEHAVED); + st = PyArray_DESCR(ar->ao)->f->setitem((PyObject*)fill, ret, ar->ao); + ((PyArrayObject_fieldaccess *)ar->ao)->flags = storeflags; if (st < 0) { PyDataMem_FREE(ret); @@ -1958,10 +1987,10 @@ PyArray_NeighborhoodIterNew(PyArrayIterObject *x, npy_intp *bounds, Py_INCREF(x); ret->_internal_iter = x; - ret->nd = x->ao->nd; + ret->nd = PyArray_NDIM(x->ao); for (i = 0; i < ret->nd; ++i) { - ret->dimensions[i] = x->ao->dimensions[i]; + ret->dimensions[i] = PyArray_DIMS(x->ao)[i]; } /* Compute the neighborhood size and copy the shape */ diff --git a/numpy/core/src/multiarray/mapping.c b/numpy/core/src/multiarray/mapping.c index 08538e492..5cd6531d4 100644 --- a/numpy/core/src/multiarray/mapping.c +++ b/numpy/core/src/multiarray/mapping.c @@ -32,8 +32,8 @@ array_subscript_simple(PyArrayObject *self, PyObject *op); NPY_NO_EXPORT Py_ssize_t array_length(PyArrayObject *self) { - if (self->nd != 0) { - return self->dimensions[0]; + if (PyArray_NDIM(self) != 0) { + return PyArray_DIMS(self)[0]; } else { PyErr_SetString(PyExc_TypeError, "len() of unsized object"); return -1; @@ -46,7 +46,7 @@ array_big_item(PyArrayObject *self, intp i) char *item; PyArrayObject *r; - if(self->nd == 0) { + if(PyArray_NDIM(self) == 0) { PyErr_SetString(PyExc_IndexError, "0-d arrays can't be indexed"); return NULL; @@ -54,19 +54,22 @@ array_big_item(PyArrayObject *self, intp i) if ((item = index2ptr(self, i)) == NULL) { return NULL; } - Py_INCREF(self->descr); + Py_INCREF(PyArray_DESCR(self)); r = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self), - self->descr, - self->nd-1, - self->dimensions+1, - self->strides+1, item, - self->flags, + PyArray_DESCR(self), + PyArray_NDIM(self)-1, + PyArray_DIMS(self)+1, + PyArray_STRIDES(self)+1, item, + PyArray_FLAGS(self), (PyObject *)self); if (r == NULL) { return NULL; } Py_INCREF(self); - r->base = (PyObject *)self; + if (PyArray_SetBaseObject(r, (PyObject *)self) < 0) { + Py_DECREF(r); + return NULL; + } PyArray_UpdateFlags(r, NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS); return (PyObject *)r; } @@ -80,12 +83,12 @@ _array_ass_item(PyArrayObject *self, Py_ssize_t i, PyObject *v) NPY_NO_EXPORT PyObject * array_item_nice(PyArrayObject *self, Py_ssize_t i) { - if (self->nd == 1) { + if (PyArray_NDIM(self) == 1) { char *item; if ((item = index2ptr(self, i)) == NULL) { return NULL; } - return PyArray_Scalar(item, self->descr, (PyObject *)self); + return PyArray_Scalar(item, PyArray_DESCR(self), (PyObject *)self); } else { return PyArray_Return( @@ -110,14 +113,14 @@ array_ass_big_item(PyArrayObject *self, intp i, PyObject *v) "array is not writeable"); return -1; } - if (self->nd == 0) { + if (PyArray_NDIM(self) == 0) { PyErr_SetString(PyExc_IndexError, "0-d arrays can't be indexed."); return -1; } - if (self->nd > 1) { + if (PyArray_NDIM(self) > 1) { if((tmp = (PyArrayObject *)array_big_item(self, i)) == NULL) { return -1; } @@ -129,7 +132,7 @@ array_ass_big_item(PyArrayObject *self, intp i, PyObject *v) if ((item = index2ptr(self, i)) == NULL) { return -1; } - if (self->descr->f->setitem(v, item, self) == -1) { + if (PyArray_DESCR(self)->f->setitem(v, item, self) == -1) { return -1; } return 0; @@ -155,11 +158,11 @@ _swap_axes(PyArrayMapIterObject *mit, PyArrayObject **ret, int getmap) * and need to be reshaped first by pre-pending ones */ arr = *ret; - if (arr->nd != mit->nd) { - for (i = 1; i <= arr->nd; i++) { - permute.ptr[mit->nd-i] = arr->dimensions[arr->nd-i]; + if (PyArray_NDIM(arr) != mit->nd) { + for (i = 1; i <= PyArray_NDIM(arr); i++) { + permute.ptr[mit->nd-i] = PyArray_DIMS(arr)[PyArray_NDIM(arr)-i]; } - for (i = 0; i < mit->nd-arr->nd; i++) { + for (i = 0; i < mit->nd-PyArray_NDIM(arr); i++) { permute.ptr[i] = 1; } new = PyArray_Newshape(arr, &permute, PyArray_ANYORDER); @@ -232,10 +235,10 @@ PyArray_GetMap(PyArrayMapIterObject *mit) of the new array in nd and dimensions. */ temp = mit->ait->ao; - Py_INCREF(temp->descr); + Py_INCREF(PyArray_DESCR(temp)); ret = (PyArrayObject *) PyArray_NewFromDescr(Py_TYPE(temp), - temp->descr, + PyArray_DESCR(temp), mit->nd, mit->dimensions, NULL, NULL, PyArray_ISFORTRAN(temp), @@ -256,7 +259,7 @@ PyArray_GetMap(PyArrayMapIterObject *mit) } index = it->size; swap = (PyArray_ISNOTSWAPPED(temp) != PyArray_ISNOTSWAPPED(ret)); - copyswap = ret->descr->f->copyswap; + copyswap = PyArray_DESCR(ret)->f->copyswap; PyArray_MapIterReset(mit); while (index--) { copyswap(it->dataptr, mit->dataptr, swap, ret); @@ -277,7 +280,7 @@ PyArray_GetMap(PyArrayMapIterObject *mit) static int PyArray_SetMap(PyArrayMapIterObject *mit, PyObject *op) { - PyObject *arr = NULL; + PyArrayObject *arr = NULL; PyArrayIterObject *it; int index; int swap; @@ -288,15 +291,16 @@ PyArray_SetMap(PyArrayMapIterObject *mit, PyObject *op) if (mit->ait == NULL) { return -1; } - descr = mit->ait->ao->descr; + descr = PyArray_DESCR(mit->ait->ao); Py_INCREF(descr); - arr = PyArray_FromAny(op, descr, 0, 0, NPY_ARRAY_FORCECAST, NULL); + arr = (PyArrayObject *)PyArray_FromAny(op, descr, + 0, 0, NPY_ARRAY_FORCECAST, NULL); if (arr == NULL) { return -1; } if ((mit->subspace != NULL) && (mit->consec)) { if (mit->iteraxes[0] > 0) { /* then we need to swap */ - _swap_axes(mit, (PyArrayObject **)&arr, 0); + _swap_axes(mit, &arr, 0); if (arr == NULL) { return -1; } @@ -307,7 +311,8 @@ PyArray_SetMap(PyArrayMapIterObject *mit, PyObject *op) to shape of mit->dimensions, mit->nd */ if ((it = (PyArrayIterObject *)\ - PyArray_BroadcastToShape(arr, mit->dimensions, mit->nd))==NULL) { + PyArray_BroadcastToShape((PyObject *)arr, + mit->dimensions, mit->nd))==NULL) { Py_DECREF(arr); return -1; } @@ -391,16 +396,21 @@ add_new_axes_0d(PyArrayObject *arr, int newaxis_count) for (i = 0; i < newaxis_count; ++i) { dimensions[i] = 1; } - Py_INCREF(arr->descr); - if ((other = (PyArrayObject *) - PyArray_NewFromDescr(Py_TYPE(arr), arr->descr, - newaxis_count, dimensions, - NULL, arr->data, - arr->flags, - (PyObject *)arr)) == NULL) + Py_INCREF(PyArray_DESCR(arr)); + other = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(arr), + PyArray_DESCR(arr), + newaxis_count, dimensions, + NULL, PyArray_DATA(arr), + PyArray_FLAGS(arr), + (PyObject *)arr); + if (other == NULL) { return NULL; - other->base = (PyObject *)arr; + } Py_INCREF(arr); + if (PyArray_SetBaseObject(other, (PyObject *)arr) < 0) { + Py_DECREF(other); + return NULL; + } return (PyObject *)other; } @@ -422,8 +432,8 @@ fancy_indexing_check(PyObject *args) for (i = 0; i < n; i++) { obj = PyTuple_GET_ITEM(args,i); if (PyArray_Check(obj)) { - if (PyArray_ISINTEGER(obj) || - PyArray_ISBOOL(obj)) { + if (PyArray_ISINTEGER((PyArrayObject *)obj) || + PyArray_ISBOOL((PyArrayObject *)obj)) { retval = SOBJ_ISFANCY; } else { @@ -437,8 +447,8 @@ fancy_indexing_check(PyObject *args) } } else if (PyArray_Check(args)) { - if ((PyArray_TYPE(args)==PyArray_BOOL) || - (PyArray_ISINTEGER(args))) { + if ((PyArray_TYPE((PyArrayObject *)args)==NPY_BOOL) || + (PyArray_ISINTEGER((PyArrayObject *)args))) { return SOBJ_ISFANCY; } else { @@ -463,7 +473,8 @@ fancy_indexing_check(PyObject *args) return SOBJ_ISFANCY; } if (PyArray_Check(obj)) { - if (PyArray_ISINTEGER(obj) || PyArray_ISBOOL(obj)) { + if (PyArray_ISINTEGER((PyArrayObject *)obj) || + PyArray_ISBOOL((PyArrayObject *)obj)) { retval = SOBJ_LISTTUP; } else { @@ -503,35 +514,44 @@ fancy_indexing_check(PyObject *args) NPY_NO_EXPORT PyObject * array_subscript_simple(PyArrayObject *self, PyObject *op) { - intp dimensions[MAX_DIMS], strides[MAX_DIMS]; - intp offset; + npy_intp dimensions[MAX_DIMS], strides[MAX_DIMS]; + npy_intp offset; int nd; PyArrayObject *other; - intp value; + npy_intp value; value = PyArray_PyIntAsIntp(op); - if (!PyErr_Occurred()) { + if (value == -1 && PyErr_Occurred()) { + PyErr_Clear(); + } + else { return array_big_item(self, value); } - PyErr_Clear(); /* Standard (view-based) Indexing */ - if ((nd = parse_index(self, op, dimensions, strides, &offset)) == -1) { + nd = parse_index(self, op, dimensions, strides, &offset); + if (nd == -1) { return NULL; } + /* This will only work if new array will be a view */ - Py_INCREF(self->descr); - if ((other = (PyArrayObject *) - PyArray_NewFromDescr(Py_TYPE(self), self->descr, - nd, dimensions, - strides, self->data+offset, - self->flags, - (PyObject *)self)) == NULL) { + Py_INCREF(PyArray_DESCR(self)); + other = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self), + PyArray_DESCR(self), + nd, dimensions, + strides, PyArray_DATA(self)+offset, + PyArray_FLAGS(self), + (PyObject *)self); + if (other == NULL) { return NULL; } - other->base = (PyObject *)self; Py_INCREF(self); + if (PyArray_SetBaseObject(other, (PyObject *)self) < 0) { + Py_DECREF(other); + return NULL; + } PyArray_UpdateFlags(other, NPY_ARRAY_UPDATE_ALL); + return (PyObject *)other; } @@ -546,8 +566,8 @@ array_subscript(PyArrayObject *self, PyObject *op) if (PyString_Check(op) || PyUnicode_Check(op)) { PyObject *temp; - if (PyDataType_HASFIELDS(self->descr)) { - obj = PyDict_GetItem(self->descr->fields, op); + if (PyDataType_HASFIELDS(PyArray_DESCR(self))) { + obj = PyDict_GetItem(PyArray_DESCR(self)->fields, op); if (obj != NULL) { PyArray_Descr *descr; int offset; @@ -574,7 +594,7 @@ array_subscript(PyArrayObject *self, PyObject *op) } /* Check for multiple field access */ - if (PyDataType_HASFIELDS(self->descr) && + if (PyDataType_HASFIELDS(PyArray_DESCR(self)) && PySequence_Check(op) && !PyTuple_Check(op)) { int seqlen, i; @@ -610,7 +630,7 @@ array_subscript(PyArrayObject *self, PyObject *op) return (PyObject *)self; } - if (self->nd == 0) { + if (PyArray_NDIM(self) == 0) { if (op == Py_None) { return add_new_axes_0d(self, 1); } @@ -625,17 +645,17 @@ array_subscript(PyArrayObject *self, PyObject *op) return add_new_axes_0d(self, nd); } /* Allow Boolean mask selection also */ - if ((PyArray_Check(op) && (PyArray_DIMS(op)==0) - && PyArray_ISBOOL(op))) { + if ((PyArray_Check(op) && (PyArray_DIMS((PyArrayObject *)op)==0) + && PyArray_ISBOOL((PyArrayObject *)op))) { if (PyObject_IsTrue(op)) { Py_INCREF(self); return (PyObject *)self; } else { intp oned = 0; - Py_INCREF(self->descr); + Py_INCREF(PyArray_DESCR(self)); return PyArray_NewFromDescr(Py_TYPE(self), - self->descr, + PyArray_DESCR(self), 1, &oned, NULL, NULL, NPY_ARRAY_DEFAULT, @@ -650,7 +670,7 @@ array_subscript(PyArrayObject *self, PyObject *op) if (fancy != SOBJ_NOTFANCY) { int oned; - oned = ((self->nd == 1) && + oned = ((PyArray_NDIM(self) == 1) && !(PyTuple_Check(op) && PyTuple_GET_SIZE(op) > 1)); /* wrap arguments into a mapiter object */ @@ -731,8 +751,8 @@ array_ass_sub_simple(PyArrayObject *self, PyObject *index, PyObject *op) tmp = (PyArrayObject *)tmp0; } - if (PyArray_ISOBJECT(self) && (tmp->nd == 0)) { - ret = tmp->descr->f->setitem(op, tmp->data, tmp); + if (PyArray_ISOBJECT(self) && (PyArray_NDIM(tmp) == 0)) { + ret = PyArray_DESCR(tmp)->f->setitem(op, PyArray_DATA(tmp), tmp); } else { ret = PyArray_CopyObject(tmp, op); @@ -754,7 +774,7 @@ _tuple_of_integers(PyObject *seq, intp *vals, int maxvals) for(i=0; i<maxvals; i++) { obj = PyTuple_GET_ITEM(seq, i); - if ((PyArray_Check(obj) && PyArray_NDIM(obj) > 0) + if ((PyArray_Check(obj) && PyArray_NDIM((PyArrayObject *)obj) > 0) || PyList_Check(obj)) { return -1; } @@ -800,10 +820,10 @@ array_ass_sub(PyArrayObject *self, PyObject *index, PyObject *op) } if (PyString_Check(index) || PyUnicode_Check(index)) { - if (PyDataType_HASFIELDS(self->descr)) { + if (PyDataType_HASFIELDS(PyArray_DESCR(self))) { PyObject *obj; - obj = PyDict_GetItem(self->descr->fields, index); + obj = PyDict_GetItem(PyArray_DESCR(self)->fields, index); if (obj != NULL) { PyArray_Descr *descr; int offset; @@ -841,7 +861,7 @@ array_ass_sub(PyArrayObject *self, PyObject *index, PyObject *op) } } - if (self->nd == 0) { + if (PyArray_NDIM(self) == 0) { /* * Several different exceptions to the 0-d no-indexing rule * @@ -853,13 +873,14 @@ array_ass_sub(PyArrayObject *self, PyObject *index, PyObject *op) if (index == Py_None || (PyTuple_Check(index) && (0 == PyTuple_GET_SIZE(index) || count_new_axes_0d(index) > 0))) { - return self->descr->f->setitem(op, self->data, self); + return PyArray_DESCR(self)->f->setitem(op, PyArray_DATA(self), self); } if (PyBool_Check(index) || PyArray_IsScalar(index, Bool) || - (PyArray_Check(index) && (PyArray_DIMS(index)==0) && - PyArray_ISBOOL(index))) { + (PyArray_Check(index) && + (PyArray_DIMS((PyArrayObject *)index)==0) && + PyArray_ISBOOL((PyArrayObject *)index))) { if (PyObject_IsTrue(index)) { - return self->descr->f->setitem(op, self->data, self); + return PyArray_DESCR(self)->f->setitem(op, PyArray_DATA(self), self); } else { /* don't do anything */ return 0; @@ -870,31 +891,31 @@ array_ass_sub(PyArrayObject *self, PyObject *index, PyObject *op) } /* Integer-tuple */ - if (PyTuple_Check(index) && (PyTuple_GET_SIZE(index) == self->nd) - && (_tuple_of_integers(index, vals, self->nd) >= 0)) { + if (PyTuple_Check(index) && (PyTuple_GET_SIZE(index) == PyArray_NDIM(self)) + && (_tuple_of_integers(index, vals, PyArray_NDIM(self)) >= 0)) { int i; char *item; - for (i = 0; i < self->nd; i++) { + for (i = 0; i < PyArray_NDIM(self); i++) { if (vals[i] < 0) { - vals[i] += self->dimensions[i]; + vals[i] += PyArray_DIMS(self)[i]; } - if ((vals[i] < 0) || (vals[i] >= self->dimensions[i])) { + if ((vals[i] < 0) || (vals[i] >= PyArray_DIMS(self)[i])) { PyErr_Format(PyExc_IndexError, "index (%"INTP_FMT") out of range "\ "(0<=index<%"INTP_FMT") in dimension %d", - vals[i], self->dimensions[i], i); + vals[i], PyArray_DIMS(self)[i], i); return -1; } } item = PyArray_GetPtr(self, vals); - return self->descr->f->setitem(op, item, self); + return PyArray_DESCR(self)->f->setitem(op, item, self); } PyErr_Clear(); fancy = fancy_indexing_check(index); if (fancy != SOBJ_NOTFANCY) { - oned = ((self->nd == 1) && + oned = ((PyArray_NDIM(self) == 1) && !(PyTuple_Check(index) && PyTuple_GET_SIZE(index) > 1)); mit = (PyArrayMapIterObject *) PyArray_MapIterNew(index, oned, fancy); if (mit == NULL) { @@ -951,26 +972,26 @@ array_subscript_nice(PyArrayObject *self, PyObject *op) } } /* optimization for a tuple of integers */ - if (self->nd > 1 && PyTuple_Check(op) && - (PyTuple_GET_SIZE(op) == self->nd) - && (_tuple_of_integers(op, vals, self->nd) >= 0)) { + if (PyArray_NDIM(self) > 1 && PyTuple_Check(op) && + (PyTuple_GET_SIZE(op) == PyArray_NDIM(self)) + && (_tuple_of_integers(op, vals, PyArray_NDIM(self)) >= 0)) { int i; char *item; - for (i = 0; i < self->nd; i++) { + for (i = 0; i < PyArray_NDIM(self); i++) { if (vals[i] < 0) { - vals[i] += self->dimensions[i]; + vals[i] += PyArray_DIMS(self)[i]; } - if ((vals[i] < 0) || (vals[i] >= self->dimensions[i])) { + if ((vals[i] < 0) || (vals[i] >= PyArray_DIMS(self)[i])) { PyErr_Format(PyExc_IndexError, "index (%"INTP_FMT") out of range "\ "(0<=index<%"INTP_FMT") in dimension %d", - vals[i], self->dimensions[i], i); + vals[i], PyArray_DIMS(self)[i], i); return NULL; } } item = PyArray_GetPtr(self, vals); - return PyArray_Scalar(item, self->descr, (PyObject *)self); + return PyArray_Scalar(item, PyArray_DESCR(self), (PyObject *)self); } PyErr_Clear(); @@ -993,14 +1014,15 @@ array_subscript_nice(PyArrayObject *self, PyObject *op) Py_XDECREF(mp); return NULL; } - if (PyArray_Check(mp) && mp->nd == 0) { + if (PyArray_Check(mp) && PyArray_NDIM(mp) == 0) { Bool noellipses = TRUE; if ((op == Py_Ellipsis) || PyString_Check(op) || PyUnicode_Check(op)) { noellipses = FALSE; } else if (PyBool_Check(op) || PyArray_IsScalar(op, Bool) || - (PyArray_Check(op) && (PyArray_DIMS(op)==0) && - PyArray_ISBOOL(op))) { + (PyArray_Check(op) && + (PyArray_DIMS((PyArrayObject *)op)==0) && + PyArray_ISBOOL((PyArrayObject *)op))) { noellipses = FALSE; } else if (PySequence_Check(op)) { @@ -1020,7 +1042,7 @@ array_subscript_nice(PyArrayObject *self, PyObject *op) } if (noellipses) { PyObject *ret; - ret = PyArray_ToScalar(mp->data, mp); + ret = PyArray_ToScalar(PyArray_DATA(mp), mp); Py_DECREF(mp); return ret; } @@ -1071,12 +1093,12 @@ _nonzero_indices(PyObject *myBool, PyArrayIterObject **iters) if (ba == NULL) { return -1; } - nd = ba->nd; + nd = PyArray_NDIM(ba); for (j = 0; j < nd; j++) { iters[j] = NULL; } size = PyArray_SIZE(ba); - ptr = (Bool *)ba->data; + ptr = (Bool *)PyArray_DATA(ba); count = 0; /* pre-determine how many nonzero entries there are */ @@ -1100,11 +1122,11 @@ _nonzero_indices(PyObject *myBool, PyArrayIterObject **iters) if (iters[j] == NULL) { goto fail; } - dptr[j] = (intp *)iters[j]->ao->data; + dptr[j] = (intp *)PyArray_DATA(iters[j]->ao); coords[j] = 0; - dims_m1[j] = ba->dimensions[j]-1; + dims_m1[j] = PyArray_DIMS(ba)[j]-1; } - ptr = (Bool *)ba->data; + ptr = (npy_bool *)PyArray_DATA(ba); if (count == 0) { goto finish; } @@ -1157,7 +1179,7 @@ _convert_obj(PyObject *obj, PyArrayIterObject **iter) if (PySlice_Check(obj) || (obj == Py_Ellipsis)) { return 0; } - else if (PyArray_Check(obj) && PyArray_ISBOOL(obj)) { + else if (PyArray_Check(obj) && PyArray_ISBOOL((PyArrayObject *)obj)) { return _nonzero_indices(obj, iter); } else { @@ -1185,10 +1207,10 @@ PyArray_MapIterReset(PyArrayMapIterObject *mit) mit->index = 0; - copyswap = mit->iters[0]->ao->descr->f->copyswap; + copyswap = PyArray_DESCR(mit->iters[0]->ao)->f->copyswap; if (mit->subspace != NULL) { - memcpy(coord, mit->bscoord, sizeof(intp)*mit->ait->ao->nd); + memcpy(coord, mit->bscoord, sizeof(intp)*PyArray_NDIM(mit->ait->ao)); PyArray_ITER_RESET(mit->subspace); for (i = 0; i < mit->numiter; i++) { it = mit->iters[i]; @@ -1235,13 +1257,14 @@ PyArray_MapIterNext(PyArrayMapIterObject *mit) if (mit->index >= mit->size) { return; } - copyswap = mit->iters[0]->ao->descr->f->copyswap; + copyswap = PyArray_DESCR(mit->iters[0]->ao)->f->copyswap; /* Sub-space iteration */ if (mit->subspace != NULL) { PyArray_ITER_NEXT(mit->subspace); if (mit->subspace->index >= mit->subspace->size) { /* reset coord to coordinates of beginning of the subspace */ - memcpy(coord, mit->bscoord, sizeof(intp)*mit->ait->ao->nd); + memcpy(coord, mit->bscoord, + sizeof(intp)*PyArray_NDIM(mit->ait->ao)); PyArray_ITER_RESET(mit->subspace); for (i = 0; i < mit->numiter; i++) { it = mit->iters[i]; @@ -1277,7 +1300,7 @@ PyArray_MapIterNext(PyArrayMapIterObject *mit) * 2) Create subspace iterator * 3) Update nd, dimensions, and size. * - * Subspace iteration is necessary if: arr->nd > mit->numiter + * Subspace iteration is necessary if: PyArray_NDIM(arr) > mit->numiter * * Need to check for index-errors somewhere. * @@ -1294,7 +1317,7 @@ PyArray_MapIterBind(PyArrayMapIterObject *mit, PyArrayObject *arr) intp dimsize; intp *indptr; - subnd = arr->nd - mit->numiter; + subnd = PyArray_NDIM(arr) - mit->numiter; if (subnd < 0) { PyErr_SetString(PyExc_ValueError, "too many indices for array"); @@ -1307,7 +1330,7 @@ PyArray_MapIterBind(PyArrayMapIterObject *mit, PyArrayObject *arr) } /* no subspace iteration needed. Finish up and Return */ if (subnd == 0) { - n = arr->nd; + n = PyArray_NDIM(arr); for (i = 0; i < n; i++) { mit->iteraxes[i] = i; } @@ -1343,9 +1366,9 @@ PyArray_MapIterBind(PyArrayMapIterObject *mit, PyArrayObject *arr) goto fail; } /* Expand dimensions of result */ - n = mit->subspace->ao->nd; + n = PyArray_NDIM(mit->subspace->ao); for (i = 0; i < n; i++) { - mit->dimensions[mit->nd+i] = mit->subspace->ao->dimensions[i]; + mit->dimensions[mit->nd+i] = PyArray_DIMS(mit->subspace->ao)[i]; } mit->nd += n; @@ -1355,7 +1378,7 @@ PyArray_MapIterBind(PyArrayMapIterObject *mit, PyArrayObject *arr) */ n = PyTuple_GET_SIZE(mit->indexobj); /* The number of dimensions an ellipsis takes up */ - ellipexp = arr->nd - n + 1; + ellipexp = PyArray_NDIM(arr) - n + 1; /* * Now fill in iteraxes -- remember indexing arrays have been * converted to 0's in mit->indexobj @@ -1364,7 +1387,7 @@ PyArray_MapIterBind(PyArrayMapIterObject *mit, PyArrayObject *arr) j = 0; /* Only expand the first ellipsis */ noellip = 1; - memset(mit->bscoord, 0, sizeof(intp)*arr->nd); + memset(mit->bscoord, 0, sizeof(intp)*PyArray_NDIM(arr)); for (i = 0; i < n; i++) { /* * We need to fill in the starting coordinates for @@ -1387,7 +1410,7 @@ PyArray_MapIterBind(PyArrayMapIterObject *mit, PyArrayObject *arr) } else if (!PySlice_Check(obj) || (slice_GetIndices((PySliceObject *)obj, - arr->dimensions[curraxis], + PyArray_DIMS(arr)[curraxis], &start, &stop, &step, &dimsize) < 0)) { PyErr_Format(PyExc_ValueError, @@ -1421,7 +1444,7 @@ PyArray_MapIterBind(PyArrayMapIterObject *mit, PyArrayObject *arr) intp indval; it = mit->iters[i]; PyArray_ITER_RESET(it); - dimsize = arr->dimensions[mit->iteraxes[i]]; + dimsize = PyArray_DIMS(arr)[mit->iteraxes[i]]; while (it->index < it->size) { indptr = ((intp *)it->dataptr); indval = *indptr; @@ -1455,7 +1478,7 @@ PyArray_MapIterNew(PyObject *indexobj, int oned, int fancy) { PyArrayMapIterObject *mit; PyArray_Descr *indtype; - PyObject *arr = NULL; + PyArrayObject *arr = NULL; int i, n, started, nonindex; if (fancy == SOBJ_BADARRAY) { @@ -1512,7 +1535,8 @@ PyArray_MapIterNew(PyObject *indexobj, int oned, int fancy) */ /* convert all inputs to iterators */ - if (PyArray_Check(indexobj) && (PyArray_TYPE(indexobj) == PyArray_BOOL)) { + if (PyArray_Check(indexobj) && + (PyArray_TYPE((PyArrayObject *)indexobj) == NPY_BOOL)) { mit->numiter = _nonzero_indices(indexobj, mit->iters); if (mit->numiter < 0) { goto fail; @@ -1532,12 +1556,12 @@ PyArray_MapIterNew(PyObject *indexobj, int oned, int fancy) else if (PyArray_Check(indexobj) || !PyTuple_Check(indexobj)) { mit->numiter = 1; indtype = PyArray_DescrFromType(NPY_INTP); - arr = PyArray_FromAny(indexobj, indtype, 0, 0, + arr = (PyArrayObject *)PyArray_FromAny(indexobj, indtype, 0, 0, NPY_ARRAY_FORCECAST, NULL); if (arr == NULL) { goto fail; } - mit->iters[0] = (PyArrayIterObject *)PyArray_IterNew(arr); + mit->iters[0] = (PyArrayIterObject *)PyArray_IterNew((PyObject *)arr); if (mit->iters[0] == NULL) { Py_DECREF(arr); goto fail; diff --git a/numpy/core/src/multiarray/methods.c b/numpy/core/src/multiarray/methods.c index 68f697a4d..28fb8f8cf 100644 --- a/numpy/core/src/multiarray/methods.c +++ b/numpy/core/src/multiarray/methods.c @@ -290,26 +290,29 @@ PyArray_GetField(PyArrayObject *self, PyArray_Descr *typed, int offset) { PyObject *ret = NULL; - if (offset < 0 || (offset + typed->elsize) > self->descr->elsize) { + if (offset < 0 || (offset + typed->elsize) > PyArray_DESCR(self)->elsize) { PyErr_Format(PyExc_ValueError, "Need 0 <= offset <= %d for requested type " \ "but received offset = %d", - self->descr->elsize-typed->elsize, offset); + PyArray_DESCR(self)->elsize-typed->elsize, offset); Py_DECREF(typed); return NULL; } ret = PyArray_NewFromDescr(Py_TYPE(self), typed, - self->nd, self->dimensions, - self->strides, - self->data + offset, - self->flags&(~NPY_ARRAY_F_CONTIGUOUS), + PyArray_NDIM(self), PyArray_DIMS(self), + PyArray_STRIDES(self), + PyArray_DATA(self) + offset, + PyArray_FLAGS(self)&(~NPY_ARRAY_F_CONTIGUOUS), (PyObject *)self); if (ret == NULL) { return NULL; } Py_INCREF(self); - ((PyArrayObject *)ret)->base = (PyObject *)self; + if (PyArray_SetBaseObject(((PyArrayObject *)ret), (PyObject *)self) < 0) { + Py_DECREF(ret); + return NULL; + } PyArray_UpdateFlags((PyArrayObject *)ret, NPY_ARRAY_UPDATE_ALL); return ret; @@ -344,23 +347,21 @@ PyArray_SetField(PyArrayObject *self, PyArray_Descr *dtype, PyObject *ret = NULL; int retval = 0; - if (offset < 0 || (offset + dtype->elsize) > self->descr->elsize) { + if (offset < 0 || (offset + dtype->elsize) > PyArray_DESCR(self)->elsize) { PyErr_Format(PyExc_ValueError, "Need 0 <= offset <= %d for requested type " \ "but received offset = %d", - self->descr->elsize-dtype->elsize, offset); + PyArray_DESCR(self)->elsize-dtype->elsize, offset); Py_DECREF(dtype); return -1; } ret = PyArray_NewFromDescr(Py_TYPE(self), - dtype, self->nd, self->dimensions, - self->strides, self->data + offset, - self->flags, (PyObject *)self); + dtype, PyArray_NDIM(self), PyArray_DIMS(self), + PyArray_STRIDES(self), PyArray_DATA(self) + offset, + PyArray_FLAGS(self), (PyObject *)self); if (ret == NULL) { return -1; } - Py_INCREF(self); - ((PyArrayObject *)ret)->base = (PyObject *)self; PyArray_UpdateFlags((PyArrayObject *)ret, NPY_ARRAY_UPDATE_ALL); retval = PyArray_CopyObject((PyArrayObject *)ret, val); @@ -410,7 +411,7 @@ PyArray_Byteswap(PyArrayObject *self, Bool inplace) PyArray_CopySwapNFunc *copyswapn; PyArrayIterObject *it; - copyswapn = self->descr->f->copyswapn; + copyswapn = PyArray_DESCR(self)->f->copyswapn; if (inplace) { if (!PyArray_ISWRITEABLE(self)) { PyErr_SetString(PyExc_RuntimeError, @@ -420,15 +421,15 @@ PyArray_Byteswap(PyArrayObject *self, Bool inplace) } size = PyArray_SIZE(self); if (PyArray_ISONESEGMENT(self)) { - copyswapn(self->data, self->descr->elsize, NULL, -1, size, 1, self); + copyswapn(PyArray_DATA(self), PyArray_DESCR(self)->elsize, NULL, -1, size, 1, self); } else { /* Use iterator */ int axis = -1; intp stride; it = (PyArrayIterObject *) \ PyArray_IterAllButAxis((PyObject *)self, &axis); - stride = self->strides[axis]; - size = self->dimensions[axis]; + stride = PyArray_STRIDES(self)[axis]; + size = PyArray_DIMS(self)[axis]; while (it->index < it->size) { copyswapn(it->dataptr, stride, NULL, -1, size, 1, self); PyArray_ITER_NEXT(it); @@ -549,8 +550,8 @@ array_toscalar(PyArrayObject *self, PyObject *args) { } if (n == 0) { - if (self->nd == 0 || PyArray_SIZE(self) == 1) - return self->descr->f->getitem(self->data, self); + if (PyArray_NDIM(self) == 0 || PyArray_SIZE(self) == 1) + return PyArray_DESCR(self)->f->getitem(PyArray_DATA(self), self); else { PyErr_SetString(PyExc_ValueError, "can only convert an array " \ @@ -558,7 +559,7 @@ array_toscalar(PyArrayObject *self, PyObject *args) { return NULL; } } - else if (n != self->nd && (n > 1 || self->nd == 0)) { + else if (n != PyArray_NDIM(self) && (n > 1 || PyArray_NDIM(self) == 0)) { PyErr_SetString(PyExc_ValueError, "incorrect number of indices for " \ "array"); @@ -579,25 +580,25 @@ array_toscalar(PyArrayObject *self, PyObject *args) { "index out of bounds"); return NULL; } - if (self->nd == 1) { - value *= self->strides[0]; - return self->descr->f->getitem(self->data + value, + if (PyArray_NDIM(self) == 1) { + value *= PyArray_STRIDES(self)[0]; + return PyArray_DESCR(self)->f->getitem(PyArray_DATA(self) + value, self); } - nd = self->nd; + nd = PyArray_NDIM(self); factor = 1; while (nd--) { factors[nd] = factor; - factor *= self->dimensions[nd]; + factor *= PyArray_DIMS(self)[nd]; } loc = 0; - for (nd = 0; nd < self->nd; nd++) { + for (nd = 0; nd < PyArray_NDIM(self); nd++) { index = value / factors[nd]; value = value % factors[nd]; - loc += self->strides[nd]*index; + loc += PyArray_STRIDES(self)[nd]*index; } - return self->descr->f->getitem(self->data + loc, + return PyArray_DESCR(self)->f->getitem(PyArray_DATA(self) + loc, self); } @@ -610,17 +611,17 @@ array_toscalar(PyArrayObject *self, PyObject *args) { loc = 0; while (nd--) { if (index[nd] < 0) { - index[nd] += self->dimensions[nd]; + index[nd] += PyArray_DIMS(self)[nd]; } if (index[nd] < 0 || - index[nd] >= self->dimensions[nd]) { + index[nd] >= PyArray_DIMS(self)[nd]) { PyErr_SetString(PyExc_ValueError, "index out of bounds"); return NULL; } - loc += self->strides[nd]*index[nd]; + loc += PyArray_STRIDES(self)[nd]*index[nd]; } - return self->descr->f->getitem(self->data + loc, self); + return PyArray_DESCR(self)->f->getitem(PyArray_DATA(self) + loc, self); } } @@ -638,8 +639,8 @@ array_setscalar(PyArrayObject *self, PyObject *args) { } obj = PyTuple_GET_ITEM(args, n); if (n == 0) { - if (self->nd == 0 || PyArray_SIZE(self) == 1) { - ret = self->descr->f->setitem(obj, self->data, self); + if (PyArray_NDIM(self) == 0 || PyArray_SIZE(self) == 1) { + ret = PyArray_DESCR(self)->f->setitem(obj, PyArray_DATA(self), self); } else { PyErr_SetString(PyExc_ValueError, @@ -648,7 +649,7 @@ array_setscalar(PyArrayObject *self, PyObject *args) { return NULL; } } - else if (n != self->nd && (n > 1 || self->nd == 0)) { + else if (n != PyArray_NDIM(self) && (n > 1 || PyArray_NDIM(self) == 0)) { PyErr_SetString(PyExc_ValueError, "incorrect number of indices for " \ "array"); @@ -689,26 +690,26 @@ array_setscalar(PyArrayObject *self, PyObject *args) { "index out of bounds"); return NULL; } - if (self->nd == 1) { - value *= self->strides[0]; - ret = self->descr->f->setitem(obj, self->data + value, + if (PyArray_NDIM(self) == 1) { + value *= PyArray_STRIDES(self)[0]; + ret = PyArray_DESCR(self)->f->setitem(obj, PyArray_DATA(self) + value, self); goto finish; } - nd = self->nd; + nd = PyArray_NDIM(self); factor = 1; while (nd--) { factors[nd] = factor; - factor *= self->dimensions[nd]; + factor *= PyArray_DIMS(self)[nd]; } loc = 0; - for (nd = 0; nd < self->nd; nd++) { + for (nd = 0; nd < PyArray_NDIM(self); nd++) { index = value / factors[nd]; value = value % factors[nd]; - loc += self->strides[nd]*index; + loc += PyArray_STRIDES(self)[nd]*index; } - ret = self->descr->f->setitem(obj, self->data + loc, self); + ret = PyArray_DESCR(self)->f->setitem(obj, PyArray_DATA(self) + loc, self); } else { intp loc, index[MAX_DIMS]; @@ -722,17 +723,17 @@ array_setscalar(PyArrayObject *self, PyObject *args) { loc = 0; while (nd--) { if (index[nd] < 0) { - index[nd] += self->dimensions[nd]; + index[nd] += PyArray_DIMS(self)[nd]; } if (index[nd] < 0 || - index[nd] >= self->dimensions[nd]) { + index[nd] >= PyArray_DIMS(self)[nd]) { PyErr_SetString(PyExc_ValueError, "index out of bounds"); return NULL; } - loc += self->strides[nd]*index[nd]; + loc += PyArray_STRIDES(self)[nd]*index[nd]; } - ret = self->descr->f->setitem(obj, self->data + loc, self); + ret = PyArray_DESCR(self)->f->setitem(obj, PyArray_DATA(self) + loc, self); } finish: @@ -878,28 +879,30 @@ array_astype(PyArrayObject *self, PyObject *args, PyObject *kwds) static PyObject * array_wraparray(PyArrayObject *self, PyObject *args) { - PyObject *arr; - PyObject *ret; + PyArrayObject *arr, *ret; + PyObject *obj; if (PyTuple_Size(args) < 1) { PyErr_SetString(PyExc_TypeError, "only accepts 1 argument"); return NULL; } - arr = PyTuple_GET_ITEM(args, 0); - if (arr == NULL) { + obj = PyTuple_GET_ITEM(args, 0); + if (obj == NULL) { return NULL; } - if (!PyArray_Check(arr)) { + if (!PyArray_Check(obj)) { PyErr_SetString(PyExc_TypeError, "can only be called with ndarray object"); return NULL; } + arr = (PyArrayObject *)obj; if (Py_TYPE(self) != Py_TYPE(arr)){ - Py_INCREF(PyArray_DESCR(arr)); - ret = PyArray_NewFromDescr(Py_TYPE(self), - PyArray_DESCR(arr), + PyArray_Descr *dtype = PyArray_DESCR(arr); + Py_INCREF(dtype); + ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self), + dtype, PyArray_NDIM(arr), PyArray_DIMS(arr), PyArray_STRIDES(arr), PyArray_DATA(arr), @@ -907,13 +910,16 @@ array_wraparray(PyArrayObject *self, PyObject *args) if (ret == NULL) { return NULL; } - Py_INCREF(arr); - PyArray_BASE(ret) = arr; - return ret; + Py_INCREF(obj); + if (PyArray_SetBaseObject(ret, obj) < 0) { + Py_DECREF(ret); + return NULL; + } + return (PyObject *)ret; } else { /*The type was set in __array_prepare__*/ Py_INCREF(arr); - return arr; + return (PyObject *)arr; } } @@ -921,30 +927,33 @@ array_wraparray(PyArrayObject *self, PyObject *args) static PyObject * array_preparearray(PyArrayObject *self, PyObject *args) { - PyObject *arr; - PyObject *ret; + PyObject *obj; + PyArrayObject *arr, *ret; + PyArray_Descr *dtype; if (PyTuple_Size(args) < 1) { PyErr_SetString(PyExc_TypeError, "only accepts 1 argument"); return NULL; } - arr = PyTuple_GET_ITEM(args, 0); - if (!PyArray_Check(arr)) { + obj = PyTuple_GET_ITEM(args, 0); + if (!PyArray_Check(obj)) { PyErr_SetString(PyExc_TypeError, "can only be called with ndarray object"); return NULL; } + arr = (PyArrayObject *)obj; if (Py_TYPE(self) == Py_TYPE(arr)) { /* No need to create a new view */ Py_INCREF(arr); - return arr; + return (PyObject *)arr; } - Py_INCREF(PyArray_DESCR(arr)); - ret = PyArray_NewFromDescr(Py_TYPE(self), - PyArray_DESCR(arr), + dtype = PyArray_DESCR(arr); + Py_INCREF(dtype); + ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self), + dtype, PyArray_NDIM(arr), PyArray_DIMS(arr), PyArray_STRIDES(arr), PyArray_DATA(arr), @@ -953,8 +962,11 @@ array_preparearray(PyArrayObject *self, PyObject *args) return NULL; } Py_INCREF(arr); - PyArray_BASE(ret) = arr; - return ret; + if (PyArray_SetBaseObject(ret, (PyObject *)arr) < 0) { + Py_DECREF(ret); + return NULL; + } + return (PyObject *)ret; } @@ -972,7 +984,7 @@ array_getarray(PyArrayObject *self, PyObject *args) /* convert to PyArray_Type */ if (!PyArray_CheckExact(self)) { - PyObject *new; + PyArrayObject *new; PyTypeObject *subtype = &PyArray_Type; if (!PyType_IsSubtype(Py_TYPE(self), &PyArray_Type)) { @@ -980,7 +992,7 @@ array_getarray(PyArrayObject *self, PyObject *args) } Py_INCREF(PyArray_DESCR(self)); - new = PyArray_NewFromDescr(subtype, + new = (PyArrayObject *)PyArray_NewFromDescr(subtype, PyArray_DESCR(self), PyArray_NDIM(self), PyArray_DIMS(self), @@ -991,15 +1003,14 @@ array_getarray(PyArrayObject *self, PyObject *args) return NULL; } Py_INCREF(self); - PyArray_BASE(new) = (PyObject *)self; - self = (PyArrayObject *)new; + PyArray_SetBaseObject(new, (PyObject *)self); + self = new; } else { Py_INCREF(self); } - if ((newtype == NULL) || - PyArray_EquivTypes(self->descr, newtype)) { + if ((newtype == NULL) || PyArray_EquivTypes(PyArray_DESCR(self), newtype)) { return (PyObject *)self; } else { @@ -1132,7 +1143,7 @@ array_sort(PyArrayObject *self, PyObject *args, PyObject *kwds) if (order != NULL) { PyObject *new_name; PyObject *_numpy_internal; - saved = self->descr; + saved = PyArray_DESCR(self); if (!PyDataType_HASFIELDS(saved)) { PyErr_SetString(PyExc_ValueError, "Cannot specify " \ "order when the array has no fields."); @@ -1150,13 +1161,13 @@ array_sort(PyArrayObject *self, PyObject *args, PyObject *kwds) } newd = PyArray_DescrNew(saved); newd->names = new_name; - self->descr = newd; + ((PyArrayObject_fieldaccess *)self)->descr = newd; } val = PyArray_Sort(self, axis, sortkind); if (order != NULL) { - Py_XDECREF(self->descr); - self->descr = saved; + Py_XDECREF(PyArray_DESCR(self)); + ((PyArrayObject_fieldaccess *)self)->descr = saved; } if (val < 0) { return NULL; @@ -1186,7 +1197,7 @@ array_argsort(PyArrayObject *self, PyObject *args, PyObject *kwds) if (order != NULL) { PyObject *new_name; PyObject *_numpy_internal; - saved = self->descr; + saved = PyArray_DESCR(self); if (!PyDataType_HASFIELDS(saved)) { PyErr_SetString(PyExc_ValueError, "Cannot specify " \ "order when the array has no fields."); @@ -1204,13 +1215,13 @@ array_argsort(PyArrayObject *self, PyObject *args, PyObject *kwds) } newd = PyArray_DescrNew(saved); newd->names = new_name; - self->descr = newd; + ((PyArrayObject_fieldaccess *)self)->descr = newd; } res = PyArray_ArgSort(self, axis, sortkind); if (order != NULL) { - Py_XDECREF(self->descr); - self->descr = saved; + Py_XDECREF(PyArray_DESCR(self)); + ((PyArrayObject_fieldaccess *)self)->descr = saved; } return _ARET(res); } @@ -1276,13 +1287,14 @@ array_deepcopy(PyArrayObject *self, PyObject *args) PyObject* visit; char *optr; PyArrayIterObject *it; - PyObject *copy, *ret, *deepcopy; + PyObject *copy, *deepcopy; + PyArrayObject *ret; if (!PyArg_ParseTuple(args, "O", &visit)) { return NULL; } - ret = PyArray_Copy(self); - if (PyDataType_REFCHK(self->descr)) { + ret = (PyArrayObject *)PyArray_Copy(self); + if (PyDataType_REFCHK(PyArray_DESCR(self))) { copy = PyImport_ImportModule("copy"); if (copy == NULL) { return NULL; @@ -1299,14 +1311,14 @@ array_deepcopy(PyArrayObject *self, PyObject *args) } optr = PyArray_DATA(ret); while(it->index < it->size) { - _deepcopy_call(it->dataptr, optr, self->descr, deepcopy, visit); - optr += self->descr->elsize; + _deepcopy_call(it->dataptr, optr, PyArray_DESCR(self), deepcopy, visit); + optr += PyArray_DESCR(self)->elsize; PyArray_ITER_NEXT(it); } Py_DECREF(deepcopy); Py_DECREF(it); } - return _ARET(ret); + return PyArray_Return(ret); } /* Convert Array to flat list (using getitem) */ @@ -1318,7 +1330,7 @@ _getlist_pkl(PyArrayObject *self) PyObject *list; PyArray_GetItemFunc *getitem; - getitem = self->descr->f->getitem; + getitem = PyArray_DESCR(self)->f->getitem; iter = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self); if (iter == NULL) { return NULL; @@ -1344,7 +1356,7 @@ _setlist_pkl(PyArrayObject *self, PyObject *list) PyArrayIterObject *iter = NULL; PyArray_SetItemFunc *setitem; - setitem = self->descr->f->setitem; + setitem = PyArray_DESCR(self)->f->setitem; iter = (PyArrayIterObject *)PyArray_IterNew((PyObject *)self); if (iter == NULL) { return -1; @@ -1416,13 +1428,13 @@ array_reduce(PyArrayObject *self, PyObject *NPY_UNUSED(args)) PyTuple_SET_ITEM(state, 0, PyInt_FromLong(version)); PyTuple_SET_ITEM(state, 1, PyObject_GetAttrString((PyObject *)self, "shape")); - descr = self->descr; + descr = PyArray_DESCR(self); Py_INCREF(descr); PyTuple_SET_ITEM(state, 2, (PyObject *)descr); mybool = (PyArray_ISFORTRAN(self) ? Py_True : Py_False); Py_INCREF(mybool); PyTuple_SET_ITEM(state, 3, mybool); - if (PyDataType_FLAGCHK(self->descr, NPY_LIST_PICKLE)) { + if (PyDataType_FLAGCHK(PyArray_DESCR(self), NPY_LIST_PICKLE)) { thestr = _getlist_pkl(self); } else { @@ -1451,6 +1463,8 @@ array_setstate(PyArrayObject *self, PyObject *args) intp size, dimensions[MAX_DIMS]; int nd; + PyArrayObject_fieldaccess *fa = (PyArrayObject_fieldaccess *)self; + /* This will free any memory associated with a and use the string in setstate as the (writeable) memory. */ @@ -1481,19 +1495,19 @@ array_setstate(PyArrayObject *self, PyObject *args) return NULL; } - Py_XDECREF(self->descr); - self->descr = typecode; + Py_XDECREF(PyArray_DESCR(self)); + fa->descr = typecode; Py_INCREF(typecode); nd = PyArray_IntpFromSequence(shape, dimensions, MAX_DIMS); if (nd < 0) { return NULL; } size = PyArray_MultiplyList(dimensions, nd); - if (self->descr->elsize == 0) { + if (PyArray_DESCR(self)->elsize == 0) { PyErr_SetString(PyExc_ValueError, "Invalid data-type size."); return NULL; } - if (size < 0 || size > MAX_INTP / self->descr->elsize) { + if (size < 0 || size > MAX_INTP / PyArray_DESCR(self)->elsize) { PyErr_NoMemory(); return NULL; } @@ -1530,7 +1544,7 @@ array_setstate(PyArrayObject *self, PyObject *args) return NULL; } - if ((len != (self->descr->elsize * size))) { + if ((len != (PyArray_DESCR(self)->elsize * size))) { PyErr_SetString(PyExc_ValueError, "buffer size does not" \ " match array size"); @@ -1539,39 +1553,39 @@ array_setstate(PyArrayObject *self, PyObject *args) } } - if ((self->flags & NPY_ARRAY_OWNDATA)) { - if (self->data != NULL) { - PyDataMem_FREE(self->data); + if ((PyArray_FLAGS(self) & NPY_ARRAY_OWNDATA)) { + if (PyArray_DATA(self) != NULL) { + PyDataMem_FREE(PyArray_DATA(self)); } - self->flags &= ~NPY_ARRAY_OWNDATA; + PyArray_CLEARFLAGS(self, NPY_ARRAY_OWNDATA); } - Py_XDECREF(self->base); + Py_XDECREF(PyArray_BASE(self)); - self->flags &= ~NPY_ARRAY_UPDATEIFCOPY; + PyArray_CLEARFLAGS(self, NPY_ARRAY_UPDATEIFCOPY); - if (self->dimensions != NULL) { - PyDimMem_FREE(self->dimensions); - self->dimensions = NULL; + if (PyArray_DIMS(self) != NULL) { + PyDimMem_FREE(PyArray_DIMS(self)); + fa->dimensions = NULL; } - self->flags = NPY_ARRAY_DEFAULT; + fa->flags = NPY_ARRAY_DEFAULT; - self->nd = nd; + fa->nd = nd; if (nd > 0) { - self->dimensions = PyDimMem_NEW(nd * 2); - self->strides = self->dimensions + nd; - memcpy(self->dimensions, dimensions, sizeof(intp)*nd); - (void) _array_fill_strides(self->strides, dimensions, nd, - (size_t) self->descr->elsize, - (is_f_order ? NPY_ARRAY_F_CONTIGUOUS : - NPY_ARRAY_C_CONTIGUOUS), - &(self->flags)); + fa->dimensions = PyDimMem_NEW(nd * 2); + fa->strides = PyArray_DIMS(self) + nd; + memcpy(PyArray_DIMS(self), dimensions, sizeof(intp)*nd); + _array_fill_strides(PyArray_STRIDES(self), dimensions, nd, + PyArray_DESCR(self)->elsize, + (is_f_order ? NPY_ARRAY_F_CONTIGUOUS : + NPY_ARRAY_C_CONTIGUOUS), + &(fa->flags)); } if (!PyDataType_FLAGCHK(typecode, NPY_LIST_PICKLE)) { int swap=!PyArray_ISNOTSWAPPED(self); - self->data = datastr; + fa->data = datastr; #ifndef NPY_PY3K /* Check that the string is not interned */ if (!_IsAligned(self) || swap || PyString_CHECK_INTERNED(rawdata)) { @@ -1580,58 +1594,60 @@ array_setstate(PyArrayObject *self, PyObject *args) if (!_IsAligned(self) || swap) { #endif intp num = PyArray_NBYTES(self); - self->data = PyDataMem_NEW(num); - if (self->data == NULL) { - self->nd = 0; - PyDimMem_FREE(self->dimensions); + fa->data = PyDataMem_NEW(num); + if (PyArray_DATA(self) == NULL) { + fa->nd = 0; + PyDimMem_FREE(PyArray_DIMS(self)); Py_DECREF(rawdata); return PyErr_NoMemory(); } if (swap) { /* byte-swap on pickle-read */ - intp numels = num / self->descr->elsize; - self->descr->f->copyswapn(self->data, self->descr->elsize, - datastr, self->descr->elsize, - numels, 1, self); + intp numels = num / PyArray_DESCR(self)->elsize; + PyArray_DESCR(self)->f->copyswapn(PyArray_DATA(self), + PyArray_DESCR(self)->elsize, + datastr, PyArray_DESCR(self)->elsize, + numels, 1, self); if (!PyArray_ISEXTENDED(self)) { - self->descr = PyArray_DescrFromType(self->descr->type_num); + fa->descr = PyArray_DescrFromType( + PyArray_DESCR(self)->type_num); } else { - self->descr = PyArray_DescrNew(typecode); - if (self->descr->byteorder == PyArray_BIG) { - self->descr->byteorder = PyArray_LITTLE; + fa->descr = PyArray_DescrNew(typecode); + if (PyArray_DESCR(self)->byteorder == PyArray_BIG) { + PyArray_DESCR(self)->byteorder = PyArray_LITTLE; } - else if (self->descr->byteorder == PyArray_LITTLE) { - self->descr->byteorder = PyArray_BIG; + else if (PyArray_DESCR(self)->byteorder == PyArray_LITTLE) { + PyArray_DESCR(self)->byteorder = PyArray_BIG; } } Py_DECREF(typecode); } else { - memcpy(self->data, datastr, num); + memcpy(PyArray_DATA(self), datastr, num); } - self->flags |= NPY_ARRAY_OWNDATA; - self->base = NULL; + PyArray_ENABLEFLAGS(self, NPY_ARRAY_OWNDATA); + fa->base = NULL; Py_DECREF(rawdata); } else { - self->base = rawdata; + fa->base = rawdata; } } else { - self->data = PyDataMem_NEW(PyArray_NBYTES(self)); - if (self->data == NULL) { - self->nd = 0; - self->data = PyDataMem_NEW(self->descr->elsize); - if (self->dimensions) { - PyDimMem_FREE(self->dimensions); + fa->data = PyDataMem_NEW(PyArray_NBYTES(self)); + if (PyArray_DATA(self) == NULL) { + fa->nd = 0; + fa->data = PyDataMem_NEW(PyArray_DESCR(self)->elsize); + if (PyArray_DIMS(self)) { + PyDimMem_FREE(PyArray_DIMS(self)); } return PyErr_NoMemory(); } - if (PyDataType_FLAGCHK(self->descr, NPY_NEEDS_INIT)) { - memset(self->data, 0, PyArray_NBYTES(self)); + if (PyDataType_FLAGCHK(PyArray_DESCR(self), NPY_NEEDS_INIT)) { + memset(PyArray_DATA(self), 0, PyArray_NBYTES(self)); } - self->flags |= NPY_ARRAY_OWNDATA; - self->base = NULL; + PyArray_ENABLEFLAGS(self, NPY_ARRAY_OWNDATA); + fa->base = NULL; if (_setlist_pkl(self, rawdata) < 0) { return NULL; } @@ -1798,7 +1814,7 @@ array_mean(PyArrayObject *self, PyObject *args, PyObject *kwds) return NULL; } - num = _get_type_num_double(self->descr, dtype); + num = _get_type_num_double(PyArray_DESCR(self), dtype); Py_XDECREF(dtype); return PyArray_Mean(self, axis, num, out); } @@ -1967,7 +1983,7 @@ array_stddev(PyArrayObject *self, PyObject *args, PyObject *kwds) return NULL; } - num = _get_type_num_double(self->descr, dtype); + num = _get_type_num_double(PyArray_DESCR(self), dtype); Py_XDECREF(dtype); return __New_PyArray_Std(self, axis, num, out, 0, ddof); } @@ -1992,7 +2008,7 @@ array_variance(PyArrayObject *self, PyObject *args, PyObject *kwds) return NULL; } - num = _get_type_num_double(self->descr, dtype); + num = _get_type_num_double(PyArray_DESCR(self), dtype); Py_XDECREF(dtype); return __New_PyArray_Std(self, axis, num, out, 1, ddof); } @@ -2156,7 +2172,9 @@ array_setflags(PyArrayObject *self, PyObject *args, PyObject *kwds) PyObject *write = Py_None; PyObject *align = Py_None; PyObject *uic = Py_None; - int flagback = self->flags; + int flagback = PyArray_FLAGS(self); + + PyArrayObject_fieldaccess *fa = (PyArrayObject_fieldaccess *)self; if (!PyArg_ParseTupleAndKeywords(args, kwds, "|OOO", kwlist, &write, @@ -2166,10 +2184,10 @@ array_setflags(PyArrayObject *self, PyObject *args, PyObject *kwds) if (align != Py_None) { if (PyObject_Not(align)) { - self->flags &= ~NPY_ARRAY_ALIGNED; + PyArray_CLEARFLAGS(self, NPY_ARRAY_ALIGNED); } else if (_IsAligned(self)) { - self->flags |= NPY_ARRAY_ALIGNED; + PyArray_ENABLEFLAGS(self, NPY_ARRAY_ALIGNED); } else { PyErr_SetString(PyExc_ValueError, @@ -2181,34 +2199,36 @@ array_setflags(PyArrayObject *self, PyObject *args, PyObject *kwds) if (uic != Py_None) { if (PyObject_IsTrue(uic)) { - self->flags = flagback; + fa->flags = flagback; PyErr_SetString(PyExc_ValueError, "cannot set UPDATEIFCOPY " \ "flag to True"); return NULL; } else { - self->flags &= ~NPY_ARRAY_UPDATEIFCOPY; - Py_XDECREF(self->base); - self->base = NULL; + PyArray_CLEARFLAGS(self, NPY_ARRAY_UPDATEIFCOPY); + Py_XDECREF(fa->base); + fa->base = NULL; } } if (write != Py_None) { - if (PyObject_IsTrue(write)) + if (PyObject_IsTrue(write)) { if (_IsWriteable(self)) { - self->flags |= NPY_ARRAY_WRITEABLE; + PyArray_ENABLEFLAGS(self, NPY_ARRAY_WRITEABLE); } else { - self->flags = flagback; + fa->flags = flagback; PyErr_SetString(PyExc_ValueError, - "cannot set WRITEABLE " \ - "flag to True of this " \ - "array"); \ + "cannot set WRITEABLE " + "flag to True of this " + "array"); return NULL; } - else - self->flags &= ~NPY_ARRAY_WRITEABLE; + } + else { + PyArray_CLEARFLAGS(self, NPY_ARRAY_WRITEABLE); + } } Py_INCREF(Py_None); @@ -2226,7 +2246,7 @@ array_newbyteorder(PyArrayObject *self, PyObject *args) &endian)) { return NULL; } - new = PyArray_DescrNewByteorder(self->descr, endian); + new = PyArray_DescrNewByteorder(PyArray_DESCR(self), endian); if (!new) { return NULL; } diff --git a/numpy/core/src/multiarray/multiarray_tests.c.src b/numpy/core/src/multiarray/multiarray_tests.c.src index d6340025c..90c63ca44 100644 --- a/numpy/core/src/multiarray/multiarray_tests.c.src +++ b/numpy/core/src/multiarray/multiarray_tests.c.src @@ -1,3 +1,4 @@ +#define NPY_NO_DEPRECATED_API #include <Python.h> #include "numpy/ndarrayobject.h" @@ -28,15 +29,16 @@ static int copy_@type@(PyArrayIterObject *itx, PyArrayNeighborhoodIterObject *ni for (i = 0; i < itx->size; ++i) { PyArrayNeighborhoodIter_Reset(niterx); - for (j = 0; j < itx->ao->nd; ++j) { + for (j = 0; j < PyArray_NDIM(itx->ao); ++j) { odims[j] = bounds[2 * j + 1] - bounds[2 * j] + 1; } - aout = (PyArrayObject*)PyArray_SimpleNew(itx->ao->nd, odims, @typenum@); + aout = (PyArrayObject*)PyArray_SimpleNew( + PyArray_NDIM(itx->ao), odims, @typenum@); if (aout == NULL) { return -1; } - ptr = (@type@*)aout->data; + ptr = (@type@*)PyArray_DATA(aout); for (j = 0; j < niterx->size; ++j) { *ptr = *((@type@*)niterx->dataptr); @@ -60,7 +62,7 @@ static int copy_object(PyArrayIterObject *itx, PyArrayNeighborhoodIterObject *ni npy_intp i, j; npy_intp odims[NPY_MAXDIMS]; PyArrayObject *aout; - PyArray_CopySwapFunc *copyswap = itx->ao->descr->f->copyswap; + PyArray_CopySwapFunc *copyswap = PyArray_DESCR(itx->ao)->f->copyswap; npy_int itemsize = PyArray_ITEMSIZE(itx->ao); /* @@ -70,16 +72,16 @@ static int copy_object(PyArrayIterObject *itx, PyArrayNeighborhoodIterObject *ni for (i = 0; i < itx->size; ++i) { PyArrayNeighborhoodIter_Reset(niterx); - for (j = 0; j < itx->ao->nd; ++j) { + for (j = 0; j < PyArray_NDIM(itx->ao); ++j) { odims[j] = bounds[2 * j + 1] - bounds[2 * j] + 1; } - aout = (PyArrayObject*)PyArray_SimpleNew(itx->ao->nd, odims, NPY_OBJECT); + aout = (PyArrayObject*)PyArray_SimpleNew(PyArray_NDIM(itx->ao), odims, NPY_OBJECT); if (aout == NULL) { return -1; } for (j = 0; j < niterx->size; ++j) { - copyswap(aout->data + j * itemsize, niterx->dataptr, 0, NULL); + copyswap(PyArray_DATA(aout) + j * itemsize, niterx->dataptr, 0, NULL); PyArrayNeighborhoodIter_Next(niterx); } @@ -116,7 +118,7 @@ test_neighborhood_iterator(PyObject* NPY_UNUSED(self), PyObject* args) if (ax == NULL) { return NULL; } - if (PySequence_Size(b) != 2 * ax->nd) { + if (PySequence_Size(b) != 2 * PyArray_NDIM(ax)) { PyErr_SetString(PyExc_ValueError, "bounds sequence size not compatible with x input"); goto clean_ax; @@ -133,7 +135,7 @@ test_neighborhood_iterator(PyObject* NPY_UNUSED(self), PyObject* args) } /* Compute boundaries for the neighborhood iterator */ - for (i = 0; i < 2 * ax->nd; ++i) { + for (i = 0; i < 2 * PyArray_NDIM(ax); ++i) { PyObject* bound; bound = PySequence_GetItem(b, i); if (bounds == NULL) { @@ -220,15 +222,16 @@ copy_double_double(PyArrayNeighborhoodIterObject *itx, */ PyArrayNeighborhoodIter_Reset(itx); for (i = 0; i < itx->size; ++i) { - for (j = 0; j < itx->ao->nd; ++j) { + for (j = 0; j < PyArray_NDIM(itx->ao); ++j) { odims[j] = bounds[2 * j + 1] - bounds[2 * j] + 1; } - aout = (PyArrayObject*)PyArray_SimpleNew(itx->ao->nd, odims, NPY_DOUBLE); + aout = (PyArrayObject*)PyArray_SimpleNew( + PyArray_NDIM(itx->ao), odims, NPY_DOUBLE); if (aout == NULL) { return -1; } - ptr = (double*)aout->data; + ptr = (double*)PyArray_DATA(aout); PyArrayNeighborhoodIter_Reset(niterx); for (j = 0; j < niterx->size; ++j) { @@ -267,12 +270,12 @@ test_neighborhood_iterator_oob(PyObject* NPY_UNUSED(self), PyObject* args) if (ax == NULL) { return NULL; } - if (PySequence_Size(b1) != 2 * ax->nd) { + if (PySequence_Size(b1) != 2 * PyArray_NDIM(ax)) { PyErr_SetString(PyExc_ValueError, "bounds sequence 1 size not compatible with x input"); goto clean_ax; } - if (PySequence_Size(b2) != 2 * ax->nd) { + if (PySequence_Size(b2) != 2 * PyArray_NDIM(ax)) { PyErr_SetString(PyExc_ValueError, "bounds sequence 2 size not compatible with x input"); goto clean_ax; @@ -289,7 +292,7 @@ test_neighborhood_iterator_oob(PyObject* NPY_UNUSED(self), PyObject* args) } /* Compute boundaries for the neighborhood iterator */ - for (i = 0; i < 2 * ax->nd; ++i) { + for (i = 0; i < 2 * PyArray_NDIM(ax); ++i) { PyObject* bound; bound = PySequence_GetItem(b1, i); if (bounds == NULL) { @@ -312,7 +315,7 @@ test_neighborhood_iterator_oob(PyObject* NPY_UNUSED(self), PyObject* args) goto clean_out; } - for (i = 0; i < 2 * ax->nd; ++i) { + for (i = 0; i < 2 * PyArray_NDIM(ax); ++i) { PyObject* bound; bound = PySequence_GetItem(b2, i); if (bounds == NULL) { diff --git a/numpy/core/src/multiarray/multiarraymodule.c b/numpy/core/src/multiarray/multiarraymodule.c index 452ddec20..2c1061656 100644 --- a/numpy/core/src/multiarray/multiarraymodule.c +++ b/numpy/core/src/multiarray/multiarraymodule.c @@ -137,9 +137,9 @@ PyArray_OverflowMultiplyList(npy_intp *l1, int n) NPY_NO_EXPORT void * PyArray_GetPtr(PyArrayObject *obj, npy_intp* ind) { - int n = obj->nd; - npy_intp *strides = obj->strides; - char *dptr = obj->data; + int n = PyArray_NDIM(obj); + npy_intp *strides = PyArray_STRIDES(obj); + char *dptr = PyArray_DATA(obj); while (n--) { dptr += (*strides++) * (*ind++); @@ -198,22 +198,22 @@ PyArray_AsCArray(PyObject **op, void *ptr, npy_intp *dims, int nd, } switch(nd) { case 1: - *((char **)ptr) = ap->data; + *((char **)ptr) = PyArray_DATA(ap); break; case 2: - n = ap->dimensions[0]; + n = PyArray_DIMS(ap)[0]; ptr2 = (char **)_pya_malloc(n * sizeof(char *)); if (!ptr2) { goto fail; } for (i = 0; i < n; i++) { - ptr2[i] = ap->data + i*ap->strides[0]; + ptr2[i] = PyArray_DATA(ap) + i*PyArray_STRIDES(ap)[0]; } *((char ***)ptr) = ptr2; break; case 3: - n = ap->dimensions[0]; - m = ap->dimensions[1]; + n = PyArray_DIMS(ap)[0]; + m = PyArray_DIMS(ap)[1]; ptr3 = (char ***)_pya_malloc(n*(m+1) * sizeof(char *)); if (!ptr3) { goto fail; @@ -221,12 +221,12 @@ PyArray_AsCArray(PyObject **op, void *ptr, npy_intp *dims, int nd, for (i = 0; i < n; i++) { ptr3[i] = ptr3[n + (m-1)*i]; for (j = 0; j < m; j++) { - ptr3[i][j] = ap->data + i*ap->strides[0] + j*ap->strides[1]; + ptr3[i][j] = PyArray_DATA(ap) + i*PyArray_STRIDES(ap)[0] + j*PyArray_STRIDES(ap)[1]; } } *((char ****)ptr) = ptr3; } - memcpy(dims, ap->dimensions, nd*sizeof(npy_intp)); + memcpy(dims, PyArray_DIMS(ap), nd*sizeof(npy_intp)); *op = (PyObject *)ap; return 0; @@ -290,10 +290,10 @@ PyArray_Free(PyObject *op, void *ptr) { PyArrayObject *ap = (PyArrayObject *)op; - if ((ap->nd < 1) || (ap->nd > 3)) { + if ((PyArray_NDIM(ap) < 1) || (PyArray_NDIM(ap) > 3)) { return -1; } - if (ap->nd >= 2) { + if (PyArray_NDIM(ap) >= 2) { _pya_free(ptr); } Py_DECREF(ap); @@ -407,17 +407,17 @@ PyArray_Concatenate(PyObject *op, int axis) goto fail; } if (i == 0) { - nd = mps[i]->nd; + nd = PyArray_NDIM(mps[i]); } else { - if (nd != mps[i]->nd) { + if (nd != PyArray_NDIM(mps[i])) { PyErr_SetString(PyExc_ValueError, "arrays must have same "\ "number of dimensions"); goto fail; } - if (!PyArray_CompareLists(mps[0]->dimensions+1, - mps[i]->dimensions+1, + if (!PyArray_CompareLists(PyArray_DIMS(mps[0])+1, + PyArray_DIMS(mps[i])+1, nd-1)) { PyErr_SetString(PyExc_ValueError, "array dimensions must "\ @@ -430,25 +430,25 @@ PyArray_Concatenate(PyObject *op, int axis) "0-d arrays can't be concatenated"); goto fail; } - new_dim += mps[i]->dimensions[0]; + new_dim += PyArray_DIMS(mps[i])[0]; } - tmp = mps[0]->dimensions[0]; - mps[0]->dimensions[0] = new_dim; - Py_INCREF(mps[0]->descr); + tmp = PyArray_DIMS(mps[0])[0]; + PyArray_DIMS(mps[0])[0] = new_dim; + Py_INCREF(PyArray_DESCR(mps[0])); ret = (PyArrayObject *)PyArray_NewFromDescr(subtype, - mps[0]->descr, nd, - mps[0]->dimensions, + PyArray_DESCR(mps[0]), nd, + PyArray_DIMS(mps[0]), NULL, NULL, 0, (PyObject *)ret); - mps[0]->dimensions[0] = tmp; + PyArray_DIMS(mps[0])[0] = tmp; if (ret == NULL) { goto fail; } - data = ret->data; + data = PyArray_DATA(ret); for (i = 0; i < n; i++) { numbytes = PyArray_NBYTES(mps[i]); - memcpy(data, mps[i]->data, numbytes); + memcpy(data, PyArray_DATA(mps[i]), numbytes); data += numbytes; } @@ -476,9 +476,9 @@ _signbit_set(PyArrayObject *arr) char byteorder; int elsize; - elsize = arr->descr->elsize; - byteorder = arr->descr->byteorder; - ptr = arr->data; + elsize = PyArray_DESCR(arr)->elsize; + byteorder = PyArray_DESCR(arr)->byteorder; + ptr = PyArray_DATA(arr); if (elsize > 1 && (byteorder == PyArray_LITTLE || (byteorder == PyArray_NATIVE && @@ -673,8 +673,8 @@ PyArray_InnerProduct(PyObject *op1, PyObject *op2) if (ap2 == NULL) { goto fail; } - if (ap1->nd == 0 || ap2->nd == 0) { - ret = (ap1->nd == 0 ? ap1 : ap2); + if (PyArray_NDIM(ap1) == 0 || PyArray_NDIM(ap2) == 0) { + ret = (PyArray_NDIM(ap1) == 0 ? ap1 : ap2); ret = (PyArrayObject *)Py_TYPE(ret)->tp_as_number->nb_multiply( (PyObject *)ap1, (PyObject *)ap2); Py_DECREF(ap1); @@ -682,19 +682,19 @@ PyArray_InnerProduct(PyObject *op1, PyObject *op2) return (PyObject *)ret; } - l = ap1->dimensions[ap1->nd - 1]; - if (ap2->dimensions[ap2->nd - 1] != l) { + l = PyArray_DIMS(ap1)[PyArray_NDIM(ap1) - 1]; + if (PyArray_DIMS(ap2)[PyArray_NDIM(ap2) - 1] != l) { PyErr_SetString(PyExc_ValueError, "matrices are not aligned"); goto fail; } - nd = ap1->nd + ap2->nd - 2; + nd = PyArray_NDIM(ap1) + PyArray_NDIM(ap2) - 2; j = 0; - for (i = 0; i < ap1->nd - 1; i++) { - dimensions[j++] = ap1->dimensions[i]; + for (i = 0; i < PyArray_NDIM(ap1) - 1; i++) { + dimensions[j++] = PyArray_DIMS(ap1)[i]; } - for (i = 0; i < ap2->nd - 1; i++) { - dimensions[j++] = ap2->dimensions[i]; + for (i = 0; i < PyArray_NDIM(ap2) - 1; i++) { + dimensions[j++] = PyArray_DIMS(ap2)[i]; } /* @@ -705,20 +705,20 @@ PyArray_InnerProduct(PyObject *op1, PyObject *op2) if (ret == NULL) { goto fail; } - dot = (ret->descr->f->dotfunc); + dot = (PyArray_DESCR(ret)->f->dotfunc); if (dot == NULL) { PyErr_SetString(PyExc_ValueError, "dot not available for this type"); goto fail; } - is1 = ap1->strides[ap1->nd - 1]; - is2 = ap2->strides[ap2->nd - 1]; - op = ret->data; os = ret->descr->elsize; - axis = ap1->nd - 1; + is1 = PyArray_STRIDES(ap1)[PyArray_NDIM(ap1) - 1]; + is2 = PyArray_STRIDES(ap2)[PyArray_NDIM(ap2) - 1]; + op = PyArray_DATA(ret); os = PyArray_DESCR(ret)->elsize; + axis = PyArray_NDIM(ap1) - 1; it1 = (PyArrayIterObject *) PyArray_IterAllButAxis((PyObject *)ap1, &axis); - axis = ap2->nd - 1; + axis = PyArray_NDIM(ap2) - 1; it2 = (PyArrayIterObject *) PyArray_IterAllButAxis((PyObject *)ap2, &axis); - NPY_BEGIN_THREADS_DESCR(ap2->descr); + NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(ap2)); while (1) { while (it2->index < it2->size) { dot(it1->dataptr, is1, it2->dataptr, is2, op, l, ret); @@ -731,7 +731,7 @@ PyArray_InnerProduct(PyObject *op1, PyObject *op2) } PyArray_ITER_RESET(it2); } - NPY_END_THREADS_DESCR(ap2->descr); + NPY_END_THREADS_DESCR(PyArray_DESCR(ap2)); Py_DECREF(it1); Py_DECREF(it2); if (PyErr_Occurred()) { @@ -782,39 +782,39 @@ PyArray_MatrixProduct2(PyObject *op1, PyObject *op2, PyArrayObject* out) if (ap2 == NULL) { goto fail; } - if (ap1->nd == 0 || ap2->nd == 0) { - ret = (ap1->nd == 0 ? ap1 : ap2); + if (PyArray_NDIM(ap1) == 0 || PyArray_NDIM(ap2) == 0) { + ret = (PyArray_NDIM(ap1) == 0 ? ap1 : ap2); ret = (PyArrayObject *)Py_TYPE(ret)->tp_as_number->nb_multiply( (PyObject *)ap1, (PyObject *)ap2); Py_DECREF(ap1); Py_DECREF(ap2); return (PyObject *)ret; } - l = ap1->dimensions[ap1->nd - 1]; - if (ap2->nd > 1) { - matchDim = ap2->nd - 2; + l = PyArray_DIMS(ap1)[PyArray_NDIM(ap1) - 1]; + if (PyArray_NDIM(ap2) > 1) { + matchDim = PyArray_NDIM(ap2) - 2; } else { matchDim = 0; } - if (ap2->dimensions[matchDim] != l) { + if (PyArray_DIMS(ap2)[matchDim] != l) { PyErr_SetString(PyExc_ValueError, "objects are not aligned"); goto fail; } - nd = ap1->nd + ap2->nd - 2; + nd = PyArray_NDIM(ap1) + PyArray_NDIM(ap2) - 2; if (nd > NPY_MAXDIMS) { PyErr_SetString(PyExc_ValueError, "dot: too many dimensions in result"); goto fail; } j = 0; - for (i = 0; i < ap1->nd - 1; i++) { - dimensions[j++] = ap1->dimensions[i]; + for (i = 0; i < PyArray_NDIM(ap1) - 1; i++) { + dimensions[j++] = PyArray_DIMS(ap1)[i]; } - for (i = 0; i < ap2->nd - 2; i++) { - dimensions[j++] = ap2->dimensions[i]; + for (i = 0; i < PyArray_NDIM(ap2) - 2; i++) { + dimensions[j++] = PyArray_DIMS(ap2)[i]; } - if(ap2->nd > 1) { - dimensions[j++] = ap2->dimensions[ap2->nd-1]; + if(PyArray_NDIM(ap2) > 1) { + dimensions[j++] = PyArray_DIMS(ap2)[PyArray_NDIM(ap2)-1]; } /* fprintf(stderr, "nd=%d dimensions=", nd); @@ -823,7 +823,7 @@ PyArray_MatrixProduct2(PyObject *op1, PyObject *op2, PyArrayObject* out) fprintf(stderr, "\n"); */ - is1 = ap1->strides[ap1->nd-1]; is2 = ap2->strides[matchDim]; + is1 = PyArray_STRIDES(ap1)[PyArray_NDIM(ap1)-1]; is2 = PyArray_STRIDES(ap2)[matchDim]; /* Choose which subtype to return */ ret = new_array_for_sum(ap1, ap2, out, nd, dimensions, typenum); if (ret == NULL) { @@ -838,20 +838,20 @@ PyArray_MatrixProduct2(PyObject *op1, PyObject *op2, PyArrayObject* out) memset(PyArray_DATA(ret), 0, PyArray_ITEMSIZE(ret)); } - dot = ret->descr->f->dotfunc; + dot = PyArray_DESCR(ret)->f->dotfunc; if (dot == NULL) { PyErr_SetString(PyExc_ValueError, "dot not available for this type"); goto fail; } - op = ret->data; os = ret->descr->elsize; - axis = ap1->nd-1; + op = PyArray_DATA(ret); os = PyArray_DESCR(ret)->elsize; + axis = PyArray_NDIM(ap1)-1; it1 = (PyArrayIterObject *) PyArray_IterAllButAxis((PyObject *)ap1, &axis); it2 = (PyArrayIterObject *) PyArray_IterAllButAxis((PyObject *)ap2, &matchDim); - NPY_BEGIN_THREADS_DESCR(ap2->descr); + NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(ap2)); while (1) { while (it2->index < it2->size) { dot(it1->dataptr, is1, it2->dataptr, is2, op, l, ret); @@ -864,7 +864,7 @@ PyArray_MatrixProduct2(PyObject *op1, PyObject *op2, PyArrayObject* out) } PyArray_ITER_RESET(it2); } - NPY_END_THREADS_DESCR(ap2->descr); + NPY_END_THREADS_DESCR(PyArray_DESCR(ap2)); Py_DECREF(it1); Py_DECREF(it2); if (PyErr_Occurred()) { @@ -958,8 +958,8 @@ _pyarray_correlate(PyArrayObject *ap1, PyArrayObject *ap2, int typenum, NPY_BEGIN_THREADS_DEF; - n1 = ap1->dimensions[0]; - n2 = ap2->dimensions[0]; + n1 = PyArray_DIMS(ap1)[0]; + n2 = PyArray_DIMS(ap2)[0]; if (n1 < n2) { ret = ap1; ap1 = ap2; @@ -1002,20 +1002,20 @@ _pyarray_correlate(PyArrayObject *ap1, PyArrayObject *ap2, int typenum, if (ret == NULL) { return NULL; } - dot = ret->descr->f->dotfunc; + dot = PyArray_DESCR(ret)->f->dotfunc; if (dot == NULL) { PyErr_SetString(PyExc_ValueError, "function not available for this data type"); goto clean_ret; } - NPY_BEGIN_THREADS_DESCR(ret->descr); - is1 = ap1->strides[0]; - is2 = ap2->strides[0]; - op = ret->data; - os = ret->descr->elsize; - ip1 = ap1->data; - ip2 = ap2->data + n_left*is2; + NPY_BEGIN_THREADS_DESCR(PyArray_DESCR(ret)); + is1 = PyArray_STRIDES(ap1)[0]; + is2 = PyArray_STRIDES(ap2)[0]; + op = PyArray_DATA(ret); + os = PyArray_DESCR(ret)->elsize; + ip1 = PyArray_DATA(ap1); + ip2 = PyArray_DATA(ap2) + n_left*is2; n = n - n_left; for (i = 0; i < n_left; i++) { dot(ip1, is1, ip2, is2, op, n, ret); @@ -1035,7 +1035,7 @@ _pyarray_correlate(PyArrayObject *ap1, PyArrayObject *ap2, int typenum, op += os; } - NPY_END_THREADS_DESCR(ret->descr); + NPY_END_THREADS_DESCR(PyArray_DESCR(ret)); if (PyErr_Occurred()) { goto clean_ret; } @@ -1062,16 +1062,16 @@ _pyarray_revert(PyArrayObject *ret) npy_intp os; char *op; - length = ret->dimensions[0]; - copyswap = ret->descr->f->copyswap; + length = PyArray_DIMS(ret)[0]; + copyswap = PyArray_DESCR(ret)->f->copyswap; - tmp = PyArray_malloc(ret->descr->elsize); + tmp = PyArray_malloc(PyArray_DESCR(ret)->elsize); if (tmp == NULL) { return -1; } - os = ret->descr->elsize; - op = ret->data; + os = PyArray_DESCR(ret)->elsize; + op = PyArray_DATA(ret); sw1 = op; sw2 = op + (length - 1) * os; if (PyArray_ISFLEXIBLE(ret) || PyArray_ISOBJECT(ret)) { @@ -1513,24 +1513,33 @@ _prepend_ones(PyArrayObject *arr, int nd, int ndmin) npy_intp newdims[MAX_DIMS]; npy_intp newstrides[MAX_DIMS]; int i, k, num; - PyObject *ret; + PyArrayObject *ret; + PyArray_Descr *dtype; num = ndmin - nd; for (i = 0; i < num; i++) { newdims[i] = 1; - newstrides[i] = arr->descr->elsize; + newstrides[i] = PyArray_DESCR(arr)->elsize; } for (i = num; i < ndmin; i++) { k = i - num; - newdims[i] = arr->dimensions[k]; - newstrides[i] = arr->strides[k]; + newdims[i] = PyArray_DIMS(arr)[k]; + newstrides[i] = PyArray_STRIDES(arr)[k]; + } + dtype = PyArray_DESCR(arr); + Py_INCREF(dtype); + ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(arr), + dtype, ndmin, newdims, newstrides, + PyArray_DATA(arr), PyArray_FLAGS(arr), (PyObject *)arr); + if (ret == NULL) { + return NULL; } - Py_INCREF(arr->descr); - ret = PyArray_NewFromDescr(Py_TYPE(arr), arr->descr, ndmin, - newdims, newstrides, arr->data, arr->flags, (PyObject *)arr); /* steals a reference to arr --- so don't increment here */ - PyArray_BASE(ret) = (PyObject *)arr; - return ret; + if (PyArray_SetBaseObject(ret, (PyObject *)arr) < 0) { + Py_DECREF(ret); + return NULL; + } + return (PyObject *)ret; } @@ -1545,9 +1554,8 @@ _prepend_ones(PyArrayObject *arr, int nd, int ndmin) static PyObject * _array_fromobject(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *kws) { - PyObject *op, *ret = NULL; - static char *kwd[]= {"object", "dtype", "copy", "order", "subok", - "ndmin", NULL}; + PyObject *op; + PyArrayObject *oparr = NULL, *ret = NULL; Bool subok = FALSE; Bool copy = TRUE; int ndmin = 0, nd; @@ -1556,6 +1564,9 @@ _array_fromobject(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *kws) NPY_ORDER order = NPY_ANYORDER; int flags = 0; + static char *kwd[]= {"object", "dtype", "copy", "order", "subok", + "ndmin", NULL}; + if (PyTuple_GET_SIZE(args) > 2) { PyErr_SetString(PyExc_ValueError, "only 2 non-keyword arguments accepted"); @@ -1579,33 +1590,34 @@ _array_fromobject(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *kws) /* fast exit if simple call */ if ((subok && PyArray_Check(op)) || (!subok && PyArray_CheckExact(op))) { + oparr = (PyArrayObject *)op; if (type == NULL) { - if (!copy && STRIDING_OK(op, order)) { + if (!copy && STRIDING_OK(oparr, order)) { Py_INCREF(op); - ret = op; + ret = oparr; goto finish; } else { - ret = PyArray_NewCopy((PyArrayObject*)op, order); + ret = (PyArrayObject *)PyArray_NewCopy(oparr, order); goto finish; } } /* One more chance */ - oldtype = PyArray_DESCR(op); + oldtype = PyArray_DESCR(oparr); if (PyArray_EquivTypes(oldtype, type)) { - if (!copy && STRIDING_OK(op, order)) { + if (!copy && STRIDING_OK(oparr, order)) { Py_INCREF(op); - ret = op; + ret = oparr; goto finish; } else { - ret = PyArray_NewCopy((PyArrayObject*)op, order); + ret = (PyArrayObject *)PyArray_NewCopy(oparr, order); if (oldtype == type) { goto finish; } Py_INCREF(oldtype); Py_DECREF(PyArray_DESCR(ret)); - PyArray_DESCR(ret) = oldtype; + ((PyArrayObject_fieldaccess *)ret)->descr = oldtype; goto finish; } } @@ -1618,8 +1630,9 @@ _array_fromobject(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *kws) flags |= NPY_ARRAY_C_CONTIGUOUS; } else if ((order == NPY_FORTRANORDER) - /* order == NPY_ANYORDER && */ - || (PyArray_Check(op) && PyArray_ISFORTRAN(op))) { + /* order == NPY_ANYORDER && */ + || (PyArray_Check(op) && + PyArray_ISFORTRAN((PyArrayObject *)op))) { flags |= NPY_ARRAY_F_CONTIGUOUS; } if (!subok) { @@ -1628,21 +1641,22 @@ _array_fromobject(PyObject *NPY_UNUSED(ignored), PyObject *args, PyObject *kws) flags |= NPY_ARRAY_FORCECAST; Py_XINCREF(type); - ret = PyArray_CheckFromAny(op, type, 0, 0, flags, NULL); + ret = (PyArrayObject *)PyArray_CheckFromAny(op, type, + 0, 0, flags, NULL); finish: Py_XDECREF(type); if (!ret) { - return ret; + return (PyObject *)ret; } else if ((nd=PyArray_NDIM(ret)) >= ndmin) { - return ret; + return (PyObject *)ret; } /* * create a new array from the same data with ones in the shape * steals a reference to ret */ - return _prepend_ones((PyArrayObject *)ret, nd, ndmin); + return _prepend_ones(ret, nd, ndmin); clean_type: Py_XDECREF(type); diff --git a/numpy/core/src/multiarray/nditer_api.c b/numpy/core/src/multiarray/nditer_api.c index 4eda968db..4875c1e34 100644 --- a/numpy/core/src/multiarray/nditer_api.c +++ b/numpy/core/src/multiarray/nditer_api.c @@ -1049,7 +1049,10 @@ NpyIter_GetIterView(NpyIter *iter, npy_intp i) } /* Tell the view who owns the data */ Py_INCREF(obj); - view->base = (PyObject *)obj; + if (PyArray_SetBaseObject(view, (PyObject *)obj) < 0) { + Py_DECREF(view); + return NULL; + } /* Make sure all the flags are good */ PyArray_UpdateFlags(view, NPY_ARRAY_UPDATE_ALL); @@ -1864,7 +1867,7 @@ npyiter_copy_from_buffers(NpyIter *iter) (int)iop, (int)op_transfersize); if (op_itflags[iop] & NPY_OP_ITFLAG_WRITEMASKED) { - npy_uint8 *maskptr; + npy_mask *maskptr; /* * The mask pointer may be in the buffer or in @@ -1873,10 +1876,10 @@ npyiter_copy_from_buffers(NpyIter *iter) delta = (ptrs[maskop] - buffers[maskop]); if (0 <= delta && delta <= buffersize*dtypes[maskop]->elsize) { - maskptr = buffers[maskop]; + maskptr = (npy_mask *)buffers[maskop]; } else { - maskptr = ad_ptrs[maskop]; + maskptr = (npy_mask *)ad_ptrs[maskop]; } PyArray_TransferMaskedStridedToNDim(ndim_transfer, diff --git a/numpy/core/src/multiarray/nditer_constr.c b/numpy/core/src/multiarray/nditer_constr.c index b9f79f1d3..441f19de0 100644 --- a/numpy/core/src/multiarray/nditer_constr.c +++ b/numpy/core/src/multiarray/nditer_constr.c @@ -2702,7 +2702,10 @@ npyiter_new_temp_array(NpyIter *iter, PyTypeObject *subtype, Py_DECREF(ret); return NULL; } - newret->base = (PyObject *)ret; + if (PyArray_SetBaseObject(newret, (PyObject *)ret) < 0) { + Py_DECREF(newret); + return NULL; + } ret = newret; } @@ -2859,10 +2862,15 @@ npyiter_allocate_arrays(NpyIter *iter, } /* If the data will be written to, set UPDATEIFCOPY */ if (op_itflags[iop] & NPY_OP_ITFLAG_WRITE) { - PyArray_FLAGS(temp) |= NPY_ARRAY_UPDATEIFCOPY; - PyArray_FLAGS(op[iop]) &= ~NPY_ARRAY_WRITEABLE; + /* + * Don't use PyArray_SetBaseObject, because that compresses + * the chain of bases. + */ Py_INCREF(op[iop]); - temp->base = (PyObject *)op[iop]; + ((PyArrayObject_fieldaccess *)temp)->base = + (PyObject *)op[iop]; + PyArray_ENABLEFLAGS(temp, NPY_ARRAY_UPDATEIFCOPY); + PyArray_CLEARFLAGS(op[iop], NPY_ARRAY_WRITEABLE); } Py_DECREF(op[iop]); diff --git a/numpy/core/src/multiarray/nditer_pywrap.c b/numpy/core/src/multiarray/nditer_pywrap.c index 1e86487f5..5e4f0ea74 100644 --- a/numpy/core/src/multiarray/nditer_pywrap.c +++ b/numpy/core/src/multiarray/nditer_pywrap.c @@ -2014,7 +2014,7 @@ npyiter_seq_length(NewNpyArrayIterObject *self) NPY_NO_EXPORT PyObject * npyiter_seq_item(NewNpyArrayIterObject *self, Py_ssize_t i) { - PyObject *ret; + PyArrayObject *ret; npy_intp ret_ndim; npy_intp nop, innerloopsize, innerstride; @@ -2072,16 +2072,19 @@ npyiter_seq_item(NewNpyArrayIterObject *self, Py_ssize_t i) } Py_INCREF(dtype); - ret = (PyObject *)PyArray_NewFromDescr(&PyArray_Type, dtype, + ret = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, dtype, ret_ndim, &innerloopsize, &innerstride, dataptr, self->writeflags[i] ? NPY_ARRAY_WRITEABLE : 0, NULL); Py_INCREF(self); - ((PyArrayObject *)ret)->base = (PyObject *)self; + if (PyArray_SetBaseObject(ret, (PyObject *)self) < 0) { + Py_DECREF(ret); + return NULL; + } - PyArray_UpdateFlags((PyArrayObject *)ret, NPY_ARRAY_UPDATE_ALL); + PyArray_UpdateFlags(ret, NPY_ARRAY_UPDATE_ALL); - return ret; + return (PyObject *)ret; } NPY_NO_EXPORT PyObject * diff --git a/numpy/core/src/multiarray/number.c b/numpy/core/src/multiarray/number.c index 8faa31c16..8bb9dfc3d 100644 --- a/numpy/core/src/multiarray/number.c +++ b/numpy/core/src/multiarray/number.c @@ -27,13 +27,13 @@ NPY_NO_EXPORT NumericOps n_ops; /* NB: static objects initialized to zero */ /* FIXME - macro contains a return */ #define SET(op) temp = PyDict_GetItemString(dict, #op); \ - if (temp != NULL) { \ - if (!(PyCallable_Check(temp))) { \ - return -1; \ - } \ - Py_INCREF(temp); \ - Py_XDECREF(n_ops.op); \ - n_ops.op = temp; \ + if (temp != NULL) { \ + if (!(PyCallable_Check(temp))) { \ + return -1; \ + } \ + Py_INCREF(temp); \ + Py_XDECREF(n_ops.op); \ + n_ops.op = temp; \ } @@ -289,8 +289,8 @@ array_power_is_scalar(PyObject *o2, double* exp) return 1; } if ((PyArray_IsZeroDim(o2) && - ((PyArray_ISINTEGER(o2) || - (optimize_fpexps && PyArray_ISFLOAT(o2))))) || + ((PyArray_ISINTEGER((PyArrayObject *)o2) || + (optimize_fpexps && PyArray_ISFLOAT((PyArrayObject *)o2))))) || PyArray_IsScalar(o2, Integer) || (optimize_fpexps && PyArray_IsScalar(o2, Floating))) { temp = Py_TYPE(o2)->tp_as_number->nb_float(o2); @@ -547,7 +547,7 @@ _array_nonzero(PyArrayObject *mp) n = PyArray_SIZE(mp); if (n == 1) { - return mp->descr->f->nonzero(mp->data, mp); + return PyArray_DESCR(mp)->f->nonzero(PyArray_DATA(mp), mp); } else if (n == 0) { return 0; @@ -593,7 +593,7 @@ array_int(PyArrayObject *v) " converted to Python scalars"); return NULL; } - pv = v->descr->f->getitem(v->data, v); + pv = PyArray_DESCR(v)->f->getitem(PyArray_DATA(v), v); if (pv == NULL) { return NULL; } @@ -613,7 +613,8 @@ array_int(PyArrayObject *v) * If we still got an array which can hold references, stop * because it could point back at 'v'. */ - if (PyArray_Check(pv) && PyDataType_REFCHK(PyArray_DESCR(pv))) { + if (PyArray_Check(pv) && + PyDataType_REFCHK(PyArray_DESCR((PyArrayObject *)pv))) { PyErr_SetString(PyExc_TypeError, "object array may be self-referencing"); return NULL; @@ -633,7 +634,7 @@ array_float(PyArrayObject *v) "be converted to Python scalars"); return NULL; } - pv = v->descr->f->getitem(v->data, v); + pv = PyArray_DESCR(v)->f->getitem(PyArray_DATA(v), v); if (pv == NULL) { return NULL; } @@ -653,7 +654,8 @@ array_float(PyArrayObject *v) * If we still got an array which can hold references, stop * because it could point back at 'v'. */ - if (PyArray_Check(pv) && PyDataType_REFCHK(PyArray_DESCR(pv))) { + if (PyArray_Check(pv) && + PyDataType_REFCHK(PyArray_DESCR((PyArrayObject *)pv))) { PyErr_SetString(PyExc_TypeError, "object array may be self-referencing"); return NULL; @@ -674,7 +676,7 @@ array_long(PyArrayObject *v) "be converted to Python scalars"); return NULL; } - pv = v->descr->f->getitem(v->data, v); + pv = PyArray_DESCR(v)->f->getitem(PyArray_DATA(v), v); if (Py_TYPE(pv)->tp_as_number == 0) { PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\ "scalar object is not a number"); @@ -689,7 +691,8 @@ array_long(PyArrayObject *v) * If we still got an array which can hold references, stop * because it could point back at 'v'. */ - if (PyArray_Check(pv) && PyDataType_REFCHK(PyArray_DESCR(pv))) { + if (PyArray_Check(pv) && + PyDataType_REFCHK(PyArray_DESCR((PyArrayObject *)pv))) { PyErr_SetString(PyExc_TypeError, "object array may be self-referencing"); return NULL; @@ -708,7 +711,7 @@ array_oct(PyArrayObject *v) "be converted to Python scalars"); return NULL; } - pv = v->descr->f->getitem(v->data, v); + pv = PyArray_DESCR(v)->f->getitem(PyArray_DATA(v), v); if (Py_TYPE(pv)->tp_as_number == 0) { PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\ "scalar object is not a number"); @@ -723,7 +726,8 @@ array_oct(PyArrayObject *v) * If we still got an array which can hold references, stop * because it could point back at 'v'. */ - if (PyArray_Check(pv) && PyDataType_REFCHK(PyArray_DESCR(pv))) { + if (PyArray_Check(pv) && + PyDataType_REFCHK(PyArray_DESCR((PyArrayObject *)pv))) { PyErr_SetString(PyExc_TypeError, "object array may be self-referencing"); return NULL; @@ -742,7 +746,7 @@ array_hex(PyArrayObject *v) "be converted to Python scalars"); return NULL; } - pv = v->descr->f->getitem(v->data, v); + pv = PyArray_DESCR(v)->f->getitem(PyArray_DATA(v), v); if (Py_TYPE(pv)->tp_as_number == 0) { PyErr_SetString(PyExc_TypeError, "cannot convert to an int; "\ "scalar object is not a number"); @@ -757,7 +761,8 @@ array_hex(PyArrayObject *v) * If we still got an array which can hold references, stop * because it could point back at 'v'. */ - if (PyArray_Check(pv) && PyDataType_REFCHK(PyArray_DESCR(pv))) { + if (PyArray_Check(pv) && + PyDataType_REFCHK(PyArray_DESCR((PyArrayObject *)pv))) { PyErr_SetString(PyExc_TypeError, "object array may be self-referencing"); return NULL; @@ -784,7 +789,7 @@ array_index(PyArrayObject *v) "one element can be converted to an index"); return NULL; } - return v->descr->f->getitem(v->data, v); + return PyArray_DESCR(v)->f->getitem(PyArray_DATA(v), v); } #endif diff --git a/numpy/core/src/multiarray/refcount.c b/numpy/core/src/multiarray/refcount.c index cd1474948..409d4d30f 100644 --- a/numpy/core/src/multiarray/refcount.c +++ b/numpy/core/src/multiarray/refcount.c @@ -104,16 +104,16 @@ PyArray_INCREF(PyArrayObject *mp) PyObject *temp; PyArrayIterObject *it; - if (!PyDataType_REFCHK(mp->descr)) { + if (!PyDataType_REFCHK(PyArray_DESCR(mp))) { return 0; } - if (mp->descr->type_num != PyArray_OBJECT) { + if (PyArray_DESCR(mp)->type_num != PyArray_OBJECT) { it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp); if (it == NULL) { return -1; } while(it->index < it->size) { - PyArray_Item_INCREF(it->dataptr, mp->descr); + PyArray_Item_INCREF(it->dataptr, PyArray_DESCR(mp)); PyArray_ITER_NEXT(it); } Py_DECREF(it); @@ -121,7 +121,7 @@ PyArray_INCREF(PyArrayObject *mp) } if (PyArray_ISONESEGMENT(mp)) { - data = (PyObject **)mp->data; + data = (PyObject **)PyArray_DATA(mp); n = PyArray_SIZE(mp); if (PyArray_ISALIGNED(mp)) { for (i = 0; i < n; i++, data++) { @@ -162,16 +162,16 @@ PyArray_XDECREF(PyArrayObject *mp) PyObject *temp; PyArrayIterObject *it; - if (!PyDataType_REFCHK(mp->descr)) { + if (!PyDataType_REFCHK(PyArray_DESCR(mp))) { return 0; } - if (mp->descr->type_num != PyArray_OBJECT) { + if (PyArray_DESCR(mp)->type_num != PyArray_OBJECT) { it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp); if (it == NULL) { return -1; } while(it->index < it->size) { - PyArray_Item_XDECREF(it->dataptr, mp->descr); + PyArray_Item_XDECREF(it->dataptr, PyArray_DESCR(mp)); PyArray_ITER_NEXT(it); } Py_DECREF(it); @@ -179,7 +179,7 @@ PyArray_XDECREF(PyArrayObject *mp) } if (PyArray_ISONESEGMENT(mp)) { - data = (PyObject **)mp->data; + data = (PyObject **)PyArray_DATA(mp); n = PyArray_SIZE(mp); if (PyArray_ISALIGNED(mp)) { for (i = 0; i < n; i++, data++) Py_XDECREF(*data); @@ -214,9 +214,9 @@ PyArray_FillObjectArray(PyArrayObject *arr, PyObject *obj) { intp i,n; n = PyArray_SIZE(arr); - if (arr->descr->type_num == PyArray_OBJECT) { + if (PyArray_DESCR(arr)->type_num == PyArray_OBJECT) { PyObject **optr; - optr = (PyObject **)(arr->data); + optr = (PyObject **)(PyArray_DATA(arr)); n = PyArray_SIZE(arr); if (obj == NULL) { for (i = 0; i < n; i++) { @@ -232,10 +232,10 @@ PyArray_FillObjectArray(PyArrayObject *arr, PyObject *obj) } else { char *optr; - optr = arr->data; + optr = PyArray_DATA(arr); for (i = 0; i < n; i++) { - _fillobject(optr, obj, arr->descr); - optr += arr->descr->elsize; + _fillobject(optr, obj, PyArray_DESCR(arr)); + optr += PyArray_DESCR(arr)->elsize; } } } diff --git a/numpy/core/src/multiarray/scalarapi.c b/numpy/core/src/multiarray/scalarapi.c index 21d8c762b..fa783dabf 100644 --- a/numpy/core/src/multiarray/scalarapi.c +++ b/numpy/core/src/multiarray/scalarapi.c @@ -227,7 +227,7 @@ PyArray_CastScalarToCtype(PyObject *scalar, void *ctypeptr, Py_DECREF(ain); return -1; } - castfunc(ain->data, aout->data, 1, ain, aout); + castfunc(PyArray_DATA(ain), PyArray_DATA(aout), 1, ain, aout); Py_DECREF(ain); Py_DECREF(aout); } @@ -270,7 +270,7 @@ NPY_NO_EXPORT PyObject * PyArray_FromScalar(PyObject *scalar, PyArray_Descr *outcode) { PyArray_Descr *typecode; - PyObject *r; + PyArrayObject *r; char *memptr; PyObject *ret; @@ -279,18 +279,24 @@ PyArray_FromScalar(PyObject *scalar, PyArray_Descr *outcode) if ((typecode->type_num == PyArray_VOID) && !(((PyVoidScalarObject *)scalar)->flags & NPY_ARRAY_OWNDATA) && outcode == NULL) { - r = PyArray_NewFromDescr(&PyArray_Type, + r = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, typecode, 0, NULL, NULL, ((PyVoidScalarObject *)scalar)->obval, ((PyVoidScalarObject *)scalar)->flags, NULL); - PyArray_BASE(r) = (PyObject *)scalar; + if (r == NULL) { + return NULL; + } Py_INCREF(scalar); - return r; + if (PyArray_SetBaseObject(r, (PyObject *)scalar) < 0) { + Py_DECREF(r); + return NULL; + } + return (PyObject *)r; } - r = PyArray_NewFromDescr(&PyArray_Type, + r = (PyArrayObject *)PyArray_NewFromDescr(&PyArray_Type, typecode, 0, NULL, NULL, NULL, 0, NULL); @@ -327,12 +333,12 @@ PyArray_FromScalar(PyObject *scalar, PyArray_Descr *outcode) finish: if (outcode == NULL) { - return r; + return (PyObject *)r; } if (outcode->type_num == typecode->type_num) { if (!PyTypeNum_ISEXTENDED(typecode->type_num) || (outcode->elsize == typecode->elsize)) { - return r; + return (PyObject *)r; } } @@ -353,7 +359,8 @@ PyArray_ScalarFromObject(PyObject *object) { PyObject *ret=NULL; if (PyArray_IsZeroDim(object)) { - return PyArray_ToScalar(PyArray_DATA(object), object); + return PyArray_ToScalar(PyArray_DATA((PyArrayObject *)object), + (PyArrayObject *)object); } /* * Booleans in Python are implemented as a subclass of integers, @@ -762,7 +769,7 @@ PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base) if (base) { Py_INCREF(base); vobj->base = base; - vobj->flags = PyArray_FLAGS(base); + vobj->flags = PyArray_FLAGS((PyArrayObject *)base); vobj->flags &= ~NPY_ARRAY_OWNDATA; vobj->obval = data; return obj; @@ -805,9 +812,9 @@ PyArray_Return(PyArrayObject *mp) if (!PyArray_Check(mp)) { return (PyObject *)mp; } - if (mp->nd == 0) { + if (PyArray_NDIM(mp) == 0) { PyObject *ret; - ret = PyArray_ToScalar(mp->data, mp); + ret = PyArray_ToScalar(PyArray_DATA(mp), mp); Py_DECREF(mp); return ret; } diff --git a/numpy/core/src/multiarray/scalartypes.c.src b/numpy/core/src/multiarray/scalartypes.c.src index e2674ac50..fc3a74fd2 100644 --- a/numpy/core/src/multiarray/scalartypes.c.src +++ b/numpy/core/src/multiarray/scalartypes.c.src @@ -681,7 +681,8 @@ timedeltatype_repr(PyObject *self) ret = PyUString_FromString("numpy.timedelta64('NaT'"); } else { - ret = PyUString_FromFormat("numpy.timedelta64(%lld", scal->obval); + ret = PyUString_FromFormat("numpy.timedelta64(%lld", + (long long)scal->obval); } /* The metadata unit */ if (scal->obmeta.base == NPY_FR_GENERIC) { @@ -1131,14 +1132,14 @@ gentype_struct_get(PyObject *self) inter = (PyArrayInterface *)PyArray_malloc(sizeof(PyArrayInterface)); inter->two = 2; inter->nd = 0; - inter->flags = arr->flags; + inter->flags = PyArray_FLAGS(arr); inter->flags &= ~(NPY_ARRAY_UPDATEIFCOPY | NPY_ARRAY_OWNDATA); inter->flags |= NPY_ARRAY_NOTSWAPPED; - inter->typekind = arr->descr->kind; - inter->itemsize = arr->descr->elsize; + inter->typekind = PyArray_DESCR(arr)->kind; + inter->itemsize = PyArray_DESCR(arr)->elsize; inter->strides = NULL; inter->shape = NULL; - inter->data = arr->data; + inter->data = PyArray_DATA(arr); inter->descr = NULL; ret = NpyCapsule_FromVoidPtrAndDesc(inter, arr, gentype_struct_free); @@ -1416,21 +1417,24 @@ static char doc_sc_wraparray[] = "sc.__array_wrap__(obj) return scalar from arra static PyObject * gentype_wraparray(PyObject *NPY_UNUSED(scalar), PyObject *args) { - PyObject *arr; + PyObject *obj; + PyArrayObject *arr; if (PyTuple_Size(args) < 1) { PyErr_SetString(PyExc_TypeError, "only accepts 1 argument."); return NULL; } - arr = PyTuple_GET_ITEM(args, 0); - if (!PyArray_Check(arr)) { + obj = PyTuple_GET_ITEM(args, 0); + if (!PyArray_Check(obj)) { PyErr_SetString(PyExc_TypeError, "can only be called with ndarray object"); return NULL; } + arr = (PyArrayObject *)obj; - return PyArray_Scalar(PyArray_DATA(arr), PyArray_DESCR(arr), arr); + return PyArray_Scalar(PyArray_DATA(arr), + PyArray_DESCR(arr), (PyObject *)arr); } /* @@ -1567,7 +1571,8 @@ voidtype_setfield(PyVoidScalarObject *self, PyObject *args, PyObject *kwds) { PyArray_Descr *typecode = NULL; int offset = 0; - PyObject *value, *src; + PyObject *value; + PyArrayObject *src; int mysize; char *dptr; static char *kwlist[] = {"value", "dtype", "offset", 0}; @@ -1607,7 +1612,8 @@ voidtype_setfield(PyVoidScalarObject *self, PyObject *args, PyObject *kwds) } else { /* Copy data from value to correct place in dptr */ - src = PyArray_FromAny(value, typecode, 0, 0, NPY_ARRAY_CARRAY, NULL); + src = (PyArrayObject *)PyArray_FromAny(value, typecode, + 0, 0, NPY_ARRAY_CARRAY, NULL); if (src == NULL) { return NULL; } @@ -2431,7 +2437,7 @@ static PyObject * { PyObject *obj = NULL; PyObject *robj; - PyObject *arr; + PyArrayObject *arr; PyArray_Descr *typecode = NULL; #if !(@default@ == 2) int itemsize; @@ -2477,12 +2483,13 @@ static PyObject * * It is expected at this point that robj is a PyArrayScalar * (even for Object Data Type) */ - arr = PyArray_FromAny(obj, typecode, 0, 0, NPY_ARRAY_FORCECAST, NULL); + arr = (PyArrayObject *)PyArray_FromAny(obj, typecode, + 0, 0, NPY_ARRAY_FORCECAST, NULL); if ((arr == NULL) || (PyArray_NDIM(arr) > 0)) { - return arr; + return (PyObject *)arr; } /* 0-d array */ - robj = PyArray_ToScalar(PyArray_DATA(arr), (PyArrayObject *)arr); + robj = PyArray_ToScalar(PyArray_DATA(arr), arr); Py_DECREF(arr); finish: @@ -2611,7 +2618,7 @@ static PyObject * bool_arrtype_new(PyTypeObject *NPY_UNUSED(type), PyObject *args, PyObject *NPY_UNUSED(kwds)) { PyObject *obj = NULL; - PyObject *arr; + PyArrayObject *arr; if (!PyArg_ParseTuple(args, "|O", &obj)) { return NULL; @@ -2625,9 +2632,10 @@ bool_arrtype_new(PyTypeObject *NPY_UNUSED(type), PyObject *args, PyObject *NPY_U if (obj == Py_True) { PyArrayScalar_RETURN_TRUE; } - arr = PyArray_FROM_OTF(obj, PyArray_BOOL, NPY_ARRAY_FORCECAST); + arr = (PyArrayObject *)PyArray_FROM_OTF(obj, + NPY_BOOL, NPY_ARRAY_FORCECAST); if (arr && 0 == PyArray_NDIM(arr)) { - Bool val = *((Bool *)PyArray_DATA(arr)); + npy_bool val = *((npy_bool *)PyArray_DATA(arr)); Py_DECREF(arr); PyArrayScalar_RETURN_BOOL_FROM_LONG(val); } @@ -2776,8 +2784,9 @@ void_arrtype_new(PyTypeObject *type, PyObject *args, PyObject *NPY_UNUSED(kwds)) */ if (PyLong_Check(obj) || PyInt_Check(obj) || PyArray_IsScalar(obj, Integer) || - (PyArray_Check(obj) && PyArray_NDIM(obj)==0 && - PyArray_ISINTEGER(obj))) { + (PyArray_Check(obj) && + PyArray_NDIM((PyArrayObject *)obj)==0 && + PyArray_ISINTEGER((PyArrayObject *)obj))) { #if defined(NPY_PY3K) new = Py_TYPE(obj)->tp_as_number->nb_int(obj); #else diff --git a/numpy/core/src/multiarray/sequence.c b/numpy/core/src/multiarray/sequence.c index b59c1d2b1..354dcfa2f 100644 --- a/numpy/core/src/multiarray/sequence.c +++ b/numpy/core/src/multiarray/sequence.c @@ -30,57 +30,59 @@ array_any_nonzero(PyArrayObject *mp); static PyObject * -array_slice(PyArrayObject *self, Py_ssize_t ilow, - Py_ssize_t ihigh) +array_slice(PyArrayObject *self, Py_ssize_t ilow, Py_ssize_t ihigh) { - PyArrayObject *r; - Py_ssize_t l; + PyArrayObject *ret; + PyArray_Descr *dtype; + Py_ssize_t dim0; char *data; + npy_intp shape[NPY_MAXDIMS]; - if (self->nd == 0) { + if (PyArray_NDIM(self) == 0) { PyErr_SetString(PyExc_ValueError, "cannot slice a 0-d array"); return NULL; } - l=self->dimensions[0]; + dim0 = PyArray_DIM(self, 0); if (ilow < 0) { ilow = 0; } - else if (ilow > l) { - ilow = l; + else if (ilow > dim0) { + ilow = dim0; } if (ihigh < ilow) { ihigh = ilow; } - else if (ihigh > l) { - ihigh = l; + else if (ihigh > dim0) { + ihigh = dim0; } - if (ihigh != ilow) { - data = index2ptr(self, ilow); - if (data == NULL) { - return NULL; - } - } - else { - data = self->data; + data = PyArray_DATA(self); + if (ilow < ihigh) { + data += ilow * PyArray_STRIDE(self, 0); } - self->dimensions[0] = ihigh-ilow; - Py_INCREF(self->descr); - r = (PyArrayObject *) \ - PyArray_NewFromDescr(Py_TYPE(self), self->descr, - self->nd, self->dimensions, - self->strides, data, - self->flags, (PyObject *)self); - self->dimensions[0] = l; - if (r == NULL) { + /* Same shape except dimension 0 */ + shape[0] = ihigh - ilow; + memcpy(shape+1, PyArray_DIMS(self) + 1, + (PyArray_NDIM(self)-1)*sizeof(npy_intp)); + + dtype = PyArray_DESCR(self); + Py_INCREF(dtype); + ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self), dtype, + PyArray_NDIM(self), shape, + PyArray_STRIDES(self), data, + PyArray_FLAGS(self), (PyObject *)self); + if (ret == NULL) { return NULL; } - r->base = (PyObject *)self; Py_INCREF(self); - PyArray_UpdateFlags(r, NPY_ARRAY_UPDATE_ALL); - return (PyObject *)r; + if (PyArray_SetBaseObject(ret, (PyObject *)self) < 0) { + Py_DECREF(ret); + return NULL; + } + PyArray_UpdateFlags(ret, NPY_ARRAY_UPDATE_ALL); + return (PyObject *)ret; } @@ -162,19 +164,19 @@ NPY_NO_EXPORT PySequenceMethods array_as_sequence = { /* Array evaluates as "TRUE" if any of the elements are non-zero*/ static int -array_any_nonzero(PyArrayObject *mp) +array_any_nonzero(PyArrayObject *arr) { intp index; PyArrayIterObject *it; Bool anyTRUE = FALSE; - it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)mp); + it = (PyArrayIterObject *)PyArray_IterNew((PyObject *)arr); if (it == NULL) { return anyTRUE; } index = it->size; while(index--) { - if (mp->descr->f->nonzero(it->dataptr, mp)) { + if (PyArray_DESCR(arr)->f->nonzero(it->dataptr, arr)) { anyTRUE = TRUE; break; } diff --git a/numpy/core/src/multiarray/shape.c b/numpy/core/src/multiarray/shape.c index ff022faf0..3754e6a1e 100644 --- a/numpy/core/src/multiarray/shape.c +++ b/numpy/core/src/multiarray/shape.c @@ -59,13 +59,13 @@ PyArray_Resize(PyArrayObject *self, PyArray_Dims *newshape, int refcheck, return NULL; } - if (self->descr->elsize == 0) { + if (PyArray_DESCR(self)->elsize == 0) { PyErr_SetString(PyExc_ValueError, "Bad data-type size."); return NULL; } newsize = 1; - largest = MAX_INTP / self->descr->elsize; + largest = MAX_INTP / PyArray_DESCR(self)->elsize; for(k = 0; k < new_nd; k++) { if (new_dimensions[k] == 0) { break; @@ -83,7 +83,7 @@ PyArray_Resize(PyArrayObject *self, PyArray_Dims *newshape, int refcheck, oldsize = PyArray_SIZE(self); if (oldsize != newsize) { - if (!(self->flags & NPY_ARRAY_OWNDATA)) { + if (!(PyArray_FLAGS(self) & NPY_ARRAY_OWNDATA)) { PyErr_SetString(PyExc_ValueError, "cannot resize this array: it does not own its data"); return NULL; @@ -96,8 +96,8 @@ PyArray_Resize(PyArrayObject *self, PyArray_Dims *newshape, int refcheck, refcnt = 1; } if ((refcnt > 2) - || (self->base != NULL) - || (self->weakreflist != NULL)) { + || (PyArray_BASE(self) != NULL) + || (((PyArrayObject_fieldaccess *)self)->weakreflist != NULL)) { PyErr_SetString(PyExc_ValueError, "cannot resize an array references or is referenced\n"\ "by another array in this way. Use the resize function"); @@ -105,60 +105,60 @@ PyArray_Resize(PyArrayObject *self, PyArray_Dims *newshape, int refcheck, } if (newsize == 0) { - sd = self->descr->elsize; + sd = PyArray_DESCR(self)->elsize; } else { - sd = newsize*self->descr->elsize; + sd = newsize*PyArray_DESCR(self)->elsize; } /* Reallocate space if needed */ - new_data = PyDataMem_RENEW(self->data, sd); + new_data = PyDataMem_RENEW(PyArray_DATA(self), sd); if (new_data == NULL) { PyErr_SetString(PyExc_MemoryError, "cannot allocate memory for array"); return NULL; } - self->data = new_data; + ((PyArrayObject_fieldaccess *)self)->data = new_data; } if ((newsize > oldsize) && PyArray_ISWRITEABLE(self)) { /* Fill new memory with zeros */ - elsize = self->descr->elsize; - if (PyDataType_FLAGCHK(self->descr, NPY_ITEM_REFCOUNT)) { + elsize = PyArray_DESCR(self)->elsize; + if (PyDataType_FLAGCHK(PyArray_DESCR(self), NPY_ITEM_REFCOUNT)) { PyObject *zero = PyInt_FromLong(0); char *optr; - optr = self->data + oldsize*elsize; + optr = PyArray_DATA(self) + oldsize*elsize; n = newsize - oldsize; for (k = 0; k < n; k++) { - _putzero((char *)optr, zero, self->descr); + _putzero((char *)optr, zero, PyArray_DESCR(self)); optr += elsize; } Py_DECREF(zero); } else{ - memset(self->data+oldsize*elsize, 0, (newsize-oldsize)*elsize); + memset(PyArray_DATA(self)+oldsize*elsize, 0, (newsize-oldsize)*elsize); } } - if (self->nd != new_nd) { + if (PyArray_NDIM(self) != new_nd) { /* Different number of dimensions. */ - self->nd = new_nd; + ((PyArrayObject_fieldaccess *)self)->nd = new_nd; /* Need new dimensions and strides arrays */ - dimptr = PyDimMem_RENEW(self->dimensions, 2*new_nd); + dimptr = PyDimMem_RENEW(PyArray_DIMS(self), 2*new_nd); if (dimptr == NULL) { PyErr_SetString(PyExc_MemoryError, "cannot allocate memory for array"); return NULL; } - self->dimensions = dimptr; - self->strides = dimptr + new_nd; + ((PyArrayObject_fieldaccess *)self)->dimensions = dimptr; + ((PyArrayObject_fieldaccess *)self)->strides = dimptr + new_nd; } /* make new_strides variable */ - sd = (size_t) self->descr->elsize; + sd = (size_t) PyArray_DESCR(self)->elsize; sd = (size_t) _array_fill_strides(new_strides, new_dimensions, new_nd, sd, - self->flags, &(self->flags)); - memmove(self->dimensions, new_dimensions, new_nd*sizeof(intp)); - memmove(self->strides, new_strides, new_nd*sizeof(intp)); + PyArray_FLAGS(self), &(((PyArrayObject_fieldaccess *)self)->flags)); + memmove(PyArray_DIMS(self), new_dimensions, new_nd*sizeof(intp)); + memmove(PyArray_STRIDES(self), new_strides, new_nd*sizeof(intp)); Py_INCREF(Py_None); return Py_None; } @@ -190,7 +190,7 @@ PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims, order = PyArray_ISFORTRAN(self); } /* Quick check to make sure anything actually needs to be done */ - if (n == self->nd) { + if (n == PyArray_NDIM(self)) { same = TRUE; i = 0; while (same && i < n) { @@ -216,7 +216,7 @@ PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims, if (i == 0) { strides = newstrides; } - flags = self->flags; + flags = PyArray_FLAGS(self); if (strides == NULL) { /* @@ -236,14 +236,14 @@ PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims, (((PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS) && order == NPY_FORTRANORDER) || (PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS) && - order == NPY_CORDER)) && (self->nd > 1))) { + order == NPY_CORDER)) && (PyArray_NDIM(self) > 1))) { int success = 0; success = _attempt_nocopy_reshape(self,n,dimensions, newstrides,order); if (success) { /* no need to copy the array after all */ strides = newstrides; - flags = self->flags; + flags = PyArray_FLAGS(self); } else { PyObject *new; @@ -253,7 +253,7 @@ PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims, } incref = FALSE; self = (PyArrayObject *)new; - flags = self->flags; + flags = PyArray_FLAGS(self); } } @@ -278,7 +278,7 @@ PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims, */ if (order == NPY_FORTRANORDER) { if (strides[0] == 0) { - strides[0] = self->descr->elsize; + strides[0] = PyArray_DESCR(self)->elsize; } for (i = 1; i < n; i++) { if (strides[i] == 0) { @@ -288,7 +288,7 @@ PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims, } else { if (strides[n-1] == 0) { - strides[n-1] = self->descr->elsize; + strides[n-1] = PyArray_DESCR(self)->elsize; } for (i = n - 2; i > -1; i--) { if (strides[i] == 0) { @@ -298,12 +298,12 @@ PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims, } } - Py_INCREF(self->descr); + Py_INCREF(PyArray_DESCR(self)); ret = (PyAO *)PyArray_NewFromDescr(Py_TYPE(self), - self->descr, + PyArray_DESCR(self), n, dimensions, strides, - self->data, + PyArray_DATA(self), flags, (PyObject *)self); if (ret == NULL) { @@ -312,7 +312,10 @@ PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims, if (incref) { Py_INCREF(self); } - ret->base = (PyObject *)self; + if (PyArray_SetBaseObject(ret, (PyObject *)self)) { + Py_DECREF(ret); + return NULL; + } PyArray_UpdateFlags(ret, NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS); return (PyObject *)ret; @@ -353,12 +356,12 @@ _check_ones(PyArrayObject *self, int newnd, intp* newdims, intp *strides) Bool done=FALSE; int j, k; - nd = self->nd; - dims = self->dimensions; + nd = PyArray_NDIM(self); + dims = PyArray_DIMS(self); for (k = 0, j = 0; !done && (j < nd || k < newnd);) { if ((j<nd) && (k<newnd) && (newdims[k] == dims[j])) { - strides[k] = self->strides[j]; + strides[k] = PyArray_STRIDES(self)[j]; j++; k++; } @@ -420,7 +423,7 @@ _putzero(char *optr, PyObject *zero, PyArray_Descr *dtype) * * The "is_f_order" argument describes how the array should be viewed * during the reshape, not how it is stored in memory (that - * information is in self->strides). + * information is in PyArray_STRIDES(self)). * * If some output dimensions have length 1, the strides assigned to * them are arbitrary. In the current implementation, they are the @@ -437,10 +440,10 @@ _attempt_nocopy_reshape(PyArrayObject *self, int newnd, intp* newdims, int np, op; oldnd = 0; - for (oi = 0; oi < self->nd; oi++) { - if (self->dimensions[oi]!= 1) { - olddims[oldnd] = self->dimensions[oi]; - oldstrides[oldnd] = self->strides[oi]; + for (oi = 0; oi < PyArray_NDIM(self); oi++) { + if (PyArray_DIMS(self)[oi]!= 1) { + olddims[oldnd] = PyArray_DIMS(self)[oi]; + oldstrides[oldnd] = PyArray_STRIDES(self)[oi]; oldnd++; } } @@ -590,40 +593,45 @@ _fix_unknown_dimension(PyArray_Dims *newshape, intp s_original) NPY_NO_EXPORT PyObject * PyArray_Squeeze(PyArrayObject *self) { - int nd = self->nd; + int nd = PyArray_NDIM(self); int newnd = nd; intp dimensions[MAX_DIMS]; intp strides[MAX_DIMS]; int i, j; - PyObject *ret; + PyArrayObject *ret; + PyArray_Descr *dtype; if (nd == 0) { Py_INCREF(self); return (PyObject *)self; } for (j = 0, i = 0; i < nd; i++) { - if (self->dimensions[i] == 1) { + if (PyArray_DIMS(self)[i] == 1) { newnd -= 1; } else { - dimensions[j] = self->dimensions[i]; - strides[j++] = self->strides[i]; + dimensions[j] = PyArray_DIMS(self)[i]; + strides[j++] = PyArray_STRIDES(self)[i]; } } - Py_INCREF(self->descr); - ret = PyArray_NewFromDescr(Py_TYPE(self), - self->descr, + dtype = PyArray_DESCR(self); + Py_INCREF(dtype); + ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(self), + dtype, newnd, dimensions, - strides, self->data, - self->flags, + strides, PyArray_DATA(self), + PyArray_FLAGS(self), (PyObject *)self); if (ret == NULL) { return NULL; } - PyArray_FLAGS(ret) &= ~NPY_ARRAY_OWNDATA; - PyArray_BASE(ret) = (PyObject *)self; + PyArray_CLEARFLAGS(ret, NPY_ARRAY_OWNDATA); Py_INCREF(self); + if (PyArray_SetBaseObject(ret, (PyObject *)self) < 0) { + Py_DECREF(ret); + return NULL; + } return (PyObject *)ret; } @@ -643,7 +651,7 @@ PyArray_SwapAxes(PyArrayObject *ap, int a1, int a2) return (PyObject *)ap; } - n = ap->nd; + n = PyArray_NDIM(ap); if (n <= 1) { Py_INCREF(ap); return (PyObject *)ap; @@ -696,7 +704,7 @@ PyArray_Transpose(PyArrayObject *ap, PyArray_Dims *permute) PyArrayObject *ret = NULL; if (permute == NULL) { - n = ap->nd; + n = PyArray_NDIM(ap); for (i = 0; i < n; i++) { permutation[i] = n-1-i; } @@ -704,7 +712,7 @@ PyArray_Transpose(PyArrayObject *ap, PyArray_Dims *permute) else { n = permute->len; axes = permute->ptr; - if (n != ap->nd) { + if (n != PyArray_NDIM(ap)) { PyErr_SetString(PyExc_ValueError, "axes don't match array"); return NULL; @@ -715,9 +723,9 @@ PyArray_Transpose(PyArrayObject *ap, PyArray_Dims *permute) for (i = 0; i < n; i++) { axis = axes[i]; if (axis < 0) { - axis = ap->nd + axis; + axis = PyArray_NDIM(ap) + axis; } - if (axis < 0 || axis >= ap->nd) { + if (axis < 0 || axis >= PyArray_NDIM(ap)) { PyErr_SetString(PyExc_ValueError, "invalid axis for this array"); return NULL; @@ -736,26 +744,29 @@ PyArray_Transpose(PyArrayObject *ap, PyArray_Dims *permute) /* * this allocates memory for dimensions and strides (but fills them - * incorrectly), sets up descr, and points data at ap->data. + * incorrectly), sets up descr, and points data at PyArray_DATA(ap). */ - Py_INCREF(ap->descr); + Py_INCREF(PyArray_DESCR(ap)); ret = (PyArrayObject *)\ PyArray_NewFromDescr(Py_TYPE(ap), - ap->descr, - n, ap->dimensions, - NULL, ap->data, ap->flags, + PyArray_DESCR(ap), + n, PyArray_DIMS(ap), + NULL, PyArray_DATA(ap), PyArray_FLAGS(ap), (PyObject *)ap); if (ret == NULL) { return NULL; } /* point at true owner of memory: */ - ret->base = (PyObject *)ap; Py_INCREF(ap); + if (PyArray_SetBaseObject(ret, (PyObject *)ap) < 0) { + Py_DECREF(ret); + return NULL; + } /* fix the dimensions and strides of the return-array */ for (i = 0; i < n; i++) { - ret->dimensions[i] = ap->dimensions[permutation[i]]; - ret->strides[i] = ap->strides[permutation[i]]; + PyArray_DIMS(ret)[i] = PyArray_DIMS(ap)[permutation[i]]; + PyArray_STRIDES(ret)[i] = PyArray_STRIDES(ap)[permutation[i]]; } PyArray_UpdateFlags(ret, NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS); return (PyObject *)ret; @@ -866,13 +877,13 @@ PyArray_Ravel(PyArrayObject *a, NPY_ORDER order) /* If all the strides matched a contiguous layout, return a view */ if (i < 0) { - PyObject *ret; + PyArrayObject *ret; npy_intp stride = PyArray_DESCR(a)->elsize; val[0] = PyArray_SIZE(a); Py_INCREF(PyArray_DESCR(a)); - ret = PyArray_NewFromDescr(Py_TYPE(a), + ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(a), PyArray_DESCR(a), 1, val, &stride, @@ -881,12 +892,15 @@ PyArray_Ravel(PyArrayObject *a, NPY_ORDER order) (PyObject *)a); if (ret != NULL) { - PyArray_UpdateFlags((PyArrayObject *)ret, + PyArray_UpdateFlags(ret, NPY_ARRAY_C_CONTIGUOUS|NPY_ARRAY_F_CONTIGUOUS); Py_INCREF(a); - PyArray_BASE(ret) = (PyObject *)a; + if (PyArray_SetBaseObject(ret, (PyObject *)a) < 0) { + Py_DECREF(ret); + ret = NULL; + } } - return ret; + return (PyObject *)ret; } } @@ -908,9 +922,9 @@ PyArray_Flatten(PyArrayObject *a, NPY_ORDER order) } size = PyArray_SIZE(a); - Py_INCREF(a->descr); + Py_INCREF(PyArray_DESCR(a)); ret = (PyArrayObject *)PyArray_NewFromDescr(Py_TYPE(a), - a->descr, + PyArray_DESCR(a), 1, &size, NULL, NULL, @@ -919,7 +933,7 @@ PyArray_Flatten(PyArrayObject *a, NPY_ORDER order) if (ret == NULL) { return NULL; } - if (PyArray_CopyAnyIntoOrdered(ret, a, order) < 0) { + if (PyArray_CopyAsFlat(ret, a, order) < 0) { Py_DECREF(ret); return NULL; } diff --git a/numpy/core/src/npymath/halffloat.c b/numpy/core/src/npymath/halffloat.c index cea9a3bd7..d5ef57d7b 100644 --- a/numpy/core/src/npymath/halffloat.c +++ b/numpy/core/src/npymath/halffloat.c @@ -145,7 +145,7 @@ npy_half npy_half_nextafter(npy_half x, npy_half y) return ret; } - + int npy_half_eq_nonan(npy_half h1, npy_half h2) { return (h1 == h2 || ((h1 | h2) & 0x7fff) == 0); @@ -239,7 +239,7 @@ npy_uint16 npy_floatbits_to_halfbits(npy_uint32 f) h_sgn = (npy_uint16) ((f&0x80000000u) >> 16); f_exp = (f&0x7f800000u); - + /* Exponent overflow/NaN converts to signed inf/NaN */ if (f_exp >= 0x47800000u) { if (f_exp == 0x7f800000u) { @@ -265,15 +265,15 @@ npy_uint16 npy_floatbits_to_halfbits(npy_uint32 f) return (npy_uint16) (h_sgn + 0x7c00u); } } - + /* Exponent underflow converts to a subnormal half or signed zero */ if (f_exp <= 0x38000000u) { - /* + /* * Signed zeros, subnormal floats, and floats with small * exponents all convert to signed zero halfs. */ if (f_exp < 0x33000000u) { -#if NPY_HALF_GENERATE_UNDERFLOW +#if NPY_HALF_GENERATE_UNDERFLOW /* If f != 0, it underflowed to 0 */ if ((f&0x7fffffff) != 0) { npy_set_floatstatus_underflow(); @@ -284,7 +284,7 @@ npy_uint16 npy_floatbits_to_halfbits(npy_uint32 f) /* Make the subnormal significand */ f_exp >>= 23; f_sig = (0x00800000u + (f&0x007fffffu)); -#if NPY_HALF_GENERATE_UNDERFLOW +#if NPY_HALF_GENERATE_UNDERFLOW /* If it's not exactly represented, it underflowed */ if ((f_sig&(((npy_uint32)1 << (126 - f_exp)) - 1)) != 0) { npy_set_floatstatus_underflow(); @@ -292,7 +292,7 @@ npy_uint16 npy_floatbits_to_halfbits(npy_uint32 f) #endif f_sig >>= (113 - f_exp); /* Handle rounding by adding 1 to the bit beyond half precision */ -#if NPY_HALF_ROUND_TIES_TO_EVEN +#if NPY_HALF_ROUND_TIES_TO_EVEN /* * If the last bit in the half significand is 0 (already even), and * the remaining bit pattern is 1000...0, then we do not add one @@ -317,7 +317,7 @@ npy_uint16 npy_floatbits_to_halfbits(npy_uint32 f) h_exp = (npy_uint16) ((f_exp - 0x38000000u) >> 13); /* Handle rounding by adding 1 to the bit beyond half precision */ f_sig = (f&0x007fffffu); -#if NPY_HALF_ROUND_TIES_TO_EVEN +#if NPY_HALF_ROUND_TIES_TO_EVEN /* * If the last bit in the half significand is 0 (already even), and * the remaining bit pattern is 1000...0, then we do not add one @@ -354,7 +354,7 @@ npy_uint16 npy_doublebits_to_halfbits(npy_uint64 d) h_sgn = (d&0x8000000000000000ULL) >> 48; d_exp = (d&0x7ff0000000000000ULL); - + /* Exponent overflow/NaN converts to signed inf/NaN */ if (d_exp >= 0x40f0000000000000ULL) { if (d_exp == 0x7ff0000000000000ULL) { @@ -380,15 +380,15 @@ npy_uint16 npy_doublebits_to_halfbits(npy_uint64 d) return h_sgn + 0x7c00u; } } - + /* Exponent underflow converts to subnormal half or signed zero */ if (d_exp <= 0x3f00000000000000ULL) { - /* + /* * Signed zeros, subnormal floats, and floats with small * exponents all convert to signed zero halfs. */ if (d_exp < 0x3e60000000000000ULL) { -#if NPY_HALF_GENERATE_UNDERFLOW +#if NPY_HALF_GENERATE_UNDERFLOW /* If d != 0, it underflowed to 0 */ if ((d&0x7fffffffffffffffULL) != 0) { npy_set_floatstatus_underflow(); @@ -399,7 +399,7 @@ npy_uint16 npy_doublebits_to_halfbits(npy_uint64 d) /* Make the subnormal significand */ d_exp >>= 52; d_sig = (0x0010000000000000ULL + (d&0x000fffffffffffffULL)); -#if NPY_HALF_GENERATE_UNDERFLOW +#if NPY_HALF_GENERATE_UNDERFLOW /* If it's not exactly represented, it underflowed */ if ((d_sig&(((npy_uint64)1 << (1051 - d_exp)) - 1)) != 0) { npy_set_floatstatus_underflow(); @@ -407,7 +407,7 @@ npy_uint16 npy_doublebits_to_halfbits(npy_uint64 d) #endif d_sig >>= (1009 - d_exp); /* Handle rounding by adding 1 to the bit beyond half precision */ -#if NPY_HALF_ROUND_TIES_TO_EVEN +#if NPY_HALF_ROUND_TIES_TO_EVEN /* * If the last bit in the half significand is 0 (already even), and * the remaining bit pattern is 1000...0, then we do not add one @@ -432,7 +432,7 @@ npy_uint16 npy_doublebits_to_halfbits(npy_uint64 d) h_exp = (npy_uint16) ((d_exp - 0x3f00000000000000ULL) >> 42); /* Handle rounding by adding 1 to the bit beyond half precision */ d_sig = (d&0x000fffffffffffffULL); -#if NPY_HALF_ROUND_TIES_TO_EVEN +#if NPY_HALF_ROUND_TIES_TO_EVEN /* * If the last bit in the half significand is 0 (already even), and * the remaining bit pattern is 1000...0, then we do not add one @@ -527,4 +527,4 @@ npy_uint64 npy_halfbits_to_doublebits(npy_uint16 h) return d_sgn + (((npy_uint64)(h&0x7fffu) + 0xfc000u) << 42); } } - + diff --git a/numpy/core/src/npymath/ieee754.c.src b/numpy/core/src/npymath/ieee754.c.src index 71be7b8ce..a81cabe5b 100644 --- a/numpy/core/src/npymath/ieee754.c.src +++ b/numpy/core/src/npymath/ieee754.c.src @@ -128,7 +128,7 @@ float _nextf(float x, int p) #ifdef HAVE_LDOUBLE_DOUBLE_DOUBLE_BE -/* +/* * FIXME: this is ugly and untested. The asm part only works with gcc, and we * should consolidate the GET_LDOUBLE* / SET_LDOUBLE macros */ @@ -561,7 +561,7 @@ npy_longdouble npy_nextafterl(npy_longdouble x, npy_longdouble y) void npy_set_floatstatus_divbyzero(void) { fpsetsticky(FP_X_DZ); -} +} void npy_set_floatstatus_overflow(void) { @@ -593,7 +593,7 @@ void npy_set_floatstatus_invalid(void) void npy_set_floatstatus_divbyzero(void) { feraiseexcept(FE_DIVBYZERO); -} +} void npy_set_floatstatus_overflow(void) { @@ -617,7 +617,7 @@ void npy_set_floatstatus_invalid(void) void npy_set_floatstatus_divbyzero(void) { fp_raise_xcp(FP_DIV_BY_ZERO); -} +} void npy_set_floatstatus_overflow(void) { diff --git a/numpy/core/src/npysort/sort.c.src b/numpy/core/src/npysort/sort.c.src index e42597384..17f734e11 100644 --- a/numpy/core/src/npysort/sort.c.src +++ b/numpy/core/src/npysort/sort.c.src @@ -469,7 +469,7 @@ mergesort0_@suff@(@type@ *pl, @type@ *pr, @type@ *pw, @type@ *vp, size_t len) int mergesort_@suff@(@type@ *start, npy_intp num, PyArrayObject *arr) { - const size_t elsize = arr->descr->elsize; + const size_t elsize = PyArray_DESCR(arr)->elsize; const size_t len = elsize / sizeof(@type@); @type@ *pl, *pr, *pw, *vp; int err = 0; @@ -500,8 +500,8 @@ fail_0: int quicksort_@suff@(@type@ *start, npy_intp num, PyArrayObject *arr) { - const size_t len = arr->descr->elsize/sizeof(@type@); - @type@ *vp = malloc(arr->descr->elsize); + const size_t len = PyArray_DESCR(arr)->elsize/sizeof(@type@); + @type@ *vp = malloc(PyArray_DESCR(arr)->elsize); @type@ *pl = start; @type@ *pr = start + (num - 1)*len; @type@ *stack[PYA_QS_STACK], **sptr = stack, *pm, *pi, *pj, *pk; @@ -567,8 +567,8 @@ quicksort_@suff@(@type@ *start, npy_intp num, PyArrayObject *arr) int heapsort_@suff@(@type@ *start, npy_intp n, PyArrayObject *arr) { - size_t len = arr->descr->elsize/sizeof(@type@); - @type@ *tmp = malloc(arr->descr->elsize); + size_t len = PyArray_DESCR(arr)->elsize/sizeof(@type@); + @type@ *tmp = malloc(PyArray_DESCR(arr)->elsize); @type@ *a = start - len; npy_intp i,j,l; @@ -616,7 +616,7 @@ heapsort_@suff@(@type@ *start, npy_intp n, PyArrayObject *arr) int aheapsort_@suff@(@type@ *v, npy_intp *tosort, npy_intp n, PyArrayObject *arr) { - size_t len = arr->descr->elsize/sizeof(@type@); + size_t len = PyArray_DESCR(arr)->elsize/sizeof(@type@); npy_intp *a, i,j,l, tmp; /* The array needs to be offset by one for heapsort indexing */ @@ -665,7 +665,7 @@ aheapsort_@suff@(@type@ *v, npy_intp *tosort, npy_intp n, PyArrayObject *arr) int aquicksort_@suff@(@type@ *v, npy_intp* tosort, npy_intp num, PyArrayObject *arr) { - size_t len = arr->descr->elsize/sizeof(@type@); + size_t len = PyArray_DESCR(arr)->elsize/sizeof(@type@); @type@ *vp; npy_intp *pl = tosort; npy_intp *pr = tosort + num - 1; @@ -775,7 +775,7 @@ amergesort0_@suff@(npy_intp *pl, npy_intp *pr, @type@ *v, npy_intp *pw, int len) int amergesort_@suff@(@type@ *v, npy_intp *tosort, npy_intp num, PyArrayObject *arr) { - const size_t elsize = arr->descr->elsize; + const size_t elsize = PyArray_DESCR(arr)->elsize; const size_t len = elsize / sizeof(@type@); npy_intp *pl, *pr, *pw; diff --git a/numpy/core/src/private/lowlevel_strided_loops.h b/numpy/core/src/private/lowlevel_strided_loops.h index b5b8159e6..b6b53ba45 100644 --- a/numpy/core/src/private/lowlevel_strided_loops.h +++ b/numpy/core/src/private/lowlevel_strided_loops.h @@ -19,7 +19,7 @@ * The 'transferdata' parameter is slightly special, following a * generic auxiliary data pattern defined in ndarraytypes.h * Use NPY_AUXDATA_CLONE and NPY_AUXDATA_FREE to deal with this data. - * + * */ typedef void (PyArray_StridedTransferFn)(char *dst, npy_intp dst_stride, char *src, npy_intp src_stride, @@ -47,10 +47,10 @@ typedef void (PyArray_MaskedStridedTransferFn)(char *dst, npy_intp dst_stride, * aligned: * Should be 1 if the src and dst pointers are always aligned, * 0 otherwise. - * src_stride: + * src_stride: * Should be the src stride if it will always be the same, * NPY_MAX_INTP otherwise. - * dst_stride: + * dst_stride: * Should be the dst stride if it will always be the same, * NPY_MAX_INTP otherwise. * itemsize: @@ -143,10 +143,10 @@ PyArray_GetDTypeCopySwapFn(int aligned, * aligned: * Should be 1 if the src and dst pointers are always aligned, * 0 otherwise. - * src_stride: + * src_stride: * Should be the src stride if it will always be the same, * NPY_MAX_INTP otherwise. - * dst_stride: + * dst_stride: * Should be the dst stride if it will always be the same, * NPY_MAX_INTP otherwise. * src_dtype: @@ -363,9 +363,9 @@ PyArray_TransferMaskedStridedToNDim(npy_intp ndim, PyArray_CompareLists(PyArray_DIMS(arr1), \ PyArray_DIMS(arr2), \ PyArray_NDIM(arr1)) && \ - (arr1->flags&(NPY_ARRAY_C_CONTIGUOUS| \ + (PyArray_FLAGS(arr1)&(NPY_ARRAY_C_CONTIGUOUS| \ NPY_ARRAY_F_CONTIGUOUS)) == \ - (arr2->flags&(NPY_ARRAY_C_CONTIGUOUS| \ + (PyArray_FLAGS(arr2)&(NPY_ARRAY_C_CONTIGUOUS| \ NPY_ARRAY_F_CONTIGUOUS)) \ ) diff --git a/numpy/core/src/private/npy_config.h b/numpy/core/src/private/npy_config.h index b4842b832..237dc94ab 100644 --- a/numpy/core/src/private/npy_config.h +++ b/numpy/core/src/private/npy_config.h @@ -10,7 +10,7 @@ #endif /* Safe to use ldexp and frexp for long double for MSVC builds */ -#if (SIZEOF_LONG_DOUBLE == SIZEOF_DOUBLE) || defined(_MSC_VER) +#if (SIZEOF_LONG_DOUBLE == SIZEOF_DOUBLE) || defined(_MSC_VER) #ifdef HAVE_LDEXP #define HAVE_LDEXPL 1 #endif @@ -24,7 +24,7 @@ #undef HAVE_ATAN2 #endif -/* +/* * On Mac OS X, because there is only one configuration stage for all the archs * in universal builds, any macro which depends on the arch needs to be * harcoded diff --git a/numpy/core/src/umath/ufunc_object.c b/numpy/core/src/umath/ufunc_object.c index 2ffca63d2..1aca37bc7 100644 --- a/numpy/core/src/umath/ufunc_object.c +++ b/numpy/core/src/umath/ufunc_object.c @@ -61,7 +61,6 @@ /********************/ #define USE_USE_DEFAULTS 1 -#define USE_NEW_ITERATOR_GENFUNC 1 /********************/ /* ---------------------------------------------------------------- */ @@ -798,7 +797,7 @@ static int get_ufunc_arguments(PyUFuncObject *self, } /* If it's an array, can use it */ if (PyArray_Check(obj)) { - if (!PyArray_ISWRITEABLE(obj)) { + if (!PyArray_ISWRITEABLE((PyArrayObject *)obj)) { PyErr_SetString(PyExc_ValueError, "return array is not writeable"); return -1; @@ -890,7 +889,7 @@ static int get_ufunc_arguments(PyUFuncObject *self, } if (PyArray_Check(value)) { - if (!PyArray_ISWRITEABLE(value)) { + if (!PyArray_ISWRITEABLE((PyArrayObject *)value)) { PyErr_SetString(PyExc_ValueError, "return array is not writeable"); goto fail; @@ -1116,6 +1115,7 @@ prepare_ufunc_output(PyUFuncObject *self, { if (arr_prep != NULL && arr_prep != Py_None) { PyObject *res; + PyArrayObject *arr; res = PyObject_CallFunction(arr_prep, "O(OOi)", *op, self, arr_prep_args, i); @@ -1128,32 +1128,33 @@ prepare_ufunc_output(PyUFuncObject *self, Py_XDECREF(res); return -1; } + arr = (PyArrayObject *)res; /* If the same object was returned, nothing to do */ - if (res == (PyObject *)*op) { - Py_DECREF(res); + if (arr == *op) { + Py_DECREF(arr); } /* If the result doesn't match, throw an error */ - else if (PyArray_NDIM(res) != PyArray_NDIM(*op) || - !PyArray_CompareLists(PyArray_DIMS(res), + else if (PyArray_NDIM(arr) != PyArray_NDIM(*op) || + !PyArray_CompareLists(PyArray_DIMS(arr), PyArray_DIMS(*op), - PyArray_NDIM(res)) || - !PyArray_CompareLists(PyArray_STRIDES(res), + PyArray_NDIM(arr)) || + !PyArray_CompareLists(PyArray_STRIDES(arr), PyArray_STRIDES(*op), - PyArray_NDIM(res)) || - !PyArray_EquivTypes(PyArray_DESCR(res), + PyArray_NDIM(arr)) || + !PyArray_EquivTypes(PyArray_DESCR(arr), PyArray_DESCR(*op))) { PyErr_SetString(PyExc_TypeError, "__array_prepare__ must return an " "ndarray or subclass thereof which is " "otherwise identical to its input"); - Py_DECREF(res); + Py_DECREF(arr); return -1; } /* Replace the op value */ else { Py_DECREF(*op); - *op = (PyArrayObject *)res; + *op = arr; } } @@ -3468,7 +3469,7 @@ PyUFunc_GenericReduction(PyUFuncObject *self, PyObject *args, return NULL; } /* Check to see if input is zero-dimensional */ - if (mp->nd == 0) { + if (PyArray_NDIM(mp) == 0) { PyErr_Format(PyExc_TypeError, "cannot %s on a scalar", _reduce_type[operation]); Py_XDECREF(otype); @@ -3487,9 +3488,9 @@ PyUFunc_GenericReduction(PyUFuncObject *self, PyObject *args, } if (axis < 0) { - axis += mp->nd; + axis += PyArray_NDIM(mp); } - if (axis < 0 || axis >= mp->nd) { + if (axis < 0 || axis >= PyArray_NDIM(mp)) { PyErr_SetString(PyExc_ValueError, "axis not in array"); Py_XDECREF(otype); Py_DECREF(mp); @@ -3500,7 +3501,7 @@ PyUFunc_GenericReduction(PyUFuncObject *self, PyObject *args, * unless otype already specified. */ if (otype == NULL && out != NULL) { - otype = out->descr; + otype = PyArray_DESCR(out); Py_INCREF(otype); } if (otype == NULL) { @@ -3515,7 +3516,7 @@ PyUFunc_GenericReduction(PyUFuncObject *self, PyObject *args, if (PyTypeNum_ISBOOL(typenum)) { typenum = PyArray_LONG; } - else if ((size_t)mp->descr->elsize < sizeof(long)) { + else if ((size_t)PyArray_DESCR(mp)->elsize < sizeof(long)) { if (PyTypeNum_ISUNSIGNED(typenum)) { typenum = PyArray_ULONG; } @@ -4322,16 +4323,16 @@ ufunc_outer(PyUFuncObject *self, PyObject *args, PyObject *kwds) return NULL; } /* Construct new shape tuple */ - shape1 = PyTuple_New(ap1->nd); + shape1 = PyTuple_New(PyArray_NDIM(ap1)); if (shape1 == NULL) { goto fail; } - for (i = 0; i < ap1->nd; i++) { + for (i = 0; i < PyArray_NDIM(ap1); i++) { PyTuple_SET_ITEM(shape1, i, - PyLong_FromLongLong((longlong)ap1->dimensions[i])); + PyLong_FromLongLong((longlong)PyArray_DIMS(ap1)[i])); } - shape2 = PyTuple_New(ap2->nd); - for (i = 0; i < ap2->nd; i++) { + shape2 = PyTuple_New(PyArray_NDIM(ap2)); + for (i = 0; i < PyArray_NDIM(ap2); i++) { PyTuple_SET_ITEM(shape2, i, PyInt_FromLong((long) 1)); } if (shape2 == NULL) { diff --git a/numpy/core/src/umath/ufunc_type_resolution.c b/numpy/core/src/umath/ufunc_type_resolution.c index b08a7f165..fb7352070 100644 --- a/numpy/core/src/umath/ufunc_type_resolution.c +++ b/numpy/core/src/umath/ufunc_type_resolution.c @@ -665,7 +665,7 @@ timedelta_dtype_with_copied_meta(PyArray_Descr *dtype) * m8[<A>] + M8[<B>] => m8[gcd(<A>,<B>)] + M8[gcd(<A>,<B>)] * TODO: Non-linear time unit cases require highly special-cased loops * M8[<A>] + m8[Y|M|B] - * m8[Y|M|B] + M8[<A>] + * m8[Y|M|B] + M8[<A>] */ NPY_NO_EXPORT int PyUFunc_AdditionTypeResolution(PyUFuncObject *ufunc, @@ -1360,7 +1360,7 @@ static NpyAuxData * ufunc_masker_data_clone(NpyAuxData *data) { _ufunc_masker_data *n; - + /* Allocate a new one */ n = (_ufunc_masker_data *)PyArray_malloc(sizeof(_ufunc_masker_data)); if (n == NULL) { diff --git a/numpy/core/tests/test_datetime.py b/numpy/core/tests/test_datetime.py index f5673b61f..a624768b6 100644 --- a/numpy/core/tests/test_datetime.py +++ b/numpy/core/tests/test_datetime.py @@ -514,7 +514,7 @@ class TestDateTime(TestCase): formatter={'datetime': lambda x : "'%s'" % np.datetime_as_string(x, timezone='UTC')}), "['2011-03-16T13:55Z', '1920-01-01T03:12Z']") - + def test_pickle(self): # Check that pickle roundtripping works diff --git a/numpy/core/tests/test_dtype.py b/numpy/core/tests/test_dtype.py index ff13dcad6..6dc3e7554 100644 --- a/numpy/core/tests/test_dtype.py +++ b/numpy/core/tests/test_dtype.py @@ -185,6 +185,12 @@ class TestRecord(TestCase): 'formats':['i1', 'O'], 'offsets':[np.dtype('intp').itemsize, 0]}) + def test_comma_datetime(self): + dt = np.dtype('M8[D],datetime64[Y],i8') + assert_equal(dt, np.dtype([('f0', 'M8[D]'), + ('f1', 'datetime64[Y]'), + ('f2', 'i8')])) + class TestSubarray(TestCase): def test_single_subarray(self): a = np.dtype((np.int, (2))) @@ -291,6 +297,25 @@ class TestString(TestCase): "('bottom', [('bleft', ('>f4', (8, 64)), (1,)), " "('bright', '>f4', (8, 36))])]") + # If the sticky aligned flag is set to True, it makes the + # str() function use a dict representation with an 'aligned' flag + dt = np.dtype([('top', [('tiles', ('>f4', (64, 64)), (1,)), + ('rtile', '>f4', (64, 36))], + (3,)), + ('bottom', [('bleft', ('>f4', (8, 64)), (1,)), + ('bright', '>f4', (8, 36))])], + align=True) + assert_equal(str(dt), + "{'names':['top','bottom'], " + "'formats':[([('tiles', ('>f4', (64, 64)), (1,)), " + "('rtile', '>f4', (64, 36))], (3,))," + "[('bleft', ('>f4', (8, 64)), (1,)), " + "('bright', '>f4', (8, 36))]], " + "'offsets':[0,76800], " + "'itemsize':80000, " + "'aligned':True}") + assert_equal(np.dtype(eval(str(dt))), dt) + dt = np.dtype({'names': ['r','g','b'], 'formats': ['u1', 'u1', 'u1'], 'offsets': [0, 1, 2], 'titles': ['Red pixel', 'Green pixel', 'Blue pixel']}) @@ -322,6 +347,10 @@ class TestString(TestCase): " 'titles':['Red pixel','Blue pixel']," " 'itemsize':3}") + dt = np.dtype([('a', '<m8[D]'), ('b', '<M8[us]')]) + assert_equal(str(dt), + "[('a', '<m8[D]'), ('b', '<M8[us]')]") + def test_complex_dtype_repr(self): dt = np.dtype([('top', [('tiles', ('>f4', (64, 64)), (1,)), ('rtile', '>f4', (64, 36))], (3,)), @@ -366,5 +395,10 @@ class TestString(TestCase): "'titles':['Red pixel','Blue pixel'], " "'itemsize':4})") + dt = np.dtype([('a', '<M8[D]'), ('b', '<m8[us]')]) + assert_equal(repr(dt), + "dtype([('a', '<M8[D]'), ('b', '<m8[us]')])") + + if __name__ == "__main__": run_module_suite() diff --git a/numpy/core/tests/test_einsum.py b/numpy/core/tests/test_einsum.py index d0161b366..d7136db51 100644 --- a/numpy/core/tests/test_einsum.py +++ b/numpy/core/tests/test_einsum.py @@ -71,7 +71,8 @@ class TestEinSum(TestCase): def test_einsum_views(self): # pass-through - a = np.arange(6).reshape(2,3) + a = np.arange(6) + a.shape = (2,3) b = np.einsum("...", a) assert_(b.base is a) @@ -88,7 +89,8 @@ class TestEinSum(TestCase): assert_equal(b, a) # transpose - a = np.arange(6).reshape(2,3) + a = np.arange(6) + a.shape = (2,3) b = np.einsum("ji", a) assert_(b.base is a) @@ -99,7 +101,8 @@ class TestEinSum(TestCase): assert_equal(b, a.T) # diagonal - a = np.arange(9).reshape(3,3) + a = np.arange(9) + a.shape = (3,3) b = np.einsum("ii->i", a) assert_(b.base is a) @@ -110,7 +113,8 @@ class TestEinSum(TestCase): assert_equal(b, [a[i,i] for i in range(3)]) # diagonal with various ways of broadcasting an additional dimension - a = np.arange(27).reshape(3,3,3) + a = np.arange(27) + a.shape = (3,3,3) b = np.einsum("...ii->...i", a) assert_(b.base is a) @@ -173,7 +177,8 @@ class TestEinSum(TestCase): for x in a.transpose(1,0,2)]) # triple diagonal - a = np.arange(27).reshape(3,3,3) + a = np.arange(27) + a.shape = (3,3,3) b = np.einsum("iii->i", a) assert_(b.base is a) @@ -184,7 +189,8 @@ class TestEinSum(TestCase): assert_equal(b, [a[i,i,i] for i in range(3)]) # swap axes - a = np.arange(24).reshape(2,3,4) + a = np.arange(24) + a.shape = (2,3,4) b = np.einsum("ijk->jik", a) assert_(b.base is a) diff --git a/numpy/core/tests/test_half.py b/numpy/core/tests/test_half.py index 37fce6460..8f1aa92c2 100644 --- a/numpy/core/tests/test_half.py +++ b/numpy/core/tests/test_half.py @@ -221,7 +221,7 @@ class TestHalf(TestCase): a = np.zeros((5,), dtype=float16) a.fill(1) assert_equal(a, np.ones((5,), dtype=float16)) - + # nonzero and copyswap a = np.array([0,0,-1,-1/1e20,0,2.0**-24, 7.629e-6], dtype=float16) assert_equal(a.nonzero()[0], @@ -235,7 +235,7 @@ class TestHalf(TestCase): b = np.ones((20,), dtype=float16) assert_equal(np.dot(a,b), 95) - + # argmax a = np.array([0, -np.inf, -2, 0.5, 12.55, 7.3, 2.1, 12.4], dtype=float16) assert_equal(a.argmax(), @@ -271,7 +271,7 @@ class TestHalf(TestCase): assert_equal(np.nextafter(a_f16[0], hinf), -a_f16[1]) assert_equal(np.nextafter(a_f16[1:], hinf), a_f16[:-1]) assert_equal(np.nextafter(a_f16[:-1], -hinf), a_f16[1:]) - + def test_half_ufuncs(self): """Test the various ufuncs""" @@ -302,7 +302,7 @@ class TestHalf(TestCase): assert_equal(np.signbit(b), [True,False,False,False,False]) assert_equal(np.copysign(b,a), [2,5,1,4,3]) - + assert_equal(np.maximum(a,b), [0,5,2,4,3]) x = np.maximum(b,c) assert_(np.isnan(x[3])) @@ -365,7 +365,7 @@ class TestHalf(TestCase): bx16 = np.array((1e4,),dtype=float16) sy16 = float16(1e-4) by16 = float16(1e4) - + # Underflow errors assert_raises_fpe('underflow', lambda a,b:a*b, sx16, sx16) assert_raises_fpe('underflow', lambda a,b:a*b, sx16, sy16) diff --git a/numpy/core/tests/test_memmap.py b/numpy/core/tests/test_memmap.py index 18b356ce2..fa4eb9de0 100644 --- a/numpy/core/tests/test_memmap.py +++ b/numpy/core/tests/test_memmap.py @@ -4,7 +4,7 @@ import warnings from numpy import memmap from numpy import arange, allclose -from numpy.testing import TestCase, assert_, assert_array_equal +from numpy.testing import * class TestMemmap(TestCase): def setUp(self): @@ -69,23 +69,22 @@ class TestMemmap(TestCase): fp = memmap(self.tmpfp, dtype=self.dtype, mode='w+', shape=self.shape) fp[:] = self.data[:] + assert_equal(fp[0], self.data[0]) fp.flush() def test_del(self): # Make sure a view does not delete the underlying mmap fp_base = memmap(self.tmpfp, dtype=self.dtype, mode='w+', shape=self.shape) - fp_view = fp_base[:] - class ViewCloseError(Exception): - pass - _close = memmap._close - def replace_close(self): - raise ViewCloseError('View should not call _close on memmap') - try: - memmap._close = replace_close - del fp_view - finally: - memmap._close = _close + fp_base[0] = 5 + fp_view = fp_base[0:1] + assert_equal(fp_view[0], 5) + del fp_view + # Should still be able to access and assign values after + # deleting the view + assert_equal(fp_base[0], 5) + fp_base[0] = 6 + assert_equal(fp_base[0], 6) if __name__ == "__main__": run_module_suite() diff --git a/numpy/core/tests/test_multiarray.py b/numpy/core/tests/test_multiarray.py index 6821fbe49..03f1b10c6 100644 --- a/numpy/core/tests/test_multiarray.py +++ b/numpy/core/tests/test_multiarray.py @@ -1056,8 +1056,12 @@ class TestPutmask(object): dtype=[('x', '<f8'), ('y', '>f8'), ('z', '<f8')]) np.putmask(rec['x'],[True,False],10) assert_array_equal(rec['x'],[10,5]) - np.putmask(rec['y'],[True,False],10) - assert_array_equal(rec['y'],[10,4]) + assert_array_equal(rec['y'],[2,4]) + assert_array_equal(rec['z'],[3,3]) + np.putmask(rec['y'],[True,False],11) + assert_array_equal(rec['x'],[10,5]) + assert_array_equal(rec['y'],[11,4]) + assert_array_equal(rec['z'],[3,3]) def test_masked_array(self): ## x = np.array([1,2,3]) diff --git a/numpy/core/tests/test_ufunc.py b/numpy/core/tests/test_ufunc.py index 974a6d6f8..773ce9a3b 100644 --- a/numpy/core/tests/test_ufunc.py +++ b/numpy/core/tests/test_ufunc.py @@ -299,7 +299,7 @@ class TestUfunc(TestCase): b[:] = 0 np.add(a,0.5,sig=('i4','i4','i4'),out=b, casting='unsafe') assert_equal(b, [0, 0, 1]) - + def test_inner1d(self): a = np.arange(6).reshape((2,3)) @@ -458,8 +458,8 @@ class TestUfunc(TestCase): for s2 in slice_3: a1 = d1.transpose(p1)[s1] a2 = d2.transpose(p2)[s2] - ref = ref and a1.base != None and a1.base.base != None - ref = ref and a2.base != None and a2.base.base != None + ref = ref and a1.base != None + ref = ref and a2.base != None if broadcastable(a1.shape[-1], a2.shape[-2]) and \ broadcastable(a1.shape[0], a2.shape[0]): assert_array_almost_equal( diff --git a/numpy/f2py/doc/multiarray/array_from_pyobj.c b/numpy/f2py/doc/multiarray/array_from_pyobj.c index 7e0de9a74..5a700eecf 100644 --- a/numpy/f2py/doc/multiarray/array_from_pyobj.c +++ b/numpy/f2py/doc/multiarray/array_from_pyobj.c @@ -1,14 +1,14 @@ -/* - * File: array_from_pyobj.c +/* + * File: array_from_pyobj.c * * Description: - * ------------ + * ------------ * Provides array_from_pyobj function that returns a contigious array * object with the given dimensions and required storage order, either * in row-major (C) or column-major (Fortran) order. The function * array_from_pyobj is very flexible about its Python object argument * that can be any number, list, tuple, or array. - * + * * array_from_pyobj is used in f2py generated Python extension * modules. * @@ -80,8 +80,8 @@ PyArrayObject* array_from_pyobj(const int type_num, if (intent & F2PY_INTENT_CACHE) { /* Don't expect correct storage order or anything reasonable when - returning cache array. */ - if ((intent & F2PY_INTENT_HIDE) + returning cache array. */ + if ((intent & F2PY_INTENT_HIDE) || (obj==Py_None)) { PyArrayObject *arr = NULL; CHECK_DIMS_DEFINED(rank,dims,"optional,intent(cache) must" @@ -92,7 +92,7 @@ PyArrayObject* array_from_pyobj(const int type_num, Py_INCREF(arr); return arr; } - if (PyArray_Check(obj) + if (PyArray_Check(obj) && ISCONTIGUOUS((PyArrayObject *)obj) && HAS_PROPER_ELSIZE((PyArrayObject *)obj,type_num) ) { @@ -124,7 +124,7 @@ PyArrayObject* array_from_pyobj(const int type_num, intent(inout) */ PyArrayObject *arr = (PyArrayObject *)obj; - int is_cont = (intent & F2PY_INTENT_C) ? + int is_cont = (intent & F2PY_INTENT_C) ? (ISCONTIGUOUS(arr)) : (array_has_column_major_storage(arr)); if (check_and_fix_dimensions(arr,rank,dims)) @@ -166,7 +166,7 @@ PyArrayObject* array_from_pyobj(const int type_num, if ((obj==Py_None) && (intent & F2PY_OPTIONAL)) { PyArrayObject *arr = NULL; - CHECK_DIMS_DEFINED(rank,dims,"optional must have defined dimensions.\n"); + CHECK_DIMS_DEFINED(rank,dims,"optional must have defined dimensions.\n"); arr = (PyArrayObject *)PyArray_FromDims(rank,dims,type_num); ARR_IS_NULL(arr,"FromDims failed: optional.\n"); if (intent & F2PY_INTENT_OUT) { @@ -240,8 +240,8 @@ void lazy_transpose(PyArrayObject* arr) { Note that this function is assumed to be used even times for a given array. Otherwise, the caller should set flags &= ~CONTIGUOUS. */ - int rank,i,s,j; - rank = arr->nd; + int rank,i,s,j; + rank = arr->nd; if (rank < 2) return; for(i=0,j=rank-1;i<rank/2;++i,--j) { @@ -268,7 +268,7 @@ int check_and_fix_dimensions(const PyArrayObject* arr,const int rank,int *dims) int free_axe = -1; int i; /* Fill dims where -1 or 0; check dimensions; calc new_size; */ - for(i=0;i<arr->nd;++i) { + for(i=0;i<arr->nd;++i) { if (dims[i] >= 0) { if (dims[i]!=arr->dimensions[i]) { fprintf(stderr,"%d-th dimension must be fixed to %d but got %d\n", @@ -311,7 +311,7 @@ int check_and_fix_dimensions(const PyArrayObject* arr,const int rank,int *dims) if (arr->dimensions[i]!=dims[i]) { fprintf(stderr,"%d-th dimension must be fixed to %d but got %d\n", i,dims[i],arr->dimensions[i]); - return 1; + return 1; } if (!dims[i]) dims[i] = 1; } else diff --git a/numpy/lib/npyio.py b/numpy/lib/npyio.py index 13f659d70..f7cde270d 100644 --- a/numpy/lib/npyio.py +++ b/numpy/lib/npyio.py @@ -627,7 +627,7 @@ def loadtxt(fname, dtype=float, comments='#', delimiter=None, data-type, arrays are returned for each field. Default is False. ndmin : int, optional The returned array will have at least `ndmin` dimensions. - Otherwise mono-dimensional axes will be squeezed. + Otherwise mono-dimensional axes will be squeezed. Legal values: 0 (default), 1 or 2. .. versionadded:: 1.6.0 @@ -803,7 +803,7 @@ def loadtxt(fname, dtype=float, comments='#', delimiter=None, fh.close() X = np.array(X, dtype) - # Multicolumn data are returned with shape (1, N, M), i.e. + # Multicolumn data are returned with shape (1, N, M), i.e. # (1, 1, M) for a single row - remove the singleton dimension there if X.ndim == 3 and X.shape[:2] == (1, 1): X.shape = (1, -1) diff --git a/numpy/lib/src/_compiled_base.c b/numpy/lib/src/_compiled_base.c index 066519bf1..ea7205a8a 100644 --- a/numpy/lib/src/_compiled_base.c +++ b/numpy/lib/src/_compiled_base.c @@ -1,12 +1,13 @@ +#define NPY_NO_DEPRECATED_API #include "Python.h" #include "structmember.h" #include "numpy/noprefix.h" #include "npy_config.h" -static intp -incr_slot_(double x, double *bins, intp lbins) +static npy_intp +incr_slot_(double x, double *bins, npy_intp lbins) { - intp i; + npy_intp i; for ( i = 0; i < lbins; i ++ ) { if ( x < bins [i] ) { @@ -16,10 +17,10 @@ incr_slot_(double x, double *bins, intp lbins) return lbins; } -static intp -decr_slot_(double x, double * bins, intp lbins) +static npy_intp +decr_slot_(double x, double * bins, npy_intp lbins) { - intp i; + npy_intp i; for ( i = lbins - 1; i >= 0; i -- ) { if (x < bins [i]) { @@ -57,11 +58,11 @@ monotonic_(double * a, int lena) /* find the index of the maximum element of an integer array */ -static intp -mxx (intp *i , intp len) +static npy_intp +mxx (npy_intp *i , npy_intp len) { - intp mx = 0, max = i[0]; - intp j; + npy_intp mx = 0, max = i[0]; + npy_intp j; for ( j = 1; j < len; j ++ ) { if ( i [j] > max ) { @@ -73,11 +74,11 @@ mxx (intp *i , intp len) } /* find the index of the minimum element of an integer array */ -static intp -mnx (intp *i , intp len) +static npy_intp +mnx (npy_intp *i , npy_intp len) { - intp mn = 0, min = i [0]; - intp j; + npy_intp mn = 0, min = i [0]; + npy_intp j; for ( j = 1; j < len; j ++ ) if ( i [j] < min ) @@ -105,8 +106,8 @@ arr_bincount(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwds) { PyArray_Descr *type; PyObject *list = NULL, *weight=Py_None, *mlength=Py_None; - PyObject *lst=NULL, *ans=NULL, *wts=NULL; - intp *numbers, *ians, len , mxi, mni, ans_size, minlength; + PyArrayObject *lst=NULL, *ans=NULL, *wts=NULL; + npy_intp *numbers, *ians, len , mxi, mni, ans_size, minlength; int i; double *weights , *dans; static char *kwlist[] = {"list", "weights", "minlength", NULL}; @@ -115,8 +116,9 @@ arr_bincount(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwds) kwlist, &list, &weight, &mlength)) { goto fail; } - if (!(lst = PyArray_ContiguousFromAny(list, PyArray_INTP, 1, 1))) { - goto fail; + lst = (PyArrayObject *)PyArray_ContiguousFromAny(list, NPY_INTP, 1, 1); + if (lst == NULL) { + goto fail; } len = PyArray_SIZE(lst); if (len < 1) { @@ -124,7 +126,7 @@ arr_bincount(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwds) "The first argument cannot be empty."); goto fail; } - numbers = (intp *) PyArray_DATA(lst); + numbers = (npy_intp *) PyArray_DATA(lst); mxi = mxx(numbers, len); mni = mnx(numbers, len); if (numbers[mni] < 0) { @@ -147,18 +149,21 @@ arr_bincount(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwds) ans_size = minlength; } } - type = PyArray_DescrFromType(PyArray_INTP); + type = PyArray_DescrFromType(NPY_INTP); if (weight == Py_None) { - if (!(ans = PyArray_Zeros(1, &ans_size, type, 0))) { + ans = (PyArrayObject *)PyArray_Zeros(1, &ans_size, type, 0); + if (ans == NULL) { goto fail; } - ians = (intp *)(PyArray_DATA(ans)); + ians = (npy_intp *)(PyArray_DATA(ans)); for (i = 0; i < len; i++) ians [numbers [i]] += 1; Py_DECREF(lst); } else { - if (!(wts = PyArray_ContiguousFromAny(weight, PyArray_DOUBLE, 1, 1))) { + wts = (PyArrayObject *)PyArray_ContiguousFromAny( + weight, NPY_DOUBLE, 1, 1); + if (wts == NULL) { goto fail; } weights = (double *)PyArray_DATA (wts); @@ -167,18 +172,19 @@ arr_bincount(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwds) "The weights and list don't have the same length."); goto fail; } - type = PyArray_DescrFromType(PyArray_DOUBLE); - if (!(ans = PyArray_Zeros(1, &ans_size, type, 0))) { + type = PyArray_DescrFromType(NPY_DOUBLE); + ans = (PyArrayObject *)PyArray_Zeros(1, &ans_size, type, 0); + if (ans == NULL) { goto fail; } - dans = (double *)PyArray_DATA (ans); + dans = (double *)PyArray_DATA(ans); for (i = 0; i < len; i++) { dans[numbers[i]] += weights[i]; } Py_DECREF(lst); Py_DECREF(wts); } - return ans; + return (PyObject *)ans; fail: Py_XDECREF(lst); @@ -200,10 +206,10 @@ arr_digitize(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwds) { /* self is not used */ PyObject *ox, *obins; - PyObject *ax = NULL, *abins = NULL, *aret = NULL; + PyArrayObject *ax = NULL, *abins = NULL, *aret = NULL; double *dx, *dbins; - intp lbins, lx; /* lengths */ - intp *iret; + npy_intp lbins, lx; /* lengths */ + npy_intp *iret; int m, i; static char *kwlist[] = {"x", "bins", NULL}; PyArray_Descr *type; @@ -211,12 +217,16 @@ arr_digitize(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwds) if (!PyArg_ParseTupleAndKeywords(args, kwds, "OO", kwlist, &ox, &obins)) { goto fail; } - type = PyArray_DescrFromType(PyArray_DOUBLE); - if (!(ax = PyArray_FromAny(ox, type, 1, 1, CARRAY, NULL))) { + type = PyArray_DescrFromType(NPY_DOUBLE); + ax = (PyArrayObject *)PyArray_FromAny(ox, type, + 1, 1, NPY_ARRAY_CARRAY, NULL); + if (ax == NULL) { goto fail; } Py_INCREF(type); - if (!(abins = PyArray_FromAny(obins, type, 1, 1, CARRAY, NULL))) { + abins = (PyArrayObject *)PyArray_FromAny(obins, type, + 1, 1, NPY_ARRAY_CARRAY, NULL); + if (abins == NULL) { goto fail; } @@ -224,10 +234,11 @@ arr_digitize(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwds) dx = (double *)PyArray_DATA(ax); lbins = PyArray_SIZE(abins); dbins = (double *)PyArray_DATA(abins); - if (!(aret = PyArray_SimpleNew(1, &lx, PyArray_INTP))) { + aret = (PyArrayObject *)PyArray_SimpleNew(1, &lx, NPY_INTP); + if (aret == NULL) { goto fail; } - iret = (intp *)PyArray_DATA(aret); + iret = (npy_intp *)PyArray_DATA(aret); if (lx <= 0 || lbins < 0) { PyErr_SetString(PyExc_ValueError, @@ -266,7 +277,7 @@ arr_digitize(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwds) Py_DECREF(ax); Py_DECREF(abins); - return aret; + return (PyObject *)aret; fail: Py_XDECREF(ax); @@ -291,7 +302,7 @@ arr_insert(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwdict) int numvals, totmask, sameshape; char *input_data, *mptr, *vptr, *zero = NULL; int melsize, delsize, copied, nd; - intp *instrides, *inshape; + npy_intp *instrides, *inshape; int mindx, rem_indx, indx, i, k, objarray; static char *kwlist[] = {"input", "mask", "vals", NULL}; @@ -302,13 +313,13 @@ arr_insert(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwdict) goto fail; } - amask = (PyArrayObject *) PyArray_FROM_OF(mask, CARRAY); + amask = (PyArrayObject *)PyArray_FROM_OF(mask, NPY_ARRAY_CARRAY); if (amask == NULL) { goto fail; } /* Cast an object array */ - if (amask->descr->type_num == PyArray_OBJECT) { - tmp = (PyArrayObject *)PyArray_Cast(amask, PyArray_INTP); + if (PyArray_DESCR(amask)->type_num == NPY_OBJECT) { + tmp = (PyArrayObject *)PyArray_Cast(amask, NPY_INTP); if (tmp == NULL) { goto fail; } @@ -317,16 +328,16 @@ arr_insert(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwdict) } sameshape = 1; - if (amask->nd == ainput->nd) { - for (k = 0; k < amask->nd; k++) { - if (amask->dimensions[k] != ainput->dimensions[k]) { + if (PyArray_NDIM(amask) == PyArray_NDIM(ainput)) { + for (k = 0; k < PyArray_NDIM(amask); k++) { + if (PyArray_DIMS(amask)[k] != PyArray_DIMS(ainput)[k]) { sameshape = 0; } } } else { /* Test to see if amask is 1d */ - if (amask->nd != 1) { + if (PyArray_NDIM(amask) != 1) { sameshape = 0; } else if ((PyArray_SIZE(ainput)) != PyArray_SIZE(amask)) { @@ -339,22 +350,23 @@ arr_insert(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwdict) goto fail; } - avals = (PyArrayObject *)PyArray_FromObject(vals, ainput->descr->type_num, 0, 1); + avals = (PyArrayObject *)PyArray_FromObject(vals, + PyArray_DESCR(ainput)->type_num, 0, 1); if (avals == NULL) { goto fail; } numvals = PyArray_SIZE(avals); - nd = ainput->nd; - input_data = ainput->data; - mptr = amask->data; - melsize = amask->descr->elsize; - vptr = avals->data; - delsize = avals->descr->elsize; + nd = PyArray_NDIM(ainput); + input_data = PyArray_DATA(ainput); + mptr = PyArray_DATA(amask); + melsize = PyArray_DESCR(amask)->elsize; + vptr = PyArray_DATA(avals); + delsize = PyArray_DESCR(avals)->elsize; zero = PyArray_Zero(amask); if (zero == NULL) { goto fail; } - objarray = (ainput->descr->type_num == PyArray_OBJECT); + objarray = (PyArray_DESCR(ainput)->type_num == NPY_OBJECT); /* Handle zero-dimensional case separately */ if (nd == 0) { @@ -380,8 +392,8 @@ arr_insert(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwdict) */ totmask = (int) PyArray_SIZE(amask); copied = 0; - instrides = ainput->strides; - inshape = ainput->dimensions; + instrides = PyArray_STRIDES(ainput); + inshape = PyArray_DIMS(ainput); for (mindx = 0; mindx < totmask; mindx++) { if (memcmp(mptr,zero,melsize) != 0) { /* compute indx into input array */ @@ -402,7 +414,7 @@ arr_insert(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwdict) copied += 1; /* If we move past value data. Reset */ if (copied >= numvals) { - vptr = avals->data; + vptr = PyArray_DATA(avals); } } mptr += melsize; @@ -476,31 +488,32 @@ arr_interp(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwdict) return NULL; } - afp = (NPY_AO*)PyArray_ContiguousFromAny(fp, NPY_DOUBLE, 1, 1); + afp = (PyArrayObject *)PyArray_ContiguousFromAny(fp, NPY_DOUBLE, 1, 1); if (afp == NULL) { return NULL; } - axp = (NPY_AO*)PyArray_ContiguousFromAny(xp, NPY_DOUBLE, 1, 1); + axp = (PyArrayObject *)PyArray_ContiguousFromAny(xp, NPY_DOUBLE, 1, 1); if (axp == NULL) { goto fail; } - ax = (NPY_AO*)PyArray_ContiguousFromAny(x, NPY_DOUBLE, 1, 0); + ax = (PyArrayObject *)PyArray_ContiguousFromAny(x, NPY_DOUBLE, 1, 0); if (ax == NULL) { goto fail; } - lenxp = axp->dimensions[0]; + lenxp = PyArray_DIMS(axp)[0]; if (lenxp == 0) { PyErr_SetString(PyExc_ValueError, "array of sample points is empty"); goto fail; } - if (afp->dimensions[0] != lenxp) { + if (PyArray_DIMS(afp)[0] != lenxp) { PyErr_SetString(PyExc_ValueError, "fp and xp are not of the same length."); goto fail; } - af = (NPY_AO*)PyArray_SimpleNew(ax->nd, ax->dimensions, NPY_DOUBLE); + af = (PyArrayObject *)PyArray_SimpleNew(PyArray_NDIM(ax), + PyArray_DIMS(ax), NPY_DOUBLE); if (af == NULL) { goto fail; } @@ -1038,7 +1051,10 @@ arr_unravel_index(PyObject *self, PyObject *args, PyObject *kwds) goto fail; } Py_INCREF(ret_arr); - view->base = (PyObject *)ret_arr; + if (PyArray_SetBaseObject(view, (PyObject *)ret_arr) < 0) { + Py_DECREF(view); + goto fail; + } PyTuple_SET_ITEM(ret_tuple, i, PyArray_Return(view)); } @@ -1246,8 +1262,8 @@ static PyObject * pack_or_unpack_bits(PyObject *input, int axis, int unpack) { PyArrayObject *inp; - PyObject *new = NULL; - PyObject *out = NULL; + PyArrayObject *new = NULL; + PyArrayObject *out = NULL; npy_intp outdims[MAX_DIMS]; int i; void (*thefunc)(void *, int, npy_intp, npy_intp, void *, npy_intp, npy_intp); @@ -1271,25 +1287,25 @@ pack_or_unpack_bits(PyObject *input, int axis, int unpack) goto fail; } - new = PyArray_CheckAxis(inp, &axis, 0); + new = (PyArrayObject *)PyArray_CheckAxis(inp, &axis, 0); Py_DECREF(inp); if (new == NULL) { return NULL; } /* Handle zero-dim array separately */ if (PyArray_SIZE(new) == 0) { - return PyArray_Copy((PyArrayObject *)new); + return PyArray_Copy(new); } if (PyArray_NDIM(new) == 0) { if (unpack) { /* Handle 0-d array by converting it to a 1-d array */ - PyObject *temp; + PyArrayObject *temp; PyArray_Dims newdim = {NULL, 1}; npy_intp shape = 1; newdim.ptr = &shape; - temp = PyArray_Newshape((PyArrayObject *)new, &newdim, NPY_CORDER); + temp = (PyArrayObject *)PyArray_Newshape(new, &newdim, NPY_CORDER); if (temp == NULL) { goto fail; } @@ -1297,8 +1313,8 @@ pack_or_unpack_bits(PyObject *input, int axis, int unpack) new = temp; } else { - ubyte *optr, *iptr; - out = PyArray_New(new->ob_type, 0, NULL, NPY_UBYTE, + char *optr, *iptr; + out = (PyArrayObject *)PyArray_New(new->ob_type, 0, NULL, NPY_UBYTE, NULL, NULL, 0, 0, NULL); if (out == NULL) { goto fail; @@ -1338,8 +1354,9 @@ pack_or_unpack_bits(PyObject *input, int axis, int unpack) } /* Create output array */ - out = PyArray_New(new->ob_type, PyArray_NDIM(new), outdims, PyArray_UBYTE, - NULL, NULL, 0, PyArray_ISFORTRAN(new), NULL); + out = (PyArrayObject *)PyArray_New(new->ob_type, + PyArray_NDIM(new), outdims, NPY_UBYTE, + NULL, NULL, 0, PyArray_ISFORTRAN(new), NULL); if (out == NULL) { goto fail; } @@ -1365,7 +1382,7 @@ pack_or_unpack_bits(PyObject *input, int axis, int unpack) finish: Py_DECREF(new); - return out; + return (PyObject *)out; fail: Py_XDECREF(new); diff --git a/numpy/lib/tests/test_index_tricks.py b/numpy/lib/tests/test_index_tricks.py index f0190937b..e4c0bde93 100644 --- a/numpy/lib/tests/test_index_tricks.py +++ b/numpy/lib/tests/test_index_tricks.py @@ -48,7 +48,7 @@ class TestRavelUnravelIndex(TestCase): uncoords = coords[0]+5*coords[1] assert_equal(np.ravel_multi_index(coords, shape, order='F'), uncoords) assert_equal(coords, np.unravel_index(uncoords, shape, order='F')) - + coords = np.array([[1,0,1,2,3,4],[1,6,1,3,2,0],[1,3,1,0,9,5]], dtype=dtype) shape = (5,8,10) diff --git a/numpy/lib/tests/test_recfunctions.py b/numpy/lib/tests/test_recfunctions.py index c6befa5f6..0a3f1e3e3 100644 --- a/numpy/lib/tests/test_recfunctions.py +++ b/numpy/lib/tests/test_recfunctions.py @@ -671,9 +671,10 @@ class TestJoinBy2(TestCase): (10, 2, 54, 69, 14, 4), (11, 2, 55, 70, 15, 5), (10, 3, 56, 71, 16, 6), (11, 3, 57, 72, 17, 7), (10, 4, 58, 73, 18, 8), (11, 4, 59, 74, 19, 9)], - dtype=[('k', '<i8'), ('a', '<i8'), ('b1', '<i8'), - ('b2', '<i8'), ('c1', '<i8'), ('c2', '<i8')]) + dtype=[('k', int), ('a', int), ('b1', int), + ('b2', int), ('c1', int), ('c2', int)]) test = join_by(['a','k'], a, b, r1postfix='1', r2postfix='2', jointype='inner') + assert_equal(test.dtype, control.dtype) assert_equal(test, control) diff --git a/numpy/lib/tests/test_stride_tricks.py b/numpy/lib/tests/test_stride_tricks.py index d7cf114f7..814f2d614 100644 --- a/numpy/lib/tests/test_stride_tricks.py +++ b/numpy/lib/tests/test_stride_tricks.py @@ -11,7 +11,7 @@ def assert_shapes_correct(input_shapes, expected_shape): outarrays = broadcast_arrays(*inarrays) outshapes = [a.shape for a in outarrays] expected = [expected_shape] * len(inarrays) - assert_(outshapes == expected) + assert_equal(outshapes, expected) def assert_incompatible_shapes_raise(input_shapes): """ Broadcast a list of arrays with the given (incompatible) input shapes @@ -76,13 +76,13 @@ def test_same_input_shapes(): for shape in data: input_shapes = [shape] # Single input. - yield assert_shapes_correct, input_shapes, shape + assert_shapes_correct(input_shapes, shape) # Double input. input_shapes2 = [shape, shape] - yield assert_shapes_correct, input_shapes2, shape + assert_shapes_correct(input_shapes2, shape) # Triple input. input_shapes3 = [shape, shape, shape] - yield assert_shapes_correct, input_shapes3, shape + assert_shapes_correct(input_shapes3, shape) def test_two_compatible_by_ones_input_shapes(): """ Check that two different input shapes (of the same length but some have @@ -104,9 +104,9 @@ def test_two_compatible_by_ones_input_shapes(): [[(1,1), (0,1)], (0,1)], ] for input_shapes, expected_shape in data: - yield assert_shapes_correct, input_shapes, expected_shape + assert_shapes_correct(input_shapes, expected_shape) # Reverse the input shapes since broadcasting should be symmetric. - yield assert_shapes_correct, input_shapes[::-1], expected_shape + assert_shapes_correct(input_shapes[::-1], expected_shape) def test_two_compatible_by_prepending_ones_input_shapes(): """ Check that two different input shapes (of different lengths) broadcast @@ -135,9 +135,9 @@ def test_two_compatible_by_prepending_ones_input_shapes(): [[(), (0,1)], (0,1)], ] for input_shapes, expected_shape in data: - yield assert_shapes_correct, input_shapes, expected_shape + assert_shapes_correct(input_shapes, expected_shape) # Reverse the input shapes since broadcasting should be symmetric. - yield assert_shapes_correct, input_shapes[::-1], expected_shape + assert_shapes_correct(input_shapes[::-1], expected_shape) def test_incompatible_shapes_raise_valueerror(): """ Check that a ValueError is raised for incompatible shapes. @@ -149,9 +149,9 @@ def test_incompatible_shapes_raise_valueerror(): [(1,3,4), (2,3,3)], ] for input_shapes in data: - yield assert_incompatible_shapes_raise, input_shapes + assert_incompatible_shapes_raise(input_shapes) # Reverse the input shapes since broadcasting should be symmetric. - yield assert_incompatible_shapes_raise, input_shapes[::-1] + assert_incompatible_shapes_raise(input_shapes[::-1]) def test_same_as_ufunc(): """ Check that the data layout is the same as if a ufunc did the operation. @@ -192,16 +192,17 @@ def test_same_as_ufunc(): [[(), (0,1)], (0,1)], ] for input_shapes, expected_shape in data: - yield assert_same_as_ufunc, input_shapes[0], input_shapes[1] + assert_same_as_ufunc(input_shapes[0], input_shapes[1], + "Shapes: %s %s" % (input_shapes[0], input_shapes[1])) # Reverse the input shapes since broadcasting should be symmetric. - yield assert_same_as_ufunc, input_shapes[1], input_shapes[0] + assert_same_as_ufunc(input_shapes[1], input_shapes[0]) # Try them transposed, too. - yield assert_same_as_ufunc, input_shapes[0], input_shapes[1], True + assert_same_as_ufunc(input_shapes[0], input_shapes[1], True) # ... and flipped for non-rank-0 inputs in order to test negative # strides. if () not in input_shapes: - yield assert_same_as_ufunc, input_shapes[0], input_shapes[1], False, True - yield assert_same_as_ufunc, input_shapes[0], input_shapes[1], True, True + assert_same_as_ufunc(input_shapes[0], input_shapes[1], False, True) + assert_same_as_ufunc(input_shapes[0], input_shapes[1], True, True) if __name__ == "__main__": diff --git a/numpy/numarray/_capi.c b/numpy/numarray/_capi.c index 446594d99..deb2cd478 100644 --- a/numpy/numarray/_capi.c +++ b/numpy/numarray/_capi.c @@ -1,5 +1,6 @@ #include <Python.h> +#define NPY_NO_DEPRECATED_API #define _libnumarray_MODULE #include "include/numpy/libnumarray.h" #include "numpy/npy_3kcompat.h" @@ -347,9 +348,9 @@ NA_NewAll(int ndim, maybelong *shape, NumarrayType type, result = NULL; } else { if (buffer) { - memcpy(result->data, buffer, NA_NBYTES(result)); + memcpy(PyArray_DATA(result), buffer, NA_NBYTES(result)); } else { - memset(result->data, 0, NA_NBYTES(result)); + memset(PyArray_DATA(result), 0, NA_NBYTES(result)); } } } @@ -366,7 +367,7 @@ NA_NewAllStrides(int ndim, maybelong *shape, maybelong *strides, byteoffset, 0, byteorder, aligned, writeable); for(i=0; i<ndim; i++) - result->strides[i] = strides[i]; + PyArray_STRIDES(result)[i] = strides[i]; return result; } @@ -703,16 +704,16 @@ _NA_callStridingHelper(PyObject *aux, long dim, { int i, j, status=0; dim -= 1; - for(i=0; i<numarray[0]->dimensions[dim]; i++) { + for(i=0; i<PyArray_DIMS(numarray[0])[dim]; i++) { for (j=0; j<nnumarray; j++) - data[j] += numarray[j]->strides[dim]*i; + data[j] += PyArray_STRIDES(numarray[j])[dim]*i; if (dim == 0) status |= f(aux, nnumarray, numarray, data); else status |= _NA_callStridingHelper( aux, dim, nnumarray, numarray, data, f); for (j=0; j<nnumarray; j++) - data[j] -= numarray[j]->strides[dim]*i; + data[j] -= PyArray_STRIDES(numarray[j])[dim]*i; } return status; } @@ -746,7 +747,7 @@ callStridingCFunc(PyObject *self, PyObject *args) { "%s arg[%d] is not an array.", me->descr.name, i); numarray[i] = (PyArrayObject *) otemp; - data[i] = numarray[i]->data; + data[i] = PyArray_DATA(numarray[i]); Py_DECREF(otemp); if (!NA_updateDataPtr(numarray[i])) return NULL; @@ -755,7 +756,7 @@ callStridingCFunc(PyObject *self, PyObject *args) { /* Cast function pointer and perform stride operation */ f = (CFUNC_STRIDED_FUNC) me->descr.fptr; - if (_NA_callStridingHelper(aux, numarray[0]->nd, + if (_NA_callStridingHelper(aux, PyArray_NDIM(numarray[0]), nnumarray, numarray, data, f)) { return NULL; } else { @@ -1052,7 +1053,7 @@ NA_InputArray(PyObject *a, NumarrayType t, int requires) static int satisfies(PyArrayObject *a, int requirements, NumarrayType t) { - int type_ok = (a->descr->type_num == t) || (t == tAny); + int type_ok = (PyArray_DESCR(a)->type_num == t) || (t == tAny); if (PyArray_ISCARRAY(a)) return type_ok; @@ -1076,7 +1077,7 @@ NA_OutputArray(PyObject *a, NumarrayType t, int requires) PyArray_Descr *dtype; PyArrayObject *ret; - if (!PyArray_Check(a) || !PyArray_ISWRITEABLE(a)) { + if (!PyArray_Check(a) || !PyArray_ISWRITEABLE((PyArrayObject *)a)) { PyErr_Format(PyExc_TypeError, "NA_OutputArray: only writeable arrays work for output."); return NULL; @@ -1087,18 +1088,22 @@ NA_OutputArray(PyObject *a, NumarrayType t, int requires) return (PyArrayObject *)a; } if (t == tAny) { - dtype = PyArray_DESCR(a); + dtype = PyArray_DESCR((PyArrayObject *)a); Py_INCREF(dtype); } else { dtype = PyArray_DescrFromType(t); } - ret = (PyArrayObject *)PyArray_Empty(PyArray_NDIM(a), PyArray_DIMS(a), - dtype, 0); - ret->flags |= NPY_UPDATEIFCOPY; - ret->base = a; - PyArray_FLAGS(a) &= ~NPY_WRITEABLE; + ret = (PyArrayObject *)PyArray_Empty(PyArray_NDIM((PyArrayObject *)a), + PyArray_DIMS((PyArrayObject *)a), + dtype, 0); Py_INCREF(a); + if (PyArray_SetBaseObject(ret, a) < 0) { + Py_DECREF(ret); + return NULL; + } + PyArray_ENABLEFLAGS(ret, NPY_ARRAY_UPDATEIFCOPY); + PyArray_CLEARFLAGS((PyArrayObject *)a, NPY_ARRAY_WRITEABLE); return ret; } @@ -1114,7 +1119,8 @@ NA_OutputArray(PyObject *a, NumarrayType t, int requires) static PyArrayObject * NA_IoArray(PyObject *a, NumarrayType t, int requires) { - PyArrayObject *shadow = NA_InputArray(a, t, requires | NPY_UPDATEIFCOPY ); + PyArrayObject *shadow = NA_InputArray(a, t, + requires | NPY_ARRAY_UPDATEIFCOPY ); if (!shadow) return NULL; @@ -1159,7 +1165,7 @@ Complex64 NA_get_Complex64(PyArrayObject *a, long offset) Complex32 v0; Complex64 v; - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tComplex32: v0 = NA_GETP(a, Complex32, (NA_PTR(a)+offset)); v.r = v0.r; @@ -1180,7 +1186,7 @@ void NA_set_Complex64(PyArrayObject *a, long offset, Complex64 v) { Complex32 v0; - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tComplex32: v0.r = v.r; v0.i = v.i; @@ -1197,7 +1203,7 @@ void NA_set_Complex64(PyArrayObject *a, long offset, Complex64 v) Int64 NA_get_Int64(PyArrayObject *a, long offset) { - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tBool: return NA_GETP(a, Bool, (NA_PTR(a)+offset)) != 0; case tInt8: @@ -1227,7 +1233,7 @@ Int64 NA_get_Int64(PyArrayObject *a, long offset) default: PyErr_Format( PyExc_TypeError, "Unknown type %d in NA_get_Int64", - a->descr->type_num); + PyArray_DESCR(a)->type_num); PyErr_Print(); } return 0; /* suppress warning */ @@ -1237,7 +1243,7 @@ void NA_set_Int64(PyArrayObject *a, long offset, Int64 v) { Bool b; - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tBool: b = (v != 0); NA_SETP(a, Bool, (NA_PTR(a)+offset), b); @@ -1275,7 +1281,7 @@ void NA_set_Int64(PyArrayObject *a, long offset, Int64 v) default: PyErr_Format( PyExc_TypeError, "Unknown type %d in NA_set_Int64", - a->descr->type_num); + PyArray_DESCR(a)->type_num); PyErr_Print(); } } @@ -1293,11 +1299,11 @@ long NA_get_offset(PyArrayObject *a, int N, ...) va_start(ap, N); if (N > 0) { /* compute offset of "outer" indices. */ for(i=0; i<N; i++) - offset += va_arg(ap, long) * a->strides[i]; + offset += va_arg(ap, long) * PyArray_STRIDES(a)[i]; } else { /* compute offset of "inner" indices. */ N = -N; for(i=0; i<N; i++) - offset += va_arg(ap, long) * a->strides[a->nd-N+i]; + offset += va_arg(ap, long) * PyArray_STRIDES(a)[PyArray_NDIM(a)-N+i]; } va_end(ap); return offset; @@ -1305,7 +1311,7 @@ long NA_get_offset(PyArrayObject *a, int N, ...) Float64 NA_get_Float64(PyArrayObject *a, long offset) { - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tBool: return NA_GETP(a, Bool, (NA_PTR(a)+offset)) != 0; case tInt8: @@ -1337,7 +1343,7 @@ Float64 NA_get_Float64(PyArrayObject *a, long offset) default: PyErr_Format( PyExc_TypeError, "Unknown type %d in NA_get_Float64", - a->descr->type_num); + PyArray_DESCR(a)->type_num); } return 0; /* suppress warning */ } @@ -1346,7 +1352,7 @@ void NA_set_Float64(PyArrayObject *a, long offset, Float64 v) { Bool b; - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tBool: b = (v != 0); NA_SETP(a, Bool, (NA_PTR(a)+offset), b); @@ -1388,7 +1394,7 @@ void NA_set_Float64(PyArrayObject *a, long offset, Float64 v) default: PyErr_Format( PyExc_TypeError, "Unknown type %d in NA_set_Float64", - a->descr->type_num ); + PyArray_DESCR(a)->type_num ); PyErr_Print(); } } @@ -1396,127 +1402,127 @@ void NA_set_Float64(PyArrayObject *a, long offset, Float64 v) Float64 NA_get1_Float64(PyArrayObject *a, long i) { - long offset = i * a->strides[0]; + long offset = i * PyArray_STRIDES(a)[0]; return NA_get_Float64(a, offset); } Float64 NA_get2_Float64(PyArrayObject *a, long i, long j) { - long offset = i * a->strides[0] - + j * a->strides[1]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1]; return NA_get_Float64(a, offset); } Float64 NA_get3_Float64(PyArrayObject *a, long i, long j, long k) { - long offset = i * a->strides[0] - + j * a->strides[1] - + k * a->strides[2]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1] + + k * PyArray_STRIDES(a)[2]; return NA_get_Float64(a, offset); } void NA_set1_Float64(PyArrayObject *a, long i, Float64 v) { - long offset = i * a->strides[0]; + long offset = i * PyArray_STRIDES(a)[0]; NA_set_Float64(a, offset, v); } void NA_set2_Float64(PyArrayObject *a, long i, long j, Float64 v) { - long offset = i * a->strides[0] - + j * a->strides[1]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1]; NA_set_Float64(a, offset, v); } void NA_set3_Float64(PyArrayObject *a, long i, long j, long k, Float64 v) { - long offset = i * a->strides[0] - + j * a->strides[1] - + k * a->strides[2]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1] + + k * PyArray_STRIDES(a)[2]; NA_set_Float64(a, offset, v); } Complex64 NA_get1_Complex64(PyArrayObject *a, long i) { - long offset = i * a->strides[0]; + long offset = i * PyArray_STRIDES(a)[0]; return NA_get_Complex64(a, offset); } Complex64 NA_get2_Complex64(PyArrayObject *a, long i, long j) { - long offset = i * a->strides[0] - + j * a->strides[1]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1]; return NA_get_Complex64(a, offset); } Complex64 NA_get3_Complex64(PyArrayObject *a, long i, long j, long k) { - long offset = i * a->strides[0] - + j * a->strides[1] - + k * a->strides[2]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1] + + k * PyArray_STRIDES(a)[2]; return NA_get_Complex64(a, offset); } void NA_set1_Complex64(PyArrayObject *a, long i, Complex64 v) { - long offset = i * a->strides[0]; + long offset = i * PyArray_STRIDES(a)[0]; NA_set_Complex64(a, offset, v); } void NA_set2_Complex64(PyArrayObject *a, long i, long j, Complex64 v) { - long offset = i * a->strides[0] - + j * a->strides[1]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1]; NA_set_Complex64(a, offset, v); } void NA_set3_Complex64(PyArrayObject *a, long i, long j, long k, Complex64 v) { - long offset = i * a->strides[0] - + j * a->strides[1] - + k * a->strides[2]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1] + + k * PyArray_STRIDES(a)[2]; NA_set_Complex64(a, offset, v); } Int64 NA_get1_Int64(PyArrayObject *a, long i) { - long offset = i * a->strides[0]; + long offset = i * PyArray_STRIDES(a)[0]; return NA_get_Int64(a, offset); } Int64 NA_get2_Int64(PyArrayObject *a, long i, long j) { - long offset = i * a->strides[0] - + j * a->strides[1]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1]; return NA_get_Int64(a, offset); } Int64 NA_get3_Int64(PyArrayObject *a, long i, long j, long k) { - long offset = i * a->strides[0] - + j * a->strides[1] - + k * a->strides[2]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1] + + k * PyArray_STRIDES(a)[2]; return NA_get_Int64(a, offset); } void NA_set1_Int64(PyArrayObject *a, long i, Int64 v) { - long offset = i * a->strides[0]; + long offset = i * PyArray_STRIDES(a)[0]; NA_set_Int64(a, offset, v); } void NA_set2_Int64(PyArrayObject *a, long i, long j, Int64 v) { - long offset = i * a->strides[0] - + j * a->strides[1]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1]; NA_set_Int64(a, offset, v); } void NA_set3_Int64(PyArrayObject *a, long i, long j, long k, Int64 v) { - long offset = i * a->strides[0] - + j * a->strides[1] - + k * a->strides[2]; + long offset = i * PyArray_STRIDES(a)[0] + + j * PyArray_STRIDES(a)[1] + + k * PyArray_STRIDES(a)[2]; NA_set_Int64(a, offset, v); } @@ -1525,7 +1531,7 @@ void NA_set3_Int64(PyArrayObject *a, long i, long j, long k, Int64 v) #define NA_SET_CMPLX(a, type, base, cnt, in) \ { \ int i; \ - int stride = a->strides[ a->nd - 1]; \ + int stride = PyArray_STRIDES(a)[ PyArray_NDIM(a) - 1]; \ NA_SET1D(a, type, base, cnt, in); \ base = NA_PTR(a) + offset + sizeof(type); \ for(i=0; i<cnt; i++) { \ @@ -1539,7 +1545,7 @@ NA_get1D_Float64(PyArrayObject *a, long offset, int cnt, Float64*out) { char *base = NA_PTR(a) + offset; - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tBool: NA_GET1D(a, Bool, base, cnt, out); break; @@ -1584,7 +1590,7 @@ NA_get1D_Float64(PyArrayObject *a, long offset, int cnt, Float64*out) default: PyErr_Format( PyExc_TypeError, "Unknown type %d in NA_get1D_Float64", - a->descr->type_num); + PyArray_DESCR(a)->type_num); PyErr_Print(); return -1; } @@ -1608,7 +1614,7 @@ NA_set1D_Float64(PyArrayObject *a, long offset, int cnt, Float64*in) { char *base = NA_PTR(a) + offset; - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tBool: NA_SET1D(a, Bool, base, cnt, in); break; @@ -1653,7 +1659,7 @@ NA_set1D_Float64(PyArrayObject *a, long offset, int cnt, Float64*in) default: PyErr_Format( PyExc_TypeError, "Unknown type %d in NA_set1D_Float64", - a->descr->type_num); + PyArray_DESCR(a)->type_num); PyErr_Print(); return -1; } @@ -1665,7 +1671,7 @@ NA_get1D_Int64(PyArrayObject *a, long offset, int cnt, Int64*out) { char *base = NA_PTR(a) + offset; - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tBool: NA_GET1D(a, Bool, base, cnt, out); break; @@ -1708,7 +1714,7 @@ NA_get1D_Int64(PyArrayObject *a, long offset, int cnt, Int64*out) default: PyErr_Format( PyExc_TypeError, "Unknown type %d in NA_get1D_Int64", - a->descr->type_num); + PyArray_DESCR(a)->type_num); PyErr_Print(); return -1; } @@ -1732,7 +1738,7 @@ NA_set1D_Int64(PyArrayObject *a, long offset, int cnt, Int64*in) { char *base = NA_PTR(a) + offset; - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tBool: NA_SET1D(a, Bool, base, cnt, in); break; @@ -1775,7 +1781,7 @@ NA_set1D_Int64(PyArrayObject *a, long offset, int cnt, Int64*in) default: PyErr_Format( PyExc_TypeError, "Unknown type %d in NA_set1D_Int64", - a->descr->type_num); + PyArray_DESCR(a)->type_num); PyErr_Print(); return -1; } @@ -1787,14 +1793,14 @@ NA_get1D_Complex64(PyArrayObject *a, long offset, int cnt, Complex64*out) { char *base = NA_PTR(a) + offset; - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tComplex64: NA_GET1D(a, Complex64, base, cnt, out); break; default: PyErr_Format( PyExc_TypeError, "Unsupported type %d in NA_get1D_Complex64", - a->descr->type_num); + PyArray_DESCR(a)->type_num); PyErr_Print(); return -1; } @@ -1806,14 +1812,14 @@ NA_set1D_Complex64(PyArrayObject *a, long offset, int cnt, Complex64*in) { char *base = NA_PTR(a) + offset; - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tComplex64: NA_SET1D(a, Complex64, base, cnt, in); break; default: PyErr_Format( PyExc_TypeError, "Unsupported type %d in NA_set1D_Complex64", - a->descr->type_num); + PyArray_DESCR(a)->type_num); PyErr_Print(); return -1; } @@ -1835,10 +1841,10 @@ NA_ShapeEqual(PyArrayObject *a, PyArrayObject *b) "NA_ShapeEqual: non-array as parameter."); return -1; } - if (a->nd != b->nd) + if (PyArray_NDIM(a) != PyArray_NDIM(b)) return 0; - for(i=0; i<a->nd; i++) - if (a->dimensions[i] != b->dimensions[i]) + for(i=0; i<PyArray_NDIM(a); i++) + if (PyArray_DIMS(a)[i] != PyArray_DIMS(b)[i]) return 0; return 1; } @@ -1858,11 +1864,11 @@ NA_ShapeLessThan(PyArrayObject *a, PyArrayObject *b) "NA_ShapeLessThan: non-array as parameter."); return -1; } - mindim = MIN(a->nd, b->nd); - aoff = a->nd - mindim; - boff = b->nd - mindim; + mindim = MIN(PyArray_NDIM(a), PyArray_NDIM(b)); + aoff = PyArray_NDIM(a) - mindim; + boff = PyArray_NDIM(b) - mindim; for(i=0; i<mindim; i++) - if (a->dimensions[i+aoff] >= b->dimensions[i+boff]) + if (PyArray_DIMS(a)[i+aoff] >= PyArray_DIMS(b)[i+boff]) return 0; return 1; } @@ -2059,7 +2065,7 @@ getShape(PyObject *a, maybelong *shape, int dims) } if (!PySequence_Check(a) || - (NA_NDArrayCheck(a) && (PyArray(a)->nd == 0))) + (NA_NDArrayCheck(a) && (PyArray_NDIM(PyArray(a)) == 0))) return dims; slen = PySequence_Length(a); if (slen < 0) { @@ -2103,13 +2109,13 @@ setArrayFromSequence(PyArrayObject *a, PyObject *s, int dim, long offset) SequenceConstraint mustbe = NOTHING; int i, seqlen=-1, slen = PySequence_Length(s); - if (dim > a->nd) { + if (dim > PyArray_NDIM(a)) { PyErr_Format(PyExc_ValueError, "setArrayFromSequence: sequence/array dimensions mismatch."); return -1; } - if (slen != a->dimensions[dim]) { + if (slen != PyArray_DIMS(a)[dim]) { PyErr_Format(PyExc_ValueError, "setArrayFromSequence: sequence/array shape mismatch."); return -1; @@ -2122,7 +2128,7 @@ setArrayFromSequence(PyArrayObject *a, PyObject *s, int dim, long offset) "setArrayFromSequence: Can't get a sequence item"); return -1; } else if ((NA_isPythonScalar(o) || - (NA_NumArrayCheck(o) && PyArray(o)->nd == 0)) && + (NA_NumArrayCheck(o) && PyArray_NDIM(PyArray(o)) == 0)) && ((mustbe == NOTHING) || (mustbe == NUMBER))) { if (NA_setFromPythonScalar(a, offset, o) < 0) return -2; @@ -2154,7 +2160,7 @@ setArrayFromSequence(PyArrayObject *a, PyObject *s, int dim, long offset) return -6; } Py_DECREF(o); - offset += a->strides[dim]; + offset += PyArray_STRIDES(a)[dim]; } return 0; } @@ -2199,7 +2205,7 @@ _NA_maxType(PyObject *seq, int limit) return -1; } if (NA_NumArrayCheck(seq)) { - switch(PyArray(seq)->descr->type_num) { + switch(PyArray_DESCR(PyArray(seq))->type_num) { case tBool: return BOOL_SCALAR; case tInt8: @@ -2302,7 +2308,7 @@ NA_isPythonScalar(PyObject *o) static PyObject * NA_getPythonScalar(PyArrayObject *a, long offset) { - int type = a->descr->type_num; + int type = PyArray_DESCR(a)->type_num; PyObject *rval = NULL; switch(type) { @@ -2355,9 +2361,9 @@ NA_getPythonScalar(PyArrayObject *a, long offset) static int NA_overflow(PyArrayObject *a, Float64 v) { - if ((a->flags & CHECKOVERFLOW) == 0) return 0; + if ((PyArray_FLAGS(a) & CHECKOVERFLOW) == 0) return 0; - switch(a->descr->type_num) { + switch(PyArray_DESCR(a)->type_num) { case tBool: return 0; case tInt8: @@ -2402,7 +2408,7 @@ NA_overflow(PyArrayObject *a, Float64 v) default: PyErr_Format( PyExc_TypeError, "Unknown type %d in NA_overflow", - a->descr->type_num ); + PyArray_DESCR(a)->type_num ); PyErr_Print(); return -1; } @@ -2425,11 +2431,11 @@ _setFromPythonScalarCore(PyArrayObject *a, long offset, PyObject*value, int entr return -1; NA_set_Int64(a, offset, v); } else if (PyLong_Check(value)) { - if (a->descr->type_num == tInt64) { + if (PyArray_DESCR(a)->type_num == tInt64) { v = (Int64) PyLong_AsLongLong( value ); - } else if (a->descr->type_num == tUInt64) { + } else if (PyArray_DESCR(a)->type_num == tUInt64) { v = (UInt64) PyLong_AsUnsignedLongLong( value ); - } else if (a->descr->type_num == tUInt32) { + } else if (PyArray_DESCR(a)->type_num == tUInt32) { v = PyLong_AsUnsignedLong(value); } else { v = PyLong_AsLongLong(value); @@ -2455,7 +2461,7 @@ _setFromPythonScalarCore(PyArrayObject *a, long offset, PyObject*value, int entr NA_set_Complex64(a, offset, vc); } else if (PyObject_HasAttrString(value, "__tonumtype__")) { int rval; - PyObject *type = NA_typeNoToTypeObject(a->descr->type_num); + PyObject *type = NA_typeNoToTypeObject(PyArray_DESCR(a)->type_num); if (!type) return -1; value = PyObject_CallMethod( value, "__tonumtype__", "(N)", type); @@ -2482,7 +2488,7 @@ _setFromPythonScalarCore(PyArrayObject *a, long offset, PyObject*value, int entr static int NA_setFromPythonScalar(PyArrayObject *a, long offset, PyObject *value) { - if (a->flags & WRITABLE) + if (PyArray_FLAGS(a) & NPY_ARRAY_WRITEABLE) return _setFromPythonScalarCore(a, offset, value, 0); else { PyErr_Format( @@ -2508,7 +2514,7 @@ NA_ComplexArrayCheck(PyObject *a) int rval = NA_NumArrayCheck(a); if (rval > 0) { PyArrayObject *arr = (PyArrayObject *) a; - switch(arr->descr->type_num) { + switch(PyArray_DESCR(arr)->type_num) { case tComplex64: case tComplex32: return 1; default: @@ -2523,8 +2529,8 @@ NA_elements(PyArrayObject *a) { int i; unsigned long n = 1; - for(i = 0; i<a->nd; i++) - n *= a->dimensions[i]; + for(i = 0; i<PyArray_NDIM(a); i++) + n *= PyArray_DIMS(a)[i]; return n; } @@ -2725,27 +2731,27 @@ NA_swapAxes(PyArrayObject *array, int x, int y) if (((PyObject *) array) == Py_None) return 0; - if (array->nd < 2) return 0; + if (PyArray_NDIM(array) < 2) return 0; - if (x < 0) x += array->nd; - if (y < 0) y += array->nd; + if (x < 0) x += PyArray_NDIM(array); + if (y < 0) y += PyArray_NDIM(array); - if ((x < 0) || (x >= array->nd) || - (y < 0) || (y >= array->nd)) { + if ((x < 0) || (x >= PyArray_NDIM(array)) || + (y < 0) || (y >= PyArray_NDIM(array))) { PyErr_Format(PyExc_ValueError, "Specified dimension does not exist"); return -1; } - temp = array->dimensions[x]; - array->dimensions[x] = array->dimensions[y]; - array->dimensions[y] = temp; + temp = PyArray_DIMS(array)[x]; + PyArray_DIMS(array)[x] = PyArray_DIMS(array)[y]; + PyArray_DIMS(array)[y] = temp; - temp = array->strides[x]; - array->strides[x] = array->strides[y]; - array->strides[y] = temp; + temp = PyArray_STRIDES(array)[x]; + PyArray_STRIDES(array)[x] = PyArray_STRIDES(array)[y]; + PyArray_STRIDES(array)[y] = temp; - PyArray_UpdateFlags(array, NPY_UPDATE_ALL); + PyArray_UpdateFlags(array, NPY_ARRAY_UPDATE_ALL); return 0; } @@ -2861,20 +2867,20 @@ NA_NewAllFromBuffer(int ndim, maybelong *shape, NumarrayType type, static void NA_updateAlignment(PyArrayObject *self) { - PyArray_UpdateFlags(self, NPY_ALIGNED); + PyArray_UpdateFlags(self, NPY_ARRAY_ALIGNED); } static void NA_updateContiguous(PyArrayObject *self) { - PyArray_UpdateFlags(self, NPY_CONTIGUOUS | NPY_FORTRAN); + PyArray_UpdateFlags(self, NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS); } static void NA_updateStatus(PyArrayObject *self) { - PyArray_UpdateFlags(self, NPY_UPDATE_ALL); + PyArray_UpdateFlags(self, NPY_ARRAY_UPDATE_ALL); } static int @@ -2915,7 +2921,7 @@ NA_getArrayData(PyArrayObject *obj) PyErr_Format(PyExc_TypeError, "expected an NDArray"); } - return obj->data; + return PyArray_DATA(obj); } /* Byteswap is not a flag of the array --- it is implicit in the data-type */ diff --git a/numpy/numarray/include/numpy/arraybase.h b/numpy/numarray/include/numpy/arraybase.h index a964979ce..32f9948f4 100644 --- a/numpy/numarray/include/numpy/arraybase.h +++ b/numpy/numarray/include/numpy/arraybase.h @@ -12,7 +12,7 @@ typedef npy_uint8 UInt8; typedef npy_int16 Int16; typedef npy_uint16 UInt16; typedef npy_int32 Int32; -typedef npy_uint32 UInt32; +typedef npy_uint32 UInt32; typedef npy_int64 Int64; typedef npy_uint64 UInt64; typedef npy_float32 Float32; @@ -65,7 +65,7 @@ typedef struct { Float64 r, i; } Complex64; #define PyArray(m) ((PyArrayObject *)(m)) #define PyArray_ISFORTRAN_CONTIGUOUS(m) (((PyArray(m))->flags & FORTRAN_CONTIGUOUS) != 0) -#define PyArray_ISWRITABLE PyArray_ISWRITEABLE +#define PyArray_ISWRITABLE PyArray_ISWRITEABLE -#endif +#endif diff --git a/numpy/numarray/include/numpy/cfunc.h b/numpy/numarray/include/numpy/cfunc.h index b581be08f..1739290ae 100644 --- a/numpy/numarray/include/numpy/cfunc.h +++ b/numpy/numarray/include/numpy/cfunc.h @@ -6,11 +6,11 @@ typedef int (*UFUNC)(long, long, long, void **, long*); /* typedef void (*CFUNC_2ARG)(long, void *, void *); */ /* typedef void (*CFUNC_3ARG)(long, void *, void *, void *); */ typedef int (*CFUNCfromPyValue)(PyObject *, void *); -typedef int (*CFUNC_STRIDE_CONV_FUNC)(long, long, maybelong *, +typedef int (*CFUNC_STRIDE_CONV_FUNC)(long, long, maybelong *, void *, long, maybelong*, void *, long, maybelong *); -typedef int (*CFUNC_STRIDED_FUNC)(PyObject *, long, PyArrayObject **, - char **data); +typedef int (*CFUNC_STRIDED_FUNC)(PyObject *, long, PyArrayObject **, + char **data); #define MAXARRAYS 16 diff --git a/numpy/numarray/include/numpy/numcomplex.h b/numpy/numarray/include/numpy/numcomplex.h index 9ed4198c7..7b4960e40 100644 --- a/numpy/numarray/include/numpy/numcomplex.h +++ b/numpy/numarray/include/numpy/numcomplex.h @@ -68,7 +68,7 @@ typedef struct { Float64 a, theta; } PolarComplex64; #define NUM_CLE(p, q) ((p).r <= (q).r) #define NUM_CGE(p, q) ((p).r >= (q).r) -/* e**z = e**x * (cos(y)+ i*sin(y)) where z = x + i*y +/* e**z = e**x * (cos(y)+ i*sin(y)) where z = x + i*y so e**z = e**x * cos(y) + i * e**x * sin(y) */ #define NUM_CEXP(p, s) \ @@ -79,7 +79,7 @@ typedef struct { Float64 a, theta; } PolarComplex64; /* e**w = z; w = u + i*v; z = r * e**(i*theta); -e**u * e**(i*v) = r * e**(i*theta); +e**u * e**(i*v) = r * e**(i*theta); log(z) = w; log(z) = log(r) + i*theta; */ @@ -110,7 +110,7 @@ log(z) = w; log(z) = log(r) + i*theta; NUM_CEXP(s, s); \ } \ } - + #define NUM_CSQRT(p, s) { Complex64 temp; temp.r = 0.5; temp.i=0; \ NUM_CPOW(p, temp, s); \ } @@ -201,7 +201,7 @@ log(z) = w; log(z) = log(r) + i*theta; NUM_CIMUL(s, s); \ NUM_CRMUL(s, 0.5, s); \ } - + /* asinh(z) = log( z + (z**2 + 1)**0.5 ) */ #define NUM_CASINH(p, s) { Complex64 p1; NUM_CASS(p, p1); \ NUM_CMUL(p, p, s); \ diff --git a/numpy/numarray/include/numpy/nummacro.h b/numpy/numarray/include/numpy/nummacro.h index e9acd6e31..0f87dfb84 100644 --- a/numpy/numarray/include/numpy/nummacro.h +++ b/numpy/numarray/include/numpy/nummacro.h @@ -6,7 +6,7 @@ /* The structs defined here are private implementation details of numarray which are subject to change w/o notice. */ - + #define PY_BOOL_CHAR "b" #define PY_INT8_CHAR "b" #define PY_INT16_CHAR "h" @@ -44,7 +44,7 @@ typedef enum #define UNCONVERTED 0 #define C_ARRAY (NUM_CONTIGUOUS | NUM_NOTSWAPPED | NUM_ALIGNED) -#define MUST_BE_COMPUTED 2 +#define MUST_BE_COMPUTED 2 #define NUM_FLOORDIVIDE(a,b,out) (out) = floor((a)/(b)) @@ -87,15 +87,15 @@ typedef enum /* from here down, type("ai") is NDInfo* */ #define NA_PTR(ai) ((char *) NA_OFFSETDATA((ai))) -#define NA_PTR1(ai, i) (NA_PTR(ai) + \ - (i)*(ai)->strides[0]) -#define NA_PTR2(ai, i, j) (NA_PTR(ai) + \ - (i)*(ai)->strides[0] + \ - (j)*(ai)->strides[1]) -#define NA_PTR3(ai, i, j, k) (NA_PTR(ai) + \ - (i)*(ai)->strides[0] + \ - (j)*(ai)->strides[1] + \ - (k)*(ai)->strides[2]) +#define NA_PTR1(ai, i) (NA_PTR(ai) + \ + (i)*PyArray_STRIDES(ai)[0]) +#define NA_PTR2(ai, i, j) (NA_PTR(ai) + \ + (i)*PyArray_STRIDES(ai)[0] + \ + (j)*PyArray_STRIDES(ai)[1]) +#define NA_PTR3(ai, i, j, k) (NA_PTR(ai) + \ + (i)*PyArray_STRIDES(ai)[0] + \ + (j)*PyArray_STRIDES(ai)[1] + \ + (k)*PyArray_STRIDES(ai)[2]) #define NA_SET_TEMP(ai, type, v) (((type *) &__temp__)[0] = v) @@ -238,10 +238,10 @@ _makeSetPa(Bool) /* fast (aligned, !byteswapped) */ #define NA_GETPf(ai, type, ptr) (*((type *) (ptr))) -#define NA_GETP(ai, type, ptr) \ - (PyArray_ISCARRAY(ai) ? NA_GETPf(ai, type, ptr) \ - : (PyArray_ISBYTESWAPPED(ai) ? \ - NA_GETPb(ai, type, ptr) \ +#define NA_GETP(ai, type, ptr) \ + (PyArray_ISCARRAY(ai) ? NA_GETPf(ai, type, ptr) \ + : (PyArray_ISBYTESWAPPED(ai) ? \ + NA_GETPb(ai, type, ptr) \ : NA_GETPa(ai, type, ptr))) /* NOTE: NA_SET* macros cannot be used as values. */ @@ -255,12 +255,12 @@ _makeSetPa(Bool) /* fast (aligned, !byteswapped) */ #define NA_SETPf(ai, type, ptr, v) ((*((type *) ptr)) = (v)) -#define NA_SETP(ai, type, ptr, v) \ - if (PyArray_ISCARRAY(ai)) { \ - NA_SETPf((ai), type, (ptr), (v)); \ - } else if (PyArray_ISBYTESWAPPED(ai)) { \ - NA_SETPb((ai), type, (ptr), (v)); \ - } else \ +#define NA_SETP(ai, type, ptr, v) \ + if (PyArray_ISCARRAY(ai)) { \ + NA_SETPf((ai), type, (ptr), (v)); \ + } else if (PyArray_ISBYTESWAPPED(ai)) { \ + NA_SETPb((ai), type, (ptr), (v)); \ + } else \ NA_SETPa((ai), type, (ptr), (v)) /* ========================== 1 index get/set ============================ */ @@ -315,42 +315,42 @@ _makeSetPa(Bool) #define NA_GET3(ai, type, i, j, k) NA_GETP(ai, type, NA_PTR3(ai, i, j, k)) /* byteswapping */ -#define NA_SET3b(ai, type, i, j, k, v) \ +#define NA_SET3b(ai, type, i, j, k, v) \ NA_SETPb(ai, type, NA_PTR3(ai, i, j, k), v) /* aligning */ -#define NA_SET3a(ai, type, i, j, k, v) \ +#define NA_SET3a(ai, type, i, j, k, v) \ NA_SETPa(ai, type, NA_PTR3(ai, i, j, k), v) /* fast (aligned, !byteswapped) */ -#define NA_SET3f(ai, type, i, j, k, v) \ +#define NA_SET3f(ai, type, i, j, k, v) \ NA_SETPf(ai, type, NA_PTR3(ai, i, j, k), v) -#define NA_SET3(ai, type, i, j, k, v) \ +#define NA_SET3(ai, type, i, j, k, v) \ NA_SETP(ai, type, NA_PTR3(ai, i, j, k), v) /* ========================== 1D get/set ================================== */ -#define NA_GET1Db(ai, type, base, cnt, out) \ - { int i, stride = ai->strides[ai->nd-1]; \ - for(i=0; i<cnt; i++) { \ - out[i] = NA_GETPb(ai, type, base); \ - base += stride; \ - } \ - } +#define NA_GET1Db(ai, type, base, cnt, out) \ + { int i, stride = PyArray_STRIDES(ai)[PyArray_NDIM(ai)-1]; \ + for(i=0; i<cnt; i++) { \ + out[i] = NA_GETPb(ai, type, base); \ + base += stride; \ + } \ + } #define NA_GET1Da(ai, type, base, cnt, out) \ - { int i, stride = ai->strides[ai->nd-1]; \ + { int i, stride = PyArray_STRIDES(ai)[PyArray_NDIM(ai)-1]; \ for(i=0; i<cnt; i++) { \ out[i] = NA_GETPa(ai, type, base); \ base += stride; \ } \ - } + } #define NA_GET1Df(ai, type, base, cnt, out) \ - { int i, stride = ai->strides[ai->nd-1]; \ + { int i, stride = PyArray_STRIDES(ai)[PyArray_NDIM(ai)-1]; \ for(i=0; i<cnt; i++) { \ out[i] = NA_GETPf(ai, type, base); \ base += stride; \ } \ - } + } #define NA_GET1D(ai, type, base, cnt, out) \ if (PyArray_ISCARRAY(ai)) { \ @@ -360,9 +360,9 @@ _makeSetPa(Bool) } else { \ NA_GET1Da(ai, type, base, cnt, out); \ } - + #define NA_SET1Db(ai, type, base, cnt, in) \ - { int i, stride = ai->strides[ai->nd-1]; \ + { int i, stride = PyArray_STRIDES(ai)[PyArray_NDIM(ai)-1]; \ for(i=0; i<cnt; i++) { \ NA_SETPb(ai, type, base, in[i]); \ base += stride; \ @@ -370,7 +370,7 @@ _makeSetPa(Bool) } #define NA_SET1Da(ai, type, base, cnt, in) \ - { int i, stride = ai->strides[ai->nd-1]; \ + { int i, stride = PyArray_STRIDES(ai)[PyArray_NDIM(ai)-1]; \ for(i=0; i<cnt; i++) { \ NA_SETPa(ai, type, base, in[i]); \ base += stride; \ @@ -378,7 +378,7 @@ _makeSetPa(Bool) } #define NA_SET1Df(ai, type, base, cnt, in) \ - { int i, stride = ai->strides[ai->nd-1]; \ + { int i, stride = PyArray_STRIDES(ai)[PyArray_NDIM(ai)-1]; \ for(i=0; i<cnt; i++) { \ NA_SETPf(ai, type, base, in[i]); \ base += stride; \ @@ -393,7 +393,7 @@ _makeSetPa(Bool) } else { \ NA_SET1Da(ai, type, base, cnt, out); \ } - + /* ========================== utilities ================================== */ #if !defined(MIN) @@ -412,7 +412,7 @@ _makeSetPa(Bool) #define BOOLEAN_BITWISE_NOT(x) ((x) ^ 1) -#define NA_NBYTES(a) (a->descr->elsize * NA_elements(a)) +#define NA_NBYTES(a) (PyArray_DESCR(a)->elsize * NA_elements(a)) #if defined(NA_SMP) #define BEGIN_THREADS Py_BEGIN_ALLOW_THREADS |