static PyObject *IIRsymorder2(PyObject *NPY_UNUSED(dummy), PyObject *args)
{
PyObject *sig=NULL;
PyArrayObject *a_sig=NULL, *out=NULL;
double r, omega;
double precision = -1.0;
int thetype, N, ret;
npy_intp outstrides, instrides;
if (!PyArg_ParseTuple(args, "Odd|d", &sig, &r, &omega, &precision))
return NULL;
thetype = PyArray_ObjectType(sig, PyArray_FLOAT);
thetype = NPY_MIN(thetype, PyArray_DOUBLE);
a_sig = (PyArrayObject *)PyArray_FromObject(sig, thetype, 1, 1);
if ((a_sig == NULL)) goto fail;
out = (PyArrayObject *)PyArray_SimpleNew(1,DIMS(a_sig),thetype);
if (out == NULL) goto fail;
N = DIMS(a_sig)[0];
convert_strides(STRIDES(a_sig), &instrides, ELSIZE(a_sig), 1);
outstrides = 1;
switch (thetype) {
case PyArray_FLOAT:
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-6;
ret = S_IIR_forback2 (r, omega, (float *)DATA(a_sig),
(float *)DATA(out), N,
instrides, outstrides, precision);
break;
case PyArray_DOUBLE:
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-11;
ret = D_IIR_forback2 (r, omega, (double *)DATA(a_sig),
(double *)DATA(out), N,
instrides, outstrides, precision);
break;
default:
PYERR("Incorrect type.");
}
if (ret < 0) PYERR("Problem occured inside routine.");
Py_DECREF(a_sig);
return PyArray_Return(out);
fail:
Py_XDECREF(a_sig);
Py_XDECREF(out);
return NULL;
}
static void* convertible(PyObject *obj_ptr)
{
// Check for a null pointer.
if(!obj_ptr)
{
//THROW_TYPE_ERROR("PyObject pointer was null");
return 0;
}
// Make sure this is a numpy array.
if (!PyArray_Check(obj_ptr))
{
//THROW_TYPE_ERROR("Conversion is only defined for numpy array and matrix types");
return 0;
}
// Check the type of the array.
int npyType = PyArray_ObjectType(obj_ptr, 0);
if(!TypeToNumPy<scalar_t>::canConvert(npyType))
{
//THROW_TYPE_ERROR("Can not convert " << npyArrayTypeString(obj_ptr) << " to " << toString()
// << ". Mismatched types.");
return 0;
}
// Check the array dimensions.
int nd = PyArray_NDIM(obj_ptr);
if(nd != 1 && nd != 2)
{
THROW_TYPE_ERROR("Conversion is only valid for arrays with 1 or 2 dimensions. Argument has " << nd << " dimensions");
}
if(nd == 1)
{
checkVectorSizes(obj_ptr);
}
else
{
// Two-dimensional matrix type.
checkMatrixSizes(obj_ptr);
}
return obj_ptr;
}
static PyObject *qspline2d(PyObject *NPY_UNUSED(dummy), PyObject *args)
{
PyObject *image=NULL;
PyArrayObject *a_image=NULL, *ck=NULL;
double lambda = 0.0;
double precision = -1.0;
int thetype, M, N, retval=0;
npy_intp outstrides[2], instrides[2];
if (!PyArg_ParseTuple(args, "O|dd", &image, &lambda, &precision)) return NULL;
if (lambda != 0.0) PYERR("Smoothing spline not yet implemented.");
thetype = PyArray_ObjectType(image, PyArray_FLOAT);
thetype = NPY_MIN(thetype, PyArray_DOUBLE);
a_image = (PyArrayObject *)PyArray_FromObject(image, thetype, 2, 2);
if (a_image == NULL) goto fail;
ck = (PyArrayObject *)PyArray_SimpleNew(2,DIMS(a_image),thetype);
if (ck == NULL) goto fail;
M = DIMS(a_image)[0];
N = DIMS(a_image)[1];
convert_strides(STRIDES(a_image), instrides, ELSIZE(a_image), 2);
outstrides[0] = N;
outstrides[1] = 1;
if (thetype == PyArray_FLOAT) {
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-3;
retval = S_quadratic_spline2D((float *)DATA(a_image), (float *)DATA(ck), M, N, lambda, instrides, outstrides, precision);
}
else if (thetype == PyArray_DOUBLE) {
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-6;
retval = D_quadratic_spline2D((double *)DATA(a_image), (double *)DATA(ck), M, N, lambda, instrides, outstrides, precision);
}
if (retval == -3) PYERR("Precision too high. Error did not converge.");
if (retval < 0) PYERR("Problem occured inside routine");
Py_DECREF(a_image);
return PyArray_Return(ck);
fail:
Py_XDECREF(a_image);
Py_XDECREF(ck);
return NULL;
}
inline std::string npyArrayTypeString(PyObject * obj_ptr)
{
std::stringstream ss;
int nd = PyArray_NDIM(obj_ptr);
ss << "numpy.array<" << npyTypeToString(PyArray_ObjectType(obj_ptr, 0)) << ">[";
if(nd > 0)
{
ss << PyArray_DIM(obj_ptr, 0);
for(int i = 1; i < nd; i++)
{
ss << ", " << PyArray_DIM(obj_ptr, i);
}
}
ss << "]";
return ss.str();
}
static PyObject*
test_neighborhood_iterator_oob(PyObject* NPY_UNUSED(self), PyObject* args)
{
PyObject *x, *out, *b1, *b2;
PyArrayObject *ax;
PyArrayIterObject *itx;
int i, typenum, mode1, mode2, st;
npy_intp bounds[NPY_MAXDIMS*2];
PyArrayNeighborhoodIterObject *niterx1, *niterx2;
if (!PyArg_ParseTuple(args, "OOiOi", &x, &b1, &mode1, &b2, &mode2)) {
return NULL;
}
if (!PySequence_Check(b1) || !PySequence_Check(b2)) {
return NULL;
}
typenum = PyArray_ObjectType(x, 0);
ax = (PyArrayObject*)PyArray_FromObject(x, typenum, 1, 10);
if (ax == NULL) {
return NULL;
}
if (PySequence_Size(b1) != 2 * PyArray_NDIM(ax)) {
PyErr_SetString(PyExc_ValueError,
"bounds sequence 1 size not compatible with x input");
goto clean_ax;
}
if (PySequence_Size(b2) != 2 * PyArray_NDIM(ax)) {
PyErr_SetString(PyExc_ValueError,
"bounds sequence 2 size not compatible with x input");
goto clean_ax;
}
out = PyList_New(0);
if (out == NULL) {
goto clean_ax;
}
itx = (PyArrayIterObject*)PyArray_IterNew(x);
if (itx == NULL) {
goto clean_out;
}
/* Compute boundaries for the neighborhood iterator */
for (i = 0; i < 2 * PyArray_NDIM(ax); ++i) {
PyObject* bound;
bound = PySequence_GetItem(b1, i);
if (bounds == NULL) {
goto clean_itx;
}
if (!PyInt_Check(bound)) {
PyErr_SetString(PyExc_ValueError,
"bound not long");
Py_DECREF(bound);
goto clean_itx;
}
bounds[i] = PyInt_AsLong(bound);
Py_DECREF(bound);
}
/* Create the neighborhood iterator */
niterx1 = (PyArrayNeighborhoodIterObject*)PyArray_NeighborhoodIterNew(
(PyArrayIterObject*)itx, bounds,
mode1, NULL);
if (niterx1 == NULL) {
goto clean_out;
}
for (i = 0; i < 2 * PyArray_NDIM(ax); ++i) {
PyObject* bound;
bound = PySequence_GetItem(b2, i);
if (bounds == NULL) {
goto clean_itx;
}
if (!PyInt_Check(bound)) {
PyErr_SetString(PyExc_ValueError,
"bound not long");
Py_DECREF(bound);
goto clean_itx;
}
bounds[i] = PyInt_AsLong(bound);
Py_DECREF(bound);
}
niterx2 = (PyArrayNeighborhoodIterObject*)PyArray_NeighborhoodIterNew(
(PyArrayIterObject*)niterx1, bounds,
mode2, NULL);
if (niterx1 == NULL) {
goto clean_niterx1;
}
switch (typenum) {
case NPY_DOUBLE:
st = copy_double_double(niterx1, niterx2, bounds, &out);
break;
default:
PyErr_SetString(PyExc_ValueError,
"Type not supported");
goto clean_niterx2;
}
if (st) {
goto clean_niterx2;
}
Py_DECREF(niterx2);
Py_DECREF(niterx1);
Py_DECREF(itx);
Py_DECREF(ax);
return out;
clean_niterx2:
Py_DECREF(niterx2);
clean_niterx1:
Py_DECREF(niterx1);
clean_itx:
Py_DECREF(itx);
clean_out:
Py_DECREF(out);
clean_ax:
Py_DECREF(ax);
return NULL;
}
static PyObject*
test_neighborhood_iterator(PyObject* NPY_UNUSED(self), PyObject* args)
{
PyObject *x, *fill, *out, *b;
PyArrayObject *ax, *afill;
PyArrayIterObject *itx;
int i, typenum, mode, st;
npy_intp bounds[NPY_MAXDIMS*2];
PyArrayNeighborhoodIterObject *niterx;
if (!PyArg_ParseTuple(args, "OOOi", &x, &b, &fill, &mode)) {
return NULL;
}
if (!PySequence_Check(b)) {
return NULL;
}
typenum = PyArray_ObjectType(x, 0);
typenum = PyArray_ObjectType(fill, typenum);
ax = (PyArrayObject*)PyArray_FromObject(x, typenum, 1, 10);
if (ax == NULL) {
return NULL;
}
if (PySequence_Size(b) != 2 * PyArray_NDIM(ax)) {
PyErr_SetString(PyExc_ValueError,
"bounds sequence size not compatible with x input");
goto clean_ax;
}
out = PyList_New(0);
if (out == NULL) {
goto clean_ax;
}
itx = (PyArrayIterObject*)PyArray_IterNew(x);
if (itx == NULL) {
goto clean_out;
}
/* Compute boundaries for the neighborhood iterator */
for (i = 0; i < 2 * PyArray_NDIM(ax); ++i) {
PyObject* bound;
bound = PySequence_GetItem(b, i);
if (bounds == NULL) {
goto clean_itx;
}
if (!PyInt_Check(bound)) {
PyErr_SetString(PyExc_ValueError,
"bound not long");
Py_DECREF(bound);
goto clean_itx;
}
bounds[i] = PyInt_AsLong(bound);
Py_DECREF(bound);
}
/* Create the neighborhood iterator */
afill = NULL;
if (mode == NPY_NEIGHBORHOOD_ITER_CONSTANT_PADDING) {
afill = (PyArrayObject *)PyArray_FromObject(fill, typenum, 0, 0);
if (afill == NULL) {
goto clean_itx;
}
}
niterx = (PyArrayNeighborhoodIterObject*)PyArray_NeighborhoodIterNew(
(PyArrayIterObject*)itx, bounds, mode, afill);
if (niterx == NULL) {
goto clean_afill;
}
switch (typenum) {
case NPY_OBJECT:
st = copy_object(itx, niterx, bounds, &out);
break;
case NPY_INT:
st = copy_int(itx, niterx, bounds, &out);
break;
case NPY_DOUBLE:
st = copy_double(itx, niterx, bounds, &out);
break;
default:
PyErr_SetString(PyExc_ValueError,
"Type not supported");
goto clean_niterx;
}
if (st) {
goto clean_niterx;
}
Py_DECREF(niterx);
Py_XDECREF(afill);
Py_DECREF(itx);
Py_DECREF(ax);
return out;
clean_niterx:
Py_DECREF(niterx);
clean_afill:
Py_XDECREF(afill);
clean_itx:
Py_DECREF(itx);
clean_out:
Py_DECREF(out);
clean_ax:
Py_DECREF(ax);
return NULL;
}
static PyObject *IIRsymorder1(PyObject *NPY_UNUSED(dummy), PyObject *args)
{
PyObject *sig=NULL;
PyArrayObject *a_sig=NULL, *out=NULL;
Py_complex c0, z1;
double precision = -1.0;
int thetype, N, ret;
npy_intp outstrides, instrides;
if (!PyArg_ParseTuple(args, "ODD|d", &sig, &c0, &z1, &precision))
return NULL;
thetype = PyArray_ObjectType(sig, PyArray_FLOAT);
thetype = NPY_MIN(thetype, PyArray_CDOUBLE);
a_sig = (PyArrayObject *)PyArray_FromObject(sig, thetype, 1, 1);
if ((a_sig == NULL)) goto fail;
out = (PyArrayObject *)PyArray_SimpleNew(1,DIMS(a_sig),thetype);
if (out == NULL) goto fail;
N = DIMS(a_sig)[0];
convert_strides(STRIDES(a_sig), &instrides, ELSIZE(a_sig), 1);
outstrides = 1;
switch (thetype) {
case PyArray_FLOAT:
{
float rc0 = c0.real;
float rz1 = z1.real;
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-6;
ret = S_IIR_forback1 (rc0, rz1, (float *)DATA(a_sig),
(float *)DATA(out), N,
instrides, outstrides, (float )precision);
}
break;
case PyArray_DOUBLE:
{
double rc0 = c0.real;
double rz1 = z1.real;
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-11;
ret = D_IIR_forback1 (rc0, rz1, (double *)DATA(a_sig),
(double *)DATA(out), N,
instrides, outstrides, precision);
}
break;
#ifdef __GNUC__
case PyArray_CFLOAT:
{
__complex__ float zc0 = c0.real + 1.0i*c0.imag;
__complex__ float zz1 = z1.real + 1.0i*z1.imag;
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-6;
ret = C_IIR_forback1 (zc0, zz1, (__complex__ float *)DATA(a_sig),
(__complex__ float *)DATA(out), N,
instrides, outstrides, (float )precision);
}
break;
case PyArray_CDOUBLE:
{
__complex__ double zc0 = c0.real + 1.0i*c0.imag;
__complex__ double zz1 = z1.real + 1.0i*z1.imag;
if ((precision <= 0.0) || (precision > 1.0)) precision = 1e-11;
ret = Z_IIR_forback1 (zc0, zz1, (__complex__ double *)DATA(a_sig),
(__complex__ double *)DATA(out), N,
instrides, outstrides, precision);
}
break;
#endif
default:
PYERR("Incorrect type.");
}
if (ret == 0) {
Py_DECREF(a_sig);
return PyArray_Return(out);
}
if (ret == -1) PYERR("Could not allocate enough memory.");
if (ret == -2) PYERR("|z1| must be less than 1.0");
if (ret == -3) PYERR("Sum to find symmetric boundary conditions did not converge.");
PYERR("Unknown error.");
fail:
Py_XDECREF(a_sig);
Py_XDECREF(out);
return NULL;
}
static PyObject *FIRsepsym2d(PyObject *NPY_UNUSED(dummy), PyObject *args)
{
PyObject *image=NULL, *hrow=NULL, *hcol=NULL;
PyArrayObject *a_image=NULL, *a_hrow=NULL, *a_hcol=NULL, *out=NULL;
int thetype, M, N, ret;
npy_intp outstrides[2], instrides[2];
if (!PyArg_ParseTuple(args, "OOO", &image, &hrow, &hcol)) return NULL;
thetype = PyArray_ObjectType(image, PyArray_FLOAT);
thetype = NPY_MIN(thetype, PyArray_CDOUBLE);
a_image = (PyArrayObject *)PyArray_FromObject(image, thetype, 2, 2);
a_hrow = (PyArrayObject *)PyArray_ContiguousFromObject(hrow, thetype, 1, 1);
a_hcol = (PyArrayObject *)PyArray_ContiguousFromObject(hcol, thetype, 1, 1);
if ((a_image == NULL) || (a_hrow == NULL) || (a_hcol==NULL)) goto fail;
out = (PyArrayObject *)PyArray_SimpleNew(2,DIMS(a_image),thetype);
if (out == NULL) goto fail;
M = DIMS(a_image)[0];
N = DIMS(a_image)[1];
convert_strides(STRIDES(a_image), instrides, ELSIZE(a_image), 2);
outstrides[0] = N;
outstrides[1] = 1;
switch (thetype) {
case PyArray_FLOAT:
ret = S_separable_2Dconvolve_mirror((float *)DATA(a_image),
(float *)DATA(out), M, N,
(float *)DATA(a_hrow),
(float *)DATA(a_hcol),
DIMS(a_hrow)[0], DIMS(a_hcol)[0],
instrides, outstrides);
break;
case PyArray_DOUBLE:
ret = D_separable_2Dconvolve_mirror((double *)DATA(a_image),
(double *)DATA(out), M, N,
(double *)DATA(a_hrow),
(double *)DATA(a_hcol),
DIMS(a_hrow)[0], DIMS(a_hcol)[0],
instrides, outstrides);
break;
#ifdef __GNUC__
case PyArray_CFLOAT:
ret = C_separable_2Dconvolve_mirror((__complex__ float *)DATA(a_image),
(__complex__ float *)DATA(out), M, N,
(__complex__ float *)DATA(a_hrow),
(__complex__ float *)DATA(a_hcol),
DIMS(a_hrow)[0], DIMS(a_hcol)[0],
instrides, outstrides);
break;
case PyArray_CDOUBLE:
ret = Z_separable_2Dconvolve_mirror((__complex__ double *)DATA(a_image),
(__complex__ double *)DATA(out), M, N,
(__complex__ double *)DATA(a_hrow),
(__complex__ double *)DATA(a_hcol),
DIMS(a_hrow)[0], DIMS(a_hcol)[0],
instrides, outstrides);
break;
#endif
default:
PYERR("Incorrect type.");
}
if (ret < 0) PYERR("Problem occured inside routine.");
Py_DECREF(a_image);
Py_DECREF(a_hrow);
Py_DECREF(a_hcol);
return PyArray_Return(out);
fail:
Py_XDECREF(a_image);
Py_XDECREF(a_hrow);
Py_XDECREF(a_hcol);
Py_XDECREF(out);
return NULL;
}
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
}
