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;
}
/*
* 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;
}
/* 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;
}
