diff options
Diffstat (limited to 'numpy/numarray/_capi.c')
| -rw-r--r-- | numpy/numarray/_capi.c | 4630 |
1 files changed, 2314 insertions, 2316 deletions
diff --git a/numpy/numarray/_capi.c b/numpy/numarray/_capi.c index 98c453083..f93618aed 100644 --- a/numpy/numarray/_capi.c +++ b/numpy/numarray/_capi.c @@ -19,29 +19,29 @@ static PyObject *pCfuncClass; static PyTypeObject CfuncType; static PyObject *pHandleErrorFunc; -static int +static int deferred_libnumarray_init(void) { - static int initialized=0; +static int initialized=0; - if (initialized) return 0; + if (initialized) return 0; - pCfuncClass = (PyObject *) &CfuncType; - Py_INCREF(pCfuncClass); + pCfuncClass = (PyObject *) &CfuncType; + Py_INCREF(pCfuncClass); - pHandleErrorFunc = - NA_initModuleGlobal("numpy.numarray.util", "handleError"); + pHandleErrorFunc = + NA_initModuleGlobal("numpy.numarray.util", "handleError"); - if (!pHandleErrorFunc) goto _fail; + if (!pHandleErrorFunc) goto _fail; - /* _exit: */ - initialized = 1; - return 0; + /* _exit: */ + initialized = 1; + return 0; - _fail: - initialized = 0; - return -1; +_fail: + initialized = 0; + return -1; } @@ -51,99 +51,99 @@ deferred_libnumarray_init(void) /**********************************************************************/ static PyObject * -getBuffer( PyObject *obj) -{ - if (!obj) return PyErr_Format(PyExc_RuntimeError, - "NULL object passed to getBuffer()"); - if (obj->ob_type->tp_as_buffer == NULL) { - return PyObject_CallMethod(obj, "__buffer__", NULL); - } else { - Py_INCREF(obj); /* Since CallMethod returns a new object when it - succeeds, We'll need to DECREF later to free it. - INCREF ordinary buffers here so we don't have to - remember where the buffer came from at DECREF time. - */ - return obj; - } +getBuffer( PyObject *obj) +{ + if (!obj) return PyErr_Format(PyExc_RuntimeError, + "NULL object passed to getBuffer()"); + if (obj->ob_type->tp_as_buffer == NULL) { + return PyObject_CallMethod(obj, "__buffer__", NULL); + } else { + Py_INCREF(obj); /* Since CallMethod returns a new object when it + succeeds, We'll need to DECREF later to free it. + INCREF ordinary buffers here so we don't have to + remember where the buffer came from at DECREF time. + */ + return obj; + } } /* Either it defines the buffer API, or it is an instance which returns -a buffer when obj.__buffer__() is called */ -static int -isBuffer (PyObject *obj) + a buffer when obj.__buffer__() is called */ +static int +isBuffer (PyObject *obj) { - PyObject *buf = getBuffer(obj); - int ans = 0; - if (buf) { - ans = buf->ob_type->tp_as_buffer != NULL; - Py_DECREF(buf); - } else { - PyErr_Clear(); - } - return ans; + PyObject *buf = getBuffer(obj); + int ans = 0; + if (buf) { + ans = buf->ob_type->tp_as_buffer != NULL; + Py_DECREF(buf); + } else { + PyErr_Clear(); + } + return ans; } /**********************************************************************/ -static int -getWriteBufferDataPtr(PyObject *buffobj, void **buff) +static int +getWriteBufferDataPtr(PyObject *buffobj, void **buff) { - int rval = -1; - PyObject *buff2; - if ((buff2 = getBuffer(buffobj))) - { - if (buff2->ob_type->tp_as_buffer->bf_getwritebuffer) - rval = buff2->ob_type->tp_as_buffer->bf_getwritebuffer(buff2, - 0, buff); - Py_DECREF(buff2); - } - return rval; + int rval = -1; + PyObject *buff2; + if ((buff2 = getBuffer(buffobj))) + { + if (buff2->ob_type->tp_as_buffer->bf_getwritebuffer) + rval = buff2->ob_type->tp_as_buffer->bf_getwritebuffer(buff2, + 0, buff); + Py_DECREF(buff2); + } + return rval; } /**********************************************************************/ -static int -isBufferWriteable (PyObject *buffobj) +static int +isBufferWriteable (PyObject *buffobj) { - void *ptr; - int rval = -1; - rval = getWriteBufferDataPtr(buffobj, &ptr); - if (rval == -1) - PyErr_Clear(); /* Since we're just "testing", it's not really an error */ - return rval != -1; + void *ptr; + int rval = -1; + rval = getWriteBufferDataPtr(buffobj, &ptr); + if (rval == -1) + PyErr_Clear(); /* Since we're just "testing", it's not really an error */ + return rval != -1; } /**********************************************************************/ -static int -getReadBufferDataPtr(PyObject *buffobj, void **buff) -{ - int rval = -1; - PyObject *buff2; - if ((buff2 = getBuffer(buffobj))) { - if (buff2->ob_type->tp_as_buffer->bf_getreadbuffer) - rval = buff2->ob_type->tp_as_buffer->bf_getreadbuffer(buff2, - 0, buff); - Py_DECREF(buff2); - } - return rval; +static int +getReadBufferDataPtr(PyObject *buffobj, void **buff) +{ + int rval = -1; + PyObject *buff2; + if ((buff2 = getBuffer(buffobj))) { + if (buff2->ob_type->tp_as_buffer->bf_getreadbuffer) + rval = buff2->ob_type->tp_as_buffer->bf_getreadbuffer(buff2, + 0, buff); + Py_DECREF(buff2); + } + return rval; } /**********************************************************************/ -static int -getBufferSize(PyObject *buffobj) +static int +getBufferSize(PyObject *buffobj) { - Py_ssize_t size=0; - PyObject *buff2; - if ((buff2 = getBuffer(buffobj))) + Py_ssize_t size=0; + PyObject *buff2; + if ((buff2 = getBuffer(buffobj))) { - (void) buff2->ob_type->tp_as_buffer->bf_getsegcount(buff2, &size); - Py_DECREF(buff2); + (void) buff2->ob_type->tp_as_buffer->bf_getsegcount(buff2, &size); + Py_DECREF(buff2); } - else - size = -1; - return size; + else + size = -1; + return size; } @@ -151,37 +151,37 @@ static double numarray_zero = 0.0; static double raiseDivByZero(void) { - return 1.0/numarray_zero; + return 1.0/numarray_zero; } static double raiseNegDivByZero(void) { - return -1.0/numarray_zero; + return -1.0/numarray_zero; } static double num_log(double x) { - if (x == 0.0) - return raiseNegDivByZero(); - else - return log(x); + if (x == 0.0) + return raiseNegDivByZero(); + else + return log(x); } static double num_log10(double x) { - if (x == 0.0) - return raiseNegDivByZero(); - else - return log10(x); + if (x == 0.0) + return raiseNegDivByZero(); + else + return log10(x); } static double num_pow(double x, double y) { - int z = (int) y; - if ((x < 0.0) && (y != z)) - return raiseDivByZero(); - else - return pow(x, y); + int z = (int) y; + if ((x < 0.0) && (y != z)) + return raiseDivByZero(); + else + return pow(x, y); } /* Inverse hyperbolic trig functions from Numeric */ @@ -218,12 +218,12 @@ static double num_round(double x) /* The following routine is used in the event of a detected integer * -** divide by zero so that a floating divide by zero is generated. * -** This is done since numarray uses the floating point exception * -** sticky bits to detect errors. The last bit is an attempt to * -** prevent optimization of the divide by zero away, the input value * -** should always be 0 * -*/ + ** divide by zero so that a floating divide by zero is generated. * + ** This is done since numarray uses the floating point exception * + ** sticky bits to detect errors. The last bit is an attempt to * + ** prevent optimization of the divide by zero away, the input value * + ** should always be 0 * + */ static int int_dividebyzero_error(long NPY_UNUSED(value), long NPY_UNUSED(unused)) { double dummy; @@ -237,392 +237,392 @@ static int int_dividebyzero_error(long NPY_UNUSED(value), long NPY_UNUSED(unused /* Likewise for Integer overflows */ #if defined(__GLIBC__) || defined(__APPLE__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__FreeBSD__) && (__FreeBSD_version >= 502114)) static int int_overflow_error(Float64 value) { /* For x86_64 */ - feraiseexcept(FE_OVERFLOW); - return (int) value; + feraiseexcept(FE_OVERFLOW); + return (int) value; } #else static int int_overflow_error(Float64 value) { - double dummy; - dummy = pow(1.e10, fabs(value/2)); - if (dummy) /* to prevent optimizer from eliminating expression */ - return (int) value; - else - return 1; + double dummy; + dummy = pow(1.e10, fabs(value/2)); + if (dummy) /* to prevent optimizer from eliminating expression */ + return (int) value; + else + return 1; } #endif static int umult64_overflow(UInt64 a, UInt64 b) { - UInt64 ah, al, bh, bl, w, x, y, z; + UInt64 ah, al, bh, bl, w, x, y, z; - ah = (a >> 32); - al = (a & 0xFFFFFFFFL); - bh = (b >> 32); - bl = (b & 0xFFFFFFFFL); + ah = (a >> 32); + al = (a & 0xFFFFFFFFL); + bh = (b >> 32); + bl = (b & 0xFFFFFFFFL); - /* 128-bit product: z*2**64 + (x+y)*2**32 + w */ - w = al*bl; - x = bh*al; - y = ah*bl; - z = ah*bh; + /* 128-bit product: z*2**64 + (x+y)*2**32 + w */ + w = al*bl; + x = bh*al; + y = ah*bl; + z = ah*bh; - /* *c = ((x + y)<<32) + w; */ - return z || (x>>32) || (y>>32) || - (((x & 0xFFFFFFFFL) + (y & 0xFFFFFFFFL) + (w >> 32)) >> 32); + /* *c = ((x + y)<<32) + w; */ + return z || (x>>32) || (y>>32) || + (((x & 0xFFFFFFFFL) + (y & 0xFFFFFFFFL) + (w >> 32)) >> 32); } static int smult64_overflow(Int64 a0, Int64 b0) { - UInt64 a, b; - UInt64 ah, al, bh, bl, w, x, y, z; + UInt64 a, b; + UInt64 ah, al, bh, bl, w, x, y, z; - /* Convert to non-negative quantities */ - if (a0 < 0) { a = -a0; } else { a = a0; } - if (b0 < 0) { b = -b0; } else { b = b0; } + /* Convert to non-negative quantities */ + if (a0 < 0) { a = -a0; } else { a = a0; } + if (b0 < 0) { b = -b0; } else { b = b0; } - ah = (a >> 32); - al = (a & 0xFFFFFFFFL); - bh = (b >> 32); - bl = (b & 0xFFFFFFFFL); + ah = (a >> 32); + al = (a & 0xFFFFFFFFL); + bh = (b >> 32); + bl = (b & 0xFFFFFFFFL); - w = al*bl; - x = bh*al; - y = ah*bl; - z = ah*bh; + w = al*bl; + x = bh*al; + y = ah*bl; + z = ah*bh; - /* - UInt64 c = ((x + y)<<32) + w; - if ((a0 < 0) ^ (b0 < 0)) - *c = -c; - else - *c = c - */ + /* + UInt64 c = ((x + y)<<32) + w; + if ((a0 < 0) ^ (b0 < 0)) + *c = -c; + else + *c = c + */ - return z || (x>>31) || (y>>31) || - (((x & 0xFFFFFFFFL) + (y & 0xFFFFFFFFL) + (w >> 32)) >> 31); + return z || (x>>31) || (y>>31) || + (((x & 0xFFFFFFFFL) + (y & 0xFFFFFFFFL) + (w >> 32)) >> 31); } static void NA_Done(void) { - return; + return; } static PyArrayObject * -NA_NewAll(int ndim, maybelong *shape, NumarrayType type, - void *buffer, maybelong byteoffset, maybelong bytestride, - int byteorder, int aligned, int writeable) -{ - PyArrayObject *result = NA_NewAllFromBuffer( - ndim, shape, type, Py_None, byteoffset, bytestride, - byteorder, aligned, writeable); - - if (result) { - if (!NA_NumArrayCheck((PyObject *) result)) { - PyErr_Format( PyExc_TypeError, - "NA_NewAll: non-NumArray result"); - result = NULL; - } else { - if (buffer) { - memcpy(result->data, buffer, NA_NBYTES(result)); - } else { - memset(result->data, 0, NA_NBYTES(result)); - } - } - } - return result; +NA_NewAll(int ndim, maybelong *shape, NumarrayType type, + void *buffer, maybelong byteoffset, maybelong bytestride, + int byteorder, int aligned, int writeable) +{ + PyArrayObject *result = NA_NewAllFromBuffer( + ndim, shape, type, Py_None, byteoffset, bytestride, + byteorder, aligned, writeable); + + if (result) { + if (!NA_NumArrayCheck((PyObject *) result)) { + PyErr_Format( PyExc_TypeError, + "NA_NewAll: non-NumArray result"); + result = NULL; + } else { + if (buffer) { + memcpy(result->data, buffer, NA_NBYTES(result)); + } else { + memset(result->data, 0, NA_NBYTES(result)); + } + } + } + return result; } static PyArrayObject * -NA_NewAllStrides(int ndim, maybelong *shape, maybelong *strides, - NumarrayType type, void *buffer, maybelong byteoffset, - int byteorder, int aligned, int writeable) +NA_NewAllStrides(int ndim, maybelong *shape, maybelong *strides, + NumarrayType type, void *buffer, maybelong byteoffset, + int byteorder, int aligned, int writeable) { - int i; - PyArrayObject *result = NA_NewAll(ndim, shape, type, buffer, - byteoffset, 0, - byteorder, aligned, writeable); - for(i=0; i<ndim; i++) - result->strides[i] = strides[i]; - return result; + int i; + PyArrayObject *result = NA_NewAll(ndim, shape, type, buffer, + byteoffset, 0, + byteorder, aligned, writeable); + for(i=0; i<ndim; i++) + result->strides[i] = strides[i]; + return result; } static PyArrayObject * NA_New(void *buffer, NumarrayType type, int ndim, ...) { - int i; - maybelong shape[MAXDIM]; - va_list ap; - va_start(ap, ndim); - for(i=0; i<ndim; i++) - shape[i] = va_arg(ap, int); - va_end(ap); - return NA_NewAll(ndim, shape, type, buffer, 0, 0, - NA_ByteOrder(), 1, 1); + int i; + maybelong shape[MAXDIM]; + va_list ap; + va_start(ap, ndim); + for(i=0; i<ndim; i++) + shape[i] = va_arg(ap, int); + va_end(ap); + return NA_NewAll(ndim, shape, type, buffer, 0, 0, + NA_ByteOrder(), 1, 1); } static PyArrayObject * NA_Empty(int ndim, maybelong *shape, NumarrayType type) { - return NA_NewAll(ndim, shape, type, NULL, 0, 0, - NA_ByteOrder(), 1, 1); + return NA_NewAll(ndim, shape, type, NULL, 0, 0, + NA_ByteOrder(), 1, 1); } /* Create a new numarray which is initially a C_array, or which -references a C_array: aligned, !byteswapped, contiguous, ... -Call with buffer==NULL to allocate storage. -*/ + references a C_array: aligned, !byteswapped, contiguous, ... + Call with buffer==NULL to allocate storage. + */ static PyArrayObject * NA_vNewArray(void *buffer, NumarrayType type, int ndim, maybelong *shape) { - return (PyArrayObject *) NA_NewAll(ndim, shape, type, buffer, 0, 0, - NA_ByteOrder(), 1, 1); + return (PyArrayObject *) NA_NewAll(ndim, shape, type, buffer, 0, 0, + NA_ByteOrder(), 1, 1); } static PyArrayObject * NA_NewArray(void *buffer, NumarrayType type, int ndim, ...) { - int i; - maybelong shape[MAXDIM]; - va_list ap; - va_start(ap, ndim); - for(i=0; i<ndim; i++) - shape[i] = va_arg(ap, int); /* literals will still be ints */ - va_end(ap); - return NA_vNewArray(buffer, type, ndim, shape); + int i; + maybelong shape[MAXDIM]; + va_list ap; + va_start(ap, ndim); + for(i=0; i<ndim; i++) + shape[i] = va_arg(ap, int); /* literals will still be ints */ + va_end(ap); + return NA_vNewArray(buffer, type, ndim, shape); } static PyObject* NA_ReturnOutput(PyObject *out, PyArrayObject *shadow) { - if ((out == Py_None) || (out == NULL)) { - /* default behavior: return shadow array as the result */ - return (PyObject *) shadow; - } else { - PyObject *rval; - /* specified output behavior: return None */ - /* del(shadow) --> out.copyFrom(shadow) */ - Py_DECREF(shadow); - Py_INCREF(Py_None); - rval = Py_None; - return rval; - } + if ((out == Py_None) || (out == NULL)) { + /* default behavior: return shadow array as the result */ + return (PyObject *) shadow; + } else { + PyObject *rval; + /* specified output behavior: return None */ + /* del(shadow) --> out.copyFrom(shadow) */ + Py_DECREF(shadow); + Py_INCREF(Py_None); + rval = Py_None; + return rval; + } } static long NA_getBufferPtrAndSize(PyObject *buffobj, int readonly, void **ptr) { - long rval; - if (readonly) - rval = getReadBufferDataPtr(buffobj, ptr); - else - rval = getWriteBufferDataPtr(buffobj, ptr); - return rval; + long rval; + if (readonly) + rval = getReadBufferDataPtr(buffobj, ptr); + else + rval = getWriteBufferDataPtr(buffobj, ptr); + return rval; } -static int NA_checkIo(char *name, - int wantIn, int wantOut, int gotIn, int gotOut) +static int NA_checkIo(char *name, + int wantIn, int wantOut, int gotIn, int gotOut) { - if (wantIn != gotIn) { - PyErr_Format(_Error, - "%s: wrong # of input buffers. Expected %d. Got %d.", - name, wantIn, gotIn); - return -1; - } - if (wantOut != gotOut) { - PyErr_Format(_Error, - "%s: wrong # of output buffers. Expected %d. Got %d.", - name, wantOut, gotOut); - return -1; - } - return 0; + if (wantIn != gotIn) { + PyErr_Format(_Error, + "%s: wrong # of input buffers. Expected %d. Got %d.", + name, wantIn, gotIn); + return -1; + } + if (wantOut != gotOut) { + PyErr_Format(_Error, + "%s: wrong # of output buffers. Expected %d. Got %d.", + name, wantOut, gotOut); + return -1; + } + return 0; } -static int NA_checkOneCBuffer(char *name, long niter, - void *buffer, long bsize, size_t typesize) +static int NA_checkOneCBuffer(char *name, long niter, + void *buffer, long bsize, size_t typesize) { - Int64 lniter = niter, ltypesize = typesize; + Int64 lniter = niter, ltypesize = typesize; - if (lniter*ltypesize > bsize) { - PyErr_Format(_Error, - "%s: access out of buffer. niter=%d typesize=%d bsize=%d", - name, (int) niter, (int) typesize, (int) bsize); - return -1; - } - if ((typesize <= sizeof(Float64)) && (((long) buffer) % typesize)) { - PyErr_Format(_Error, - "%s: buffer not aligned on %d byte boundary.", - name, (int) typesize); - return -1; - } - return 0; + if (lniter*ltypesize > bsize) { + PyErr_Format(_Error, + "%s: access out of buffer. niter=%d typesize=%d bsize=%d", + name, (int) niter, (int) typesize, (int) bsize); + return -1; + } + if ((typesize <= sizeof(Float64)) && (((long) buffer) % typesize)) { + PyErr_Format(_Error, + "%s: buffer not aligned on %d byte boundary.", + name, (int) typesize); + return -1; + } + return 0; } -static int NA_checkNCBuffers(char *name, int N, long niter, - void **buffers, long *bsizes, - Int8 *typesizes, Int8 *iters) +static int NA_checkNCBuffers(char *name, int N, long niter, + void **buffers, long *bsizes, + Int8 *typesizes, Int8 *iters) { - int i; - for (i=0; i<N; i++) - if (NA_checkOneCBuffer(name, iters[i] ? iters[i] : niter, - buffers[i], bsizes[i], typesizes[i])) - return -1; - return 0; + int i; + for (i=0; i<N; i++) + if (NA_checkOneCBuffer(name, iters[i] ? iters[i] : niter, + buffers[i], bsizes[i], typesizes[i])) + return -1; + return 0; } static int NA_checkOneStriding(char *name, long dim, maybelong *shape, - long offset, maybelong *stride, long buffersize, long itemsize, - int align) -{ - int i; - long omin=offset, omax=offset; - long alignsize = ((size_t)itemsize <= sizeof(Float64) ? (size_t)itemsize : sizeof(Float64)); - - if (align && (offset % alignsize)) { - PyErr_Format(_Error, - "%s: buffer not aligned on %d byte boundary.", - name, (int) alignsize); - return -1; - } - for(i=0; i<dim; i++) { - long strideN = stride[i] * (shape[i]-1); - long tmax = omax + strideN; - long tmin = omin + strideN; - if (shape[i]-1 >= 0) { /* Skip dimension == 0. */ - omax = MAX(omax, tmax); - omin = MIN(omin, tmin); - if (align && (ABS(stride[i]) % alignsize)) { - PyErr_Format(_Error, - "%s: stride %d not aligned on %d byte boundary.", - name, (int) stride[i], (int) alignsize); - return -1; - } - if (omax + itemsize > buffersize) { - PyErr_Format(_Error, - "%s: access beyond buffer. offset=%d buffersize=%d", - name, (int) (omax+itemsize-1), (int) buffersize); - return -1; - } - if (omin < 0) { - PyErr_Format(_Error, - "%s: access before buffer. offset=%d buffersize=%d", - name, (int) omin, (int) buffersize); - return -1; - } - } - } - return 0; + long offset, maybelong *stride, long buffersize, long itemsize, + int align) +{ + int i; + long omin=offset, omax=offset; + long alignsize = ((size_t)itemsize <= sizeof(Float64) ? (size_t)itemsize : sizeof(Float64)); + + if (align && (offset % alignsize)) { + PyErr_Format(_Error, + "%s: buffer not aligned on %d byte boundary.", + name, (int) alignsize); + return -1; + } + for(i=0; i<dim; i++) { + long strideN = stride[i] * (shape[i]-1); + long tmax = omax + strideN; + long tmin = omin + strideN; + if (shape[i]-1 >= 0) { /* Skip dimension == 0. */ + omax = MAX(omax, tmax); + omin = MIN(omin, tmin); + if (align && (ABS(stride[i]) % alignsize)) { + PyErr_Format(_Error, + "%s: stride %d not aligned on %d byte boundary.", + name, (int) stride[i], (int) alignsize); + return -1; + } + if (omax + itemsize > buffersize) { + PyErr_Format(_Error, + "%s: access beyond buffer. offset=%d buffersize=%d", + name, (int) (omax+itemsize-1), (int) buffersize); + return -1; + } + if (omin < 0) { + PyErr_Format(_Error, + "%s: access before buffer. offset=%d buffersize=%d", + name, (int) omin, (int) buffersize); + return -1; + } + } + } + return 0; } /* Function to call standard C Ufuncs -** -** The C Ufuncs expect contiguous 1-d data numarray, input and output numarray -** iterate with standard increments of one data element over all numarray. -** (There are some exceptions like arrayrangexxx which use one or more of -** the data numarray as parameter or other sources of information and do not -** iterate over every buffer). -** -** Arguments: -** -** Number of iterations (simple integer value). -** Number of input numarray. -** Number of output numarray. -** Tuple of tuples, one tuple per input/output array. Each of these -** tuples consists of a buffer object and a byte offset to start. -** -** Returns None -*/ + ** + ** The C Ufuncs expect contiguous 1-d data numarray, input and output numarray + ** iterate with standard increments of one data element over all numarray. + ** (There are some exceptions like arrayrangexxx which use one or more of + ** the data numarray as parameter or other sources of information and do not + ** iterate over every buffer). + ** + ** Arguments: + ** + ** Number of iterations (simple integer value). + ** Number of input numarray. + ** Number of output numarray. + ** Tuple of tuples, one tuple per input/output array. Each of these + ** tuples consists of a buffer object and a byte offset to start. + ** + ** Returns None + */ static PyObject * -NA_callCUFuncCore(PyObject *self, - long niter, long ninargs, long noutargs, - PyObject **BufferObj, long *offset) -{ - CfuncObject *me = (CfuncObject *) self; - char *buffers[MAXARGS]; - long bsizes[MAXARGS]; - long i, pnargs = ninargs + noutargs; - UFUNC ufuncptr; - - if (pnargs > MAXARGS) - return PyErr_Format(PyExc_RuntimeError, "NA_callCUFuncCore: too many parameters"); - - if (!PyObject_IsInstance(self, (PyObject *) &CfuncType) - || me->descr.type != CFUNC_UFUNC) - return PyErr_Format(PyExc_TypeError, - "NA_callCUFuncCore: problem with cfunc."); - - for (i=0; i<pnargs; i++) { - int readonly = (i < ninargs); - if (offset[i] < 0) - return PyErr_Format(_Error, - "%s: invalid negative offset:%d for buffer[%d]", - me->descr.name, (int) offset[i], (int) i); - if ((bsizes[i] = NA_getBufferPtrAndSize(BufferObj[i], readonly, - (void *) &buffers[i])) < 0) - return PyErr_Format(_Error, - "%s: Problem with %s buffer[%d].", - me->descr.name, - readonly ? "read" : "write", (int) i); - buffers[i] += offset[i]; - bsizes[i] -= offset[i]; /* "shorten" buffer size by offset. */ - } - - ufuncptr = (UFUNC) me->descr.fptr; - - /* If it's not a self-checking ufunc, check arg count match, - buffer size, and alignment for all buffers */ - if (!me->descr.chkself && - (NA_checkIo(me->descr.name, - me->descr.wantIn, me->descr.wantOut, ninargs, noutargs) || - NA_checkNCBuffers(me->descr.name, pnargs, - niter, (void **) buffers, bsizes, - me->descr.sizes, me->descr.iters))) - return NULL; - - /* Since the parameters are valid, call the C Ufunc */ - if (!(*ufuncptr)(niter, ninargs, noutargs, (void **)buffers, bsizes)) { - Py_INCREF(Py_None); - return Py_None; - } else { - return NULL; - } +NA_callCUFuncCore(PyObject *self, + long niter, long ninargs, long noutargs, + PyObject **BufferObj, long *offset) +{ + CfuncObject *me = (CfuncObject *) self; + char *buffers[MAXARGS]; + long bsizes[MAXARGS]; + long i, pnargs = ninargs + noutargs; + UFUNC ufuncptr; + + if (pnargs > MAXARGS) + return PyErr_Format(PyExc_RuntimeError, "NA_callCUFuncCore: too many parameters"); + + if (!PyObject_IsInstance(self, (PyObject *) &CfuncType) + || me->descr.type != CFUNC_UFUNC) + return PyErr_Format(PyExc_TypeError, + "NA_callCUFuncCore: problem with cfunc."); + + for (i=0; i<pnargs; i++) { + int readonly = (i < ninargs); + if (offset[i] < 0) + return PyErr_Format(_Error, + "%s: invalid negative offset:%d for buffer[%d]", + me->descr.name, (int) offset[i], (int) i); + if ((bsizes[i] = NA_getBufferPtrAndSize(BufferObj[i], readonly, + (void *) &buffers[i])) < 0) + return PyErr_Format(_Error, + "%s: Problem with %s buffer[%d].", + me->descr.name, + readonly ? "read" : "write", (int) i); + buffers[i] += offset[i]; + bsizes[i] -= offset[i]; /* "shorten" buffer size by offset. */ + } + + ufuncptr = (UFUNC) me->descr.fptr; + + /* If it's not a self-checking ufunc, check arg count match, + buffer size, and alignment for all buffers */ + if (!me->descr.chkself && + (NA_checkIo(me->descr.name, + me->descr.wantIn, me->descr.wantOut, ninargs, noutargs) || + NA_checkNCBuffers(me->descr.name, pnargs, + niter, (void **) buffers, bsizes, + me->descr.sizes, me->descr.iters))) + return NULL; + + /* Since the parameters are valid, call the C Ufunc */ + if (!(*ufuncptr)(niter, ninargs, noutargs, (void **)buffers, bsizes)) { + Py_INCREF(Py_None); + return Py_None; + } else { + return NULL; + } } static PyObject * callCUFunc(PyObject *self, PyObject *args) { - PyObject *DataArgs, *ArgTuple; - long pnargs, ninargs, noutargs, niter, i; - CfuncObject *me = (CfuncObject *) self; - PyObject *BufferObj[MAXARGS]; - long offset[MAXARGS]; - - if (!PyArg_ParseTuple(args, "lllO", - &niter, &ninargs, &noutargs, &DataArgs)) - return PyErr_Format(_Error, - "%s: Problem with argument list", me->descr.name); - - /* check consistency of stated inputs/outputs and supplied buffers */ - pnargs = PyObject_Length(DataArgs); - if ((pnargs != (ninargs+noutargs)) || (pnargs > MAXARGS)) - return PyErr_Format(_Error, - "%s: wrong buffer count for function", me->descr.name); - - /* Unpack buffers and offsets, get data pointers */ - for (i=0; i<pnargs; i++) { - ArgTuple = PySequence_GetItem(DataArgs, i); - Py_DECREF(ArgTuple); - if (!PyArg_ParseTuple(ArgTuple, "Ol", &BufferObj[i], &offset[i])) - return PyErr_Format(_Error, - "%s: Problem with buffer/offset tuple", me->descr.name); - } - return NA_callCUFuncCore(self, niter, ninargs, noutargs, BufferObj, offset); + PyObject *DataArgs, *ArgTuple; + long pnargs, ninargs, noutargs, niter, i; + CfuncObject *me = (CfuncObject *) self; + PyObject *BufferObj[MAXARGS]; + long offset[MAXARGS]; + + if (!PyArg_ParseTuple(args, "lllO", + &niter, &ninargs, &noutargs, &DataArgs)) + return PyErr_Format(_Error, + "%s: Problem with argument list", me->descr.name); + + /* check consistency of stated inputs/outputs and supplied buffers */ + pnargs = PyObject_Length(DataArgs); + if ((pnargs != (ninargs+noutargs)) || (pnargs > MAXARGS)) + return PyErr_Format(_Error, + "%s: wrong buffer count for function", me->descr.name); + + /* Unpack buffers and offsets, get data pointers */ + for (i=0; i<pnargs; i++) { + ArgTuple = PySequence_GetItem(DataArgs, i); + Py_DECREF(ArgTuple); + if (!PyArg_ParseTuple(ArgTuple, "Ol", &BufferObj[i], &offset[i])) + return PyErr_Format(_Error, + "%s: Problem with buffer/offset tuple", me->descr.name); + } + return NA_callCUFuncCore(self, niter, ninargs, noutargs, BufferObj, offset); } static PyObject * @@ -631,22 +631,22 @@ callStrideConvCFunc(PyObject *self, PyObject *args) { PyObject *inbstridesObj, *outbstridesObj; CfuncObject *me = (CfuncObject *) self; int nshape, ninbstrides, noutbstrides; - maybelong shape[MAXDIM], inbstrides[MAXDIM], - outbstrides[MAXDIM], *outbstrides1 = outbstrides; + maybelong shape[MAXDIM], inbstrides[MAXDIM], + outbstrides[MAXDIM], *outbstrides1 = outbstrides; long inboffset, outboffset, nbytes=0; if (!PyArg_ParseTuple(args, "OOlOOlO|l", - &shapeObj, &inbuffObj, &inboffset, &inbstridesObj, - &outbuffObj, &outboffset, &outbstridesObj, - &nbytes)) { + &shapeObj, &inbuffObj, &inboffset, &inbstridesObj, + &outbuffObj, &outboffset, &outbstridesObj, + &nbytes)) { return PyErr_Format(_Error, - "%s: Problem with argument list", - me->descr.name); + "%s: Problem with argument list", + me->descr.name); } nshape = NA_maybeLongsFromIntTuple(MAXDIM, shape, shapeObj); if (nshape < 0) return NULL; - + ninbstrides = NA_maybeLongsFromIntTuple(MAXDIM, inbstrides, inbstridesObj); if (ninbstrides < 0) return NULL; @@ -655,44 +655,44 @@ callStrideConvCFunc(PyObject *self, PyObject *args) { if (nshape && (nshape != ninbstrides)) { return PyErr_Format(_Error, - "%s: Missmatch between input iteration and strides tuples", - me->descr.name); + "%s: Missmatch between input iteration and strides tuples", + me->descr.name); } if (nshape && (nshape != noutbstrides)) { - if (noutbstrides < 1 || - outbstrides[ noutbstrides - 1 ])/* allow 0 for reductions. */ - return PyErr_Format(_Error, - "%s: Missmatch between output " - "iteration and strides tuples", - me->descr.name); - } - + if (noutbstrides < 1 || + outbstrides[ noutbstrides - 1 ])/* allow 0 for reductions. */ + return PyErr_Format(_Error, + "%s: Missmatch between output " + "iteration and strides tuples", + me->descr.name); + } + return NA_callStrideConvCFuncCore( - self, nshape, shape, - inbuffObj, inboffset, ninbstrides, inbstrides, - outbuffObj, outboffset, noutbstrides, outbstrides1, nbytes); + self, nshape, shape, + inbuffObj, inboffset, ninbstrides, inbstrides, + outbuffObj, outboffset, noutbstrides, outbstrides1, nbytes); } -static int -_NA_callStridingHelper(PyObject *aux, long dim, - long nnumarray, PyArrayObject *numarray[], char *data[], - CFUNC_STRIDED_FUNC f) -{ - int i, j, status=0; - dim -= 1; - for(i=0; i<numarray[0]->dimensions[dim]; i++) { - for (j=0; j<nnumarray; j++) - data[j] += numarray[j]->strides[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; - } - return status; +static int +_NA_callStridingHelper(PyObject *aux, long dim, + long nnumarray, PyArrayObject *numarray[], char *data[], + CFUNC_STRIDED_FUNC f) +{ + int i, j, status=0; + dim -= 1; + for(i=0; i<numarray[0]->dimensions[dim]; i++) { + for (j=0; j<nnumarray; j++) + data[j] += numarray[j]->strides[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; + } + return status; } @@ -707,55 +707,55 @@ callStridingCFunc(PyObject *self, PyObject *args) { int nnumarray = PySequence_Length(args)-1; if ((nnumarray < 1) || (nnumarray > MAXARRAYS)) - return PyErr_Format(_Error, "%s, too many or too few numarray.", - me->descr.name); + return PyErr_Format(_Error, "%s, too many or too few numarray.", + me->descr.name); aux = PySequence_GetItem(args, 0); if (!aux) - return NULL; + return NULL; for(i=0; i<nnumarray; i++) { - PyObject *otemp = PySequence_GetItem(args, i+1); - if (!otemp) - return PyErr_Format(_Error, "%s couldn't get array[%d]", - me->descr.name, i); - if (!NA_NDArrayCheck(otemp)) - return PyErr_Format(PyExc_TypeError, - "%s arg[%d] is not an array.", - me->descr.name, i); - numarray[i] = (PyArrayObject *) otemp; - data[i] = numarray[i]->data; - Py_DECREF(otemp); - if (!NA_updateDataPtr(numarray[i])) - return NULL; - } - + PyObject *otemp = PySequence_GetItem(args, i+1); + if (!otemp) + return PyErr_Format(_Error, "%s couldn't get array[%d]", + me->descr.name, i); + if (!NA_NDArrayCheck(otemp)) + return PyErr_Format(PyExc_TypeError, + "%s arg[%d] is not an array.", + me->descr.name, i); + numarray[i] = (PyArrayObject *) otemp; + data[i] = numarray[i]->data; + Py_DECREF(otemp); + if (!NA_updateDataPtr(numarray[i])) + return NULL; + } + /* Cast function pointer and perform stride operation */ f = (CFUNC_STRIDED_FUNC) me->descr.fptr; - - if (_NA_callStridingHelper(aux, numarray[0]->nd, - nnumarray, numarray, data, f)) { - return NULL; + + if (_NA_callStridingHelper(aux, numarray[0]->nd, + nnumarray, numarray, data, f)) { + return NULL; } else { - Py_INCREF(Py_None); - return Py_None; + Py_INCREF(Py_None); + return Py_None; } } /* Convert a standard C numeric value to a Python numeric value. -** -** Handles both nonaligned and/or byteswapped C data. -** -** Input arguments are: -** -** Buffer object that contains the C numeric value. -** Offset (in bytes) into the buffer that the data is located at. -** The size of the C numeric data item in bytes. -** Flag indicating if the C data is byteswapped from the processor's -** natural representation. -** -** Returns a Python numeric value. -*/ + ** + ** Handles both nonaligned and/or byteswapped C data. + ** + ** Input arguments are: + ** + ** Buffer object that contains the C numeric value. + ** Offset (in bytes) into the buffer that the data is located at. + ** The size of the C numeric data item in bytes. + ** Flag indicating if the C data is byteswapped from the processor's + ** natural representation. + ** + ** Returns a Python numeric value. + */ static PyObject * NumTypeAsPyValue(PyObject *self, PyObject *args) { @@ -767,23 +767,23 @@ NumTypeAsPyValue(PyObject *self, PyObject *args) { CFUNCasPyValue funcptr; CfuncObject *me = (CfuncObject *) self; - if (!PyArg_ParseTuple(args, "Olll", - &bufferObj, &offset, &itemsize, &byteswap)) + if (!PyArg_ParseTuple(args, "Olll", + &bufferObj, &offset, &itemsize, &byteswap)) return PyErr_Format(_Error, - "NumTypeAsPyValue: Problem with argument list"); + "NumTypeAsPyValue: Problem with argument list"); if ((buffersize = NA_getBufferPtrAndSize(bufferObj, 1, &buffer)) < 0) return PyErr_Format(_Error, "NumTypeAsPyValue: Problem with array buffer"); if (offset < 0) - return PyErr_Format(_Error, - "NumTypeAsPyValue: invalid negative offset: %d", (int) offset); + return PyErr_Format(_Error, + "NumTypeAsPyValue: invalid negative offset: %d", (int) offset); /* Guarantee valid buffer pointer */ if (offset+itemsize > buffersize) - return PyErr_Format(_Error, - "NumTypeAsPyValue: buffer too small for offset and itemsize."); + return PyErr_Format(_Error, + "NumTypeAsPyValue: buffer too small for offset and itemsize."); /* Do byteswapping. Guarantee double alignment by using temp. */ tempptr = (char *) &temp; @@ -804,20 +804,20 @@ NumTypeAsPyValue(PyObject *self, PyObject *args) { } /* Convert a Python numeric value to a standard C numeric value. -** -** Handles both nonaligned and/or byteswapped C data. -** -** Input arguments are: -** -** The Python numeric value to be converted. -** Buffer object to contain the C numeric value. -** Offset (in bytes) into the buffer that the data is to be copied to. -** The size of the C numeric data item in bytes. -** Flag indicating if the C data is byteswapped from the processor's -** natural representation. -** -** Returns None -*/ + ** + ** Handles both nonaligned and/or byteswapped C data. + ** + ** Input arguments are: + ** + ** The Python numeric value to be converted. + ** Buffer object to contain the C numeric value. + ** Offset (in bytes) into the buffer that the data is to be copied to. + ** The size of the C numeric data item in bytes. + ** Flag indicating if the C data is byteswapped from the processor's + ** natural representation. + ** + ** Returns None + */ static PyObject * NumTypeFromPyValue(PyObject *self, PyObject *args) { @@ -829,13 +829,13 @@ NumTypeFromPyValue(PyObject *self, PyObject *args) { CFUNCfromPyValue funcptr; CfuncObject *me = (CfuncObject *) self; - if (!PyArg_ParseTuple(args, "OOlll", - &valueObj, &bufferObj, &offset, &itemsize, &byteswap)) + if (!PyArg_ParseTuple(args, "OOlll", + &valueObj, &bufferObj, &offset, &itemsize, &byteswap)) return PyErr_Format(_Error, - "%s: Problem with argument list", me->descr.name); + "%s: Problem with argument list", me->descr.name); if ((buffersize = NA_getBufferPtrAndSize(bufferObj, 0, &buffer)) < 0) - return PyErr_Format(_Error, + return PyErr_Format(_Error, "%s: Problem with array buffer (read only?)", me->descr.name); funcptr = (CFUNCfromPyValue) me->descr.fptr; @@ -843,17 +843,17 @@ NumTypeFromPyValue(PyObject *self, PyObject *args) { /* Convert python object into "temp". Always safe. */ if (!((*funcptr)(valueObj, (void *)( &temp)))) return PyErr_Format(_Error, - "%s: Problem converting value", me->descr.name); + "%s: Problem converting value", me->descr.name); /* Check buffer offset. */ if (offset < 0) - return PyErr_Format(_Error, - "%s: invalid negative offset: %d", me->descr.name, (int) offset); + return PyErr_Format(_Error, + "%s: invalid negative offset: %d", me->descr.name, (int) offset); if (offset+itemsize > buffersize) - return PyErr_Format(_Error, - "%s: buffer too small(%d) for offset(%d) and itemsize(%d)", - me->descr.name, (int) buffersize, (int) offset, (int) itemsize); + return PyErr_Format(_Error, + "%s: buffer too small(%d) for offset(%d) and itemsize(%d)", + me->descr.name, (int) buffersize, (int) offset, (int) itemsize); /* Copy "temp" to array buffer. */ tempptr = (char *) &temp; @@ -869,36 +869,36 @@ NumTypeFromPyValue(PyObject *self, PyObject *args) { return Py_None; } -/* Handle "calling" the cfunc object at the python level. +/* Handle "calling" the cfunc object at the python level. Dispatch the call to the appropriate python-c wrapper based on the cfunc type. Do this dispatch to avoid having to check that python code didn't somehow create a mismatch between cfunc and wrapper. -*/ + */ static PyObject * cfunc_call(PyObject *self, PyObject *argsTuple, PyObject *NPY_UNUSED(argsDict)) { - CfuncObject *me = (CfuncObject *) self; - switch(me->descr.type) { - case CFUNC_UFUNC: - return callCUFunc(self, argsTuple); - break; - case CFUNC_STRIDING: - return callStrideConvCFunc(self, argsTuple); - break; - case CFUNC_NSTRIDING: - return callStridingCFunc(self, argsTuple); - case CFUNC_FROM_PY_VALUE: - return NumTypeFromPyValue(self, argsTuple); - break; - case CFUNC_AS_PY_VALUE: - return NumTypeAsPyValue(self, argsTuple); - break; - default: - return PyErr_Format( _Error, - "cfunc_call: Can't dispatch cfunc '%s' with type: %d.", - me->descr.name, me->descr.type); - } + CfuncObject *me = (CfuncObject *) self; + switch(me->descr.type) { + case CFUNC_UFUNC: + return callCUFunc(self, argsTuple); + break; + case CFUNC_STRIDING: + return callStrideConvCFunc(self, argsTuple); + break; + case CFUNC_NSTRIDING: + return callStridingCFunc(self, argsTuple); + case CFUNC_FROM_PY_VALUE: + return NumTypeFromPyValue(self, argsTuple); + break; + case CFUNC_AS_PY_VALUE: + return NumTypeAsPyValue(self, argsTuple); + break; + default: + return PyErr_Format( _Error, + "cfunc_call: Can't dispatch cfunc '%s' with type: %d.", + me->descr.name, me->descr.type); + } } staticforward PyTypeObject CfuncType; @@ -906,61 +906,61 @@ staticforward PyTypeObject CfuncType; static void cfunc_dealloc(PyObject* self) { - PyObject_Del(self); + PyObject_Del(self); } static PyObject * cfunc_repr(PyObject *self) { - char buf[256]; - CfuncObject *me = (CfuncObject *) self; - sprintf(buf, "<cfunc '%s' at %08lx check-self:%d align:%d io:(%d, %d)>", - me->descr.name, (unsigned long ) me->descr.fptr, - me->descr.chkself, me->descr.align, - me->descr.wantIn, me->descr.wantOut); - return PyString_FromString(buf); + char buf[256]; + CfuncObject *me = (CfuncObject *) self; + sprintf(buf, "<cfunc '%s' at %08lx check-self:%d align:%d io:(%d, %d)>", + me->descr.name, (unsigned long ) me->descr.fptr, + me->descr.chkself, me->descr.align, + me->descr.wantIn, me->descr.wantOut); + return PyString_FromString(buf); } static PyTypeObject CfuncType = { - PyObject_HEAD_INIT(NULL) - 0, - "Cfunc", - sizeof(CfuncObject), - 0, - cfunc_dealloc, /*tp_dealloc*/ - 0, /*tp_print*/ - 0, /*tp_getattr*/ - 0, /*tp_setattr*/ - 0, /*tp_compare*/ - cfunc_repr, /*tp_repr*/ - 0, /*tp_as_number*/ - 0, /*tp_as_sequence*/ - 0, /*tp_as_mapping*/ - 0, /*tp_hash */ - cfunc_call, /* tp_call */ -}; + PyObject_HEAD_INIT(NULL) + 0, + "Cfunc", + sizeof(CfuncObject), + 0, + cfunc_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + cfunc_repr, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + cfunc_call, /* tp_call */ + }; /* CfuncObjects are created at the c-level only. They ensure that each -cfunc is called via the correct python-c-wrapper as defined by its -CfuncDescriptor. The wrapper, in turn, does conversions and buffer size -and alignment checking. Allowing these to be created at the python level -would enable them to be created *wrong* at the python level, and thereby -enable python code to *crash* python. -*/ + cfunc is called via the correct python-c-wrapper as defined by its + CfuncDescriptor. The wrapper, in turn, does conversions and buffer size + and alignment checking. Allowing these to be created at the python level + would enable them to be created *wrong* at the python level, and thereby + enable python code to *crash* python. + */ static PyObject* NA_new_cfunc(CfuncDescriptor *cfd) { CfuncObject* cfunc; - + CfuncType.ob_type = &PyType_Type; /* Should be done once at init. - Do now since there is no init. */ + Do now since there is no init. */ cfunc = PyObject_New(CfuncObject, &CfuncType); - + if (!cfunc) { - return PyErr_Format(_Error, - "NA_new_cfunc: failed creating '%s'", - cfd->name); + return PyErr_Format(_Error, + "NA_new_cfunc: failed creating '%s'", + cfd->name); } cfunc->descr = *cfd; @@ -968,795 +968,795 @@ NA_new_cfunc(CfuncDescriptor *cfd) return (PyObject*)cfunc; } -static int NA_add_cfunc(PyObject *dict, char *keystr, CfuncDescriptor *descr) +static int NA_add_cfunc(PyObject *dict, char *keystr, CfuncDescriptor *descr) { - PyObject *c = (PyObject *) NA_new_cfunc(descr); - if (!c) return -1; - return PyDict_SetItemString(dict, keystr, c); + PyObject *c = (PyObject *) NA_new_cfunc(descr); + if (!c) return -1; + return PyDict_SetItemString(dict, keystr, c); } static PyArrayObject* NA_InputArray(PyObject *a, NumarrayType t, int requires) { - PyArray_Descr *descr; - if (t == tAny) descr = NULL; - else descr = PyArray_DescrFromType(t); - return (PyArrayObject *) \ - PyArray_CheckFromAny(a, descr, 0, 0, requires, NULL); + PyArray_Descr *descr; + if (t == tAny) descr = NULL; + else descr = PyArray_DescrFromType(t); + return (PyArrayObject *) \ + PyArray_CheckFromAny(a, descr, 0, 0, requires, NULL); } -/* satisfies ensures that 'a' meets a set of requirements and matches -the specified type. -*/ +/* satisfies ensures that 'a' meets a set of requirements and matches + the specified type. + */ static int satisfies(PyArrayObject *a, int requirements, NumarrayType t) { - int type_ok = (a->descr->type_num == t) || (t == tAny); + int type_ok = (a->descr->type_num == t) || (t == tAny); - if (PyArray_ISCARRAY(a)) - return type_ok; - if (PyArray_ISBYTESWAPPED(a) && (requirements & NUM_NOTSWAPPED)) - return 0; - if (!PyArray_ISALIGNED(a) && (requirements & NUM_ALIGNED)) - return 0; - if (!PyArray_ISCONTIGUOUS(a) && (requirements & NUM_CONTIGUOUS)) - return 0; - if (!PyArray_ISWRITABLE(a) && (requirements & NUM_WRITABLE)) - return 0; - if (requirements & NUM_COPY) - return 0; - return type_ok; + if (PyArray_ISCARRAY(a)) + return type_ok; + if (PyArray_ISBYTESWAPPED(a) && (requirements & NUM_NOTSWAPPED)) + return 0; + if (!PyArray_ISALIGNED(a) && (requirements & NUM_ALIGNED)) + return 0; + if (!PyArray_ISCONTIGUOUS(a) && (requirements & NUM_CONTIGUOUS)) + return 0; + if (!PyArray_ISWRITABLE(a) && (requirements & NUM_WRITABLE)) + return 0; + if (requirements & NUM_COPY) + return 0; + return type_ok; } static PyArrayObject * NA_OutputArray(PyObject *a, NumarrayType t, int requires) { - PyArray_Descr *dtype; - PyArrayObject *ret; + PyArray_Descr *dtype; + PyArrayObject *ret; - if (!PyArray_Check(a) || !PyArray_ISWRITEABLE(a)) { - PyErr_Format(PyExc_TypeError, - "NA_OutputArray: only writeable arrays work for output."); - return NULL; - } + if (!PyArray_Check(a) || !PyArray_ISWRITEABLE(a)) { + PyErr_Format(PyExc_TypeError, + "NA_OutputArray: only writeable arrays work for output."); + return NULL; + } - if (satisfies((PyArrayObject *)a, requires, t)) { - Py_INCREF(a); - return (PyArrayObject *)a; - } - if (t == tAny) { - dtype = PyArray_DESCR(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; + if (satisfies((PyArrayObject *)a, requires, t)) { Py_INCREF(a); - return ret; + return (PyArrayObject *)a; + } + if (t == tAny) { + dtype = PyArray_DESCR(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; + Py_INCREF(a); + return ret; } /* NA_IoArray is a combination of NA_InputArray and NA_OutputArray. -Unlike NA_OutputArray, if a temporary is required it is initialized to a copy -of the input array. + Unlike NA_OutputArray, if a temporary is required it is initialized to a copy + of the input array. -Unlike NA_InputArray, deallocating any resulting temporary array results in a -copy from the temporary back to the original. -*/ + Unlike NA_InputArray, deallocating any resulting temporary array results in a + copy from the temporary back to the original. + */ 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_UPDATEIFCOPY ); - if (!shadow) return NULL; + if (!shadow) return NULL; - /* Guard against non-writable, but otherwise satisfying requires. - In this case, shadow == a. - */ - if (!PyArray_ISWRITABLE(shadow)) { - PyErr_Format(PyExc_TypeError, - "NA_IoArray: I/O array must be writable array"); - PyArray_XDECREF_ERR(shadow); - return NULL; - } + /* Guard against non-writable, but otherwise satisfying requires. + In this case, shadow == a. + */ + if (!PyArray_ISWRITABLE(shadow)) { + PyErr_Format(PyExc_TypeError, + "NA_IoArray: I/O array must be writable array"); + PyArray_XDECREF_ERR(shadow); + return NULL; + } - return shadow; + return shadow; } /* NA_OptionalOutputArray works like NA_OutputArray, but handles the case -where the output array 'optional' is omitted entirely at the python level, -resulting in 'optional'==Py_None. When 'optional' is Py_None, the return -value is cloned (but with NumarrayType 't') from 'master', typically an input -array with the same shape as the output array. -*/ + where the output array 'optional' is omitted entirely at the python level, + resulting in 'optional'==Py_None. When 'optional' is Py_None, the return + value is cloned (but with NumarrayType 't') from 'master', typically an input + array with the same shape as the output array. + */ static PyArrayObject * -NA_OptionalOutputArray(PyObject *optional, NumarrayType t, int requires, - PyArrayObject *master) -{ - if ((optional == Py_None) || (optional == NULL)) { - PyObject *rval; - PyArray_Descr *descr; - if (t == tAny) descr=NULL; - else descr = PyArray_DescrFromType(t); - rval = PyArray_FromArray( - master, descr, NUM_C_ARRAY | NUM_COPY | NUM_WRITABLE); - return (PyArrayObject *)rval; - } else { - return NA_OutputArray(optional, t, requires); - } +NA_OptionalOutputArray(PyObject *optional, NumarrayType t, int requires, + PyArrayObject *master) +{ + if ((optional == Py_None) || (optional == NULL)) { + PyObject *rval; + PyArray_Descr *descr; + if (t == tAny) descr=NULL; + else descr = PyArray_DescrFromType(t); + rval = PyArray_FromArray( + master, descr, NUM_C_ARRAY | NUM_COPY | NUM_WRITABLE); + return (PyArrayObject *)rval; + } else { + return NA_OutputArray(optional, t, requires); + } } Complex64 NA_get_Complex64(PyArrayObject *a, long offset) { - Complex32 v0; - Complex64 v; - - switch(a->descr->type_num) { - case tComplex32: - v0 = NA_GETP(a, Complex32, (NA_PTR(a)+offset)); - v.r = v0.r; - v.i = v0.i; - break; - case tComplex64: - v = NA_GETP(a, Complex64, (NA_PTR(a)+offset)); - break; - default: - v.r = NA_get_Float64(a, offset); - v.i = 0; - break; - } - return v; + Complex32 v0; + Complex64 v; + + switch(a->descr->type_num) { + case tComplex32: + v0 = NA_GETP(a, Complex32, (NA_PTR(a)+offset)); + v.r = v0.r; + v.i = v0.i; + break; + case tComplex64: + v = NA_GETP(a, Complex64, (NA_PTR(a)+offset)); + break; + default: + v.r = NA_get_Float64(a, offset); + v.i = 0; + break; + } + return v; } void NA_set_Complex64(PyArrayObject *a, long offset, Complex64 v) { - Complex32 v0; - - switch(a->descr->type_num) { - case tComplex32: - v0.r = v.r; - v0.i = v.i; - NA_SETP(a, Complex32, (NA_PTR(a)+offset), v0); - break; - case tComplex64: - NA_SETP(a, Complex64, (NA_PTR(a)+offset), v); - break; - default: - NA_set_Float64(a, offset, v.r); - break; - } + Complex32 v0; + + switch(a->descr->type_num) { + case tComplex32: + v0.r = v.r; + v0.i = v.i; + NA_SETP(a, Complex32, (NA_PTR(a)+offset), v0); + break; + case tComplex64: + NA_SETP(a, Complex64, (NA_PTR(a)+offset), v); + break; + default: + NA_set_Float64(a, offset, v.r); + break; + } } Int64 NA_get_Int64(PyArrayObject *a, long offset) { - switch(a->descr->type_num) { - case tBool: - return NA_GETP(a, Bool, (NA_PTR(a)+offset)) != 0; - case tInt8: - return NA_GETP(a, Int8, (NA_PTR(a)+offset)); - case tUInt8: - return NA_GETP(a, UInt8, (NA_PTR(a)+offset)); - case tInt16: - return NA_GETP(a, Int16, (NA_PTR(a)+offset)); - case tUInt16: - return NA_GETP(a, UInt16, (NA_PTR(a)+offset)); - case tInt32: - return NA_GETP(a, Int32, (NA_PTR(a)+offset)); - case tUInt32: - return NA_GETP(a, UInt32, (NA_PTR(a)+offset)); - case tInt64: - return NA_GETP(a, Int64, (NA_PTR(a)+offset)); - case tUInt64: - return NA_GETP(a, UInt64, (NA_PTR(a)+offset)); - case tFloat32: - return NA_GETP(a, Float32, (NA_PTR(a)+offset)); - case tFloat64: - return NA_GETP(a, Float64, (NA_PTR(a)+offset)); - case tComplex32: - return NA_GETP(a, Float32, (NA_PTR(a)+offset)); - case tComplex64: - return NA_GETP(a, Float64, (NA_PTR(a)+offset)); - default: - PyErr_Format( PyExc_TypeError, - "Unknown type %d in NA_get_Int64", - a->descr->type_num); - PyErr_Print(); - } - return 0; /* suppress warning */ + switch(a->descr->type_num) { + case tBool: + return NA_GETP(a, Bool, (NA_PTR(a)+offset)) != 0; + case tInt8: + return NA_GETP(a, Int8, (NA_PTR(a)+offset)); + case tUInt8: + return NA_GETP(a, UInt8, (NA_PTR(a)+offset)); + case tInt16: + return NA_GETP(a, Int16, (NA_PTR(a)+offset)); + case tUInt16: + return NA_GETP(a, UInt16, (NA_PTR(a)+offset)); + case tInt32: + return NA_GETP(a, Int32, (NA_PTR(a)+offset)); + case tUInt32: + return NA_GETP(a, UInt32, (NA_PTR(a)+offset)); + case tInt64: + return NA_GETP(a, Int64, (NA_PTR(a)+offset)); + case tUInt64: + return NA_GETP(a, UInt64, (NA_PTR(a)+offset)); + case tFloat32: + return NA_GETP(a, Float32, (NA_PTR(a)+offset)); + case tFloat64: + return NA_GETP(a, Float64, (NA_PTR(a)+offset)); + case tComplex32: + return NA_GETP(a, Float32, (NA_PTR(a)+offset)); + case tComplex64: + return NA_GETP(a, Float64, (NA_PTR(a)+offset)); + default: + PyErr_Format( PyExc_TypeError, + "Unknown type %d in NA_get_Int64", + a->descr->type_num); + PyErr_Print(); + } + return 0; /* suppress warning */ } void NA_set_Int64(PyArrayObject *a, long offset, Int64 v) { - Bool b; - - switch(a->descr->type_num) { - case tBool: - b = (v != 0); - NA_SETP(a, Bool, (NA_PTR(a)+offset), b); - break; - case tInt8: NA_SETP(a, Int8, (NA_PTR(a)+offset), v); - break; - case tUInt8: NA_SETP(a, UInt8, (NA_PTR(a)+offset), v); - break; - case tInt16: NA_SETP(a, Int16, (NA_PTR(a)+offset), v); - break; - case tUInt16: NA_SETP(a, UInt16, (NA_PTR(a)+offset), v); - break; - case tInt32: NA_SETP(a, Int32, (NA_PTR(a)+offset), v); - break; - case tUInt32: NA_SETP(a, UInt32, (NA_PTR(a)+offset), v); - break; - case tInt64: NA_SETP(a, Int64, (NA_PTR(a)+offset), v); - break; - case tUInt64: NA_SETP(a, UInt64, (NA_PTR(a)+offset), v); - break; - case tFloat32: - NA_SETP(a, Float32, (NA_PTR(a)+offset), v); - break; - case tFloat64: - NA_SETP(a, Float64, (NA_PTR(a)+offset), v); - break; - case tComplex32: - NA_SETP(a, Float32, (NA_PTR(a)+offset), v); - NA_SETP(a, Float32, (NA_PTR(a)+offset+sizeof(Float32)), 0); - break; - case tComplex64: - NA_SETP(a, Float64, (NA_PTR(a)+offset), v); - NA_SETP(a, Float64, (NA_PTR(a)+offset+sizeof(Float64)), 0); - break; - default: - PyErr_Format( PyExc_TypeError, - "Unknown type %d in NA_set_Int64", - a->descr->type_num); - PyErr_Print(); - } + Bool b; + + switch(a->descr->type_num) { + case tBool: + b = (v != 0); + NA_SETP(a, Bool, (NA_PTR(a)+offset), b); + break; + case tInt8: NA_SETP(a, Int8, (NA_PTR(a)+offset), v); + break; + case tUInt8: NA_SETP(a, UInt8, (NA_PTR(a)+offset), v); + break; + case tInt16: NA_SETP(a, Int16, (NA_PTR(a)+offset), v); + break; + case tUInt16: NA_SETP(a, UInt16, (NA_PTR(a)+offset), v); + break; + case tInt32: NA_SETP(a, Int32, (NA_PTR(a)+offset), v); + break; + case tUInt32: NA_SETP(a, UInt32, (NA_PTR(a)+offset), v); + break; + case tInt64: NA_SETP(a, Int64, (NA_PTR(a)+offset), v); + break; + case tUInt64: NA_SETP(a, UInt64, (NA_PTR(a)+offset), v); + break; + case tFloat32: + NA_SETP(a, Float32, (NA_PTR(a)+offset), v); + break; + case tFloat64: + NA_SETP(a, Float64, (NA_PTR(a)+offset), v); + break; + case tComplex32: + NA_SETP(a, Float32, (NA_PTR(a)+offset), v); + NA_SETP(a, Float32, (NA_PTR(a)+offset+sizeof(Float32)), 0); + break; + case tComplex64: + NA_SETP(a, Float64, (NA_PTR(a)+offset), v); + NA_SETP(a, Float64, (NA_PTR(a)+offset+sizeof(Float64)), 0); + break; + default: + PyErr_Format( PyExc_TypeError, + "Unknown type %d in NA_set_Int64", + a->descr->type_num); + PyErr_Print(); + } } /* NA_get_offset computes the offset specified by the set of indices. -If N > 0, the indices are taken from the outer dimensions of the array. -If N < 0, the indices are taken from the inner dimensions of the array. -If N == 0, the offset is 0. -*/ + If N > 0, the indices are taken from the outer dimensions of the array. + If N < 0, the indices are taken from the inner dimensions of the array. + If N == 0, the offset is 0. + */ long NA_get_offset(PyArrayObject *a, int N, ...) { - int i; - long offset = 0; - va_list ap; - 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]; - } 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]; - } - va_end(ap); - return offset; + int i; + long offset = 0; + va_list ap; + 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]; + } 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]; + } + va_end(ap); + return offset; } Float64 NA_get_Float64(PyArrayObject *a, long offset) { - switch(a->descr->type_num) { - case tBool: - return NA_GETP(a, Bool, (NA_PTR(a)+offset)) != 0; - case tInt8: - return NA_GETP(a, Int8, (NA_PTR(a)+offset)); - case tUInt8: - return NA_GETP(a, UInt8, (NA_PTR(a)+offset)); - case tInt16: - return NA_GETP(a, Int16, (NA_PTR(a)+offset)); - case tUInt16: - return NA_GETP(a, UInt16, (NA_PTR(a)+offset)); - case tInt32: - return NA_GETP(a, Int32, (NA_PTR(a)+offset)); - case tUInt32: - return NA_GETP(a, UInt32, (NA_PTR(a)+offset)); - case tInt64: - return NA_GETP(a, Int64, (NA_PTR(a)+offset)); - #if HAS_UINT64 - case tUInt64: - return NA_GETP(a, UInt64, (NA_PTR(a)+offset)); - #endif - case tFloat32: - return NA_GETP(a, Float32, (NA_PTR(a)+offset)); - case tFloat64: - return NA_GETP(a, Float64, (NA_PTR(a)+offset)); - case tComplex32: /* Since real value is first */ - return NA_GETP(a, Float32, (NA_PTR(a)+offset)); - case tComplex64: /* Since real value is first */ - return NA_GETP(a, Float64, (NA_PTR(a)+offset)); - default: - PyErr_Format( PyExc_TypeError, - "Unknown type %d in NA_get_Float64", - a->descr->type_num); - } - return 0; /* suppress warning */ + switch(a->descr->type_num) { + case tBool: + return NA_GETP(a, Bool, (NA_PTR(a)+offset)) != 0; + case tInt8: + return NA_GETP(a, Int8, (NA_PTR(a)+offset)); + case tUInt8: + return NA_GETP(a, UInt8, (NA_PTR(a)+offset)); + case tInt16: + return NA_GETP(a, Int16, (NA_PTR(a)+offset)); + case tUInt16: + return NA_GETP(a, UInt16, (NA_PTR(a)+offset)); + case tInt32: + return NA_GETP(a, Int32, (NA_PTR(a)+offset)); + case tUInt32: + return NA_GETP(a, UInt32, (NA_PTR(a)+offset)); + case tInt64: + return NA_GETP(a, Int64, (NA_PTR(a)+offset)); +#if HAS_UINT64 + case tUInt64: + return NA_GETP(a, UInt64, (NA_PTR(a)+offset)); +#endif + case tFloat32: + return NA_GETP(a, Float32, (NA_PTR(a)+offset)); + case tFloat64: + return NA_GETP(a, Float64, (NA_PTR(a)+offset)); + case tComplex32: /* Since real value is first */ + return NA_GETP(a, Float32, (NA_PTR(a)+offset)); + case tComplex64: /* Since real value is first */ + return NA_GETP(a, Float64, (NA_PTR(a)+offset)); + default: + PyErr_Format( PyExc_TypeError, + "Unknown type %d in NA_get_Float64", + a->descr->type_num); + } + return 0; /* suppress warning */ } void NA_set_Float64(PyArrayObject *a, long offset, Float64 v) { - Bool b; - - switch(a->descr->type_num) { - case tBool: - b = (v != 0); - NA_SETP(a, Bool, (NA_PTR(a)+offset), b); - break; - case tInt8: NA_SETP(a, Int8, (NA_PTR(a)+offset), v); - break; - case tUInt8: NA_SETP(a, UInt8, (NA_PTR(a)+offset), v); - break; - case tInt16: NA_SETP(a, Int16, (NA_PTR(a)+offset), v); - break; - case tUInt16: NA_SETP(a, UInt16, (NA_PTR(a)+offset), v); - break; - case tInt32: NA_SETP(a, Int32, (NA_PTR(a)+offset), v); - break; - case tUInt32: NA_SETP(a, UInt32, (NA_PTR(a)+offset), v); - break; - case tInt64: NA_SETP(a, Int64, (NA_PTR(a)+offset), v); - break; - #if HAS_UINT64 - case tUInt64: NA_SETP(a, UInt64, (NA_PTR(a)+offset), v); - break; - #endif - case tFloat32: - NA_SETP(a, Float32, (NA_PTR(a)+offset), v); - break; - case tFloat64: - NA_SETP(a, Float64, (NA_PTR(a)+offset), v); - break; - case tComplex32: { - NA_SETP(a, Float32, (NA_PTR(a)+offset), v); - NA_SETP(a, Float32, (NA_PTR(a)+offset+sizeof(Float32)), 0); - break; - } - case tComplex64: { - NA_SETP(a, Float64, (NA_PTR(a)+offset), v); - NA_SETP(a, Float64, (NA_PTR(a)+offset+sizeof(Float64)), 0); - break; - } - default: - PyErr_Format( PyExc_TypeError, - "Unknown type %d in NA_set_Float64", - a->descr->type_num ); - PyErr_Print(); - } + Bool b; + + switch(a->descr->type_num) { + case tBool: + b = (v != 0); + NA_SETP(a, Bool, (NA_PTR(a)+offset), b); + break; + case tInt8: NA_SETP(a, Int8, (NA_PTR(a)+offset), v); + break; + case tUInt8: NA_SETP(a, UInt8, (NA_PTR(a)+offset), v); + break; + case tInt16: NA_SETP(a, Int16, (NA_PTR(a)+offset), v); + break; + case tUInt16: NA_SETP(a, UInt16, (NA_PTR(a)+offset), v); + break; + case tInt32: NA_SETP(a, Int32, (NA_PTR(a)+offset), v); + break; + case tUInt32: NA_SETP(a, UInt32, (NA_PTR(a)+offset), v); + break; + case tInt64: NA_SETP(a, Int64, (NA_PTR(a)+offset), v); + break; +#if HAS_UINT64 + case tUInt64: NA_SETP(a, UInt64, (NA_PTR(a)+offset), v); + break; +#endif + case tFloat32: + NA_SETP(a, Float32, (NA_PTR(a)+offset), v); + break; + case tFloat64: + NA_SETP(a, Float64, (NA_PTR(a)+offset), v); + break; + case tComplex32: { + NA_SETP(a, Float32, (NA_PTR(a)+offset), v); + NA_SETP(a, Float32, (NA_PTR(a)+offset+sizeof(Float32)), 0); + break; + } + case tComplex64: { + NA_SETP(a, Float64, (NA_PTR(a)+offset), v); + NA_SETP(a, Float64, (NA_PTR(a)+offset+sizeof(Float64)), 0); + break; + } + default: + PyErr_Format( PyExc_TypeError, + "Unknown type %d in NA_set_Float64", + a->descr->type_num ); + PyErr_Print(); + } } Float64 NA_get1_Float64(PyArrayObject *a, long i) { - long offset = i * a->strides[0]; - return NA_get_Float64(a, offset); + long offset = i * a->strides[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]; - return NA_get_Float64(a, offset); + long offset = i * a->strides[0] + + j * a->strides[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]; - return NA_get_Float64(a, offset); + long offset = i * a->strides[0] + + j * a->strides[1] + + k * a->strides[2]; + return NA_get_Float64(a, offset); } void NA_set1_Float64(PyArrayObject *a, long i, Float64 v) { - long offset = i * a->strides[0]; - NA_set_Float64(a, offset, v); + long offset = i * a->strides[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]; - NA_set_Float64(a, offset, v); + long offset = i * a->strides[0] + + j * a->strides[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]; - NA_set_Float64(a, offset, v); + long offset = i * a->strides[0] + + j * a->strides[1] + + k * a->strides[2]; + NA_set_Float64(a, offset, v); } Complex64 NA_get1_Complex64(PyArrayObject *a, long i) { - long offset = i * a->strides[0]; - return NA_get_Complex64(a, offset); + long offset = i * a->strides[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]; - return NA_get_Complex64(a, offset); + long offset = i * a->strides[0] + + j * a->strides[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]; - return NA_get_Complex64(a, offset); + long offset = i * a->strides[0] + + j * a->strides[1] + + k * a->strides[2]; + return NA_get_Complex64(a, offset); } void NA_set1_Complex64(PyArrayObject *a, long i, Complex64 v) { - long offset = i * a->strides[0]; - NA_set_Complex64(a, offset, v); + long offset = i * a->strides[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]; - NA_set_Complex64(a, offset, v); + long offset = i * a->strides[0] + + j * a->strides[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]; - NA_set_Complex64(a, offset, v); + long offset = i * a->strides[0] + + j * a->strides[1] + + k * a->strides[2]; + NA_set_Complex64(a, offset, v); } Int64 NA_get1_Int64(PyArrayObject *a, long i) { - long offset = i * a->strides[0]; - return NA_get_Int64(a, offset); + long offset = i * a->strides[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]; - return NA_get_Int64(a, offset); + long offset = i * a->strides[0] + + j * a->strides[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]; - return NA_get_Int64(a, offset); + long offset = i * a->strides[0] + + j * a->strides[1] + + k * a->strides[2]; + return NA_get_Int64(a, offset); } void NA_set1_Int64(PyArrayObject *a, long i, Int64 v) { - long offset = i * a->strides[0]; - NA_set_Int64(a, offset, v); + long offset = i * a->strides[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]; - NA_set_Int64(a, offset, v); + long offset = i * a->strides[0] + + j * a->strides[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]; - NA_set_Int64(a, offset, v); + long offset = i * a->strides[0] + + j * a->strides[1] + + k * a->strides[2]; + NA_set_Int64(a, offset, v); } /* SET_CMPLX could be made faster by factoring it into 3 seperate loops. */ #define NA_SET_CMPLX(a, type, base, cnt, in) \ { \ - int i; \ - int stride = a->strides[ a->nd - 1]; \ - NA_SET1D(a, type, base, cnt, in); \ - base = NA_PTR(a) + offset + sizeof(type); \ - for(i=0; i<cnt; i++) { \ - NA_SETP(a, Float32, base, 0); \ - base += stride; \ - } \ + int i; \ + int stride = a->strides[ a->nd - 1]; \ + NA_SET1D(a, type, base, cnt, in); \ + base = NA_PTR(a) + offset + sizeof(type); \ + for(i=0; i<cnt; i++) { \ + NA_SETP(a, Float32, base, 0); \ + base += stride; \ + } \ } static int NA_get1D_Float64(PyArrayObject *a, long offset, int cnt, Float64*out) { - char *base = NA_PTR(a) + offset; - - switch(a->descr->type_num) { - case tBool: - NA_GET1D(a, Bool, base, cnt, out); - break; - case tInt8: - NA_GET1D(a, Int8, base, cnt, out); - break; - case tUInt8: - NA_GET1D(a, UInt8, base, cnt, out); - break; - case tInt16: - NA_GET1D(a, Int16, base, cnt, out); - break; - case tUInt16: - NA_GET1D(a, UInt16, base, cnt, out); - break; - case tInt32: - NA_GET1D(a, Int32, base, cnt, out); - break; - case tUInt32: - NA_GET1D(a, UInt32, base, cnt, out); - break; - case tInt64: - NA_GET1D(a, Int64, base, cnt, out); - break; - #if HAS_UINT64 - case tUInt64: - NA_GET1D(a, UInt64, base, cnt, out); - break; - #endif - case tFloat32: - NA_GET1D(a, Float32, base, cnt, out); - break; - case tFloat64: - NA_GET1D(a, Float64, base, cnt, out); - break; - case tComplex32: - NA_GET1D(a, Float32, base, cnt, out); - break; - case tComplex64: - NA_GET1D(a, Float64, base, cnt, out); - break; - default: - PyErr_Format( PyExc_TypeError, - "Unknown type %d in NA_get1D_Float64", - a->descr->type_num); - PyErr_Print(); - return -1; - } - return 0; + char *base = NA_PTR(a) + offset; + + switch(a->descr->type_num) { + case tBool: + NA_GET1D(a, Bool, base, cnt, out); + break; + case tInt8: + NA_GET1D(a, Int8, base, cnt, out); + break; + case tUInt8: + NA_GET1D(a, UInt8, base, cnt, out); + break; + case tInt16: + NA_GET1D(a, Int16, base, cnt, out); + break; + case tUInt16: + NA_GET1D(a, UInt16, base, cnt, out); + break; + case tInt32: + NA_GET1D(a, Int32, base, cnt, out); + break; + case tUInt32: + NA_GET1D(a, UInt32, base, cnt, out); + break; + case tInt64: + NA_GET1D(a, Int64, base, cnt, out); + break; +#if HAS_UINT64 + case tUInt64: + NA_GET1D(a, UInt64, base, cnt, out); + break; +#endif + case tFloat32: + NA_GET1D(a, Float32, base, cnt, out); + break; + case tFloat64: + NA_GET1D(a, Float64, base, cnt, out); + break; + case tComplex32: + NA_GET1D(a, Float32, base, cnt, out); + break; + case tComplex64: + NA_GET1D(a, Float64, base, cnt, out); + break; + default: + PyErr_Format( PyExc_TypeError, + "Unknown type %d in NA_get1D_Float64", + a->descr->type_num); + PyErr_Print(); + return -1; + } + return 0; } static Float64 * NA_alloc1D_Float64(PyArrayObject *a, long offset, int cnt) { - Float64 *result = PyMem_New(Float64, (size_t)cnt); - if (!result) return NULL; - if (NA_get1D_Float64(a, offset, cnt, result) < 0) { - PyMem_Free(result); - return NULL; - } - return result; + Float64 *result = PyMem_New(Float64, (size_t)cnt); + if (!result) return NULL; + if (NA_get1D_Float64(a, offset, cnt, result) < 0) { + PyMem_Free(result); + return NULL; + } + return result; } static int NA_set1D_Float64(PyArrayObject *a, long offset, int cnt, Float64*in) { - char *base = NA_PTR(a) + offset; - - switch(a->descr->type_num) { - case tBool: - NA_SET1D(a, Bool, base, cnt, in); - break; - case tInt8: - NA_SET1D(a, Int8, base, cnt, in); - break; - case tUInt8: - NA_SET1D(a, UInt8, base, cnt, in); - break; - case tInt16: - NA_SET1D(a, Int16, base, cnt, in); - break; - case tUInt16: - NA_SET1D(a, UInt16, base, cnt, in); - break; - case tInt32: - NA_SET1D(a, Int32, base, cnt, in); - break; - case tUInt32: - NA_SET1D(a, UInt32, base, cnt, in); - break; - case tInt64: - NA_SET1D(a, Int64, base, cnt, in); - break; - #if HAS_UINT64 - case tUInt64: - NA_SET1D(a, UInt64, base, cnt, in); - break; - #endif - case tFloat32: - NA_SET1D(a, Float32, base, cnt, in); - break; - case tFloat64: - NA_SET1D(a, Float64, base, cnt, in); - break; - case tComplex32: - NA_SET_CMPLX(a, Float32, base, cnt, in); - break; - case tComplex64: - NA_SET_CMPLX(a, Float64, base, cnt, in); - break; - default: - PyErr_Format( PyExc_TypeError, - "Unknown type %d in NA_set1D_Float64", - a->descr->type_num); - PyErr_Print(); - return -1; - } - return 0; + char *base = NA_PTR(a) + offset; + + switch(a->descr->type_num) { + case tBool: + NA_SET1D(a, Bool, base, cnt, in); + break; + case tInt8: + NA_SET1D(a, Int8, base, cnt, in); + break; + case tUInt8: + NA_SET1D(a, UInt8, base, cnt, in); + break; + case tInt16: + NA_SET1D(a, Int16, base, cnt, in); + break; + case tUInt16: + NA_SET1D(a, UInt16, base, cnt, in); + break; + case tInt32: + NA_SET1D(a, Int32, base, cnt, in); + break; + case tUInt32: + NA_SET1D(a, UInt32, base, cnt, in); + break; + case tInt64: + NA_SET1D(a, Int64, base, cnt, in); + break; +#if HAS_UINT64 + case tUInt64: + NA_SET1D(a, UInt64, base, cnt, in); + break; +#endif + case tFloat32: + NA_SET1D(a, Float32, base, cnt, in); + break; + case tFloat64: + NA_SET1D(a, Float64, base, cnt, in); + break; + case tComplex32: + NA_SET_CMPLX(a, Float32, base, cnt, in); + break; + case tComplex64: + NA_SET_CMPLX(a, Float64, base, cnt, in); + break; + default: + PyErr_Format( PyExc_TypeError, + "Unknown type %d in NA_set1D_Float64", + a->descr->type_num); + PyErr_Print(); + return -1; + } + return 0; } static int NA_get1D_Int64(PyArrayObject *a, long offset, int cnt, Int64*out) { - char *base = NA_PTR(a) + offset; - - switch(a->descr->type_num) { - case tBool: - NA_GET1D(a, Bool, base, cnt, out); - break; - case tInt8: - NA_GET1D(a, Int8, base, cnt, out); - break; - case tUInt8: - NA_GET1D(a, UInt8, base, cnt, out); - break; - case tInt16: - NA_GET1D(a, Int16, base, cnt, out); - break; - case tUInt16: - NA_GET1D(a, UInt16, base, cnt, out); - break; - case tInt32: - NA_GET1D(a, Int32, base, cnt, out); - break; - case tUInt32: - NA_GET1D(a, UInt32, base, cnt, out); - break; - case tInt64: - NA_GET1D(a, Int64, base, cnt, out); - break; - case tUInt64: - NA_GET1D(a, UInt64, base, cnt, out); - break; - case tFloat32: - NA_GET1D(a, Float32, base, cnt, out); - break; - case tFloat64: - NA_GET1D(a, Float64, base, cnt, out); - break; - case tComplex32: - NA_GET1D(a, Float32, base, cnt, out); - break; - case tComplex64: - NA_GET1D(a, Float64, base, cnt, out); - break; - default: - PyErr_Format( PyExc_TypeError, - "Unknown type %d in NA_get1D_Int64", - a->descr->type_num); - PyErr_Print(); - return -1; - } - return 0; + char *base = NA_PTR(a) + offset; + + switch(a->descr->type_num) { + case tBool: + NA_GET1D(a, Bool, base, cnt, out); + break; + case tInt8: + NA_GET1D(a, Int8, base, cnt, out); + break; + case tUInt8: + NA_GET1D(a, UInt8, base, cnt, out); + break; + case tInt16: + NA_GET1D(a, Int16, base, cnt, out); + break; + case tUInt16: + NA_GET1D(a, UInt16, base, cnt, out); + break; + case tInt32: + NA_GET1D(a, Int32, base, cnt, out); + break; + case tUInt32: + NA_GET1D(a, UInt32, base, cnt, out); + break; + case tInt64: + NA_GET1D(a, Int64, base, cnt, out); + break; + case tUInt64: + NA_GET1D(a, UInt64, base, cnt, out); + break; + case tFloat32: + NA_GET1D(a, Float32, base, cnt, out); + break; + case tFloat64: + NA_GET1D(a, Float64, base, cnt, out); + break; + case tComplex32: + NA_GET1D(a, Float32, base, cnt, out); + break; + case tComplex64: + NA_GET1D(a, Float64, base, cnt, out); + break; + default: + PyErr_Format( PyExc_TypeError, + "Unknown type %d in NA_get1D_Int64", + a->descr->type_num); + PyErr_Print(); + return -1; + } + return 0; } static Int64 * NA_alloc1D_Int64(PyArrayObject *a, long offset, int cnt) { - Int64 *result = PyMem_New(Int64, (size_t)cnt); - if (!result) return NULL; - if (NA_get1D_Int64(a, offset, cnt, result) < 0) { - PyMem_Free(result); - return NULL; - } - return result; + Int64 *result = PyMem_New(Int64, (size_t)cnt); + if (!result) return NULL; + if (NA_get1D_Int64(a, offset, cnt, result) < 0) { + PyMem_Free(result); + return NULL; + } + return result; } static int NA_set1D_Int64(PyArrayObject *a, long offset, int cnt, Int64*in) { - char *base = NA_PTR(a) + offset; - - switch(a->descr->type_num) { - case tBool: - NA_SET1D(a, Bool, base, cnt, in); - break; - case tInt8: - NA_SET1D(a, Int8, base, cnt, in); - break; - case tUInt8: - NA_SET1D(a, UInt8, base, cnt, in); - break; - case tInt16: - NA_SET1D(a, Int16, base, cnt, in); - break; - case tUInt16: - NA_SET1D(a, UInt16, base, cnt, in); - break; - case tInt32: - NA_SET1D(a, Int32, base, cnt, in); - break; - case tUInt32: - NA_SET1D(a, UInt32, base, cnt, in); - break; - case tInt64: - NA_SET1D(a, Int64, base, cnt, in); - break; - case tUInt64: - NA_SET1D(a, UInt64, base, cnt, in); - break; - case tFloat32: - NA_SET1D(a, Float32, base, cnt, in); - break; - case tFloat64: - NA_SET1D(a, Float64, base, cnt, in); - break; - case tComplex32: - NA_SET_CMPLX(a, Float32, base, cnt, in); - break; - case tComplex64: - NA_SET_CMPLX(a, Float64, base, cnt, in); - break; - default: - PyErr_Format( PyExc_TypeError, - "Unknown type %d in NA_set1D_Int64", - a->descr->type_num); - PyErr_Print(); - return -1; - } - return 0; + char *base = NA_PTR(a) + offset; + + switch(a->descr->type_num) { + case tBool: + NA_SET1D(a, Bool, base, cnt, in); + break; + case tInt8: + NA_SET1D(a, Int8, base, cnt, in); + break; + case tUInt8: + NA_SET1D(a, UInt8, base, cnt, in); + break; + case tInt16: + NA_SET1D(a, Int16, base, cnt, in); + break; + case tUInt16: + NA_SET1D(a, UInt16, base, cnt, in); + break; + case tInt32: + NA_SET1D(a, Int32, base, cnt, in); + break; + case tUInt32: + NA_SET1D(a, UInt32, base, cnt, in); + break; + case tInt64: + NA_SET1D(a, Int64, base, cnt, in); + break; + case tUInt64: + NA_SET1D(a, UInt64, base, cnt, in); + break; + case tFloat32: + NA_SET1D(a, Float32, base, cnt, in); + break; + case tFloat64: + NA_SET1D(a, Float64, base, cnt, in); + break; + case tComplex32: + NA_SET_CMPLX(a, Float32, base, cnt, in); + break; + case tComplex64: + NA_SET_CMPLX(a, Float64, base, cnt, in); + break; + default: + PyErr_Format( PyExc_TypeError, + "Unknown type %d in NA_set1D_Int64", + a->descr->type_num); + PyErr_Print(); + return -1; + } + return 0; } static int NA_get1D_Complex64(PyArrayObject *a, long offset, int cnt, Complex64*out) { - char *base = NA_PTR(a) + offset; - - switch(a->descr->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); - PyErr_Print(); - return -1; - } - return 0; + char *base = NA_PTR(a) + offset; + + switch(a->descr->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); + PyErr_Print(); + return -1; + } + return 0; } -static int +static int NA_set1D_Complex64(PyArrayObject *a, long offset, int cnt, Complex64*in) { - char *base = NA_PTR(a) + offset; - - switch(a->descr->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); - PyErr_Print(); - return -1; - } - return 0; + char *base = NA_PTR(a) + offset; + + switch(a->descr->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); + PyErr_Print(); + return -1; + } + return 0; } @@ -1765,74 +1765,74 @@ NA_set1D_Complex64(PyArrayObject *a, long offset, int cnt, Complex64*in) static int NA_ShapeEqual(PyArrayObject *a, PyArrayObject *b) { - int i; - - if (!NA_NDArrayCheck((PyObject *) a) || - !NA_NDArrayCheck((PyObject*) b)) { - PyErr_Format( - PyExc_TypeError, - "NA_ShapeEqual: non-array as parameter."); - return -1; - } - if (a->nd != b->nd) - return 0; - for(i=0; i<a->nd; i++) - if (a->dimensions[i] != b->dimensions[i]) - return 0; - return 1; -} - -/* NA_ShapeLessThan returns 1 if a.shape[i] < b.shape[i] for all i, else 0. -If they have a different number of dimensions, it compares the innermost -overlapping dimensions of each. -*/ + int i; + + if (!NA_NDArrayCheck((PyObject *) a) || + !NA_NDArrayCheck((PyObject*) b)) { + PyErr_Format( + PyExc_TypeError, + "NA_ShapeEqual: non-array as parameter."); + return -1; + } + if (a->nd != b->nd) + return 0; + for(i=0; i<a->nd; i++) + if (a->dimensions[i] != b->dimensions[i]) + return 0; + return 1; +} + +/* NA_ShapeLessThan returns 1 if a.shape[i] < b.shape[i] for all i, else 0. + If they have a different number of dimensions, it compares the innermost + overlapping dimensions of each. + */ static int NA_ShapeLessThan(PyArrayObject *a, PyArrayObject *b) { - int i; - int mindim, aoff, boff; - if (!NA_NDArrayCheck((PyObject *) a) || - !NA_NDArrayCheck((PyObject *) b)) { - PyErr_Format(PyExc_TypeError, - "NA_ShapeLessThan: non-array as parameter."); - return -1; - } - mindim = MIN(a->nd, b->nd); - aoff = a->nd - mindim; - boff = b->nd - mindim; - for(i=0; i<mindim; i++) - if (a->dimensions[i+aoff] >= b->dimensions[i+boff]) - return 0; - return 1; -} - -static int + int i; + int mindim, aoff, boff; + if (!NA_NDArrayCheck((PyObject *) a) || + !NA_NDArrayCheck((PyObject *) b)) { + PyErr_Format(PyExc_TypeError, + "NA_ShapeLessThan: non-array as parameter."); + return -1; + } + mindim = MIN(a->nd, b->nd); + aoff = a->nd - mindim; + boff = b->nd - mindim; + for(i=0; i<mindim; i++) + if (a->dimensions[i+aoff] >= b->dimensions[i+boff]) + return 0; + return 1; +} + +static int NA_ByteOrder(void) { - unsigned long byteorder_test; - byteorder_test = 1; - if (*((char *) &byteorder_test)) - return NUM_LITTLE_ENDIAN; - else - return NUM_BIG_ENDIAN; + unsigned long byteorder_test; + byteorder_test = 1; + if (*((char *) &byteorder_test)) + return NUM_LITTLE_ENDIAN; + else + return NUM_BIG_ENDIAN; } -static Bool +static Bool NA_IeeeSpecial32( Float32 *f, Int32 *mask) { - return NA_IeeeMask32(*f, *mask); + return NA_IeeeMask32(*f, *mask); } -static Bool +static Bool NA_IeeeSpecial64( Float64 *f, Int32 *mask) { - return NA_IeeeMask64(*f, *mask); + return NA_IeeeMask64(*f, *mask); } static PyArrayObject * NA_updateDataPtr(PyArrayObject *me) { - return me; + return me; } @@ -1840,389 +1840,389 @@ NA_updateDataPtr(PyArrayObject *me) typedef struct { - char *name; - int typeno; + char *name; + int typeno; } NumarrayTypeNameMapping; static NumarrayTypeNameMapping NumarrayTypeNameMap[] = { - {"Any", tAny}, - {"Bool", tBool}, - {"Int8", tInt8}, - {"UInt8", tUInt8}, - {"Int16", tInt16}, - {"UInt16", tUInt16}, - {"Int32", tInt32}, - {"UInt32", tUInt32}, - {"Int64", tInt64}, - {"UInt64", tUInt64}, - {"Float32", tFloat32}, - {"Float64", tFloat64}, - {"Complex32", tComplex32}, - {"Complex64", tComplex64}, - {"Object", tObject}, - {"Long", tLong}, + {"Any", tAny}, + {"Bool", tBool}, + {"Int8", tInt8}, + {"UInt8", tUInt8}, + {"Int16", tInt16}, + {"UInt16", tUInt16}, + {"Int32", tInt32}, + {"UInt32", tUInt32}, + {"Int64", tInt64}, + {"UInt64", tUInt64}, + {"Float32", tFloat32}, + {"Float64", tFloat64}, + {"Complex32", tComplex32}, + {"Complex64", tComplex64}, + {"Object", tObject}, + {"Long", tLong}, }; /* Convert NumarrayType 'typeno' into the string of the type's name. */ static char * -NA_typeNoToName(int typeno) +NA_typeNoToName(int typeno) { - size_t i; - PyObject *typeObj; - int typeno2; + size_t i; + PyObject *typeObj; + int typeno2; + + for(i=0; i<ELEM(NumarrayTypeNameMap); i++) + if (typeno == NumarrayTypeNameMap[i].typeno) + return NumarrayTypeNameMap[i].name; - for(i=0; i<ELEM(NumarrayTypeNameMap); i++) - if (typeno == NumarrayTypeNameMap[i].typeno) - return NumarrayTypeNameMap[i].name; + /* Handle Numeric typecodes */ + typeObj = NA_typeNoToTypeObject(typeno); + if (!typeObj) return 0; + typeno2 = NA_typeObjectToTypeNo(typeObj); + Py_DECREF(typeObj); - /* Handle Numeric typecodes */ - typeObj = NA_typeNoToTypeObject(typeno); - if (!typeObj) return 0; - typeno2 = NA_typeObjectToTypeNo(typeObj); - Py_DECREF(typeObj); - - return NA_typeNoToName(typeno2); + return NA_typeNoToName(typeno2); } /* Look up the NumarrayType which corresponds to typename */ -static int +static int NA_nameToTypeNo(char *typename) { - size_t i; - for(i=0; i<ELEM(NumarrayTypeNameMap); i++) - if (!strcmp(typename, NumarrayTypeNameMap[i].name)) - return NumarrayTypeNameMap[i].typeno; - return -1; + size_t i; + for(i=0; i<ELEM(NumarrayTypeNameMap); i++) + if (!strcmp(typename, NumarrayTypeNameMap[i].name)) + return NumarrayTypeNameMap[i].typeno; + return -1; } static PyObject * -getTypeObject(NumarrayType type) +getTypeObject(NumarrayType type) { - return (PyObject *)PyArray_DescrFromType(type); + return (PyObject *)PyArray_DescrFromType(type); } static PyObject * NA_typeNoToTypeObject(int typeno) { - PyObject *o; - o = getTypeObject(typeno); - if (o) Py_INCREF(o); - return o; + PyObject *o; + o = getTypeObject(typeno); + if (o) Py_INCREF(o); + return o; } static PyObject * NA_intTupleFromMaybeLongs(int len, maybelong *Longs) { - return PyArray_IntTupleFromIntp(len, Longs); + return PyArray_IntTupleFromIntp(len, Longs); } static long NA_maybeLongsFromIntTuple(int len, maybelong *arr, PyObject *sequence) { - return PyArray_IntpFromSequence(sequence, arr, len); + return PyArray_IntpFromSequence(sequence, arr, len); } static int NA_intTupleProduct(PyObject *shape, long *prod) { - int i, nshape, rval = -1; - - if (!PySequence_Check(shape)) { - PyErr_Format(PyExc_TypeError, - "NA_intSequenceProduct: object is not a sequence."); - goto _exit; - } - nshape = PySequence_Size(shape); - - for(i=0, *prod=1; i<nshape; i++) { - PyObject *obj = PySequence_GetItem(shape, i); - if (!obj || !(PyInt_Check(obj) || PyLong_Check(obj))) { - PyErr_Format(PyExc_TypeError, - "NA_intTupleProduct: non-integer in shape."); - Py_XDECREF(obj); - goto _exit; - } - *prod *= PyInt_AsLong(obj); - Py_DECREF(obj); - if (PyErr_Occurred()) - goto _exit; - } - rval = 0; - _exit: - return rval; -} - -static long + int i, nshape, rval = -1; + + if (!PySequence_Check(shape)) { + PyErr_Format(PyExc_TypeError, + "NA_intSequenceProduct: object is not a sequence."); + goto _exit; + } + nshape = PySequence_Size(shape); + + for(i=0, *prod=1; i<nshape; i++) { + PyObject *obj = PySequence_GetItem(shape, i); + if (!obj || !(PyInt_Check(obj) || PyLong_Check(obj))) { + PyErr_Format(PyExc_TypeError, + "NA_intTupleProduct: non-integer in shape."); + Py_XDECREF(obj); + goto _exit; + } + *prod *= PyInt_AsLong(obj); + Py_DECREF(obj); + if (PyErr_Occurred()) + goto _exit; + } + rval = 0; +_exit: + return rval; +} + +static long NA_isIntegerSequence(PyObject *sequence) { - PyObject *o; - long i, size, isInt = 1; - if (!sequence) { - isInt = -1; - goto _exit; - } - if (!PySequence_Check(sequence)) { - isInt = 0; - goto _exit; - } - if ((size = PySequence_Length(sequence)) < 0) { - isInt = -1; - goto _exit; - } - for(i=0; i<size; i++) { - o = PySequence_GetItem(sequence, i); - if (!PyInt_Check(o) && !PyLong_Check(o)) { - isInt = 0; - Py_XDECREF(o); - goto _exit; - } - Py_XDECREF(o); - } - _exit: - return isInt; -} - -static int + PyObject *o; + long i, size, isInt = 1; + if (!sequence) { + isInt = -1; + goto _exit; + } + if (!PySequence_Check(sequence)) { + isInt = 0; + goto _exit; + } + if ((size = PySequence_Length(sequence)) < 0) { + isInt = -1; + goto _exit; + } + for(i=0; i<size; i++) { + o = PySequence_GetItem(sequence, i); + if (!PyInt_Check(o) && !PyLong_Check(o)) { + isInt = 0; + Py_XDECREF(o); + goto _exit; + } + Py_XDECREF(o); + } +_exit: + return isInt; +} + +static int getShape(PyObject *a, maybelong *shape, int dims) { - long slen; - - if (PyString_Check(a)) { - PyErr_Format(PyExc_TypeError, - "getShape: numerical sequences can't contain strings."); - return -1; - } - - if (!PySequence_Check(a) || - (NA_NDArrayCheck(a) && (PyArray(a)->nd == 0))) - return dims; - slen = PySequence_Length(a); - if (slen < 0) { - PyErr_Format(_Error, - "getShape: couldn't get sequence length."); - return -1; - } - if (!slen) { - *shape = 0; - return dims+1; - } else if (dims < MAXDIM) { - PyObject *item0 = PySequence_GetItem(a, 0); - if (item0) { - *shape = PySequence_Length(a); - dims = getShape(item0, ++shape, dims+1); - Py_DECREF(item0); - } else { - PyErr_Format(_Error, - "getShape: couldn't get sequence item."); - return -1; - } - } else { - PyErr_Format(_Error, - "getShape: sequence object nested more than MAXDIM deep."); - return -1; - } - return dims; + long slen; + + if (PyString_Check(a)) { + PyErr_Format(PyExc_TypeError, + "getShape: numerical sequences can't contain strings."); + return -1; + } + + if (!PySequence_Check(a) || + (NA_NDArrayCheck(a) && (PyArray(a)->nd == 0))) + return dims; + slen = PySequence_Length(a); + if (slen < 0) { + PyErr_Format(_Error, + "getShape: couldn't get sequence length."); + return -1; + } + if (!slen) { + *shape = 0; + return dims+1; + } else if (dims < MAXDIM) { + PyObject *item0 = PySequence_GetItem(a, 0); + if (item0) { + *shape = PySequence_Length(a); + dims = getShape(item0, ++shape, dims+1); + Py_DECREF(item0); + } else { + PyErr_Format(_Error, + "getShape: couldn't get sequence item."); + return -1; + } + } else { + PyErr_Format(_Error, + "getShape: sequence object nested more than MAXDIM deep."); + return -1; + } + return dims; } typedef enum { - NOTHING, - NUMBER, - SEQUENCE + NOTHING, + NUMBER, + SEQUENCE } SequenceConstraint; -static int +static int setArrayFromSequence(PyArrayObject *a, PyObject *s, int dim, long offset) { - SequenceConstraint mustbe = NOTHING; - int i, seqlen=-1, slen = PySequence_Length(s); - - if (dim > a->nd) { - PyErr_Format(PyExc_ValueError, - "setArrayFromSequence: sequence/array dimensions mismatch."); - return -1; - } - - if (slen != a->dimensions[dim]) { - PyErr_Format(PyExc_ValueError, - "setArrayFromSequence: sequence/array shape mismatch."); - return -1; - } - - for(i=0; i<slen; i++) { - PyObject *o = PySequence_GetItem(s, i); - if (!o) { - PyErr_SetString(_Error, - "setArrayFromSequence: Can't get a sequence item"); - return -1; - } else if ((NA_isPythonScalar(o) || - (NA_NumArrayCheck(o) && PyArray(o)->nd == 0)) && - ((mustbe == NOTHING) || (mustbe == NUMBER))) { - if (NA_setFromPythonScalar(a, offset, o) < 0) - return -2; - mustbe = NUMBER; - } else if (PyString_Check(o)) { - PyErr_SetString( PyExc_ValueError, - "setArrayFromSequence: strings can't define numeric numarray."); - return -3; - } else if (PySequence_Check(o)) { - if ((mustbe == NOTHING) || (mustbe == SEQUENCE)) { - if (mustbe == NOTHING) { - mustbe = SEQUENCE; - seqlen = PySequence_Length(o); - } else if (PySequence_Length(o) != seqlen) { - PyErr_SetString( - PyExc_ValueError, - "Nested sequences with different lengths."); - return -5; - } - setArrayFromSequence(a, o, dim+1, offset); - } else { - PyErr_SetString(PyExc_ValueError, - "Nested sequences with different lengths."); - return -4; - } - } else { - PyErr_SetString(PyExc_ValueError, "Invalid sequence."); - return -6; - } - Py_DECREF(o); - offset += a->strides[dim]; - } - return 0; + SequenceConstraint mustbe = NOTHING; + int i, seqlen=-1, slen = PySequence_Length(s); + + if (dim > a->nd) { + PyErr_Format(PyExc_ValueError, + "setArrayFromSequence: sequence/array dimensions mismatch."); + return -1; + } + + if (slen != a->dimensions[dim]) { + PyErr_Format(PyExc_ValueError, + "setArrayFromSequence: sequence/array shape mismatch."); + return -1; + } + + for(i=0; i<slen; i++) { + PyObject *o = PySequence_GetItem(s, i); + if (!o) { + PyErr_SetString(_Error, + "setArrayFromSequence: Can't get a sequence item"); + return -1; + } else if ((NA_isPythonScalar(o) || + (NA_NumArrayCheck(o) && PyArray(o)->nd == 0)) && + ((mustbe == NOTHING) || (mustbe == NUMBER))) { + if (NA_setFromPythonScalar(a, offset, o) < 0) + return -2; + mustbe = NUMBER; + } else if (PyString_Check(o)) { + PyErr_SetString( PyExc_ValueError, + "setArrayFromSequence: strings can't define numeric numarray."); + return -3; + } else if (PySequence_Check(o)) { + if ((mustbe == NOTHING) || (mustbe == SEQUENCE)) { + if (mustbe == NOTHING) { + mustbe = SEQUENCE; + seqlen = PySequence_Length(o); + } else if (PySequence_Length(o) != seqlen) { + PyErr_SetString( + PyExc_ValueError, + "Nested sequences with different lengths."); + return -5; + } + setArrayFromSequence(a, o, dim+1, offset); + } else { + PyErr_SetString(PyExc_ValueError, + "Nested sequences with different lengths."); + return -4; + } + } else { + PyErr_SetString(PyExc_ValueError, "Invalid sequence."); + return -6; + } + Py_DECREF(o); + offset += a->strides[dim]; + } + return 0; } static PyObject * NA_setArrayFromSequence(PyArrayObject *a, PyObject *s) { - maybelong shape[MAXDIM]; + maybelong shape[MAXDIM]; + + if (!PySequence_Check(s)) + return PyErr_Format( PyExc_TypeError, + "NA_setArrayFromSequence: (array, seq) expected."); + + if (getShape(s, shape, 0) < 0) + return NULL; - if (!PySequence_Check(s)) - return PyErr_Format( PyExc_TypeError, - "NA_setArrayFromSequence: (array, seq) expected."); + if (!NA_updateDataPtr(a)) + return NULL; - if (getShape(s, shape, 0) < 0) - return NULL; - - if (!NA_updateDataPtr(a)) - return NULL; - - if (setArrayFromSequence(a, s, 0, 0) < 0) - return NULL; - - Py_INCREF(Py_None); - return Py_None; + if (setArrayFromSequence(a, s, 0, 0) < 0) + return NULL; + + Py_INCREF(Py_None); + return Py_None; } enum { - BOOL_SCALAR, - INT_SCALAR, - LONG_SCALAR, - FLOAT_SCALAR, - COMPLEX_SCALAR + BOOL_SCALAR, + INT_SCALAR, + LONG_SCALAR, + FLOAT_SCALAR, + COMPLEX_SCALAR }; static int _NA_maxType(PyObject *seq, int limit) { - if (limit > MAXDIM) { - PyErr_Format( PyExc_ValueError, - "NA_maxType: sequence nested too deep." ); - return -1; - } - if (NA_NumArrayCheck(seq)) { - switch(PyArray(seq)->descr->type_num) { - case tBool: - return BOOL_SCALAR; - case tInt8: - case tUInt8: - case tInt16: - case tUInt16: - case tInt32: - case tUInt32: - return INT_SCALAR; - case tInt64: - case tUInt64: - return LONG_SCALAR; - case tFloat32: - case tFloat64: - return FLOAT_SCALAR; - case tComplex32: - case tComplex64: - return COMPLEX_SCALAR; - default: - PyErr_Format(PyExc_TypeError, - "Expecting a python numeric type, got something else."); - return -1; - } - } else if (PySequence_Check(seq) && !PyString_Check(seq)) { - long i, maxtype=BOOL_SCALAR, slen; - - slen = PySequence_Length(seq); - if (slen < 0) return -1; - - if (slen == 0) return INT_SCALAR; - - for(i=0; i<slen; i++) { - long newmax; - PyObject *o = PySequence_GetItem(seq, i); - if (!o) return -1; - newmax = _NA_maxType(o, limit+1); - if (newmax < 0) - return -1; - else if (newmax > maxtype) { - maxtype = newmax; - } - Py_DECREF(o); - } - return maxtype; - } else { + if (limit > MAXDIM) { + PyErr_Format( PyExc_ValueError, + "NA_maxType: sequence nested too deep." ); + return -1; + } + if (NA_NumArrayCheck(seq)) { + switch(PyArray(seq)->descr->type_num) { + case tBool: + return BOOL_SCALAR; + case tInt8: + case tUInt8: + case tInt16: + case tUInt16: + case tInt32: + case tUInt32: + return INT_SCALAR; + case tInt64: + case tUInt64: + return LONG_SCALAR; + case tFloat32: + case tFloat64: + return FLOAT_SCALAR; + case tComplex32: + case tComplex64: + return COMPLEX_SCALAR; + default: + PyErr_Format(PyExc_TypeError, + "Expecting a python numeric type, got something else."); + return -1; + } + } else if (PySequence_Check(seq) && !PyString_Check(seq)) { + long i, maxtype=BOOL_SCALAR, slen; + + slen = PySequence_Length(seq); + if (slen < 0) return -1; + + if (slen == 0) return INT_SCALAR; + + for(i=0; i<slen; i++) { + long newmax; + PyObject *o = PySequence_GetItem(seq, i); + if (!o) return -1; + newmax = _NA_maxType(o, limit+1); + if (newmax < 0) + return -1; + else if (newmax > maxtype) { + maxtype = newmax; + } + Py_DECREF(o); + } + return maxtype; + } else { #if PY_VERSION_HEX >= 0x02030000 - if (PyBool_Check(seq)) - return BOOL_SCALAR; - else + if (PyBool_Check(seq)) + return BOOL_SCALAR; + else #endif - if (PyInt_Check(seq)) - return INT_SCALAR; - else if (PyLong_Check(seq)) - return LONG_SCALAR; - else if (PyFloat_Check(seq)) - return FLOAT_SCALAR; - else if (PyComplex_Check(seq)) - return COMPLEX_SCALAR; - else { - PyErr_Format(PyExc_TypeError, - "Expecting a python numeric type, got something else."); - return -1; - } - } -} - -static int + if (PyInt_Check(seq)) + return INT_SCALAR; + else if (PyLong_Check(seq)) + return LONG_SCALAR; + else if (PyFloat_Check(seq)) + return FLOAT_SCALAR; + else if (PyComplex_Check(seq)) + return COMPLEX_SCALAR; + else { + PyErr_Format(PyExc_TypeError, + "Expecting a python numeric type, got something else."); + return -1; + } + } +} + +static int NA_maxType(PyObject *seq) { - int rval; - rval = _NA_maxType(seq, 0); - return rval; + int rval; + rval = _NA_maxType(seq, 0); + return rval; } static int NA_isPythonScalar(PyObject *o) { - int rval; - rval = PyInt_Check(o) || - PyLong_Check(o) || - PyFloat_Check(o) || - PyComplex_Check(o) || - (PyString_Check(o) && (PyString_Size(o) == 1)); - return rval; + int rval; + rval = PyInt_Check(o) || + PyLong_Check(o) || + PyFloat_Check(o) || + PyComplex_Check(o) || + (PyString_Check(o) && (PyString_Size(o) == 1)); + return rval; } #if (NPY_SIZEOF_INTP == 8) @@ -2237,670 +2237,670 @@ NA_isPythonScalar(PyObject *o) static PyObject * NA_getPythonScalar(PyArrayObject *a, long offset) { - int type = a->descr->type_num; - PyObject *rval = NULL; + int type = a->descr->type_num; + PyObject *rval = NULL; + + switch(type) { + case tBool: + case tInt8: + case tUInt8: + case tInt16: + case tUInt16: + case tInt32: { + Int64 v = NA_get_Int64(a, offset); + rval = PyInt_FromLong(v); + break; + } + case tUInt32: { + Int64 v = NA_get_Int64(a, offset); + rval = PlatBigUInt(v); + break; + } + case tInt64: { + Int64 v = NA_get_Int64(a, offset); + rval = PlatBigInt( v); + break; + } + case tUInt64: { + Int64 v = NA_get_Int64(a, offset); + rval = PlatBigUInt( v); + break; + } + case tFloat32: + case tFloat64: { + Float64 v = NA_get_Float64(a, offset); + rval = PyFloat_FromDouble( v ); + break; + } + case tComplex32: + case tComplex64: + { + Complex64 v = NA_get_Complex64(a, offset); + rval = PyComplex_FromDoubles(v.r, v.i); + break; + } + default: + rval = PyErr_Format(PyExc_TypeError, + "NA_getPythonScalar: bad type %d\n", + type); + } + return rval; +} - switch(type) { - case tBool: - case tInt8: - case tUInt8: - case tInt16: - case tUInt16: - case tInt32: { - Int64 v = NA_get_Int64(a, offset); - rval = PyInt_FromLong(v); - break; - } - case tUInt32: { - Int64 v = NA_get_Int64(a, offset); - rval = PlatBigUInt(v); - break; - } - case tInt64: { - Int64 v = NA_get_Int64(a, offset); - rval = PlatBigInt( v); - break; - } - case tUInt64: { - Int64 v = NA_get_Int64(a, offset); - rval = PlatBigUInt( v); - break; - } - case tFloat32: - case tFloat64: { - Float64 v = NA_get_Float64(a, offset); - rval = PyFloat_FromDouble( v ); - break; - } - case tComplex32: - case tComplex64: - { - Complex64 v = NA_get_Complex64(a, offset); - rval = PyComplex_FromDoubles(v.r, v.i); - break; - } - default: - rval = PyErr_Format(PyExc_TypeError, - "NA_getPythonScalar: bad type %d\n", - type); - } - return rval; -} - -static int +static int NA_overflow(PyArrayObject *a, Float64 v) { - if ((a->flags & CHECKOVERFLOW) == 0) return 0; - - switch(a->descr->type_num) { - case tBool: - return 0; - case tInt8: - if ((v < -128) || (v > 127)) goto _fail; - return 0; - case tUInt8: - if ((v < 0) || (v > 255)) goto _fail; - return 0; - case tInt16: - if ((v < -32768) || (v > 32767)) goto _fail; - return 0; - case tUInt16: - if ((v < 0) || (v > 65535)) goto _fail; - return 0; - case tInt32: - if ((v < -2147483648.) || - (v > 2147483647.)) goto _fail; - return 0; - case tUInt32: - if ((v < 0) || (v > 4294967295.)) goto _fail; - return 0; - case tInt64: - if ((v < -9223372036854775808.) || - (v > 9223372036854775807.)) goto _fail; - return 0; - #if HAS_UINT64 - case tUInt64: - if ((v < 0) || - (v > 18446744073709551615.)) goto _fail; - return 0; - #endif - case tFloat32: - if ((v < -FLT_MAX) || (v > FLT_MAX)) goto _fail; - return 0; - case tFloat64: - return 0; - case tComplex32: - if ((v < -FLT_MAX) || (v > FLT_MAX)) goto _fail; - return 0; - case tComplex64: - return 0; - default: - PyErr_Format( PyExc_TypeError, - "Unknown type %d in NA_overflow", - a->descr->type_num ); - PyErr_Print(); - return -1; - } - _fail: - PyErr_Format(PyExc_OverflowError, "value out of range for array"); - return -1; -} - -static int + if ((a->flags & CHECKOVERFLOW) == 0) return 0; + + switch(a->descr->type_num) { + case tBool: + return 0; + case tInt8: + if ((v < -128) || (v > 127)) goto _fail; + return 0; + case tUInt8: + if ((v < 0) || (v > 255)) goto _fail; + return 0; + case tInt16: + if ((v < -32768) || (v > 32767)) goto _fail; + return 0; + case tUInt16: + if ((v < 0) || (v > 65535)) goto _fail; + return 0; + case tInt32: + if ((v < -2147483648.) || + (v > 2147483647.)) goto _fail; + return 0; + case tUInt32: + if ((v < 0) || (v > 4294967295.)) goto _fail; + return 0; + case tInt64: + if ((v < -9223372036854775808.) || + (v > 9223372036854775807.)) goto _fail; + return 0; +#if HAS_UINT64 + case tUInt64: + if ((v < 0) || + (v > 18446744073709551615.)) goto _fail; + return 0; +#endif + case tFloat32: + if ((v < -FLT_MAX) || (v > FLT_MAX)) goto _fail; + return 0; + case tFloat64: + return 0; + case tComplex32: + if ((v < -FLT_MAX) || (v > FLT_MAX)) goto _fail; + return 0; + case tComplex64: + return 0; + default: + PyErr_Format( PyExc_TypeError, + "Unknown type %d in NA_overflow", + a->descr->type_num ); + PyErr_Print(); + return -1; + } +_fail: + PyErr_Format(PyExc_OverflowError, "value out of range for array"); + return -1; +} + +static int _setFromPythonScalarCore(PyArrayObject *a, long offset, PyObject*value, int entries) { - Int64 v; - if (entries >= 100) { - PyErr_Format(PyExc_RuntimeError, - "NA_setFromPythonScalar: __tonumtype__ conversion chain too long"); - return -1; - } else if (PyInt_Check(value)) { - v = PyInt_AsLong(value); - if (NA_overflow(a, v) < 0) - return -1; - NA_set_Int64(a, offset, v); - } else if (PyLong_Check(value)) { - if (a->descr->type_num == tInt64) { - v = (Int64) PyLong_AsLongLong( value ); - } else if (a->descr->type_num == tUInt64) { - v = (UInt64) PyLong_AsUnsignedLongLong( value ); - } else if (a->descr->type_num == tUInt32) { - v = PyLong_AsUnsignedLong(value); - } else { - v = PyLong_AsLongLong(value); - } - if (PyErr_Occurred()) - return -1; - if (NA_overflow(a, v) < 0) - return -1; - NA_set_Int64(a, offset, v); - } else if (PyFloat_Check(value)) { - Float64 v = PyFloat_AsDouble(value); - if (NA_overflow(a, v) < 0) - return -1; - NA_set_Float64(a, offset, v); - } else if (PyComplex_Check(value)) { - Complex64 vc; - vc.r = PyComplex_RealAsDouble(value); - vc.i = PyComplex_ImagAsDouble(value); - if (NA_overflow(a, vc.r) < 0) - return -1; - if (NA_overflow(a, vc.i) < 0) - return -1; - NA_set_Complex64(a, offset, vc); - } else if (PyObject_HasAttrString(value, "__tonumtype__")) { - int rval; - PyObject *type = NA_typeNoToTypeObject(a->descr->type_num); - if (!type) return -1; - value = PyObject_CallMethod( - value, "__tonumtype__", "(N)", type); - if (!value) return -1; - rval = _setFromPythonScalarCore(a, offset, value, entries+1); - Py_DECREF(value); - return rval; - } else if (PyString_Check(value)) { - long size = PyString_Size(value); - if ((size <= 0) || (size > 1)) { - PyErr_Format( PyExc_ValueError, - "NA_setFromPythonScalar: len(string) must be 1."); - return -1; - } - NA_set_Int64(a, offset, *PyString_AsString(value)); - } else { - PyErr_Format(PyExc_TypeError, - "NA_setFromPythonScalar: bad value type."); - return -1; - } - return 0; + Int64 v; + if (entries >= 100) { + PyErr_Format(PyExc_RuntimeError, + "NA_setFromPythonScalar: __tonumtype__ conversion chain too long"); + return -1; + } else if (PyInt_Check(value)) { + v = PyInt_AsLong(value); + if (NA_overflow(a, v) < 0) + return -1; + NA_set_Int64(a, offset, v); + } else if (PyLong_Check(value)) { + if (a->descr->type_num == tInt64) { + v = (Int64) PyLong_AsLongLong( value ); + } else if (a->descr->type_num == tUInt64) { + v = (UInt64) PyLong_AsUnsignedLongLong( value ); + } else if (a->descr->type_num == tUInt32) { + v = PyLong_AsUnsignedLong(value); + } else { + v = PyLong_AsLongLong(value); + } + if (PyErr_Occurred()) + return -1; + if (NA_overflow(a, v) < 0) + return -1; + NA_set_Int64(a, offset, v); + } else if (PyFloat_Check(value)) { + Float64 v = PyFloat_AsDouble(value); + if (NA_overflow(a, v) < 0) + return -1; + NA_set_Float64(a, offset, v); + } else if (PyComplex_Check(value)) { + Complex64 vc; + vc.r = PyComplex_RealAsDouble(value); + vc.i = PyComplex_ImagAsDouble(value); + if (NA_overflow(a, vc.r) < 0) + return -1; + if (NA_overflow(a, vc.i) < 0) + return -1; + NA_set_Complex64(a, offset, vc); + } else if (PyObject_HasAttrString(value, "__tonumtype__")) { + int rval; + PyObject *type = NA_typeNoToTypeObject(a->descr->type_num); + if (!type) return -1; + value = PyObject_CallMethod( + value, "__tonumtype__", "(N)", type); + if (!value) return -1; + rval = _setFromPythonScalarCore(a, offset, value, entries+1); + Py_DECREF(value); + return rval; + } else if (PyString_Check(value)) { + long size = PyString_Size(value); + if ((size <= 0) || (size > 1)) { + PyErr_Format( PyExc_ValueError, + "NA_setFromPythonScalar: len(string) must be 1."); + return -1; + } + NA_set_Int64(a, offset, *PyString_AsString(value)); + } else { + PyErr_Format(PyExc_TypeError, + "NA_setFromPythonScalar: bad value type."); + return -1; + } + return 0; } static int NA_setFromPythonScalar(PyArrayObject *a, long offset, PyObject *value) { - if (a->flags & WRITABLE) - return _setFromPythonScalarCore(a, offset, value, 0); - else { - PyErr_Format( - PyExc_ValueError, "NA_setFromPythonScalar: assigment to readonly array buffer"); - return -1; - } + if (a->flags & WRITABLE) + return _setFromPythonScalarCore(a, offset, value, 0); + else { + PyErr_Format( + PyExc_ValueError, "NA_setFromPythonScalar: assigment to readonly array buffer"); + return -1; + } } static int NA_NDArrayCheck(PyObject *obj) { - return PyArray_Check(obj); + return PyArray_Check(obj); } static int NA_NumArrayCheck(PyObject *obj) { - return PyArray_Check(obj); + return PyArray_Check(obj); } static int NA_ComplexArrayCheck(PyObject *a) { - int rval = NA_NumArrayCheck(a); - if (rval > 0) { - PyArrayObject *arr = (PyArrayObject *) a; - switch(arr->descr->type_num) { - case tComplex64: case tComplex32: - return 1; - default: - return 0; - } - } - return rval; + int rval = NA_NumArrayCheck(a); + if (rval > 0) { + PyArrayObject *arr = (PyArrayObject *) a; + switch(arr->descr->type_num) { + case tComplex64: case tComplex32: + return 1; + default: + return 0; + } + } + return rval; } -static unsigned long +static unsigned long NA_elements(PyArrayObject *a) { - int i; - unsigned long n = 1; - for(i = 0; i<a->nd; i++) - n *= a->dimensions[i]; - return n; + int i; + unsigned long n = 1; + for(i = 0; i<a->nd; i++) + n *= a->dimensions[i]; + return n; } -static int +static int NA_typeObjectToTypeNo(PyObject *typeObj) { - PyArray_Descr *dtype; - int i; - if (PyArray_DescrConverter(typeObj, &dtype) == NPY_FAIL) i=-1; - else i=dtype->type_num; - return i; + PyArray_Descr *dtype; + int i; + if (PyArray_DescrConverter(typeObj, &dtype) == NPY_FAIL) i=-1; + else i=dtype->type_num; + return i; } static int NA_copyArray(PyArrayObject *to, const PyArrayObject *from) { - return PyArray_CopyInto(to, (PyArrayObject *)from); + return PyArray_CopyInto(to, (PyArrayObject *)from); } static PyArrayObject * NA_copy(PyArrayObject *from) { - return (PyArrayObject *)PyArray_NewCopy(from, 0); + return (PyArrayObject *)PyArray_NewCopy(from, 0); } static PyObject * NA_getType( PyObject *type) { - PyArray_Descr *typeobj = NULL; - if (!type && PyArray_DescrConverter(type, &typeobj) == NPY_FAIL) { - PyErr_Format(PyExc_ValueError, "NA_getType: unknown type."); - typeobj = NULL; - } - return (PyObject *)typeobj; + PyArray_Descr *typeobj = NULL; + if (!type && PyArray_DescrConverter(type, &typeobj) == NPY_FAIL) { + PyErr_Format(PyExc_ValueError, "NA_getType: unknown type."); + typeobj = NULL; + } + return (PyObject *)typeobj; } /* Call a standard "stride" function -** -** Stride functions always take one input and one output array. -** They can handle n-dimensional data with arbitrary strides (of -** either sign) for both the input and output numarray. Typically -** these functions are used to copy data, byteswap, or align data. -** -** -** It expects the following arguments: -** -** Number of iterations for each dimension as a tuple -** Input Buffer Object -** Offset in bytes for input buffer -** Input strides (in bytes) for each dimension as a tuple -** Output Buffer Object -** Offset in bytes for output buffer -** Output strides (in bytes) for each dimension as a tuple -** An integer (Optional), typically the number of bytes to copy per -* element. -** -** Returns None -** -** The arguments expected by the standard stride functions that this -** function calls are: -** -** Number of dimensions to iterate over -** Long int value (from the optional last argument to -** callStrideConvCFunc) -** often unused by the C Function -** An array of long ints. Each is the number of iterations for each -** dimension. NOTE: the previous argument as well as the stride -** arguments are reversed in order with respect to how they are -** used in Python. Fastest changing dimension is the first element -** in the numarray! -** A void pointer to the input data buffer. -** The starting offset for the input data buffer in bytes (long int). -** An array of long int input strides (in bytes) [reversed as with -** the iteration array] -** A void pointer to the output data buffer. -** The starting offset for the output data buffer in bytes (long int). -** An array of long int output strides (in bytes) [also reversed] -*/ + ** + ** Stride functions always take one input and one output array. + ** They can handle n-dimensional data with arbitrary strides (of + ** either sign) for both the input and output numarray. Typically + ** these functions are used to copy data, byteswap, or align data. + ** + ** + ** It expects the following arguments: + ** + ** Number of iterations for each dimension as a tuple + ** Input Buffer Object + ** Offset in bytes for input buffer + ** Input strides (in bytes) for each dimension as a tuple + ** Output Buffer Object + ** Offset in bytes for output buffer + ** Output strides (in bytes) for each dimension as a tuple + ** An integer (Optional), typically the number of bytes to copy per + * element. + ** + ** Returns None + ** + ** The arguments expected by the standard stride functions that this + ** function calls are: + ** + ** Number of dimensions to iterate over + ** Long int value (from the optional last argument to + ** callStrideConvCFunc) + ** often unused by the C Function + ** An array of long ints. Each is the number of iterations for each + ** dimension. NOTE: the previous argument as well as the stride + ** arguments are reversed in order with respect to how they are + ** used in Python. Fastest changing dimension is the first element + ** in the numarray! + ** A void pointer to the input data buffer. + ** The starting offset for the input data buffer in bytes (long int). + ** An array of long int input strides (in bytes) [reversed as with + ** the iteration array] + ** A void pointer to the output data buffer. + ** The starting offset for the output data buffer in bytes (long int). + ** An array of long int output strides (in bytes) [also reversed] + */ static PyObject * NA_callStrideConvCFuncCore( - PyObject *self, int nshape, maybelong *shape, - PyObject *inbuffObj, long inboffset, - int NPY_UNUSED(ninbstrides), maybelong *inbstrides, - PyObject *outbuffObj, long outboffset, - int NPY_UNUSED(noutbstrides), maybelong *outbstrides, - long nbytes) -{ - CfuncObject *me = (CfuncObject *) self; - CFUNC_STRIDE_CONV_FUNC funcptr; - void *inbuffer, *outbuffer; - long inbsize, outbsize; - maybelong i, lshape[MAXDIM], in_strides[MAXDIM], out_strides[MAXDIM]; - maybelong shape_0, inbstr_0, outbstr_0; - - if (nshape == 0) { /* handle rank-0 numarray. */ - nshape = 1; - shape = &shape_0; - inbstrides = &inbstr_0; - outbstrides = &outbstr_0; - shape[0] = 1; - inbstrides[0] = outbstrides[0] = 0; - } - - for(i=0; i<nshape; i++) - lshape[i] = shape[nshape-1-i]; - for(i=0; i<nshape; i++) - in_strides[i] = inbstrides[nshape-1-i]; - for(i=0; i<nshape; i++) - out_strides[i] = outbstrides[nshape-1-i]; - - if (!PyObject_IsInstance(self , (PyObject *) &CfuncType) - || me->descr.type != CFUNC_STRIDING) - return PyErr_Format(PyExc_TypeError, - "NA_callStrideConvCFuncCore: problem with cfunc"); - - if ((inbsize = NA_getBufferPtrAndSize(inbuffObj, 1, &inbuffer)) < 0) - return PyErr_Format(_Error, - "%s: Problem with input buffer", me->descr.name); - - if ((outbsize = NA_getBufferPtrAndSize(outbuffObj, 0, &outbuffer)) < 0) - return PyErr_Format(_Error, - "%s: Problem with output buffer (read only?)", - me->descr.name); - - /* Check buffer alignment and bounds */ - if (NA_checkOneStriding(me->descr.name, nshape, lshape, - inboffset, in_strides, inbsize, - (me->descr.sizes[0] == -1) ? - nbytes : me->descr.sizes[0], - me->descr.align) || - NA_checkOneStriding(me->descr.name, nshape, lshape, - outboffset, out_strides, outbsize, - (me->descr.sizes[1] == -1) ? - nbytes : me->descr.sizes[1], - me->descr.align)) - return NULL; - - /* Cast function pointer and perform stride operation */ - funcptr = (CFUNC_STRIDE_CONV_FUNC) me->descr.fptr; - if ((*funcptr)(nshape-1, nbytes, lshape, - inbuffer, inboffset, in_strides, - outbuffer, outboffset, out_strides) == 0) { - Py_INCREF(Py_None); - return Py_None; - } else { - return NULL; - } + PyObject *self, int nshape, maybelong *shape, + PyObject *inbuffObj, long inboffset, + int NPY_UNUSED(ninbstrides), maybelong *inbstrides, + PyObject *outbuffObj, long outboffset, + int NPY_UNUSED(noutbstrides), maybelong *outbstrides, + long nbytes) +{ + CfuncObject *me = (CfuncObject *) self; + CFUNC_STRIDE_CONV_FUNC funcptr; + void *inbuffer, *outbuffer; + long inbsize, outbsize; + maybelong i, lshape[MAXDIM], in_strides[MAXDIM], out_strides[MAXDIM]; + maybelong shape_0, inbstr_0, outbstr_0; + + if (nshape == 0) { /* handle rank-0 numarray. */ + nshape = 1; + shape = &shape_0; + inbstrides = &inbstr_0; + outbstrides = &outbstr_0; + shape[0] = 1; + inbstrides[0] = outbstrides[0] = 0; + } + + for(i=0; i<nshape; i++) + lshape[i] = shape[nshape-1-i]; + for(i=0; i<nshape; i++) + in_strides[i] = inbstrides[nshape-1-i]; + for(i=0; i<nshape; i++) + out_strides[i] = outbstrides[nshape-1-i]; + + if (!PyObject_IsInstance(self , (PyObject *) &CfuncType) + || me->descr.type != CFUNC_STRIDING) + return PyErr_Format(PyExc_TypeError, + "NA_callStrideConvCFuncCore: problem with cfunc"); + + if ((inbsize = NA_getBufferPtrAndSize(inbuffObj, 1, &inbuffer)) < 0) + return PyErr_Format(_Error, + "%s: Problem with input buffer", me->descr.name); + + if ((outbsize = NA_getBufferPtrAndSize(outbuffObj, 0, &outbuffer)) < 0) + return PyErr_Format(_Error, + "%s: Problem with output buffer (read only?)", + me->descr.name); + + /* Check buffer alignment and bounds */ + if (NA_checkOneStriding(me->descr.name, nshape, lshape, + inboffset, in_strides, inbsize, + (me->descr.sizes[0] == -1) ? + nbytes : me->descr.sizes[0], + me->descr.align) || + NA_checkOneStriding(me->descr.name, nshape, lshape, + outboffset, out_strides, outbsize, + (me->descr.sizes[1] == -1) ? + nbytes : me->descr.sizes[1], + me->descr.align)) + return NULL; + + /* Cast function pointer and perform stride operation */ + funcptr = (CFUNC_STRIDE_CONV_FUNC) me->descr.fptr; + if ((*funcptr)(nshape-1, nbytes, lshape, + inbuffer, inboffset, in_strides, + outbuffer, outboffset, out_strides) == 0) { + Py_INCREF(Py_None); + return Py_None; + } else { + return NULL; + } } static void -NA_stridesFromShape(int nshape, maybelong *shape, maybelong bytestride, - maybelong *strides) +NA_stridesFromShape(int nshape, maybelong *shape, maybelong bytestride, + maybelong *strides) { - int i; - if (nshape > 0) { - for(i=0; i<nshape; i++) - strides[i] = bytestride; - for(i=nshape-2; i>=0; i--) - strides[i] = strides[i+1]*shape[i+1]; - } + int i; + if (nshape > 0) { + for(i=0; i<nshape; i++) + strides[i] = bytestride; + for(i=nshape-2; i>=0; i--) + strides[i] = strides[i+1]*shape[i+1]; + } } static int NA_OperatorCheck(PyObject *NPY_UNUSED(op)) { - return 0; + return 0; } static int NA_ConverterCheck(PyObject *NPY_UNUSED(op)) { - return 0; + return 0; } static int NA_UfuncCheck(PyObject *NPY_UNUSED(op)) { - return 0; + return 0; } -static int +static int NA_CfuncCheck(PyObject *op) { - return PyObject_TypeCheck(op, &CfuncType); + return PyObject_TypeCheck(op, &CfuncType); } static int NA_getByteOffset(PyArrayObject *NPY_UNUSED(array), int NPY_UNUSED(nindices), - maybelong *NPY_UNUSED(indices), long *NPY_UNUSED(offset)) + maybelong *NPY_UNUSED(indices), long *NPY_UNUSED(offset)) { - return 0; + return 0; } static int NA_swapAxes(PyArrayObject *array, int x, int y) { - long temp; + long temp; + + if (((PyObject *) array) == Py_None) return 0; - if (((PyObject *) array) == Py_None) return 0; + if (array->nd < 2) return 0; - if (array->nd < 2) return 0; + if (x < 0) x += array->nd; + if (y < 0) y += array->nd; - if (x < 0) x += array->nd; - if (y < 0) y += array->nd; + if ((x < 0) || (x >= array->nd) || + (y < 0) || (y >= array->nd)) { + PyErr_Format(PyExc_ValueError, + "Specified dimension does not exist"); + return -1; + } - if ((x < 0) || (x >= array->nd) || - (y < 0) || (y >= array->nd)) { - 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 = array->dimensions[x]; - array->dimensions[x] = array->dimensions[y]; - array->dimensions[y] = temp; - - temp = array->strides[x]; - array->strides[x] = array->strides[y]; - array->strides[y] = temp; + temp = array->strides[x]; + array->strides[x] = array->strides[y]; + array->strides[y] = temp; - PyArray_UpdateFlags(array, NPY_UPDATE_ALL); + PyArray_UpdateFlags(array, NPY_UPDATE_ALL); - return 0; + return 0; } -static PyObject * +static PyObject * NA_initModuleGlobal(char *modulename, char *globalname) { - PyObject *module, *dict, *global = NULL; - module = PyImport_ImportModule(modulename); - if (!module) { - PyErr_Format(PyExc_RuntimeError, - "Can't import '%s' module", - modulename); - goto _exit; - } - dict = PyModule_GetDict(module); - global = PyDict_GetItemString(dict, globalname); - if (!global) { - PyErr_Format(PyExc_RuntimeError, - "Can't find '%s' global in '%s' module.", - globalname, modulename); - goto _exit; - } - Py_DECREF(module); - Py_INCREF(global); - _exit: - return global; -} - -NumarrayType + PyObject *module, *dict, *global = NULL; + module = PyImport_ImportModule(modulename); + if (!module) { + PyErr_Format(PyExc_RuntimeError, + "Can't import '%s' module", + modulename); + goto _exit; + } + dict = PyModule_GetDict(module); + global = PyDict_GetItemString(dict, globalname); + if (!global) { + PyErr_Format(PyExc_RuntimeError, + "Can't find '%s' global in '%s' module.", + globalname, modulename); + goto _exit; + } + Py_DECREF(module); + Py_INCREF(global); +_exit: + return global; +} + + NumarrayType NA_NumarrayType(PyObject *seq) { - int maxtype = NA_maxType(seq); - int rval; - switch(maxtype) { - case BOOL_SCALAR: - rval = tBool; - goto _exit; - case INT_SCALAR: - case LONG_SCALAR: - rval = tLong; /* tLong corresponds to C long int, - not Python long int */ - goto _exit; - case FLOAT_SCALAR: - rval = tFloat64; - goto _exit; - case COMPLEX_SCALAR: - rval = tComplex64; - goto _exit; - default: - PyErr_Format(PyExc_TypeError, - "expecting Python numeric scalar value; got something else."); - rval = -1; - } - _exit: - return rval; + int maxtype = NA_maxType(seq); + int rval; + switch(maxtype) { + case BOOL_SCALAR: + rval = tBool; + goto _exit; + case INT_SCALAR: + case LONG_SCALAR: + rval = tLong; /* tLong corresponds to C long int, + not Python long int */ + goto _exit; + case FLOAT_SCALAR: + rval = tFloat64; + goto _exit; + case COMPLEX_SCALAR: + rval = tComplex64; + goto _exit; + default: + PyErr_Format(PyExc_TypeError, + "expecting Python numeric scalar value; got something else."); + rval = -1; + } +_exit: + return rval; } /* ignores bytestride */ static PyArrayObject * NA_NewAllFromBuffer(int ndim, maybelong *shape, NumarrayType type, - PyObject *bufferObject, maybelong byteoffset, - maybelong NPY_UNUSED(bytestride), int byteorder, - int NPY_UNUSED(aligned), int NPY_UNUSED(writeable)) -{ - PyArrayObject *self = NULL; - PyArray_Descr *dtype; - - if (type == tAny) - type = tDefault; - - dtype = PyArray_DescrFromType(type); - if (dtype == NULL) return NULL; - - if (byteorder != NA_ByteOrder()) { - PyArray_Descr *temp; - temp = PyArray_DescrNewByteorder(dtype, PyArray_SWAP); - Py_DECREF(dtype); - if (temp == NULL) return NULL; - dtype = temp; - } - - if (bufferObject == Py_None || bufferObject == NULL) { - self = (PyArrayObject *) \ - PyArray_NewFromDescr(&PyArray_Type, dtype, - ndim, shape, NULL, NULL, - 0, NULL); - } - else { - npy_intp size = 1; - int i; - PyArrayObject *newself; - PyArray_Dims newdims; - for(i=0; i<ndim; i++) { - size *= shape[i]; - } - self = (PyArrayObject *)\ - PyArray_FromBuffer(bufferObject, dtype, - size, byteoffset); - - if (self == NULL) return self; - newdims.len = ndim; - newdims.ptr = shape; - newself = (PyArrayObject *)\ - PyArray_Newshape(self, &newdims, PyArray_CORDER); - Py_DECREF(self); - self = newself; - } - - return self; + PyObject *bufferObject, maybelong byteoffset, + maybelong NPY_UNUSED(bytestride), int byteorder, + int NPY_UNUSED(aligned), int NPY_UNUSED(writeable)) +{ + PyArrayObject *self = NULL; + PyArray_Descr *dtype; + + if (type == tAny) + type = tDefault; + + dtype = PyArray_DescrFromType(type); + if (dtype == NULL) return NULL; + + if (byteorder != NA_ByteOrder()) { + PyArray_Descr *temp; + temp = PyArray_DescrNewByteorder(dtype, PyArray_SWAP); + Py_DECREF(dtype); + if (temp == NULL) return NULL; + dtype = temp; + } + + if (bufferObject == Py_None || bufferObject == NULL) { + self = (PyArrayObject *) \ + PyArray_NewFromDescr(&PyArray_Type, dtype, + ndim, shape, NULL, NULL, + 0, NULL); + } + else { + npy_intp size = 1; + int i; + PyArrayObject *newself; + PyArray_Dims newdims; + for(i=0; i<ndim; i++) { + size *= shape[i]; + } + self = (PyArrayObject *)\ + PyArray_FromBuffer(bufferObject, dtype, + size, byteoffset); + + if (self == NULL) return self; + newdims.len = ndim; + newdims.ptr = shape; + newself = (PyArrayObject *)\ + PyArray_Newshape(self, &newdims, PyArray_CORDER); + Py_DECREF(self); + self = newself; + } + + return self; } static void NA_updateAlignment(PyArrayObject *self) { - PyArray_UpdateFlags(self, NPY_ALIGNED); + PyArray_UpdateFlags(self, NPY_ALIGNED); } static void NA_updateContiguous(PyArrayObject *self) { - PyArray_UpdateFlags(self, NPY_CONTIGUOUS | NPY_FORTRAN); + PyArray_UpdateFlags(self, NPY_CONTIGUOUS | NPY_FORTRAN); } -static void +static void NA_updateStatus(PyArrayObject *self) { - PyArray_UpdateFlags(self, NPY_UPDATE_ALL); + PyArray_UpdateFlags(self, NPY_UPDATE_ALL); } static int NA_NumArrayCheckExact(PyObject *op) { - return (op->ob_type == &PyArray_Type); + return (op->ob_type == &PyArray_Type); } static int NA_NDArrayCheckExact(PyObject *op) { - return (op->ob_type == &PyArray_Type); + return (op->ob_type == &PyArray_Type); } static int NA_OperatorCheckExact(PyObject *NPY_UNUSED(op)) { - return 0; + return 0; } static int NA_ConverterCheckExact(PyObject *NPY_UNUSED(op)) { - return 0; + return 0; } static int NA_UfuncCheckExact(PyObject *NPY_UNUSED(op)) { - return 0; + return 0; } static int NA_CfuncCheckExact(PyObject *op) { - return op->ob_type == &CfuncType; + return op->ob_type == &CfuncType; } static char * NA_getArrayData(PyArrayObject *obj) { - if (!NA_NDArrayCheck((PyObject *) obj)) { - PyErr_Format(PyExc_TypeError, - "expected an NDArray"); - } - return obj->data; + if (!NA_NDArrayCheck((PyObject *) obj)) { + PyErr_Format(PyExc_TypeError, + "expected an NDArray"); + } + return obj->data; } /* Byteswap is not a flag of the array --- it is implicit in the data-type */ static void NA_updateByteswap(PyArrayObject *NPY_UNUSED(self)) { - return; + return; } static PyArray_Descr * NA_DescrFromType(int type) { - if (type == tAny) - type = tDefault; - return PyArray_DescrFromType(type); + if (type == tAny) + type = tDefault; + return PyArray_DescrFromType(type); } -static PyObject * -NA_Cast(PyArrayObject *a, int type) +static PyObject * +NA_Cast(PyArrayObject *a, int type) { - return PyArray_Cast(a, type); + return PyArray_Cast(a, type); } /* The following function has much platform dependent code since -** there is no platform-independent way of checking Floating Point -** status bits -*/ + ** there is no platform-independent way of checking Floating Point + ** status bits + */ /* OSF/Alpha (Tru64) ---------------------------------------------*/ #if defined(__osf__) && defined(__alpha) -static int +static int NA_checkFPErrors(void) { - unsigned long fpstatus; - int retstatus; + unsigned long fpstatus; + int retstatus; #include <machine/fpu.h> /* Should migrate to global scope */ - fpstatus = ieee_get_fp_control(); - /* clear status bits as well as disable exception mode if on */ - ieee_set_fp_control( 0 ); - retstatus = - pyFPE_DIVIDE_BY_ZERO* (int)((IEEE_STATUS_DZE & fpstatus) != 0) - + pyFPE_OVERFLOW * (int)((IEEE_STATUS_OVF & fpstatus) != 0) - + pyFPE_UNDERFLOW * (int)((IEEE_STATUS_UNF & fpstatus) != 0) - + pyFPE_INVALID * (int)((IEEE_STATUS_INV & fpstatus) != 0); + fpstatus = ieee_get_fp_control(); + /* clear status bits as well as disable exception mode if on */ + ieee_set_fp_control( 0 ); + retstatus = + pyFPE_DIVIDE_BY_ZERO* (int)((IEEE_STATUS_DZE & fpstatus) != 0) + + pyFPE_OVERFLOW * (int)((IEEE_STATUS_OVF & fpstatus) != 0) + + pyFPE_UNDERFLOW * (int)((IEEE_STATUS_UNF & fpstatus) != 0) + + pyFPE_INVALID * (int)((IEEE_STATUS_INV & fpstatus) != 0); - return retstatus; + return retstatus; } /* MS Windows -----------------------------------------------------*/ @@ -2908,65 +2908,65 @@ NA_checkFPErrors(void) #include <float.h> -static int +static int NA_checkFPErrors(void) { - int fpstatus = (int) _clear87(); - int retstatus = - pyFPE_DIVIDE_BY_ZERO * ((SW_ZERODIVIDE & fpstatus) != 0) - + pyFPE_OVERFLOW * ((SW_OVERFLOW & fpstatus) != 0) - + pyFPE_UNDERFLOW * ((SW_UNDERFLOW & fpstatus) != 0) - + pyFPE_INVALID * ((SW_INVALID & fpstatus) != 0); + int fpstatus = (int) _clear87(); + int retstatus = + pyFPE_DIVIDE_BY_ZERO * ((SW_ZERODIVIDE & fpstatus) != 0) + + pyFPE_OVERFLOW * ((SW_OVERFLOW & fpstatus) != 0) + + pyFPE_UNDERFLOW * ((SW_UNDERFLOW & fpstatus) != 0) + + pyFPE_INVALID * ((SW_INVALID & fpstatus) != 0); - return retstatus; + return retstatus; } /* Solaris --------------------------------------------------------*/ /* --------ignoring SunOS ieee_flags approach, someone else can -** deal with that! */ + ** deal with that! */ #elif defined(sun) #include <ieeefp.h> -static int +static int NA_checkFPErrors(void) { - int fpstatus; - int retstatus; + int fpstatus; + int retstatus; - fpstatus = (int) fpgetsticky(); - retstatus = pyFPE_DIVIDE_BY_ZERO * ((FP_X_DZ & fpstatus) != 0) - + pyFPE_OVERFLOW * ((FP_X_OFL & fpstatus) != 0) - + pyFPE_UNDERFLOW * ((FP_X_UFL & fpstatus) != 0) - + pyFPE_INVALID * ((FP_X_INV & fpstatus) != 0); - (void) fpsetsticky(0); + fpstatus = (int) fpgetsticky(); + retstatus = pyFPE_DIVIDE_BY_ZERO * ((FP_X_DZ & fpstatus) != 0) + + pyFPE_OVERFLOW * ((FP_X_OFL & fpstatus) != 0) + + pyFPE_UNDERFLOW * ((FP_X_UFL & fpstatus) != 0) + + pyFPE_INVALID * ((FP_X_INV & fpstatus) != 0); + (void) fpsetsticky(0); - return retstatus; + return retstatus; } #elif defined(__GLIBC__) || defined(__APPLE__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__FreeBSD__) && (__FreeBSD_version >= 502114)) -static int +static int NA_checkFPErrors(void) { - int fpstatus = (int) fetestexcept( - FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW | FE_INVALID); - int retstatus = - pyFPE_DIVIDE_BY_ZERO * ((FE_DIVBYZERO & fpstatus) != 0) - + pyFPE_OVERFLOW * ((FE_OVERFLOW & fpstatus) != 0) - + pyFPE_UNDERFLOW * ((FE_UNDERFLOW & fpstatus) != 0) - + pyFPE_INVALID * ((FE_INVALID & fpstatus) != 0); - (void) feclearexcept(FE_DIVBYZERO | FE_OVERFLOW | - FE_UNDERFLOW | FE_INVALID); - return retstatus; + int fpstatus = (int) fetestexcept( + FE_DIVBYZERO | FE_OVERFLOW | FE_UNDERFLOW | FE_INVALID); + int retstatus = + pyFPE_DIVIDE_BY_ZERO * ((FE_DIVBYZERO & fpstatus) != 0) + + pyFPE_OVERFLOW * ((FE_OVERFLOW & fpstatus) != 0) + + pyFPE_UNDERFLOW * ((FE_UNDERFLOW & fpstatus) != 0) + + pyFPE_INVALID * ((FE_INVALID & fpstatus) != 0); + (void) feclearexcept(FE_DIVBYZERO | FE_OVERFLOW | + FE_UNDERFLOW | FE_INVALID); + return retstatus; } #else -static int +static int NA_checkFPErrors(void) { - return 0; + return 0; } #endif @@ -2974,24 +2974,24 @@ NA_checkFPErrors(void) static void NA_clearFPErrors() { - NA_checkFPErrors(); + NA_checkFPErrors(); } /* Not supported yet */ static int NA_checkAndReportFPErrors(char *name) { - int error = NA_checkFPErrors(); - if (error) { - PyObject *ans; - char msg[128]; - strcpy(msg, " in "); - strncat(msg, name, 100); - ans = PyObject_CallFunction(pHandleErrorFunc, "(is)", error, msg); - if (!ans) return -1; - Py_DECREF(ans); /* Py_None */ - } - return 0; + int error = NA_checkFPErrors(); + if (error) { + PyObject *ans; + char msg[128]; + strcpy(msg, " in "); + strncat(msg, name, 100); + ans = PyObject_CallFunction(pHandleErrorFunc, "(is)", error, msg); + if (!ans) return -1; + Py_DECREF(ans); /* Py_None */ + } + return 0; } @@ -2999,309 +2999,309 @@ NA_checkAndReportFPErrors(char *name) #define WITHIN32(v, f) (((v) >= f##_MIN32) && ((v) <= f##_MAX32)) #define WITHIN64(v, f) (((v) >= f##_MIN64) && ((v) <= f##_MAX64)) -static Bool +static Bool NA_IeeeMask32( Float32 f, Int32 mask) { - Int32 category; - UInt32 v = *(UInt32 *) &f; - - if (v & BIT(31)) { - if (WITHIN32(v, NEG_NORMALIZED)) { - category = MSK_NEG_NOR; - } else if (WITHIN32(v, NEG_DENORMALIZED)) { - category = MSK_NEG_DEN; - } else if (WITHIN32(v, NEG_SIGNAL_NAN)) { - category = MSK_NEG_SNAN; - } else if (WITHIN32(v, NEG_QUIET_NAN)) { - category = MSK_NEG_QNAN; - } else if (v == NEG_INFINITY_MIN32) { - category = MSK_NEG_INF; - } else if (v == NEG_ZERO_MIN32) { - category = MSK_NEG_ZERO; - } else if (v == INDETERMINATE_MIN32) { - category = MSK_INDETERM; - } else { - category = MSK_BUG; - } - } else { - if (WITHIN32(v, POS_NORMALIZED)) { - category = MSK_POS_NOR; - } else if (WITHIN32(v, POS_DENORMALIZED)) { - category = MSK_POS_DEN; - } else if (WITHIN32(v, POS_SIGNAL_NAN)) { - category = MSK_POS_SNAN; - } else if (WITHIN32(v, POS_QUIET_NAN)) { - category = MSK_POS_QNAN; - } else if (v == POS_INFINITY_MIN32) { - category = MSK_POS_INF; - } else if (v == POS_ZERO_MIN32) { - category = MSK_POS_ZERO; - } else { - category = MSK_BUG; - } - } - return (category & mask) != 0; -} - -static Bool + Int32 category; + UInt32 v = *(UInt32 *) &f; + + if (v & BIT(31)) { + if (WITHIN32(v, NEG_NORMALIZED)) { + category = MSK_NEG_NOR; + } else if (WITHIN32(v, NEG_DENORMALIZED)) { + category = MSK_NEG_DEN; + } else if (WITHIN32(v, NEG_SIGNAL_NAN)) { + category = MSK_NEG_SNAN; + } else if (WITHIN32(v, NEG_QUIET_NAN)) { + category = MSK_NEG_QNAN; + } else if (v == NEG_INFINITY_MIN32) { + category = MSK_NEG_INF; + } else if (v == NEG_ZERO_MIN32) { + category = MSK_NEG_ZERO; + } else if (v == INDETERMINATE_MIN32) { + category = MSK_INDETERM; + } else { + category = MSK_BUG; + } + } else { + if (WITHIN32(v, POS_NORMALIZED)) { + category = MSK_POS_NOR; + } else if (WITHIN32(v, POS_DENORMALIZED)) { + category = MSK_POS_DEN; + } else if (WITHIN32(v, POS_SIGNAL_NAN)) { + category = MSK_POS_SNAN; + } else if (WITHIN32(v, POS_QUIET_NAN)) { + category = MSK_POS_QNAN; + } else if (v == POS_INFINITY_MIN32) { + category = MSK_POS_INF; + } else if (v == POS_ZERO_MIN32) { + category = MSK_POS_ZERO; + } else { + category = MSK_BUG; + } + } + return (category & mask) != 0; +} + +static Bool NA_IeeeMask64( Float64 f, Int32 mask) { - Int32 category; - UInt64 v = *(UInt64 *) &f; - - if (v & BIT(63)) { - if (WITHIN64(v, NEG_NORMALIZED)) { - category = MSK_NEG_NOR; - } else if (WITHIN64(v, NEG_DENORMALIZED)) { - category = MSK_NEG_DEN; - } else if (WITHIN64(v, NEG_SIGNAL_NAN)) { - category = MSK_NEG_SNAN; - } else if (WITHIN64(v, NEG_QUIET_NAN)) { - category = MSK_NEG_QNAN; - } else if (v == NEG_INFINITY_MIN64) { - category = MSK_NEG_INF; - } else if (v == NEG_ZERO_MIN64) { - category = MSK_NEG_ZERO; - } else if (v == INDETERMINATE_MIN64) { - category = MSK_INDETERM; - } else { - category = MSK_BUG; - } - } else { - if (WITHIN64(v, POS_NORMALIZED)) { - category = MSK_POS_NOR; - } else if (WITHIN64(v, POS_DENORMALIZED)) { - category = MSK_POS_DEN; - } else if (WITHIN64(v, POS_SIGNAL_NAN)) { - category = MSK_POS_SNAN; - } else if (WITHIN64(v, POS_QUIET_NAN)) { - category = MSK_POS_QNAN; - } else if (v == POS_INFINITY_MIN64) { - category = MSK_POS_INF; - } else if (v == POS_ZERO_MIN64) { - category = MSK_POS_ZERO; - } else { - category = MSK_BUG; - } - } - return (category & mask) != 0; + Int32 category; + UInt64 v = *(UInt64 *) &f; + + if (v & BIT(63)) { + if (WITHIN64(v, NEG_NORMALIZED)) { + category = MSK_NEG_NOR; + } else if (WITHIN64(v, NEG_DENORMALIZED)) { + category = MSK_NEG_DEN; + } else if (WITHIN64(v, NEG_SIGNAL_NAN)) { + category = MSK_NEG_SNAN; + } else if (WITHIN64(v, NEG_QUIET_NAN)) { + category = MSK_NEG_QNAN; + } else if (v == NEG_INFINITY_MIN64) { + category = MSK_NEG_INF; + } else if (v == NEG_ZERO_MIN64) { + category = MSK_NEG_ZERO; + } else if (v == INDETERMINATE_MIN64) { + category = MSK_INDETERM; + } else { + category = MSK_BUG; + } + } else { + if (WITHIN64(v, POS_NORMALIZED)) { + category = MSK_POS_NOR; + } else if (WITHIN64(v, POS_DENORMALIZED)) { + category = MSK_POS_DEN; + } else if (WITHIN64(v, POS_SIGNAL_NAN)) { + category = MSK_POS_SNAN; + } else if (WITHIN64(v, POS_QUIET_NAN)) { + category = MSK_POS_QNAN; + } else if (v == POS_INFINITY_MIN64) { + category = MSK_POS_INF; + } else if (v == POS_ZERO_MIN64) { + category = MSK_POS_ZERO; + } else { + category = MSK_BUG; + } + } + return (category & mask) != 0; } static PyArrayObject * -NA_FromDimsStridesDescrAndData(int nd, maybelong *d, maybelong *s, PyArray_Descr *descr, char *data) +NA_FromDimsStridesDescrAndData(int nd, maybelong *d, maybelong *s, PyArray_Descr *descr, char *data) { - return (PyArrayObject *)\ - PyArray_NewFromDescr(&PyArray_Type, descr, nd, d, - s, data, 0, NULL); + return (PyArrayObject *)\ + PyArray_NewFromDescr(&PyArray_Type, descr, nd, d, + s, data, 0, NULL); } static PyArrayObject * -NA_FromDimsTypeAndData(int nd, maybelong *d, int type, char *data) +NA_FromDimsTypeAndData(int nd, maybelong *d, int type, char *data) { PyArray_Descr *descr = NA_DescrFromType(type); return NA_FromDimsStridesDescrAndData(nd, d, NULL, descr, data); } static PyArrayObject * -NA_FromDimsStridesTypeAndData(int nd, maybelong *shape, maybelong *strides, - int type, char *data) +NA_FromDimsStridesTypeAndData(int nd, maybelong *shape, maybelong *strides, + int type, char *data) { PyArray_Descr *descr = NA_DescrFromType(type); return NA_FromDimsStridesDescrAndData(nd, shape, strides, descr, data); } -typedef struct +typedef struct { - NumarrayType type_num; - char suffix[5]; - int itemsize; + NumarrayType type_num; + char suffix[5]; + int itemsize; } scipy_typestr; static scipy_typestr scipy_descriptors[ ] = { - { tAny, ""}, - - { tBool, "b1", 1}, + { tAny, ""}, + + { tBool, "b1", 1}, - { tInt8, "i1", 1}, - { tUInt8, "u1", 1}, + { tInt8, "i1", 1}, + { tUInt8, "u1", 1}, - { tInt16, "i2", 2}, - { tUInt16, "u2", 2}, + { tInt16, "i2", 2}, + { tUInt16, "u2", 2}, - { tInt32, "i4", 4}, - { tUInt32, "u4", 4}, + { tInt32, "i4", 4}, + { tUInt32, "u4", 4}, - { tInt64, "i8", 8}, - { tUInt64, "u8", 8}, + { tInt64, "i8", 8}, + { tUInt64, "u8", 8}, - { tFloat32, "f4", 4}, - { tFloat64, "f8", 8}, + { tFloat32, "f4", 4}, + { tFloat64, "f8", 8}, - { tComplex32, "c8", 8}, - { tComplex64, "c16", 16} + { tComplex32, "c8", 8}, + { tComplex64, "c16", 16} }; static int NA_scipy_typestr(NumarrayType t, int byteorder, char *typestr) { - size_t i; - if (byteorder) - strcpy(typestr, ">"); - else - strcpy(typestr, "<"); - for(i=0; i<ELEM(scipy_descriptors); i++) { - scipy_typestr *ts = &scipy_descriptors[i]; - if (ts->type_num == t) { - strncat(typestr, ts->suffix, 4); - return 0; - } - } - return -1; + size_t i; + if (byteorder) + strcpy(typestr, ">"); + else + strcpy(typestr, "<"); + for(i=0; i<ELEM(scipy_descriptors); i++) { + scipy_typestr *ts = &scipy_descriptors[i]; + if (ts->type_num == t) { + strncat(typestr, ts->suffix, 4); + return 0; + } + } + return -1; } static PyArrayObject * NA_FromArrayStruct(PyObject *obj) { - return (PyArrayObject *)PyArray_FromStructInterface(obj); + return (PyArrayObject *)PyArray_FromStructInterface(obj); } static PyObject *_Error; void *libnumarray_API[] = { - (void*) getBuffer, - (void*) isBuffer, - (void*) getWriteBufferDataPtr, - (void*) isBufferWriteable, - (void*) getReadBufferDataPtr, - (void*) getBufferSize, - (void*) num_log, - (void*) num_log10, - (void*) num_pow, - (void*) num_acosh, - (void*) num_asinh, - (void*) num_atanh, - (void*) num_round, - (void*) int_dividebyzero_error, - (void*) int_overflow_error, - (void*) umult64_overflow, - (void*) smult64_overflow, - (void*) NA_Done, - (void*) NA_NewAll, - (void*) NA_NewAllStrides, - (void*) NA_New, - (void*) NA_Empty, - (void*) NA_NewArray, - (void*) NA_vNewArray, - (void*) NA_ReturnOutput, - (void*) NA_getBufferPtrAndSize, - (void*) NA_checkIo, - (void*) NA_checkOneCBuffer, - (void*) NA_checkNCBuffers, - (void*) NA_checkOneStriding, - (void*) NA_new_cfunc, - (void*) NA_add_cfunc, - (void*) NA_InputArray, - (void*) NA_OutputArray, - (void*) NA_IoArray, - (void*) NA_OptionalOutputArray, - (void*) NA_get_offset, - (void*) NA_get_Float64, - (void*) NA_set_Float64, - (void*) NA_get_Complex64, - (void*) NA_set_Complex64, - (void*) NA_get_Int64, - (void*) NA_set_Int64, - (void*) NA_get1_Float64, - (void*) NA_get2_Float64, - (void*) NA_get3_Float64, - (void*) NA_set1_Float64, - (void*) NA_set2_Float64, - (void*) NA_set3_Float64, - (void*) NA_get1_Complex64, - (void*) NA_get2_Complex64, - (void*) NA_get3_Complex64, - (void*) NA_set1_Complex64, - (void*) NA_set2_Complex64, - (void*) NA_set3_Complex64, - (void*) NA_get1_Int64, - (void*) NA_get2_Int64, - (void*) NA_get3_Int64, - (void*) NA_set1_Int64, - (void*) NA_set2_Int64, - (void*) NA_set3_Int64, - (void*) NA_get1D_Float64, - (void*) NA_set1D_Float64, - (void*) NA_get1D_Int64, - (void*) NA_set1D_Int64, - (void*) NA_get1D_Complex64, - (void*) NA_set1D_Complex64, - (void*) NA_ShapeEqual, - (void*) NA_ShapeLessThan, - (void*) NA_ByteOrder, - (void*) NA_IeeeSpecial32, - (void*) NA_IeeeSpecial64, - (void*) NA_updateDataPtr, - (void*) NA_typeNoToName, - (void*) NA_nameToTypeNo, - (void*) NA_typeNoToTypeObject, - (void*) NA_intTupleFromMaybeLongs, - (void*) NA_maybeLongsFromIntTuple, - (void*) NA_intTupleProduct, - (void*) NA_isIntegerSequence, - (void*) NA_setArrayFromSequence, - (void*) NA_maxType, - (void*) NA_isPythonScalar, - (void*) NA_getPythonScalar, - (void*) NA_setFromPythonScalar, - (void*) NA_NDArrayCheck, - (void*) NA_NumArrayCheck, - (void*) NA_ComplexArrayCheck, - (void*) NA_elements, - (void*) NA_typeObjectToTypeNo, - (void*) NA_copyArray, - (void*) NA_copy, - (void*) NA_getType, - (void*) NA_callCUFuncCore, - (void*) NA_callStrideConvCFuncCore, - (void*) NA_stridesFromShape, - (void*) NA_OperatorCheck, - (void*) NA_ConverterCheck, - (void*) NA_UfuncCheck, - (void*) NA_CfuncCheck, - (void*) NA_getByteOffset, - (void*) NA_swapAxes, - (void*) NA_initModuleGlobal, - (void*) NA_NumarrayType, - (void*) NA_NewAllFromBuffer, - (void*) NA_alloc1D_Float64, - (void*) NA_alloc1D_Int64, - (void*) NA_updateAlignment, - (void*) NA_updateContiguous, - (void*) NA_updateStatus, - (void*) NA_NumArrayCheckExact, - (void*) NA_NDArrayCheckExact, - (void*) NA_OperatorCheckExact, - (void*) NA_ConverterCheckExact, - (void*) NA_UfuncCheckExact, - (void*) NA_CfuncCheckExact, - (void*) NA_getArrayData, - (void*) NA_updateByteswap, - (void*) NA_DescrFromType, - (void*) NA_Cast, - (void*) NA_checkFPErrors, - (void*) NA_clearFPErrors, - (void*) NA_checkAndReportFPErrors, - (void*) NA_IeeeMask32, - (void*) NA_IeeeMask64, - (void*) _NA_callStridingHelper, - (void*) NA_FromDimsStridesDescrAndData, - (void*) NA_FromDimsTypeAndData, - (void*) NA_FromDimsStridesTypeAndData, - (void*) NA_scipy_typestr, - (void*) NA_FromArrayStruct + (void*) getBuffer, + (void*) isBuffer, + (void*) getWriteBufferDataPtr, + (void*) isBufferWriteable, + (void*) getReadBufferDataPtr, + (void*) getBufferSize, + (void*) num_log, + (void*) num_log10, + (void*) num_pow, + (void*) num_acosh, + (void*) num_asinh, + (void*) num_atanh, + (void*) num_round, + (void*) int_dividebyzero_error, + (void*) int_overflow_error, + (void*) umult64_overflow, + (void*) smult64_overflow, + (void*) NA_Done, + (void*) NA_NewAll, + (void*) NA_NewAllStrides, + (void*) NA_New, + (void*) NA_Empty, + (void*) NA_NewArray, + (void*) NA_vNewArray, + (void*) NA_ReturnOutput, + (void*) NA_getBufferPtrAndSize, + (void*) NA_checkIo, + (void*) NA_checkOneCBuffer, + (void*) NA_checkNCBuffers, + (void*) NA_checkOneStriding, + (void*) NA_new_cfunc, + (void*) NA_add_cfunc, + (void*) NA_InputArray, + (void*) NA_OutputArray, + (void*) NA_IoArray, + (void*) NA_OptionalOutputArray, + (void*) NA_get_offset, + (void*) NA_get_Float64, + (void*) NA_set_Float64, + (void*) NA_get_Complex64, + (void*) NA_set_Complex64, + (void*) NA_get_Int64, + (void*) NA_set_Int64, + (void*) NA_get1_Float64, + (void*) NA_get2_Float64, + (void*) NA_get3_Float64, + (void*) NA_set1_Float64, + (void*) NA_set2_Float64, + (void*) NA_set3_Float64, + (void*) NA_get1_Complex64, + (void*) NA_get2_Complex64, + (void*) NA_get3_Complex64, + (void*) NA_set1_Complex64, + (void*) NA_set2_Complex64, + (void*) NA_set3_Complex64, + (void*) NA_get1_Int64, + (void*) NA_get2_Int64, + (void*) NA_get3_Int64, + (void*) NA_set1_Int64, + (void*) NA_set2_Int64, + (void*) NA_set3_Int64, + (void*) NA_get1D_Float64, + (void*) NA_set1D_Float64, + (void*) NA_get1D_Int64, + (void*) NA_set1D_Int64, + (void*) NA_get1D_Complex64, + (void*) NA_set1D_Complex64, + (void*) NA_ShapeEqual, + (void*) NA_ShapeLessThan, + (void*) NA_ByteOrder, + (void*) NA_IeeeSpecial32, + (void*) NA_IeeeSpecial64, + (void*) NA_updateDataPtr, + (void*) NA_typeNoToName, + (void*) NA_nameToTypeNo, + (void*) NA_typeNoToTypeObject, + (void*) NA_intTupleFromMaybeLongs, + (void*) NA_maybeLongsFromIntTuple, + (void*) NA_intTupleProduct, + (void*) NA_isIntegerSequence, + (void*) NA_setArrayFromSequence, + (void*) NA_maxType, + (void*) NA_isPythonScalar, + (void*) NA_getPythonScalar, + (void*) NA_setFromPythonScalar, + (void*) NA_NDArrayCheck, + (void*) NA_NumArrayCheck, + (void*) NA_ComplexArrayCheck, + (void*) NA_elements, + (void*) NA_typeObjectToTypeNo, + (void*) NA_copyArray, + (void*) NA_copy, + (void*) NA_getType, + (void*) NA_callCUFuncCore, + (void*) NA_callStrideConvCFuncCore, + (void*) NA_stridesFromShape, + (void*) NA_OperatorCheck, + (void*) NA_ConverterCheck, + (void*) NA_UfuncCheck, + (void*) NA_CfuncCheck, + (void*) NA_getByteOffset, + (void*) NA_swapAxes, + (void*) NA_initModuleGlobal, + (void*) NA_NumarrayType, + (void*) NA_NewAllFromBuffer, + (void*) NA_alloc1D_Float64, + (void*) NA_alloc1D_Int64, + (void*) NA_updateAlignment, + (void*) NA_updateContiguous, + (void*) NA_updateStatus, + (void*) NA_NumArrayCheckExact, + (void*) NA_NDArrayCheckExact, + (void*) NA_OperatorCheckExact, + (void*) NA_ConverterCheckExact, + (void*) NA_UfuncCheckExact, + (void*) NA_CfuncCheckExact, + (void*) NA_getArrayData, + (void*) NA_updateByteswap, + (void*) NA_DescrFromType, + (void*) NA_Cast, + (void*) NA_checkFPErrors, + (void*) NA_clearFPErrors, + (void*) NA_checkAndReportFPErrors, + (void*) NA_IeeeMask32, + (void*) NA_IeeeMask64, + (void*) _NA_callStridingHelper, + (void*) NA_FromDimsStridesDescrAndData, + (void*) NA_FromDimsTypeAndData, + (void*) NA_FromDimsStridesTypeAndData, + (void*) NA_scipy_typestr, + (void*) NA_FromArrayStruct }; #if (!defined(METHOD_TABLE_EXISTS)) @@ -3322,21 +3322,19 @@ PyMODINIT_FUNC init_capi(void) c_api_object = PyCObject_FromVoidPtr((void *)libnumarray_API, NULL); if (c_api_object != NULL) { - /* Create a name for this object in the module's namespace */ - PyObject *d = PyModule_GetDict(m); + /* Create a name for this object in the module's namespace */ + PyObject *d = PyModule_GetDict(m); - PyDict_SetItemString(d, "_C_API", c_api_object); - PyDict_SetItemString(d, "error", _Error); - Py_DECREF(c_api_object); + PyDict_SetItemString(d, "_C_API", c_api_object); + PyDict_SetItemString(d, "error", _Error); + Py_DECREF(c_api_object); } else { return; } - if (PyModule_AddObject(m, "__version__", - PyString_FromString("0.9")) < 0) return; + if (PyModule_AddObject(m, "__version__", + PyString_FromString("0.9")) < 0) return; if (_import_array() < 0) return; deferred_libnumarray_init(); return; } - - |