/*NUMPY_API
* Conjugate
*/
NPY_NO_EXPORT PyObject *
PyArray_Conjugate(PyArrayObject *self, PyArrayObject *out)
{
if (PyArray_ISCOMPLEX(self)) {
if (out == NULL) {
return PyArray_GenericUnaryFunction(self,
n_ops.conjugate);
}
else {
return PyArray_GenericBinaryFunction(self,
(PyObject *)out,
n_ops.conjugate);
}
}
else {
PyArrayObject *ret;
if (out) {
if (PyArray_AssignArray(out, self,
NULL, NPY_DEFAULT_ASSIGN_CASTING) < 0) {
return NULL;
}
ret = out;
}
else {
ret = self;
}
Py_INCREF(ret);
return (PyObject *)ret;
}
}
static PyObject *
array_invert(PyArrayObject *m1)
{
if (can_elide_temp_unary(m1)) {
return PyArray_GenericInplaceUnaryFunction(m1, n_ops.invert);
}
return PyArray_GenericUnaryFunction(m1, n_ops.invert);
}
static PyObject *
array_absolute(PyArrayObject *m1)
{
if (can_elide_temp_unary(m1) && !PyArray_ISCOMPLEX(m1)) {
return PyArray_GenericInplaceUnaryFunction(m1, n_ops.absolute);
}
return PyArray_GenericUnaryFunction(m1, n_ops.absolute);
}
/* optimize float array or complex array to a scalar power */
static PyObject *
fast_scalar_power(PyArrayObject *a1, PyObject *o2, int inplace)
{
double exp;
if (PyArray_Check(a1) && array_power_is_scalar(o2, &exp)) {
PyObject *fastop = NULL;
if (PyArray_ISFLOAT(a1) || PyArray_ISCOMPLEX(a1)) {
if (exp == 1.0) {
/* we have to do this one special, as the
"copy" method of array objects isn't set
up early enough to be added
by PyArray_SetNumericOps.
*/
if (inplace) {
Py_INCREF(a1);
return (PyObject *)a1;
} else {
return PyArray_Copy(a1);
}
}
else if (exp == -1.0) {
fastop = n_ops.reciprocal;
}
else if (exp == 0.0) {
fastop = n_ops.ones_like;
}
else if (exp == 0.5) {
fastop = n_ops.sqrt;
}
else if (exp == 2.0) {
fastop = n_ops.square;
}
else {
return NULL;
}
if (inplace) {
return PyArray_GenericInplaceUnaryFunction(a1, fastop);
} else {
return PyArray_GenericUnaryFunction(a1, fastop);
}
}
else if (exp==2.0) {
fastop = n_ops.multiply;
if (inplace) {
return PyArray_GenericInplaceBinaryFunction
(a1, (PyObject *)a1, fastop);
}
else {
return PyArray_GenericBinaryFunction
(a1, (PyObject *)a1, fastop);
}
}
}
return NULL;
}
/*NUMPY_API
* Conjugate
*/
NPY_NO_EXPORT PyObject *
PyArray_Conjugate(PyArrayObject *self, PyArrayObject *out)
{
if (PyArray_ISCOMPLEX(self) || PyArray_ISOBJECT(self) ||
PyArray_ISUSERDEF(self)) {
if (out == NULL) {
return PyArray_GenericUnaryFunction(self,
n_ops.conjugate);
}
else {
return PyArray_GenericBinaryFunction(self,
(PyObject *)out,
n_ops.conjugate);
}
}
else {
PyArrayObject *ret;
if (!PyArray_ISNUMBER(self)) {
/* 2017-05-04, 1.13 */
if (DEPRECATE("attempting to conjugate non-numeric dtype; this "
"will error in the future to match the behavior of "
"np.conjugate") < 0) {
return NULL;
}
}
if (out) {
if (PyArray_AssignArray(out, self,
NULL, NPY_DEFAULT_ASSIGN_CASTING) < 0) {
return NULL;
}
ret = out;
}
else {
ret = self;
}
Py_INCREF(ret);
return (PyObject *)ret;
}
}
/*
* optimize float array or complex array to a scalar power
* returns 0 on success, -1 if no optimization is possible
* the result is in value (can be NULL if an error occurred)
*/
static int
fast_scalar_power(PyArrayObject *a1, PyObject *o2, int inplace,
PyObject **value)
{
double exponent;
NPY_SCALARKIND kind; /* NPY_NOSCALAR is not scalar */
if (PyArray_Check(a1) &&
!PyArray_ISOBJECT(a1) &&
((kind=is_scalar_with_conversion(o2, &exponent))>0)) {
PyObject *fastop = NULL;
if (PyArray_ISFLOAT(a1) || PyArray_ISCOMPLEX(a1)) {
if (exponent == 1.0) {
fastop = n_ops.positive;
}
else if (exponent == -1.0) {
fastop = n_ops.reciprocal;
}
else if (exponent == 0.0) {
fastop = n_ops._ones_like;
}
else if (exponent == 0.5) {
fastop = n_ops.sqrt;
}
else if (exponent == 2.0) {
fastop = n_ops.square;
}
else {
return -1;
}
if (inplace || can_elide_temp_unary(a1)) {
*value = PyArray_GenericInplaceUnaryFunction(a1, fastop);
}
else {
*value = PyArray_GenericUnaryFunction(a1, fastop);
}
return 0;
}
/* Because this is called with all arrays, we need to
* change the output if the kind of the scalar is different
* than that of the input and inplace is not on ---
* (thus, the input should be up-cast)
*/
else if (exponent == 2.0) {
fastop = n_ops.square;
if (inplace) {
*value = PyArray_GenericInplaceUnaryFunction(a1, fastop);
}
else {
/* We only special-case the FLOAT_SCALAR and integer types */
if (kind == NPY_FLOAT_SCALAR && PyArray_ISINTEGER(a1)) {
PyArray_Descr *dtype = PyArray_DescrFromType(NPY_DOUBLE);
a1 = (PyArrayObject *)PyArray_CastToType(a1, dtype,
PyArray_ISFORTRAN(a1));
if (a1 != NULL) {
/* cast always creates a new array */
*value = PyArray_GenericInplaceUnaryFunction(a1, fastop);
Py_DECREF(a1);
}
}
else {
*value = PyArray_GenericUnaryFunction(a1, fastop);
}
}
return 0;
}
}
/* no fast operation found */
return -1;
}
static PyObject *
array_invert(PyArrayObject *m1)
{
return PyArray_GenericUnaryFunction(m1, n_ops.invert);
}
static PyObject *
array_absolute(PyArrayObject *m1)
{
return PyArray_GenericUnaryFunction(m1, n_ops.absolute);
}
static PyObject *
array_negative(PyArrayObject *m1)
{
return PyArray_GenericUnaryFunction(m1, n_ops.negative);
}
/* optimize float array or complex array to a scalar power */
static PyObject *
fast_scalar_power(PyArrayObject *a1, PyObject *o2, int inplace)
{
double exponent;
NPY_SCALARKIND kind; /* NPY_NOSCALAR is not scalar */
if (PyArray_Check(a1) && ((kind=is_scalar_with_conversion(o2, &exponent))>0)) {
PyObject *fastop = NULL;
if (PyArray_ISFLOAT(a1) || PyArray_ISCOMPLEX(a1)) {
if (exponent == 1.0) {
/* we have to do this one special, as the
"copy" method of array objects isn't set
up early enough to be added
by PyArray_SetNumericOps.
*/
if (inplace) {
Py_INCREF(a1);
return (PyObject *)a1;
} else {
return PyArray_Copy(a1);
}
}
else if (exponent == -1.0) {
fastop = n_ops.reciprocal;
}
else if (exponent == 0.0) {
fastop = n_ops._ones_like;
}
else if (exponent == 0.5) {
fastop = n_ops.sqrt;
}
else if (exponent == 2.0) {
fastop = n_ops.square;
}
else {
return NULL;
}
if (inplace) {
return PyArray_GenericInplaceUnaryFunction(a1, fastop);
} else {
return PyArray_GenericUnaryFunction(a1, fastop);
}
}
/* Because this is called with all arrays, we need to
* change the output if the kind of the scalar is different
* than that of the input and inplace is not on ---
* (thus, the input should be up-cast)
*/
else if (exponent == 2.0) {
fastop = n_ops.multiply;
if (inplace) {
return PyArray_GenericInplaceBinaryFunction
(a1, (PyObject *)a1, fastop);
}
else {
PyArray_Descr *dtype = NULL;
PyObject *res;
/* We only special-case the FLOAT_SCALAR and integer types */
if (kind == NPY_FLOAT_SCALAR && PyArray_ISINTEGER(a1)) {
dtype = PyArray_DescrFromType(NPY_DOUBLE);
a1 = (PyArrayObject *)PyArray_CastToType(a1, dtype,
PyArray_ISFORTRAN(a1));
if (a1 == NULL) {
return NULL;
}
}
else {
Py_INCREF(a1);
}
res = PyArray_GenericBinaryFunction(a1, (PyObject *)a1, fastop);
Py_DECREF(a1);
return res;
}
}
}
return NULL;
}
NPY_NO_EXPORT PyObject *
__New_PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject *out,
int variance, int num)
{
PyObject *obj1 = NULL, *obj2 = NULL, *obj3 = NULL;
PyArrayObject *arr1 = NULL, *arr2 = NULL, *arrnew = NULL;
PyObject *ret = NULL, *newshape = NULL;
int i, n;
npy_intp val;
arrnew = (PyArrayObject *)PyArray_CheckAxis(self, &axis, 0);
if (arrnew == NULL) {
return NULL;
}
/* Compute and reshape mean */
arr1 = (PyArrayObject *)PyArray_EnsureAnyArray(
PyArray_Mean(arrnew, axis, rtype, NULL));
if (arr1 == NULL) {
Py_DECREF(arrnew);
return NULL;
}
n = PyArray_NDIM(arrnew);
newshape = PyTuple_New(n);
if (newshape == NULL) {
Py_DECREF(arr1);
Py_DECREF(arrnew);
return NULL;
}
for (i = 0; i < n; i++) {
if (i == axis) {
val = 1;
}
else {
val = PyArray_DIM(arrnew,i);
}
PyTuple_SET_ITEM(newshape, i, PyInt_FromLong((long)val));
}
arr2 = (PyArrayObject *)PyArray_Reshape(arr1, newshape);
Py_DECREF(arr1);
Py_DECREF(newshape);
if (arr2 == NULL) {
Py_DECREF(arrnew);
return NULL;
}
/* Compute x = x - mx */
arr1 = (PyArrayObject *)PyArray_EnsureAnyArray(
PyNumber_Subtract((PyObject *)arrnew, (PyObject *)arr2));
Py_DECREF(arr2);
if (arr1 == NULL) {
Py_DECREF(arrnew);
return NULL;
}
/* Compute x * x */
if (PyArray_ISCOMPLEX(arr1)) {
obj3 = PyArray_Conjugate(arr1, NULL);
}
else {
obj3 = (PyObject *)arr1;
Py_INCREF(arr1);
}
if (obj3 == NULL) {
Py_DECREF(arrnew);
return NULL;
}
arr2 = (PyArrayObject *)PyArray_EnsureAnyArray(
PyArray_GenericBinaryFunction(arr1, obj3, n_ops.multiply));
Py_DECREF(arr1);
Py_DECREF(obj3);
if (arr2 == NULL) {
Py_DECREF(arrnew);
return NULL;
}
if (PyArray_ISCOMPLEX(arr2)) {
obj3 = PyObject_GetAttrString((PyObject *)arr2, "real");
switch(rtype) {
case NPY_CDOUBLE:
rtype = NPY_DOUBLE;
break;
case NPY_CFLOAT:
rtype = NPY_FLOAT;
break;
case NPY_CLONGDOUBLE:
rtype = NPY_LONGDOUBLE;
break;
}
}
else {
obj3 = (PyObject *)arr2;
Py_INCREF(arr2);
}
if (obj3 == NULL) {
Py_DECREF(arrnew);
return NULL;
}
/* Compute add.reduce(x*x,axis) */
obj1 = PyArray_GenericReduceFunction((PyArrayObject *)obj3, n_ops.add,
axis, rtype, NULL);
Py_DECREF(obj3);
Py_DECREF(arr2);
if (obj1 == NULL) {
Py_DECREF(arrnew);
return NULL;
}
n = PyArray_DIM(arrnew,axis);
Py_DECREF(arrnew);
n = (n-num);
if (n == 0) {
n = 1;
}
obj2 = PyFloat_FromDouble(1.0/((double )n));
if (obj2 == NULL) {
Py_DECREF(obj1);
return NULL;
}
ret = PyNumber_Multiply(obj1, obj2);
Py_DECREF(obj1);
Py_DECREF(obj2);
if (!variance) {
arr1 = (PyArrayObject *)PyArray_EnsureAnyArray(ret);
/* sqrt() */
ret = PyArray_GenericUnaryFunction(arr1, n_ops.sqrt);
Py_DECREF(arr1);
}
if (ret == NULL) {
return NULL;
}
if (PyArray_CheckExact(self)) {
goto finish;
}
if (PyArray_Check(self) && Py_TYPE(self) == Py_TYPE(ret)) {
goto finish;
}
arr1 = (PyArrayObject *)PyArray_EnsureArray(ret);
if (arr1 == NULL) {
return NULL;
}
ret = PyArray_View(arr1, NULL, Py_TYPE(self));
Py_DECREF(arr1);
finish:
if (out) {
if (PyArray_AssignArray(out, (PyArrayObject *)ret,
NULL, NPY_DEFAULT_ASSIGN_CASTING) < 0) {
Py_DECREF(ret);
return NULL;
}
Py_DECREF(ret);
Py_INCREF(out);
return (PyObject *)out;
}
return ret;
}