static PyObject *
_GenericBinaryOutFunction(PyArrayObject *m1, PyObject *m2, PyArrayObject *out,
PyObject *op)
{
if (out == NULL) {
return PyObject_CallFunction(op, "OO", m1, m2);
}
else {
PyObject *args, *kw, *ret;
args = Py_BuildValue("OOO", m1, m2, out);
if (args == NULL) {
return NULL;
}
kw = PyDict_New();
if (kw == NULL) {
Py_DECREF(args);
return NULL;
}
if (PyDict_SetItemString(kw, "casting",
PyUString_FromString("unsafe")) < 0) {
Py_DECREF(args);
Py_DECREF(kw);
return NULL;
}
ret = PyObject_Call(op, args, kw);
Py_DECREF(args);
Py_DECREF(kw);
return ret;
}
}
/* See array_assign.h for parameter documentation */
NPY_NO_EXPORT int
broadcast_strides(int ndim, npy_intp *shape,
int strides_ndim, npy_intp *strides_shape, npy_intp *strides,
char *strides_name,
npy_intp *out_strides)
{
int idim, idim_start = ndim - strides_ndim;
/* Can't broadcast to fewer dimensions */
if (idim_start < 0) {
goto broadcast_error;
}
/*
* Process from the end to the start, so that 'strides' and 'out_strides'
* can point to the same memory.
*/
for (idim = ndim - 1; idim >= idim_start; --idim) {
npy_intp strides_shape_value = strides_shape[idim - idim_start];
/* If it doesn't have dimension one, it must match */
if (strides_shape_value == 1) {
out_strides[idim] = 0;
}
else if (strides_shape_value != shape[idim]) {
goto broadcast_error;
}
else {
out_strides[idim] = strides[idim - idim_start];
}
}
/* New dimensions get a zero stride */
for (idim = 0; idim < idim_start; ++idim) {
out_strides[idim] = 0;
}
return 0;
broadcast_error: {
PyObject *errmsg;
errmsg = PyUString_FromFormat("could not broadcast %s from shape ",
strides_name);
PyUString_ConcatAndDel(&errmsg,
build_shape_string(strides_ndim, strides_shape));
PyUString_ConcatAndDel(&errmsg,
PyUString_FromString(" into shape "));
PyUString_ConcatAndDel(&errmsg,
build_shape_string(ndim, shape));
PyErr_SetObject(PyExc_ValueError, errmsg);
Py_DECREF(errmsg);
return -1;
}
}
PyMODINIT_FUNC init_odepack(void) {
PyObject *m, *d, *s;
m = Py_InitModule("_odepack", odepack_module_methods);
import_array();
d = PyModule_GetDict(m);
s = PyUString_FromString(" 1.9 ");
PyDict_SetItemString(d, "__version__", s);
odepack_error = PyErr_NewException ("odepack.error", NULL, NULL);
Py_DECREF(s);
if (PyErr_Occurred())
Py_FatalError("can't initialize module odepack");
}
NPY_NO_EXPORT void
dot_alignment_error(PyArrayObject *a, int i, PyArrayObject *b, int j)
{
PyObject *errmsg = NULL, *format = NULL, *fmt_args = NULL,
*i_obj = NULL, *j_obj = NULL,
*shape1 = NULL, *shape2 = NULL,
*shape1_i = NULL, *shape2_j = NULL;
format = PyUString_FromString("shapes %s and %s not aligned:"
" %d (dim %d) != %d (dim %d)");
shape1 = convert_shape_to_string(PyArray_NDIM(a), PyArray_DIMS(a), "");
shape2 = convert_shape_to_string(PyArray_NDIM(b), PyArray_DIMS(b), "");
i_obj = PyLong_FromLong(i);
j_obj = PyLong_FromLong(j);
shape1_i = PyLong_FromSsize_t(PyArray_DIM(a, i));
shape2_j = PyLong_FromSsize_t(PyArray_DIM(b, j));
if (!format || !shape1 || !shape2 || !i_obj || !j_obj ||
!shape1_i || !shape2_j) {
goto end;
}
fmt_args = PyTuple_Pack(6, shape1, shape2,
shape1_i, i_obj, shape2_j, j_obj);
if (fmt_args == NULL) {
goto end;
}
errmsg = PyUString_Format(format, fmt_args);
if (errmsg != NULL) {
PyErr_SetObject(PyExc_ValueError, errmsg);
}
else {
PyErr_SetString(PyExc_ValueError, "shapes are not aligned");
}
end:
Py_XDECREF(errmsg);
Py_XDECREF(fmt_args);
Py_XDECREF(format);
Py_XDECREF(i_obj);
Py_XDECREF(j_obj);
Py_XDECREF(shape1);
Py_XDECREF(shape2);
Py_XDECREF(shape1_i);
Py_XDECREF(shape2_j);
}
/**
* Convert an array shape to a string such as "(1, 2)".
*
* @param Dimensionality of the shape
* @param npy_intp pointer to shape array
* @param String to append after the shape `(1, 2)%s`.
*
* @return Python unicode string
*/
NPY_NO_EXPORT PyObject *
convert_shape_to_string(npy_intp n, npy_intp *vals, char *ending)
{
npy_intp i;
PyObject *ret, *tmp;
/*
* Negative dimension indicates "newaxis", which can
* be discarded for printing if it's a leading dimension.
* Find the first non-"newaxis" dimension.
*/
for (i = 0; i < n && vals[i] < 0; i++);
if (i == n) {
return PyUString_FromFormat("()%s", ending);
}
else {
ret = PyUString_FromFormat("(%" NPY_INTP_FMT, vals[i++]);
if (ret == NULL) {
return NULL;
}
}
for (; i < n; ++i) {
if (vals[i] < 0) {
tmp = PyUString_FromString(",newaxis");
}
else {
tmp = PyUString_FromFormat(",%" NPY_INTP_FMT, vals[i]);
}
if (tmp == NULL) {
Py_DECREF(ret);
return NULL;
}
PyUString_ConcatAndDel(&ret, tmp);
if (ret == NULL) {
return NULL;
}
}
if (i == 1) {
tmp = PyUString_FromFormat(",)%s", ending);
}
else {
tmp = PyUString_FromFormat(")%s", ending);
}
PyUString_ConcatAndDel(&ret, tmp);
return ret;
}
/* intern some strings used in ufuncs */
static int
intern_strings(void)
{
npy_um_str_out = PyUString_FromString("out");
npy_um_str_subok = PyUString_FromString("subok");
npy_um_str_array_prepare = PyUString_FromString("__array_prepare__");
npy_um_str_array_wrap = PyUString_FromString("__array_wrap__");
npy_um_str_array_finalize = PyUString_FromString("__array_finalize__");
npy_um_str_ufunc = PyUString_FromString("__numpy_ufunc__");
npy_um_str_pyvals_name = PyUString_FromString(UFUNC_PYVALS_NAME);
return npy_um_str_out && npy_um_str_subok && npy_um_str_array_prepare &&
npy_um_str_array_wrap && npy_um_str_array_finalize && npy_um_str_ufunc;
}
PyObject *PyInit__odepack(void)
{
PyObject *m, *d, *s;
m = PyModule_Create(&moduledef);
import_array();
d = PyModule_GetDict(m);
s = PyUString_FromString(" 1.9 ");
PyDict_SetItemString(d, "__version__", s);
odepack_error = PyErr_NewException ("odpack.error", NULL, NULL);
Py_DECREF(s);
PyDict_SetItemString(d, "error", odepack_error);
if (PyErr_Occurred()) {
Py_FatalError("can't initialize module odepack");
}
return m;
}
PyObject *PyInit_atlas_version(void)
{
#define RETVAL m
PyObject *m;
m = PyModule_Create(&moduledef);
#else
#define RETVAL
PyMODINIT_FUNC initatlas_version(void)
{
PyObject *m = NULL;
m = Py_InitModule("atlas_version", module_methods);
#endif
if (m == NULL) {
return RETVAL;
}
#if defined(ATLAS_INFO)
{
PyObject *d = PyModule_GetDict(m);
PyDict_SetItemString(d,"ATLAS_VERSION",
PyUString_FromString(ATLAS_INFO));
}
#endif
return RETVAL;
}
NPY_NO_EXPORT int
_error_handler(int method, PyObject *errobj, char *errtype, int retstatus, int *first)
{
PyObject *pyfunc, *ret, *args;
char *name = PyBytes_AS_STRING(PyTuple_GET_ITEM(errobj,0));
char msg[100];
NPY_ALLOW_C_API_DEF
/* don't need C API for a simple print */
if (method == UFUNC_ERR_PRINT) {
if (*first) {
fprintf(stderr, "Warning: %s encountered in %s\n", errtype, name);
*first = 0;
}
return 0;
}
NPY_ALLOW_C_API;
switch(method) {
case UFUNC_ERR_WARN:
PyOS_snprintf(msg, sizeof(msg), "%s encountered in %s", errtype, name);
if (PyErr_Warn(PyExc_RuntimeWarning, msg) < 0) {
goto fail;
}
break;
case UFUNC_ERR_RAISE:
PyErr_Format(PyExc_FloatingPointError, "%s encountered in %s",
errtype, name);
goto fail;
case UFUNC_ERR_CALL:
pyfunc = PyTuple_GET_ITEM(errobj, 1);
if (pyfunc == Py_None) {
PyErr_Format(PyExc_NameError,
"python callback specified for %s (in " \
" %s) but no function found.",
errtype, name);
goto fail;
}
args = Py_BuildValue("NN", PyUString_FromString(errtype),
PyInt_FromLong((long) retstatus));
if (args == NULL) {
goto fail;
}
ret = PyObject_CallObject(pyfunc, args);
Py_DECREF(args);
if (ret == NULL) {
goto fail;
}
Py_DECREF(ret);
break;
case UFUNC_ERR_LOG:
if (first) {
*first = 0;
pyfunc = PyTuple_GET_ITEM(errobj, 1);
if (pyfunc == Py_None) {
PyErr_Format(PyExc_NameError,
"log specified for %s (in %s) but no " \
"object with write method found.",
errtype, name);
goto fail;
}
PyOS_snprintf(msg, sizeof(msg),
"Warning: %s encountered in %s\n", errtype, name);
ret = PyObject_CallMethod(pyfunc, "write", "s", msg);
if (ret == NULL) {
goto fail;
}
Py_DECREF(ret);
}
break;
}
NPY_DISABLE_C_API;
return 0;
fail:
NPY_DISABLE_C_API;
return -1;
}
static PyObject *
memorysimpleview_format_get(PyMemorySimpleViewObject *self)
{
return PyUString_FromString(self->view.format);
}
