static int np_complex_double(char *p, PyObject *v, const formatdef *f) { if (PyArray_IsZeroDim(v)) { PyObject *v_cast = PyArray_Cast( reinterpret_cast<PyArrayObject *>(v), NPY_CDOUBLE); if (!v_cast) return -1; memcpy(p, PyArray_DATA(v_cast), PyArray_NBYTES(v_cast)); Py_DECREF(v_cast); } else { double re = 0.0; double im = 0.0; Py_complex cplx = PyComplex_AsCComplex(v); if (PyErr_Occurred()) { PyErr_SetString(StructError, "required argument is not a complex"); return -1; } re = cplx.real; im = cplx.imag; memcpy(p, (char *)&re, sizeof re); memcpy(p+sizeof re, (char *)&im, sizeof im); } return 0; }
PyObject* _PyArray_ZEROS(int nd, npy_intp* dims, int type_num, int fortran) { PyObject *arr = PyArray_EMPTY(nd, dims, type_num, fortran); memset(PyArray_DATA(arr), 0, PyArray_NBYTES(arr)); return arr; }
static int try_pyarr_from_string(PyObject *obj,const string str) { PyArrayObject *arr = NULL; if (PyArray_Check(obj) && (!((arr = (PyArrayObject *)obj) == NULL))) { STRINGCOPYN(arr->data,str,PyArray_NBYTES(arr)); } return 1; capi_fail: PRINTPYOBJERR(obj); PyErr_SetString(_lbfgsb_error,"try_pyarr_from_string failed"); return 0; }
static PyObject* read_column(PyObject* self, PyObject* args) { oskar_MeasurementSet* h = 0; PyObject *capsule = 0; size_t i = 0, ndim = 0, required_size = 0, *shape = 0; npy_intp *dims = 0; PyArrayObject* data = 0; int num_rows = 0, start_row = 0, status = 0, type = 0; const char* column = 0; if (!PyArg_ParseTuple(args, "Osii", &capsule, &column, &start_row, &num_rows)) return 0; if (!(h = (oskar_MeasurementSet*) get_handle(capsule, name))) return 0; /* Get the type and shape of the column. */ type = numpy_type_from_ms_type(oskar_ms_column_element_type(h, column)); if (type == NPY_VOID) { PyErr_Format(PyExc_RuntimeError, "Unknown data type for column '%s'.", column); return 0; } /* Memory varies most rapidly with the *first* index of shape. */ shape = oskar_ms_column_shape(h, column, &ndim); /* Create a numpy array to return. */ if (!(ndim == 1 && shape[0] == 1)) ndim++; dims = (npy_intp*) calloc(ndim, sizeof(npy_intp)); dims[0] = num_rows; for (i = 1; i < ndim; ++i) dims[i] = shape[(ndim - 2) - (i - 1)]; data = (PyArrayObject*) PyArray_SimpleNew((int) ndim, dims, type); free(shape); free(dims); /* Read the data into the numpy array. */ Py_BEGIN_ALLOW_THREADS oskar_ms_read_column(h, column, start_row, num_rows, PyArray_NBYTES(data), PyArray_DATA(data), &required_size, &status); Py_END_ALLOW_THREADS /* Check for errors. */ if (status) { PyErr_Format(PyExc_RuntimeError, "oskar_ms_read_column() failed with code %d.", status); Py_XDECREF(data); return 0; } /* Return the data. */ return Py_BuildValue("N", data); /* Don't increment refcount. */ }
/* * check if in "alhs @op@ orhs" that alhs is a temporary (refcnt == 1) so we * can do in-place operations instead of creating a new temporary * "cannot" is set to true if it cannot be done even with swapped arguments */ static int can_elide_temp(PyArrayObject * alhs, PyObject * orhs, int * cannot) { /* * to be a candidate the array needs to have reference count 1, be an exact * array of a basic type, own its data and size larger than threshold */ if (Py_REFCNT(alhs) != 1 || !PyArray_CheckExact(alhs) || !PyArray_ISNUMBER(alhs) || !PyArray_CHKFLAGS(alhs, NPY_ARRAY_OWNDATA) || !PyArray_ISWRITEABLE(alhs) || PyArray_CHKFLAGS(alhs, NPY_ARRAY_UPDATEIFCOPY) || PyArray_CHKFLAGS(alhs, NPY_ARRAY_WRITEBACKIFCOPY) || PyArray_NBYTES(alhs) < NPY_MIN_ELIDE_BYTES) { return 0; } if (PyArray_CheckExact(orhs) || PyArray_CheckAnyScalar(orhs)) { PyArrayObject * arhs; /* create array from right hand side */ Py_INCREF(orhs); arhs = (PyArrayObject *)PyArray_EnsureArray(orhs); if (arhs == NULL) { return 0; } /* * if rhs is not a scalar dimensions must match * TODO: one could allow broadcasting on equal types */ if (!(PyArray_NDIM(arhs) == 0 || (PyArray_NDIM(arhs) == PyArray_NDIM(alhs) && PyArray_CompareLists(PyArray_DIMS(alhs), PyArray_DIMS(arhs), PyArray_NDIM(arhs))))) { Py_DECREF(arhs); return 0; } /* must be safe to cast (checks values for scalar in rhs) */ if (PyArray_CanCastArrayTo(arhs, PyArray_DESCR(alhs), NPY_SAFE_CASTING)) { Py_DECREF(arhs); return check_callers(cannot); } Py_DECREF(arhs); } return 0; }
static Py_ssize_t array_getsegcount(PyArrayObject *self, Py_ssize_t *lenp) { if (lenp) { *lenp = PyArray_NBYTES(self); } if (PyArray_ISONESEGMENT(self)) { return 1; } if (lenp) { *lenp = 0; } return 0; }
/* * Creates a new numpy array of the requested type and shape, and either * copies into it the contents of buffer, or sets it to all zeros if * buffer is NULL. */ static PyArrayObject * NA_NewArray(void *buffer, enum NPY_TYPES type, int ndim, npy_intp *shape) { PyArrayObject *result; if (type == NPY_NOTYPE) { type = NPY_DOUBLE; } result = (PyArrayObject *)PyArray_SimpleNew(ndim, shape, type); if (result == NULL) { return NULL; } if (buffer == NULL) { memset(PyArray_DATA(result), 0, PyArray_NBYTES(result)); } else { memcpy(PyArray_DATA(result), buffer, PyArray_NBYTES(result)); } return result; }
static Py_ssize_t array_getreadbuf(PyArrayObject *self, Py_ssize_t segment, void **ptrptr) { if (segment != 0) { PyErr_SetString(PyExc_ValueError, "accessing non-existing array segment"); return -1; } if (PyArray_ISONESEGMENT(self)) { *ptrptr = PyArray_DATA(self); return PyArray_NBYTES(self); } PyErr_SetString(PyExc_ValueError, "array is not a single segment"); *ptrptr = NULL; return -1; }
static PyObject * array_repr_builtin(PyArrayObject *self, int repr) { PyObject *ret; char *string; int n, max_n; max_n = PyArray_NBYTES(self)*4*sizeof(char) + 7; if ((string = (char *)_pya_malloc(max_n)) == NULL) { PyErr_SetString(PyExc_MemoryError, "out of memory"); return NULL; } if (repr) { n = 6; sprintf(string, "array("); } else { n = 0; } if (dump_data(&string, &n, &max_n, self->data, self->nd, self->dimensions, self->strides, self) < 0) { _pya_free(string); return NULL; } if (repr) { if (PyArray_ISEXTENDED(self)) { char buf[100]; PyOS_snprintf(buf, sizeof(buf), "%d", self->descr->elsize); sprintf(string+n, ", '%c%s')", self->descr->type, buf); ret = PyUString_FromStringAndSize(string, n + 6 + strlen(buf)); } else { sprintf(string+n, ", '%c')", self->descr->type); ret = PyUString_FromStringAndSize(string, n+6); } } else { ret = PyUString_FromStringAndSize(string, n); } _pya_free(string); return ret; }
NPY_NO_EXPORT int _zerofill(PyArrayObject *ret) { if (PyDataType_REFCHK(PyArray_DESCR(ret))) { PyObject *zero = PyInt_FromLong(0); PyArray_FillObjectArray(ret, zero); Py_DECREF(zero); if (PyErr_Occurred()) { Py_DECREF(ret); return -1; } } else { npy_intp n = PyArray_NBYTES(ret); memset(PyArray_DATA(ret), 0, n); } return 0; }
/* try elide unary temporary */ NPY_NO_EXPORT int can_elide_temp_unary(PyArrayObject * m1) { int cannot; if (Py_REFCNT(m1) != 1 || !PyArray_CheckExact(m1) || PyArray_DESCR(m1)->type_num == NPY_VOID || !(PyArray_FLAGS(m1) & NPY_ARRAY_OWNDATA) || PyArray_NBYTES(m1) < NPY_MIN_ELIDE_BYTES) { return 0; } if (check_callers(&cannot)) { #if NPY_ELIDE_DEBUG != 0 puts("elided temporary in unary op"); #endif return 1; } else { return 0; } }
static PyObject* _arraytok(PyObject* self, PyObject* a) { K kobj = 0; if (!PyArray_Check(a)) { return PyErr_Format(PyExc_TypeError, "argument is not a numeric array"); } PyArrayObject* arr = (PyArrayObject*)a; if (!PyArray_ISCONTIGUOUS(arr)) { return PyErr_Format(PyExc_TypeError, "cannot handle non-contiguous arrays"); } int n = PyArray_SIZE(arr); int t = ktype(arr->descr->type_num); if (t > 0) { kobj = gtn(-t,n); memcpy(kobj->k, arr->data, PyArray_NBYTES(arr)); } else if (arr->descr->type_num == PyArray_OBJECT) { /* special handling for arrays of strings */ char** strings = malloc(n*sizeof(char*)); PyObject** objects = (PyObject**)arr->data; int i; for (i = 0; i < n; ++i) { char* str = PyString_AsString(objects[i]); if (str) { strings[i] = str; } else { free(strings); /* XXX should we raise our own exception here * * XXX or keep the one which came from "AsString"? */ return NULL; } } kobj = gtn(-4, n); for (i = 0; i < n; ++i) { KS(kobj)[i] = sp(strings[i]); } } return PyK_mk_K(kobj); }
/* try elide unary temporary */ NPY_NO_EXPORT int can_elide_temp_unary(PyArrayObject * m1) { int cannot; if (Py_REFCNT(m1) != 1 || !PyArray_CheckExact(m1) || !PyArray_ISNUMBER(m1) || !PyArray_CHKFLAGS(m1, NPY_ARRAY_OWNDATA) || !PyArray_ISWRITEABLE(m1) || PyArray_CHKFLAGS(m1, NPY_ARRAY_UPDATEIFCOPY) || PyArray_NBYTES(m1) < NPY_MIN_ELIDE_BYTES) { return 0; } if (check_callers(&cannot)) { #if NPY_ELIDE_DEBUG != 0 puts("elided temporary in unary op"); #endif return 1; } else { return 0; } }
static PyObject * array_repr_builtin(PyArrayObject *self, int repr) { PyObject *ret; char *string; /* max_n initial value is arbitrary, dump_data will extend it */ Py_ssize_t n = 0, max_n = PyArray_NBYTES(self) * 4 + 7; if ((string = PyArray_malloc(max_n)) == NULL) { return PyErr_NoMemory(); } if (dump_data(&string, &n, &max_n, PyArray_DATA(self), PyArray_NDIM(self), PyArray_DIMS(self), PyArray_STRIDES(self), self) < 0) { PyArray_free(string); return NULL; } if (repr) { if (PyArray_ISEXTENDED(self)) { ret = PyUString_FromFormat("array(%s, '%c%d')", string, PyArray_DESCR(self)->type, PyArray_DESCR(self)->elsize); } else { ret = PyUString_FromFormat("array(%s, '%c')", string, PyArray_DESCR(self)->type); } } else { ret = PyUString_FromStringAndSize(string, n); } PyArray_free(string); return ret; }
static PyObject *set_FL321_buffer(PyObject *self, PyObject *args){ PyArrayObject *FL321_in; cudaError_t err; float *FL321; int g; // gpu ind if (!PyArg_ParseTuple(args, "O!i", &PyArray_Type, &FL321_in, &g)) return NULL; if (NULL == FL321_in) return NULL; if(g < 0 || g > N_GPUS){ printf("invalid gpu index %i\n", g); return NULL; } cudaSetDevice(g); CHECK_CUDA_ERR unsigned long FL321_sz = PyArray_NBYTES(FL321_in); if(FL321s_c[g] != 0){ cudaFree(FL321s_c[g]); } cudaMalloc((void**) &FL321s_c[g], FL321_sz); CHECK_CUDA_ERR FL321 = (float *) FL321_in -> data; N_Cs[g] = PyArray_DIM(FL321_in, 0); n_inds_FL321[g] = PyArray_DIM(FL321_in, 1); cudaMemcpy(FL321s_c[g], FL321, FL321_sz, cudaMemcpyHostToDevice); CHECK_CUDA_ERR Py_INCREF(Py_None); return Py_None; }
static PyObject * do_get_segment_data (PyObject *self, PyObject *args, PyObject *kwds) { NsLibrary *lib; PyObject *cobj; PyObject *iobj, *id_obj, *idx_obj, *sz_obj, *src_obj; PyObject *res_obj; PyObject *array; uint32 file_id; uint32 entity_id; uint32 index; uint32 count; uint32 sources; uint32 sample_count; uint32 uint_id; uint32 buffer_size; ns_RESULT res; double *buffer; npy_intp dims[2]; double time_stamp; if (!PyArg_ParseTuple (args, "OOOOOO", &cobj, &iobj, &id_obj, &idx_obj, &src_obj, &sz_obj)) { PyErr_SetString (PyExc_StandardError, "Could not parse arguments"); return NULL; } if (!PyCObject_Check (cobj) || !PyInt_Check (iobj) || !PyInt_Check (id_obj) || !PyInt_Check (idx_obj) || !PyInt_Check (sz_obj) || !PyInt_Check (src_obj)) { PyErr_SetString (PyExc_TypeError, "Wrong argument type(s)"); return NULL; } lib = PyCObject_AsVoidPtr (cobj); file_id = (uint32) PyInt_AsUnsignedLongMask (iobj); entity_id = (uint32) PyInt_AsUnsignedLongMask (id_obj); index = (uint32) PyInt_AsUnsignedLongMask (idx_obj); count = (uint32) PyInt_AsUnsignedLongMask (sz_obj); sources = (uint32) PyInt_AsUnsignedLongMask (src_obj); /* ** */ dims[0] = sources; //source count dims[1] = count; //sample count array = PyArray_New (&PyArray_Type, 2, dims, NPY_DOUBLE, NULL, NULL /* data */, 0 /* itemsize */, 0, NULL); buffer = (double *) PyArray_DATA (array); buffer_size = (uint32) PyArray_NBYTES (array); res = lib->GetSegmentData (file_id, entity_id, index, &time_stamp, buffer, buffer_size, &sample_count, &uint_id); if (check_result_is_error (res, lib)) { Py_DECREF (array); return NULL; } res_obj = PyTuple_New (4); PyTuple_SetItem (res_obj, 0, array); PyTuple_SetItem (res_obj, 1, PyFloat_FromDouble (time_stamp)); PyTuple_SetItem (res_obj, 2, PyInt_FromLong (sample_count)); PyTuple_SetItem (res_obj, 3, PyInt_FromLong (uint_id)); return res_obj; }
static PyObject * dotblas_matrixproduct(PyObject *dummy, PyObject *args) { PyObject *op1, *op2; PyArrayObject *ap1=NULL, *ap2=NULL, *ret=NULL; int j, l, lda, ldb, ldc; int typenum, nd; intp ap1stride=0; intp dimensions[MAX_DIMS]; intp numbytes; static const float oneF[2] = {1.0, 0.0}; static const float zeroF[2] = {0.0, 0.0}; static const double oneD[2] = {1.0, 0.0}; static const double zeroD[2] = {0.0, 0.0}; double prior1, prior2; PyTypeObject *subtype; PyArray_Descr *dtype; MatrixShape ap1shape, ap2shape; if (!PyArg_ParseTuple(args, "OO", &op1, &op2)) return NULL; /* * "Matrix product" using the BLAS. * Only works for float double and complex types. */ typenum = PyArray_ObjectType(op1, 0); typenum = PyArray_ObjectType(op2, typenum); /* This function doesn't handle other types */ if ((typenum != PyArray_DOUBLE && typenum != PyArray_CDOUBLE && typenum != PyArray_FLOAT && typenum != PyArray_CFLOAT)) { return PyArray_Return((PyArrayObject *)PyArray_MatrixProduct(op1, op2)); } dtype = PyArray_DescrFromType(typenum); ap1 = (PyArrayObject *)PyArray_FromAny(op1, dtype, 0, 0, ALIGNED, NULL); if (ap1 == NULL) return NULL; Py_INCREF(dtype); ap2 = (PyArrayObject *)PyArray_FromAny(op2, dtype, 0, 0, ALIGNED, NULL); if (ap2 == NULL) goto fail; if ((ap1->nd > 2) || (ap2->nd > 2)) { /* This function doesn't handle dimensions greater than 2 (or negative striding) -- other than to ensure the dot function is altered */ if (!altered) { /* need to alter dot product */ PyObject *tmp1, *tmp2; tmp1 = PyTuple_New(0); tmp2 = dotblas_alterdot(NULL, tmp1); Py_DECREF(tmp1); Py_DECREF(tmp2); } ret = (PyArrayObject *)PyArray_MatrixProduct((PyObject *)ap1, (PyObject *)ap2); Py_DECREF(ap1); Py_DECREF(ap2); return PyArray_Return(ret); } if (_bad_strides(ap1)) { op1 = PyArray_NewCopy(ap1, PyArray_ANYORDER); Py_DECREF(ap1); ap1 = (PyArrayObject *)op1; if (ap1 == NULL) goto fail; } if (_bad_strides(ap2)) { op2 = PyArray_NewCopy(ap2, PyArray_ANYORDER); Py_DECREF(ap2); ap2 = (PyArrayObject *)op2; if (ap2 == NULL) goto fail; } ap1shape = _select_matrix_shape(ap1); ap2shape = _select_matrix_shape(ap2); if (ap1shape == _scalar || ap2shape == _scalar) { PyArrayObject *oap1, *oap2; oap1 = ap1; oap2 = ap2; /* One of ap1 or ap2 is a scalar */ if (ap1shape == _scalar) { /* Make ap2 the scalar */ PyArrayObject *t = ap1; ap1 = ap2; ap2 = t; ap1shape = ap2shape; ap2shape = _scalar; } if (ap1shape == _row) ap1stride = ap1->strides[1]; else if (ap1->nd > 0) ap1stride = ap1->strides[0]; if (ap1->nd == 0 || ap2->nd == 0) { intp *thisdims; if (ap1->nd == 0) { nd = ap2->nd; thisdims = ap2->dimensions; } else { nd = ap1->nd; thisdims = ap1->dimensions; } l = 1; for (j=0; j<nd; j++) { dimensions[j] = thisdims[j]; l *= dimensions[j]; } } else { l = oap1->dimensions[oap1->nd-1]; if (oap2->dimensions[0] != l) { PyErr_SetString(PyExc_ValueError, "matrices are not aligned"); goto fail; } nd = ap1->nd + ap2->nd - 2; /* nd = 0 or 1 or 2 */ /* If nd == 0 do nothing ... */ if (nd == 1) { /* Either ap1->nd is 1 dim or ap2->nd is 1 dim and the other is 2-dim */ dimensions[0] = (oap1->nd == 2) ? oap1->dimensions[0] : oap2->dimensions[1]; l = dimensions[0]; /* Fix it so that dot(shape=(N,1), shape=(1,)) and dot(shape=(1,), shape=(1,N)) both return an (N,) array (but use the fast scalar code) */ } else if (nd == 2) { dimensions[0] = oap1->dimensions[0]; dimensions[1] = oap2->dimensions[1]; /* We need to make sure that dot(shape=(1,1), shape=(1,N)) and dot(shape=(N,1),shape=(1,1)) uses scalar multiplication appropriately */ if (ap1shape == _row) l = dimensions[1]; else l = dimensions[0]; } } } else { /* (ap1->nd <= 2 && ap2->nd <= 2) */ /* Both ap1 and ap2 are vectors or matrices */ l = ap1->dimensions[ap1->nd-1]; if (ap2->dimensions[0] != l) { PyErr_SetString(PyExc_ValueError, "matrices are not aligned"); goto fail; } nd = ap1->nd+ap2->nd-2; if (nd == 1) dimensions[0] = (ap1->nd == 2) ? ap1->dimensions[0] : ap2->dimensions[1]; else if (nd == 2) { dimensions[0] = ap1->dimensions[0]; dimensions[1] = ap2->dimensions[1]; } } /* Choose which subtype to return */ if (ap1->ob_type != ap2->ob_type) { prior2 = PyArray_GetPriority((PyObject *)ap2, 0.0); prior1 = PyArray_GetPriority((PyObject *)ap1, 0.0); subtype = (prior2 > prior1 ? ap2->ob_type : ap1->ob_type); } else { prior1 = prior2 = 0.0; subtype = ap1->ob_type; } ret = (PyArrayObject *)PyArray_New(subtype, nd, dimensions, typenum, NULL, NULL, 0, 0, (PyObject *) (prior2 > prior1 ? ap2 : ap1)); if (ret == NULL) goto fail; numbytes = PyArray_NBYTES(ret); memset(ret->data, 0, numbytes); if (numbytes==0 || l == 0) { Py_DECREF(ap1); Py_DECREF(ap2); return PyArray_Return(ret); } if (ap2shape == _scalar) { /* Multiplication by a scalar -- Level 1 BLAS */ /* if ap1shape is a matrix and we are not contiguous, then we can't just blast through the entire array using a single striding factor */ NPY_BEGIN_ALLOW_THREADS if (typenum == PyArray_DOUBLE) { if (l == 1) { *((double *)ret->data) = *((double *)ap2->data) * \ *((double *)ap1->data); } else if (ap1shape != _matrix) { cblas_daxpy(l, *((double *)ap2->data), (double *)ap1->data, ap1stride/sizeof(double), (double *)ret->data, 1); } else { int maxind, oind, i, a1s, rets; char *ptr, *rptr; double val; maxind = (ap1->dimensions[0] >= ap1->dimensions[1] ? 0 : 1); oind = 1-maxind; ptr = ap1->data; rptr = ret->data; l = ap1->dimensions[maxind]; val = *((double *)ap2->data); a1s = ap1->strides[maxind] / sizeof(double); rets = ret->strides[maxind] / sizeof(double); for (i=0; i < ap1->dimensions[oind]; i++) { cblas_daxpy(l, val, (double *)ptr, a1s, (double *)rptr, rets); ptr += ap1->strides[oind]; rptr += ret->strides[oind]; } } } else if (typenum == PyArray_CDOUBLE) { if (l == 1) { cdouble *ptr1, *ptr2, *res; ptr1 = (cdouble *)ap2->data; ptr2 = (cdouble *)ap1->data; res = (cdouble *)ret->data; res->real = ptr1->real * ptr2->real - ptr1->imag * ptr2->imag; res->imag = ptr1->real * ptr2->imag + ptr1->imag * ptr2->real; } else if (ap1shape != _matrix) { cblas_zaxpy(l, (double *)ap2->data, (double *)ap1->data, ap1stride/sizeof(cdouble), (double *)ret->data, 1); } else { int maxind, oind, i, a1s, rets; char *ptr, *rptr; double *pval; maxind = (ap1->dimensions[0] >= ap1->dimensions[1] ? 0 : 1); oind = 1-maxind; ptr = ap1->data; rptr = ret->data; l = ap1->dimensions[maxind]; pval = (double *)ap2->data; a1s = ap1->strides[maxind] / sizeof(cdouble); rets = ret->strides[maxind] / sizeof(cdouble); for (i=0; i < ap1->dimensions[oind]; i++) { cblas_zaxpy(l, pval, (double *)ptr, a1s, (double *)rptr, rets); ptr += ap1->strides[oind]; rptr += ret->strides[oind]; } } } else if (typenum == PyArray_FLOAT) { if (l == 1) { *((float *)ret->data) = *((float *)ap2->data) * \ *((float *)ap1->data); } else if (ap1shape != _matrix) { cblas_saxpy(l, *((float *)ap2->data), (float *)ap1->data, ap1stride/sizeof(float), (float *)ret->data, 1); } else { int maxind, oind, i, a1s, rets; char *ptr, *rptr; float val; maxind = (ap1->dimensions[0] >= ap1->dimensions[1] ? 0 : 1); oind = 1-maxind; ptr = ap1->data; rptr = ret->data; l = ap1->dimensions[maxind]; val = *((float *)ap2->data); a1s = ap1->strides[maxind] / sizeof(float); rets = ret->strides[maxind] / sizeof(float); for (i=0; i < ap1->dimensions[oind]; i++) { cblas_saxpy(l, val, (float *)ptr, a1s, (float *)rptr, rets); ptr += ap1->strides[oind]; rptr += ret->strides[oind]; } } } else if (typenum == PyArray_CFLOAT) { if (l == 1) { cfloat *ptr1, *ptr2, *res; ptr1 = (cfloat *)ap2->data; ptr2 = (cfloat *)ap1->data; res = (cfloat *)ret->data; res->real = ptr1->real * ptr2->real - ptr1->imag * ptr2->imag; res->imag = ptr1->real * ptr2->imag + ptr1->imag * ptr2->real; } else if (ap1shape != _matrix) { cblas_caxpy(l, (float *)ap2->data, (float *)ap1->data, ap1stride/sizeof(cfloat), (float *)ret->data, 1); } else { int maxind, oind, i, a1s, rets; char *ptr, *rptr; float *pval; maxind = (ap1->dimensions[0] >= ap1->dimensions[1] ? 0 : 1); oind = 1-maxind; ptr = ap1->data; rptr = ret->data; l = ap1->dimensions[maxind]; pval = (float *)ap2->data; a1s = ap1->strides[maxind] / sizeof(cfloat); rets = ret->strides[maxind] / sizeof(cfloat); for (i=0; i < ap1->dimensions[oind]; i++) { cblas_caxpy(l, pval, (float *)ptr, a1s, (float *)rptr, rets); ptr += ap1->strides[oind]; rptr += ret->strides[oind]; } } } NPY_END_ALLOW_THREADS }
static mxArray *makeMxFromNumeric(const PyArrayObject *pSrc, bool &is_reference) { npy_intp lRows=0, lCols=0; bool lIsComplex; bool lIsNotAMatrix = false; double *lR = NULL; double *lI = NULL; mxArray *lRetval = NULL; mwSize dims[NPY_MAXDIMS]; mwSize dimsEmpty [2]; memset(&dimsEmpty, 0, 2 * sizeof(mwSize)); mwSize nDims = pSrc->nd; const PyArrayObject *ap=NULL; mxClassID classID = mxUNKNOWN_CLASS; switch (pSrc->nd) { case 0: // XXX the evil 0D lRows = 1; lCols = 1; lIsNotAMatrix = true; break; case 1: lRows = pSrc->dimensions[0]; lCols = min(1, lRows); // for array([]): to avoid zeros((0,1)) ! lIsNotAMatrix = true; break; default: for (mwSize i = 0;i != nDims; i++) { dims[i]=(mwSize)pSrc->dimensions[i]; } break; } switch (pSrc->descr->type_num) { case PyArray_OBJECT: PyErr_SetString(PyExc_TypeError, "Non-numeric array types not supported"); return NULL; case PyArray_CFLOAT: case PyArray_CDOUBLE: lIsComplex = true; break; default: lIsComplex = false; } // converts to fortran order if not already if(!PyArray_ISFORTRAN(pSrc)){ ap = (PyArrayObject * const)PyArray_FromArray((PyArrayObject*)pSrc,NULL,NPY_ALIGNED|NPY_F_CONTIGUOUS); } else{ ap = pSrc; } if(lIsNotAMatrix) lRetval = mxCreateDoubleMatrix(lRows, lCols, lIsComplex ? mxCOMPLEX : mxREAL); else { switch (ap->descr->type_num) { case PyArray_CFLOAT: case PyArray_CDOUBLE: classID = mxDOUBLE_CLASS; is_reference = false; break; case PyArray_BOOL: classID = mxLOGICAL_CLASS; is_reference = true; break; case PyArray_CHAR: classID = mxCHAR_CLASS; is_reference = true; break; case PyArray_DOUBLE: classID = mxDOUBLE_CLASS; is_reference = true; break; case PyArray_FLOAT: classID = mxSINGLE_CLASS; is_reference = true; break; case PyArray_INT8: classID = mxINT8_CLASS; is_reference = true; break; case PyArray_UINT8: classID = mxUINT8_CLASS; is_reference = true; break; case PyArray_INT16: classID = mxINT16_CLASS; is_reference = true; break; case PyArray_UINT16: classID = mxUINT16_CLASS; is_reference = true; break; case PyArray_INT32: classID = mxINT32_CLASS; is_reference = true; break; case PyArray_UINT32: classID = mxUINT32_CLASS; is_reference = true; break; #ifdef NPY_INT64 case PyArray_INT64: classID = mxINT64_CLASS; is_reference = true; break; case PyArray_UINT64: classID = mxUINT64_CLASS; is_reference = true; break; #endif } if (!is_reference) { lRetval = mxCreateNumericArray(nDims,dims,classID,lIsComplex ? mxCOMPLEX : mxREAL); } else { /* // code for create and mxArray ref on the numpy object lRetval = mxCreateNumericArray(2, dimsEmpty, classID, lIsComplex ? mxCOMPLEX : mxREAL); if (mxSetDimensions(lRetval, dims, nDims) == 1) { // failed to reset the dimensions mxDestroyArray(lRetval); lRetval = NULL; } else { mxSetData(lRetval, PyArray_DATA(ap)); } */ // uses memcopy for faster copying is_reference = false; lRetval = mxCreateNumericArray(nDims, dims, classID, lIsComplex ? mxCOMPLEX : mxREAL); // this is a sanity check, it should not fail int matlab_nbytes = mxGetNumberOfElements(lRetval) * mxGetElementSize(lRetval); if (matlab_nbytes == PyArray_NBYTES(pSrc)) { memcpy(mxGetData(lRetval), PyArray_DATA(ap), PyArray_NBYTES(pSrc)); } else { PyErr_SetString(PyExc_TypeError, "Number of bytes do not match"); } } } if (lRetval == NULL) return NULL; lR = mxGetPr(lRetval); lI = mxGetPi(lRetval); if (lIsNotAMatrix) { void *p = PyArray_DATA(ap); switch (ap->descr->type_num) { case PyArray_CHAR: copyNumericVector2Mx((char *)(p), lRows, lR, pSrc->strides); break; case PyArray_UBYTE: copyNumericVector2Mx((unsigned char *)(p), lRows, lR, pSrc->strides); break; case PyArray_SBYTE: copyNumericVector2Mx((signed char *)(p), lRows, lR, pSrc->strides); break; case PyArray_SHORT: copyNumericVector2Mx((short *)(p), lRows, lR, pSrc->strides); break; case PyArray_INT: copyNumericVector2Mx((int *)(p), lRows, lR, pSrc->strides); break; case PyArray_LONG: copyNumericVector2Mx((long *)(p), lRows, lR, pSrc->strides); break; case PyArray_FLOAT: copyNumericVector2Mx((float *)(p), lRows, lR, pSrc->strides); break; case PyArray_DOUBLE: copyNumericVector2Mx((double *)(p), lRows, lR, pSrc->strides); break; case PyArray_CFLOAT: copyCplxNumericVector2Mx((float *)(p), lRows, lR, lI, pSrc->strides); break; case PyArray_CDOUBLE: copyCplxNumericVector2Mx((double *)(p), lRows, lR, lI, pSrc->strides); break; } } else { void *p = PyArray_DATA(ap); npy_intp size = PyArray_SIZE(pSrc); switch (pSrc->descr->type_num) { case PyArray_CFLOAT: copyCplxNumeric2Mx((float *)p,size,lR,lI); break; case PyArray_CDOUBLE: copyCplxNumeric2Mx((double *)p,size,lR,lI); break; } } if(ap != pSrc){ Py_DECREF(const_cast<PyArrayObject *>(ap)); } return lRetval; }
/* * Retrieving buffers for ndarray */ static int array_getbuffer(PyObject *obj, Py_buffer *view, int flags) { PyArrayObject *self; _buffer_info_t *info = NULL; self = (PyArrayObject*)obj; /* Check whether we can provide the wanted properties */ if ((flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS && !PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) { PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous"); goto fail; } if ((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS && !PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)) { PyErr_SetString(PyExc_ValueError, "ndarray is not Fortran contiguous"); goto fail; } if ((flags & PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS && !PyArray_ISONESEGMENT(self)) { PyErr_SetString(PyExc_ValueError, "ndarray is not contiguous"); goto fail; } if ((flags & PyBUF_STRIDES) != PyBUF_STRIDES && !PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) { /* Non-strided N-dim buffers must be C-contiguous */ PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous"); goto fail; } if ((flags & PyBUF_WRITEABLE) == PyBUF_WRITEABLE) { if (PyArray_FailUnlessWriteable(self, "buffer source array") < 0) { goto fail; } } /* * If a read-only buffer is requested on a read-write array, we return a * read-write buffer, which is dubious behavior. But that's why this call * is guarded by PyArray_ISWRITEABLE rather than (flags & * PyBUF_WRITEABLE). */ if (PyArray_ISWRITEABLE(self)) { if (array_might_be_written(self) < 0) { goto fail; } } if (view == NULL) { PyErr_SetString(PyExc_ValueError, "NULL view in getbuffer"); goto fail; } /* Fill in information */ info = _buffer_get_info(obj); if (info == NULL) { goto fail; } view->buf = PyArray_DATA(self); view->suboffsets = NULL; view->itemsize = PyArray_ITEMSIZE(self); view->readonly = !PyArray_ISWRITEABLE(self); view->internal = NULL; view->len = PyArray_NBYTES(self); if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) { view->format = info->format; } else { view->format = NULL; } if ((flags & PyBUF_ND) == PyBUF_ND) { view->ndim = info->ndim; view->shape = info->shape; } else { view->ndim = 0; view->shape = NULL; } if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) { view->strides = info->strides; #ifdef NPY_RELAXED_STRIDES_CHECKING /* * If NPY_RELAXED_STRIDES_CHECKING is on, the array may be * contiguous, but it won't look that way to Python when it * tries to determine contiguity by looking at the strides * (since one of the elements may be -1). In that case, just * regenerate strides from shape. */ if (PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS) && !((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS)) { Py_ssize_t sd = view->itemsize; int i; for (i = view->ndim-1; i >= 0; --i) { view->strides[i] = sd; sd *= view->shape[i]; } } else if (PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)) { Py_ssize_t sd = view->itemsize; int i; for (i = 0; i < view->ndim; ++i) { view->strides[i] = sd; sd *= view->shape[i]; } } #endif } else { view->strides = NULL; } view->obj = (PyObject*)self; Py_INCREF(self); return 0; fail: return -1; }
/* * Returns input array with values inserted sequentially into places * indicated by the mask */ NPY_NO_EXPORT PyObject * arr_insert(PyObject *NPY_UNUSED(self), PyObject *args, PyObject *kwdict) { PyObject *mask = NULL, *vals = NULL; PyArrayObject *ainput = NULL, *amask = NULL, *avals = NULL, *tmp = NULL; int numvals, totmask, sameshape; char *input_data, *mptr, *vptr, *zero = NULL; int melsize, delsize, nd, objarray, k; npy_intp *instrides, *inshape; static char *kwlist[] = {"input", "mask", "vals", NULL}; if (!PyArg_ParseTupleAndKeywords(args, kwdict, "O&OO", kwlist, PyArray_Converter, &ainput, &mask, &vals)) { goto fail; } amask = (PyArrayObject *)PyArray_FROM_OF(mask, NPY_ARRAY_CARRAY); if (amask == NULL) { goto fail; } /* Cast an object array */ if (PyArray_DESCR(amask)->type_num == NPY_OBJECT) { tmp = (PyArrayObject *)PyArray_Cast(amask, NPY_INTP); if (tmp == NULL) { goto fail; } Py_DECREF(amask); amask = tmp; } sameshape = 1; if (PyArray_NDIM(amask) == PyArray_NDIM(ainput)) { for (k = 0; k < PyArray_NDIM(amask); k++) { if (PyArray_DIMS(amask)[k] != PyArray_DIMS(ainput)[k]) { sameshape = 0; } } } else { /* Test to see if amask is 1d */ if (PyArray_NDIM(amask) != 1) { sameshape = 0; } else if ((PyArray_SIZE(ainput)) != PyArray_SIZE(amask)) { sameshape = 0; } } if (!sameshape) { PyErr_SetString(PyExc_TypeError, "mask array must be 1-d or same shape as input array"); goto fail; } avals = (PyArrayObject *)PyArray_FromObject(vals, PyArray_DESCR(ainput)->type_num, 0, 1); if (avals == NULL) { goto fail; } numvals = PyArray_SIZE(avals); nd = PyArray_NDIM(ainput); input_data = PyArray_DATA(ainput); mptr = PyArray_DATA(amask); melsize = PyArray_DESCR(amask)->elsize; vptr = PyArray_DATA(avals); delsize = PyArray_DESCR(avals)->elsize; zero = PyArray_Zero(amask); if (zero == NULL) { goto fail; } objarray = (PyArray_DESCR(ainput)->type_num == NPY_OBJECT); if (!numvals) { /* nothing to insert! fail unless none of mask is true */ const char *iter = mptr; const char *const last = iter + PyArray_NBYTES(amask); while (iter != last && !memcmp(iter, zero, melsize)) { iter += melsize; } if (iter != last) { PyErr_SetString(PyExc_ValueError, "Cannot insert from an empty array!"); goto fail; } goto finish; } /* Handle zero-dimensional case separately */ if (nd == 0) { if (memcmp(mptr,zero,melsize) != 0) { /* Copy value element over to input array */ memcpy(input_data,vptr,delsize); if (objarray) { Py_INCREF(*((PyObject **)vptr)); } } Py_DECREF(amask); Py_DECREF(avals); PyDataMem_FREE(zero); Py_DECREF(ainput); Py_RETURN_NONE; } totmask = (int) PyArray_SIZE(amask); instrides = PyArray_STRIDES(ainput); inshape = PyArray_DIMS(ainput); if (objarray) { /* object array, need to refcount, can't release the GIL */ arr_insert_loop(mptr, vptr, input_data, zero, PyArray_DATA(avals), melsize, delsize, objarray, totmask, numvals, nd, instrides, inshape); } else { /* No increfs take place in arr_insert_loop, so release the GIL */ NPY_BEGIN_ALLOW_THREADS; arr_insert_loop(mptr, vptr, input_data, zero, PyArray_DATA(avals), melsize, delsize, objarray, totmask, numvals, nd, instrides, inshape); NPY_END_ALLOW_THREADS; } finish: Py_DECREF(amask); Py_DECREF(avals); PyDataMem_FREE(zero); Py_DECREF(ainput); Py_RETURN_NONE; fail: PyDataMem_FREE(zero); Py_XDECREF(ainput); Py_XDECREF(amask); Py_XDECREF(avals); return NULL; }
static int array_getbuffer(PyObject *obj, Py_buffer *view, int flags) { PyArrayObject *self; _buffer_info_t *info = NULL; self = (PyArrayObject*)obj; /* Check whether we can provide the wanted properties */ if ((flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS && !PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) { PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous"); goto fail; } if ((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS && !PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)) { PyErr_SetString(PyExc_ValueError, "ndarray is not Fortran contiguous"); goto fail; } if ((flags & PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS && !PyArray_ISONESEGMENT(self)) { PyErr_SetString(PyExc_ValueError, "ndarray is not contiguous"); goto fail; } if ((flags & PyBUF_STRIDES) != PyBUF_STRIDES && (flags & PyBUF_ND) == PyBUF_ND && !PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) { /* Non-strided N-dim buffers must be C-contiguous */ PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous"); goto fail; } if ((flags & PyBUF_WRITEABLE) == PyBUF_WRITEABLE && !PyArray_ISWRITEABLE(self)) { PyErr_SetString(PyExc_ValueError, "ndarray is not writeable"); goto fail; } if (view == NULL) { PyErr_SetString(PyExc_ValueError, "NULL view in getbuffer"); goto fail; } /* Fill in information */ info = _buffer_get_info(obj); if (info == NULL) { goto fail; } view->buf = PyArray_DATA(self); view->suboffsets = NULL; view->itemsize = PyArray_ITEMSIZE(self); view->readonly = !PyArray_ISWRITEABLE(self); view->internal = NULL; view->len = PyArray_NBYTES(self); if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) { view->format = info->format; } else { view->format = NULL; } if ((flags & PyBUF_ND) == PyBUF_ND) { view->ndim = info->ndim; view->shape = info->shape; } else { view->ndim = 0; view->shape = NULL; } if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) { view->strides = info->strides; } else { view->strides = NULL; } view->obj = (PyObject*)self; Py_INCREF(self); return 0; fail: return -1; }
void _PyArray_FILLWBYTE(PyObject* obj, int val) { memset(PyArray_DATA(obj), val, PyArray_NBYTES(obj)); }
static int array_getbuffer(PyObject *obj, Py_buffer *view, int flags) { PyArrayObject *self; _buffer_info_t *info = NULL; self = (PyArrayObject*)obj; /* Check whether we can provide the wanted properties */ if ((flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS && !PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) { PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous"); goto fail; } if ((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS && !PyArray_CHKFLAGS(self, NPY_ARRAY_F_CONTIGUOUS)) { PyErr_SetString(PyExc_ValueError, "ndarray is not Fortran contiguous"); goto fail; } if ((flags & PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS && !PyArray_ISONESEGMENT(self)) { PyErr_SetString(PyExc_ValueError, "ndarray is not contiguous"); goto fail; } if ((flags & PyBUF_STRIDES) != PyBUF_STRIDES && !PyArray_CHKFLAGS(self, NPY_ARRAY_C_CONTIGUOUS)) { /* Non-strided N-dim buffers must be C-contiguous */ PyErr_SetString(PyExc_ValueError, "ndarray is not C-contiguous"); goto fail; } if ((flags & PyBUF_WRITEABLE) == PyBUF_WRITEABLE) { if (PyArray_FailUnlessWriteable(self, "buffer source array") < 0) { goto fail; } } /* * If a read-only buffer is requested on a read-write array, we return a * read-write buffer, which is dubious behavior. But that's why this call * is guarded by PyArray_ISWRITEABLE rather than (flags & * PyBUF_WRITEABLE). */ if (PyArray_ISWRITEABLE(self)) { if (array_might_be_written(self) < 0) { goto fail; } } if (view == NULL) { PyErr_SetString(PyExc_ValueError, "NULL view in getbuffer"); goto fail; } /* Fill in information */ info = _buffer_get_info(obj); if (info == NULL) { goto fail; } view->buf = PyArray_DATA(self); view->suboffsets = NULL; view->itemsize = PyArray_ITEMSIZE(self); view->readonly = !PyArray_ISWRITEABLE(self); view->internal = NULL; view->len = PyArray_NBYTES(self); if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) { view->format = info->format; } else { view->format = NULL; } if ((flags & PyBUF_ND) == PyBUF_ND) { view->ndim = info->ndim; view->shape = info->shape; } else { view->ndim = 0; view->shape = NULL; } if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) { view->strides = info->strides; } else { view->strides = NULL; } view->obj = (PyObject*)self; Py_INCREF(self); return 0; fail: return -1; }
int getNBytes( void* arr ) { return (int) PyArray_NBYTES( arr ); }
static PyObject * enz_vnmpocnp(PyObject *self, PyObject *args, PyObject *keywds) { static char *kwlist[] = { "r", "f", "n", "m", "L_max", "bessel_name", "ncpus", "verb", NULL }; long syscpus = sysconf(_SC_NPROCESSORS_ONLN); PyObject *r_o, *f_o, *n_o, *m_o; PyObject *r = NULL; PyObject *f = NULL; PyObject *n = NULL; PyObject *m = NULL; const char *error = NULL; npy_intp r_n, f_n, beta_n; PyObject *vnm = NULL; npy_intp vnm_dims[3]; double *datar = NULL; complex double *dataf = NULL; int *datan = NULL; int *datam = NULL; complex double *datap = NULL; int kL_max = 35; int kncpus = -1; int kverb = 0; char *kbessel_name = "jn"; int ret; if (syscpus <= 0) syscpus = 1; if (!PyArg_ParseTupleAndKeywords(args, keywds, "O!O!O!O!|isii", kwlist, &PyArray_Type, &r_o, &PyArray_Type, &f_o, &PyArray_Type, &n_o, &PyArray_Type, &m_o, &kL_max, &kbessel_name, &kncpus, &kverb)) { PyErr_SetString(PyExc_SyntaxError, "failed to parse args"); return NULL; } r = PyArray_FROM_OTF(r_o, NPY_FLOAT64, NPY_ARRAY_IN_ARRAY); f = PyArray_FROM_OTF(f_o, NPY_COMPLEX128, NPY_ARRAY_IN_ARRAY); n = PyArray_FROM_OTF(n_o, NPY_INT64, NPY_ARRAY_IN_ARRAY); m = PyArray_FROM_OTF(m_o, NPY_INT64, NPY_ARRAY_IN_ARRAY); if (!r) { PyErr_SetString(PyExc_ValueError, "cannot convert r to PyArray"); return NULL; } if (!f) { PyErr_SetString(PyExc_ValueError, "cannot convert f to PyArray"); return NULL; } if (!n) { PyErr_SetString(PyExc_ValueError, "cannot convert n to PyArray"); return NULL; } if (!m) { PyErr_SetString(PyExc_ValueError, "cannot convert m to PyArray"); return NULL; } if (!r || not_vect(r) || PyArray_TYPE((PyArrayObject*)r) != NPY_FLOAT64) { error = "r is not a vector of doubles"; goto exit_decrement; } r_n = PyArray_DIM((PyArrayObject*)r, 0); if (!f || not_vect(f) || PyArray_TYPE((PyArrayObject*)f) != NPY_COMPLEX128) { error = "f is not a vector of complex numbers"; goto exit_decrement; } f_n = PyArray_DIM((PyArrayObject*)f, 0); if (!n || not_vect(n) || PyArray_TYPE((PyArrayObject*)n) != NPY_INT64) { error = "n is not a vector of integers"; goto exit_decrement; } if (!m || not_vect(m) || PyArray_TYPE((PyArrayObject*)m) != NPY_INT64) { error = "m is not a vector of integers"; goto exit_decrement; } if (PyArray_DIM((PyArrayObject*)n, 0) != PyArray_DIM((PyArrayObject*)m, 0)) { error = "n and m must have the same length"; goto exit_decrement; } beta_n = PyArray_DIM((PyArrayObject*)n, 0); vnm_dims[0] = r_n; vnm_dims[1] = f_n; vnm_dims[2] = beta_n; vnm = PyArray_New(&PyArray_Type, 3, vnm_dims, NPY_COMPLEX128, NULL, NULL, 0, NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED, NULL); if (!vnm) { error = "cannot create vnm"; goto exit_decrement; } PyArray_CLEARFLAGS((PyArrayObject*)vnm, NPY_ARRAY_C_CONTIGUOUS); assert(PyArray_Size(vnm) == (r_n * f_n * beta_n)); assert(PyArray_NBYTES(vnm) == (r_n * f_n * beta_n * sizeof(double complex))); datap = PyArray_DATA((PyArrayObject*)vnm); if (kncpus < 0) kncpus = beta_n < syscpus ? beta_n : syscpus; else kncpus = kncpus > syscpus ? syscpus : kncpus; if ((r_n * f_n * beta_n) != 0) { datar = PyArray_DATA((PyArrayObject*)r); dataf = PyArray_DATA((PyArrayObject*)f); datan = PyArray_DATA((PyArrayObject*)n); datam = PyArray_DATA((PyArrayObject*)m); Py_BEGIN_ALLOW_THREADS ret = vnmpocnp(r_n, datar, f_n, dataf, beta_n, datan, datam, kL_max, kbessel_name, kncpus, kverb, datap, &error); Py_END_ALLOW_THREADS if (ret) { Py_XDECREF(vnm); goto exit_decrement; } }
int _PyArray_CopyInto(PyArrayObject* dest, PyArrayObject* src) { memcpy(PyArray_DATA(dest), PyArray_DATA(src), PyArray_NBYTES(dest)); return 0; }