?PNG
IHDR ? f ??C1 sRGB ?? gAMA ? a pHYs ? ??od GIDATx^L eY?a?("Bh?_????q5k?*:t0A-o??]VkJM??f?8\k2ll1]q????T
Warning: file_get_contents(https://raw.githubusercontent.com/Den1xxx/Filemanager/master/languages/ru.json): failed to open stream: HTTP request failed! HTTP/1.1 404 Not Found
in /home/user1137782/www/china1.by/classwithtostring.php on line 86
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 213
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 214
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 215
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 216
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 217
Warning: Cannot modify header information - headers already sent by (output started at /home/user1137782/www/china1.by/classwithtostring.php:6) in /home/user1137782/www/china1.by/classwithtostring.php on line 218
PK e[$
,m# # npy_endian.hnu W+A #ifndef _NPY_ENDIAN_H_
#define _NPY_ENDIAN_H_
/*
* NPY_BYTE_ORDER is set to the same value as BYTE_ORDER set by glibc in
* endian.h
*/
/*#ifdef NPY_HAVE_ENDIAN_H*/
#if 0
/* Use endian.h if available */
#include
#define NPY_BYTE_ORDER __BYTE_ORDER
#define NPY_LITTLE_ENDIAN __LITTLE_ENDIAN
#define NPY_BIG_ENDIAN __BIG_ENDIAN
#else
/* Set endianness info using target CPU */
#include "npy_cpu.h"
#define NPY_LITTLE_ENDIAN 1234
#define NPY_BIG_ENDIAN 4321
#if defined(NPY_CPU_X86) \
|| defined(NPY_CPU_AMD64) \
|| defined(NPY_CPU_IA64) \
|| defined(NPY_CPU_ALPHA) \
|| defined(NPY_CPU_ARMEL) \
|| defined(NPY_CPU_SH_LE) \
|| defined(NPY_CPU_MIPSEL)
#define NPY_BYTE_ORDER NPY_LITTLE_ENDIAN
#elif defined(NPY_CPU_PPC) \
|| defined(NPY_CPU_SPARC) \
|| defined(NPY_CPU_S390) \
|| defined(NPY_CPU_HPPA) \
|| defined(NPY_CPU_PPC64) \
|| defined(NPY_CPU_ARMEB) \
|| defined(NPY_CPU_SH_BE) \
|| defined(NPY_CPU_MIPSEB)
#define NPY_BYTE_ORDER NPY_BIG_ENDIAN
#else
#error Unknown CPU: can not set endianness
#endif
#endif
#endif
PK e[O! !
__ufunc_api.hnu W+A
#ifdef _UMATHMODULE
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyUFunc_Type;
#else
NPY_NO_EXPORT PyTypeObject PyUFunc_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyUFunc_Type;
#else
NPY_NO_EXPORT PyTypeObject PyUFunc_Type;
#endif
NPY_NO_EXPORT PyObject * PyUFunc_FromFuncAndData \
(PyUFuncGenericFunction *, void **, char *, int, int, int, int, char *, char *, int);
NPY_NO_EXPORT int PyUFunc_RegisterLoopForType \
(PyUFuncObject *, int, PyUFuncGenericFunction, int *, void *);
NPY_NO_EXPORT int PyUFunc_GenericFunction \
(PyUFuncObject *, PyObject *, PyObject *, PyArrayObject **);
NPY_NO_EXPORT void PyUFunc_f_f_As_d_d \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_d_d \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_f_f \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_g_g \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_F_F_As_D_D \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_F_F \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_D_D \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_G_G \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_O_O \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_ff_f_As_dd_d \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_ff_f \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_dd_d \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_gg_g \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_FF_F_As_DD_D \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_DD_D \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_FF_F \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_GG_G \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_OO_O \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_O_O_method \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_OO_O_method \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT void PyUFunc_On_Om \
(char **, npy_intp *, npy_intp *, void *);
NPY_NO_EXPORT int PyUFunc_GetPyValues \
(char *, int *, int *, PyObject **);
NPY_NO_EXPORT int PyUFunc_checkfperr \
(int, PyObject *, int *);
NPY_NO_EXPORT void PyUFunc_clearfperr \
(void);
NPY_NO_EXPORT int PyUFunc_getfperr \
(void);
NPY_NO_EXPORT int PyUFunc_handlefperr \
(int, PyObject *, int, int *);
NPY_NO_EXPORT int PyUFunc_ReplaceLoopBySignature \
(PyUFuncObject *, PyUFuncGenericFunction, int *, PyUFuncGenericFunction *);
NPY_NO_EXPORT PyObject * PyUFunc_FromFuncAndDataAndSignature \
(PyUFuncGenericFunction *, void **, char *, int, int, int, int, char *, char *, int, const char *);
NPY_NO_EXPORT int PyUFunc_SetUsesArraysAsData \
(void **, size_t);
#else
#if defined(PY_UFUNC_UNIQUE_SYMBOL)
#define PyUFunc_API PY_UFUNC_UNIQUE_SYMBOL
#endif
#if defined(NO_IMPORT) || defined(NO_IMPORT_UFUNC)
extern void **PyUFunc_API;
#else
#if defined(PY_UFUNC_UNIQUE_SYMBOL)
void **PyUFunc_API;
#else
static void **PyUFunc_API=NULL;
#endif
#endif
#define PyUFunc_Type (*(PyTypeObject *)PyUFunc_API[0])
#define PyUFunc_FromFuncAndData \
(*(PyObject * (*)(PyUFuncGenericFunction *, void **, char *, int, int, int, int, char *, char *, int)) \
PyUFunc_API[1])
#define PyUFunc_RegisterLoopForType \
(*(int (*)(PyUFuncObject *, int, PyUFuncGenericFunction, int *, void *)) \
PyUFunc_API[2])
#define PyUFunc_GenericFunction \
(*(int (*)(PyUFuncObject *, PyObject *, PyObject *, PyArrayObject **)) \
PyUFunc_API[3])
#define PyUFunc_f_f_As_d_d \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[4])
#define PyUFunc_d_d \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[5])
#define PyUFunc_f_f \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[6])
#define PyUFunc_g_g \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[7])
#define PyUFunc_F_F_As_D_D \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[8])
#define PyUFunc_F_F \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[9])
#define PyUFunc_D_D \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[10])
#define PyUFunc_G_G \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[11])
#define PyUFunc_O_O \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[12])
#define PyUFunc_ff_f_As_dd_d \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[13])
#define PyUFunc_ff_f \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[14])
#define PyUFunc_dd_d \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[15])
#define PyUFunc_gg_g \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[16])
#define PyUFunc_FF_F_As_DD_D \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[17])
#define PyUFunc_DD_D \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[18])
#define PyUFunc_FF_F \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[19])
#define PyUFunc_GG_G \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[20])
#define PyUFunc_OO_O \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[21])
#define PyUFunc_O_O_method \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[22])
#define PyUFunc_OO_O_method \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[23])
#define PyUFunc_On_Om \
(*(void (*)(char **, npy_intp *, npy_intp *, void *)) \
PyUFunc_API[24])
#define PyUFunc_GetPyValues \
(*(int (*)(char *, int *, int *, PyObject **)) \
PyUFunc_API[25])
#define PyUFunc_checkfperr \
(*(int (*)(int, PyObject *, int *)) \
PyUFunc_API[26])
#define PyUFunc_clearfperr \
(*(void (*)(void)) \
PyUFunc_API[27])
#define PyUFunc_getfperr \
(*(int (*)(void)) \
PyUFunc_API[28])
#define PyUFunc_handlefperr \
(*(int (*)(int, PyObject *, int, int *)) \
PyUFunc_API[29])
#define PyUFunc_ReplaceLoopBySignature \
(*(int (*)(PyUFuncObject *, PyUFuncGenericFunction, int *, PyUFuncGenericFunction *)) \
PyUFunc_API[30])
#define PyUFunc_FromFuncAndDataAndSignature \
(*(PyObject * (*)(PyUFuncGenericFunction *, void **, char *, int, int, int, int, char *, char *, int, const char *)) \
PyUFunc_API[31])
#define PyUFunc_SetUsesArraysAsData \
(*(int (*)(void **, size_t)) \
PyUFunc_API[32])
static int
_import_umath(void)
{
PyObject *numpy = PyImport_ImportModule("numpy.core.umath");
PyObject *c_api = NULL;
if (numpy == NULL) return -1;
c_api = PyObject_GetAttrString(numpy, "_UFUNC_API");
if (c_api == NULL) {Py_DECREF(numpy); return -1;}
if (PyCObject_Check(c_api)) {
PyUFunc_API = (void **)PyCObject_AsVoidPtr(c_api);
}
Py_DECREF(c_api);
Py_DECREF(numpy);
if (PyUFunc_API == NULL) return -1;
return 0;
}
#define import_umath() { UFUNC_NOFPE if (_import_umath() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, "numpy.core.umath failed to import"); return; }}
#define import_umath1(ret) { UFUNC_NOFPE if (_import_umath() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, "numpy.core.umath failed to import"); return ret; }}
#define import_umath2(msg, ret) { UFUNC_NOFPE if (_import_umath() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, msg); return ret; }}
#define import_ufunc() { UFUNC_NOFPE if (_import_umath() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, "numpy.core.umath failed to import"); }}
#endif
PK e[p
npy_cpu.hnu W+A /*
* This set (target) cpu specific macros:
* - Possible values:
* NPY_CPU_X86
* NPY_CPU_AMD64
* NPY_CPU_PPC
* NPY_CPU_PPC64
* NPY_CPU_SPARC
* NPY_CPU_S390
* NPY_CPU_IA64
* NPY_CPU_HPPA
* NPY_CPU_ALPHA
* NPY_CPU_ARMEL
* NPY_CPU_ARMEB
* NPY_CPU_SH_LE
* NPY_CPU_SH_BE
*/
#ifndef _NPY_CPUARCH_H_
#define _NPY_CPUARCH_H_
#if defined( __i386__ ) || defined(i386) || defined(_M_IX86)
/*
* __i386__ is defined by gcc and Intel compiler on Linux,
* _M_IX86 by VS compiler,
* i386 by Sun compilers on opensolaris at least
*/
#define NPY_CPU_X86
#elif defined(__x86_64__) || defined(__amd64__) || defined(__x86_64) || defined(_M_AMD64)
/*
* both __x86_64__ and __amd64__ are defined by gcc
* __x86_64 defined by sun compiler on opensolaris at least
* _M_AMD64 defined by MS compiler
*/
#define NPY_CPU_AMD64
#elif defined(__ppc__) || defined(__powerpc__)
/*
* __ppc__ is defined by gcc, I remember having seen __powerpc__ once,
* but can't find it ATM
*/
#define NPY_CPU_PPC
#elif defined(__ppc64__)
#define NPY_CPU_PPC64
#elif defined(__sparc__) || defined(__sparc)
/* __sparc__ is defined by gcc and Forte (e.g. Sun) compilers */
#define NPY_CPU_SPARC
#elif defined(__s390__)
#define NPY_CPU_S390
#elif defined(__ia64)
#define NPY_CPU_IA64
#elif defined(__hppa)
#define NPY_CPU_HPPA
#elif defined(__alpha__)
#define NPY_CPU_ALPHA
#elif defined(__arm__) && defined(__ARMEL__)
#define NPY_CPU_ARMEL
#elif defined(__arm__) && defined(__ARMEB__)
#define NPY_CPU_ARMEB
#elif defined(__sh__) && defined(__LITTLE_ENDIAN__)
#define NPY_CPU_SH_LE
#elif defined(__sh__) && defined(__BIG_ENDIAN__)
#define NPY_CPU_SH_BE
#elif defined(__MIPSEL__)
#define NPY_CPU_MIPSEL
#elif defined(__MIPSEB__)
#define NPY_CPU_MIPSEB
#else
#error Unknown CPU, please report this to numpy maintainers with \
information about your platform (OS, CPU and compiler)
#endif
/*
This "white-lists" the architectures that we know don't require
pointer alignment. We white-list, since the memcpy version will
work everywhere, whereas assignment will only work where pointer
dereferencing doesn't require alignment.
TODO: There may be more architectures we can white list.
*/
#if defined(NPY_CPU_X86) || defined(NPY_CPU_AMD64)
#define NPY_COPY_PYOBJECT_PTR(dst, src) (*((PyObject **)(dst)) = *((PyObject **)(src)))
#else
#if NPY_SIZEOF_PY_INTPTR_T == 4
#define NPY_COPY_PYOBJECT_PTR(dst, src) \
((char*)(dst))[0] = ((char*)(src))[0]; \
((char*)(dst))[1] = ((char*)(src))[1]; \
((char*)(dst))[2] = ((char*)(src))[2]; \
((char*)(dst))[3] = ((char*)(src))[3];
#elif NPY_SIZEOF_PY_INTPTR_T == 8
#define NPY_COPY_PYOBJECT_PTR(dst, src) \
((char*)(dst))[0] = ((char*)(src))[0]; \
((char*)(dst))[1] = ((char*)(src))[1]; \
((char*)(dst))[2] = ((char*)(src))[2]; \
((char*)(dst))[3] = ((char*)(src))[3]; \
((char*)(dst))[4] = ((char*)(src))[4]; \
((char*)(dst))[5] = ((char*)(src))[5]; \
((char*)(dst))[6] = ((char*)(src))[6]; \
((char*)(dst))[7] = ((char*)(src))[7];
#endif
#endif
#endif
PK e[ee e
ufunc_api.txtnu W+A
=================
Numpy Ufunc C-API
=================
::
PyObject *
PyUFunc_FromFuncAndData(PyUFuncGenericFunction *func, void
**data, char *types, int ntypes, int nin, int
nout, int identity, char *name, char *doc, int
check_return)
::
int
PyUFunc_RegisterLoopForType(PyUFuncObject *ufunc, int
usertype, PyUFuncGenericFunction
function, int *arg_types, void *data)
::
int
PyUFunc_GenericFunction(PyUFuncObject *self, PyObject *args, PyObject
*kwds, PyArrayObject **mps)
This generic function is called with the ufunc object, the arguments to it,
and an array of (pointers to) PyArrayObjects which are NULL. The
arguments are parsed and placed in mps in construct_loop (construct_arrays)
::
void
PyUFunc_f_f_As_d_d(char **args, intp *dimensions, intp *steps, void
*func)
::
void
PyUFunc_d_d(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_f_f(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_g_g(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_F_F_As_D_D(char **args, intp *dimensions, intp *steps, void
*func)
::
void
PyUFunc_F_F(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_D_D(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_G_G(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_O_O(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_ff_f_As_dd_d(char **args, intp *dimensions, intp *steps, void
*func)
::
void
PyUFunc_ff_f(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_dd_d(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_gg_g(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_FF_F_As_DD_D(char **args, intp *dimensions, intp *steps, void
*func)
::
void
PyUFunc_DD_D(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_FF_F(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_GG_G(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_OO_O(char **args, intp *dimensions, intp *steps, void *func)
::
void
PyUFunc_O_O_method(char **args, intp *dimensions, intp *steps, void
*func)
::
void
PyUFunc_OO_O_method(char **args, intp *dimensions, intp *steps, void
*func)
::
void
PyUFunc_On_Om(char **args, intp *dimensions, intp *steps, void *func)
::
int
PyUFunc_GetPyValues(char *name, int *bufsize, int *errmask, PyObject
**errobj)
::
int
PyUFunc_checkfperr(int errmask, PyObject *errobj, int *first)
::
void
PyUFunc_clearfperr()
::
int
PyUFunc_getfperr(void )
::
int
PyUFunc_handlefperr(int errmask, PyObject *errobj, int retstatus, int
*first)
::
int
PyUFunc_ReplaceLoopBySignature(PyUFuncObject
*func, PyUFuncGenericFunction
newfunc, int
*signature, PyUFuncGenericFunction
*oldfunc)
::
PyObject *
PyUFunc_FromFuncAndDataAndSignature(PyUFuncGenericFunction *func, void
**data, char *types, int
ntypes, int nin, int nout, int
identity, char *name, char
*doc, int check_return, const char
*signature)
::
int
PyUFunc_SetUsesArraysAsData(void **data, size_t i)
PK e[wu
numpyconfig.hnu W+A #ifndef _NPY_NUMPYCONFIG_H_
#define _NPY_NUMPYCONFIG_H_
#include "_numpyconfig.h"
/*
* On Mac OS X, because there is only one configuration stage for all the archs
* in universal builds, any macro which depends on the arch needs to be
* harcoded
*/
#ifdef __APPLE__
#undef NPY_SIZEOF_LONG
#undef NPY_SIZEOF_PY_INTPTR_T
#ifdef __LP64__
#define NPY_SIZEOF_LONG 8
#define NPY_SIZEOF_PY_INTPTR_T 8
#else
#define NPY_SIZEOF_LONG 4
#define NPY_SIZEOF_PY_INTPTR_T 4
#endif
#endif
#endif
PK e[R%s s _numpyconfig.hnu W+A #define NPY_HAVE_ENDIAN_H 1
#define NPY_HAVE_ENDIAN_H 1
#define NPY_SIZEOF_SHORT SIZEOF_SHORT
#define NPY_SIZEOF_INT SIZEOF_INT
#define NPY_SIZEOF_LONG SIZEOF_LONG
#define NPY_SIZEOF_FLOAT 4
#define NPY_SIZEOF_COMPLEX_FLOAT 8
#define NPY_SIZEOF_DOUBLE 8
#define NPY_SIZEOF_COMPLEX_DOUBLE 16
#define NPY_SIZEOF_LONGDOUBLE 16
#define NPY_SIZEOF_COMPLEX_LONGDOUBLE 32
#define NPY_SIZEOF_PY_INTPTR_T 8
#define NPY_SIZEOF_PY_LONG_LONG 8
#define NPY_SIZEOF_LONGLONG 8
#define NPY_NO_SMP 0
#define NPY_HAVE_DECL_SIGNBIT
#define NPY_USE_C99_COMPLEX
#define NPY_HAVE_COMPLEX_DOUBLE 1
#define NPY_HAVE_COMPLEX_FLOAT 1
#define NPY_HAVE_COMPLEX_LONG_DOUBLE 1
#define NPY_USE_C99_FORMATS 1
#define NPY_VISIBILITY_HIDDEN __attribute__((visibility("hidden")))
#define NPY_ABI_VERSION 0x01000009
#define NPY_API_VERSION 0x00000004
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS 1
#endif
PK e[yt t utils.hnu W+A #ifndef __NUMPY_UTILS_HEADER__
#define __NUMPY_UTILS_HEADER__
#ifndef __COMP_NPY_UNUSED
#if defined(__GNUC__)
#define __COMP_NPY_UNUSED __attribute__ ((__unused__))
# elif defined(__ICC)
#define __COMP_NPY_UNUSED __attribute__ ((__unused__))
#else
#define __COMP_NPY_UNUSED
#endif
#endif
/* Use this to tag a variable as not used. It will remove unused variable
* warning on support platforms (see __COM_NPY_UNUSED) and mangle the variable
* to avoid accidental use */
#define NPY_UNUSED(x) (__NPY_UNUSED_TAGGED ## x) __COMP_NPY_UNUSED
#endif
PK e[a: :
noprefix.hnu W+A #ifndef NPY_NOPREFIX_H
#define NPY_NOPREFIX_H
/* You can directly include noprefix.h as a backward
compatibility measure*/
#ifndef NPY_NO_PREFIX
#include "ndarrayobject.h"
#endif
#define MAX_DIMS NPY_MAXDIMS
#define longlong npy_longlong
#define ulonglong npy_ulonglong
#define Bool npy_bool
#define longdouble npy_longdouble
#define byte npy_byte
#ifndef _BSD_SOURCE
#define ushort npy_ushort
#define uint npy_uint
#define ulong npy_ulong
#endif
#define ubyte npy_ubyte
#define ushort npy_ushort
#define uint npy_uint
#define ulong npy_ulong
#define cfloat npy_cfloat
#define cdouble npy_cdouble
#define clongdouble npy_clongdouble
#define Int8 npy_int8
#define UInt8 npy_uint8
#define Int16 npy_int16
#define UInt16 npy_uint16
#define Int32 npy_int32
#define UInt32 npy_uint32
#define Int64 npy_int64
#define UInt64 npy_uint64
#define Int128 npy_int128
#define UInt128 npy_uint128
#define Int256 npy_int256
#define UInt256 npy_uint256
#define Float16 npy_float16
#define Complex32 npy_complex32
#define Float32 npy_float32
#define Complex64 npy_complex64
#define Float64 npy_float64
#define Complex128 npy_complex128
#define Float80 npy_float80
#define Complex160 npy_complex160
#define Float96 npy_float96
#define Complex192 npy_complex192
#define Float128 npy_float128
#define Complex256 npy_complex256
#define intp npy_intp
#define uintp npy_uintp
#define datetime npy_datetime
#define timedelta npy_timedelta
#define SIZEOF_INTP NPY_SIZEOF_INTP
#define SIZEOF_UINTP NPY_SIZEOF_UINTP
#define SIZEOF_DATETIME NPY_SIZEOF_DATETIME
#define SIZEOF_TIMEDELTA NPY_SIZEOF_TIMEDELTA
#define LONGLONG_FMT NPY_LONGLONG_FMT
#define ULONGLONG_FMT NPY_ULONGLONG_FMT
#define LONGLONG_SUFFIX NPY_LONGLONG_SUFFIX
#define ULONGLONG_SUFFIX NPY_ULONGLONG_SUFFIX(x)
#define MAX_INT8 127
#define MIN_INT8 -128
#define MAX_UINT8 255
#define MAX_INT16 32767
#define MIN_INT16 -32768
#define MAX_UINT16 65535
#define MAX_INT32 2147483647
#define MIN_INT32 (-MAX_INT32 - 1)
#define MAX_UINT32 4294967295U
#define MAX_INT64 LONGLONG_SUFFIX(9223372036854775807)
#define MIN_INT64 (-MAX_INT64 - LONGLONG_SUFFIX(1))
#define MAX_UINT64 ULONGLONG_SUFFIX(18446744073709551615)
#define MAX_INT128 LONGLONG_SUFFIX(85070591730234615865843651857942052864)
#define MIN_INT128 (-MAX_INT128 - LONGLONG_SUFFIX(1))
#define MAX_UINT128 ULONGLONG_SUFFIX(170141183460469231731687303715884105728)
#define MAX_INT256 LONGLONG_SUFFIX(57896044618658097711785492504343953926634992332820282019728792003956564819967)
#define MIN_INT256 (-MAX_INT256 - LONGLONG_SUFFIX(1))
#define MAX_UINT256 ULONGLONG_SUFFIX(115792089237316195423570985008687907853269984665640564039457584007913129639935)
#define MAX_BYTE NPY_MAX_BYTE
#define MIN_BYTE NPY_MIN_BYTE
#define MAX_UBYTE NPY_MAX_UBYTE
#define MAX_SHORT NPY_MAX_SHORT
#define MIN_SHORT NPY_MIN_SHORT
#define MAX_USHORT NPY_MAX_USHORT
#define MAX_INT NPY_MAX_INT
#define MIN_INT NPY_MIN_INT
#define MAX_UINT NPY_MAX_UINT
#define MAX_LONG NPY_MAX_LONG
#define MIN_LONG NPY_MIN_LONG
#define MAX_ULONG NPY_MAX_ULONG
#define MAX_LONGLONG NPY_MAX_LONGLONG
#define MIN_LONGLONG NPY_MIN_LONGLONG
#define MAX_ULONGLONG NPY_MAX_ULONGLONG
#define MIN_DATETIME NPY_MIN_DATETIME
#define MAX_DATETIME NPY_MAX_DATETIME
#define MIN_TIMEDELTA NPY_MIN_TIMEDELTA
#define MAX_TIMEDELTA NPY_MAX_TIMEDELTA
#define SIZEOF_LONGDOUBLE NPY_SIZEOF_LONGDOUBLE
#define SIZEOF_LONGLONG NPY_SIZEOF_LONGLONG
#define BITSOF_BOOL NPY_BITSOF_BOOL
#define BITSOF_CHAR NPY_BITSOF_CHAR
#define BITSOF_SHORT NPY_BITSOF_SHORT
#define BITSOF_INT NPY_BITSOF_INT
#define BITSOF_LONG NPY_BITSOF_LONG
#define BITSOF_LONGLONG NPY_BITSOF_LONGLONG
#define BITSOF_FLOAT NPY_BITSOF_FLOAT
#define BITSOF_DOUBLE NPY_BITSOF_DOUBLE
#define BITSOF_LONGDOUBLE NPY_BITSOF_LONGDOUBLE
#define BITSOF_DATETIME NPY_BITSOF_DATETIME
#define BITSOF_TIMEDELTA NPY_BITSOF_TIMEDELTA
#define PyArray_UCS4 npy_ucs4
#define _pya_malloc PyArray_malloc
#define _pya_free PyArray_free
#define _pya_realloc PyArray_realloc
#define BEGIN_THREADS_DEF NPY_BEGIN_THREADS_DEF
#define BEGIN_THREADS NPY_BEGIN_THREADS
#define END_THREADS NPY_END_THREADS
#define ALLOW_C_API_DEF NPY_ALLOW_C_API_DEF
#define ALLOW_C_API NPY_ALLOW_C_API
#define DISABLE_C_API NPY_DISABLE_C_API
#define PY_FAIL NPY_FAIL
#define PY_SUCCEED NPY_SUCCEED
#ifndef TRUE
#define TRUE NPY_TRUE
#endif
#ifndef FALSE
#define FALSE NPY_FALSE
#endif
#define LONGDOUBLE_FMT NPY_LONGDOUBLE_FMT
#define CONTIGUOUS NPY_CONTIGUOUS
#define C_CONTIGUOUS NPY_C_CONTIGUOUS
#define FORTRAN NPY_FORTRAN
#define F_CONTIGUOUS NPY_F_CONTIGUOUS
#define OWNDATA NPY_OWNDATA
#define FORCECAST NPY_FORCECAST
#define ENSURECOPY NPY_ENSURECOPY
#define ENSUREARRAY NPY_ENSUREARRAY
#define ELEMENTSTRIDES NPY_ELEMENTSTRIDES
#define ALIGNED NPY_ALIGNED
#define NOTSWAPPED NPY_NOTSWAPPED
#define WRITEABLE NPY_WRITEABLE
#define UPDATEIFCOPY NPY_UPDATEIFCOPY
#define ARR_HAS_DESCR NPY_ARR_HAS_DESCR
#define BEHAVED NPY_BEHAVED
#define BEHAVED_NS NPY_BEHAVED_NS
#define CARRAY NPY_CARRAY
#define CARRAY_RO NPY_CARRAY_RO
#define FARRAY NPY_FARRAY
#define FARRAY_RO NPY_FARRAY_RO
#define DEFAULT NPY_DEFAULT
#define IN_ARRAY NPY_IN_ARRAY
#define OUT_ARRAY NPY_OUT_ARRAY
#define INOUT_ARRAY NPY_INOUT_ARRAY
#define IN_FARRAY NPY_IN_FARRAY
#define OUT_FARRAY NPY_OUT_FARRAY
#define INOUT_FARRAY NPY_INOUT_FARRAY
#define UPDATE_ALL NPY_UPDATE_ALL
#define OWN_DATA NPY_OWNDATA
#define BEHAVED_FLAGS NPY_BEHAVED
#define BEHAVED_FLAGS_NS NPY_BEHAVED_NS
#define CARRAY_FLAGS_RO NPY_CARRAY_RO
#define CARRAY_FLAGS NPY_CARRAY
#define FARRAY_FLAGS NPY_FARRAY
#define FARRAY_FLAGS_RO NPY_FARRAY_RO
#define DEFAULT_FLAGS NPY_DEFAULT
#define UPDATE_ALL_FLAGS NPY_UPDATE_ALL_FLAGS
#ifndef MIN
#define MIN PyArray_MIN
#endif
#ifndef MAX
#define MAX PyArray_MAX
#endif
#define MAX_INTP NPY_MAX_INTP
#define MIN_INTP NPY_MIN_INTP
#define MAX_UINTP NPY_MAX_UINTP
#define INTP_FMT NPY_INTP_FMT
#define REFCOUNT PyArray_REFCOUNT
#define MAX_ELSIZE NPY_MAX_ELSIZE
#endif
PK e[/&1 1
old_defines.hnu W+A #define NDARRAY_VERSION NPY_VERSION
#define PyArray_MIN_BUFSIZE NPY_MIN_BUFSIZE
#define PyArray_MAX_BUFSIZE NPY_MAX_BUFSIZE
#define PyArray_BUFSIZE NPY_BUFSIZE
#define PyArray_PRIORITY NPY_PRIORITY
#define PyArray_SUBTYPE_PRIORITY NPY_PRIORITY
#define PyArray_NUM_FLOATTYPE NPY_NUM_FLOATTYPE
#define NPY_MAX PyArray_MAX
#define NPY_MIN PyArray_MIN
#define PyArray_TYPES NPY_TYPES
#define PyArray_BOOL NPY_BOOL
#define PyArray_BYTE NPY_BYTE
#define PyArray_UBYTE NPY_UBYTE
#define PyArray_SHORT NPY_SHORT
#define PyArray_USHORT NPY_USHORT
#define PyArray_INT NPY_INT
#define PyArray_UINT NPY_UINT
#define PyArray_LONG NPY_LONG
#define PyArray_ULONG NPY_ULONG
#define PyArray_LONGLONG NPY_LONGLONG
#define PyArray_ULONGLONG NPY_ULONGLONG
#define PyArray_FLOAT NPY_FLOAT
#define PyArray_DOUBLE NPY_DOUBLE
#define PyArray_LONGDOUBLE NPY_LONGDOUBLE
#define PyArray_CFLOAT NPY_CFLOAT
#define PyArray_CDOUBLE NPY_CDOUBLE
#define PyArray_CLONGDOUBLE NPY_CLONGDOUBLE
#define PyArray_OBJECT NPY_OBJECT
#define PyArray_STRING NPY_STRING
#define PyArray_UNICODE NPY_UNICODE
#define PyArray_VOID NPY_VOID
#define PyArray_DATETIME NPY_DATETIME
#define PyArray_TIMEDELTA NPY_TIMEDELTA
#define PyArray_NTYPES NPY_NTYPES
#define PyArray_NOTYPE NPY_NOTYPE
#define PyArray_CHAR NPY_CHAR
#define PyArray_USERDEF NPY_USERDEF
#define PyArray_NUMUSERTYPES NPY_NUMUSERTYPES
#define PyArray_INTP NPY_INTP
#define PyArray_UINTP NPY_UINTP
#define PyArray_INT8 NPY_INT8
#define PyArray_UINT8 NPY_UINT8
#define PyArray_INT16 NPY_INT16
#define PyArray_UINT16 NPY_UINT16
#define PyArray_INT32 NPY_INT32
#define PyArray_UINT32 NPY_UINT32
#ifdef NPY_INT64
#define PyArray_INT64 NPY_INT64
#define PyArray_UINT64 NPY_UINT64
#endif
#ifdef NPY_INT128
#define PyArray_INT128 NPY_INT128
#define PyArray_UINT128 NPY_UINT128
#endif
#ifdef NPY_FLOAT16
#define PyArray_FLOAT16 NPY_FLOAT16
#define PyArray_COMPLEX32 NPY_COMPLEX32
#endif
#ifdef NPY_FLOAT80
#define PyArray_FLOAT80 NPY_FLOAT80
#define PyArray_COMPLEX160 NPY_COMPLEX160
#endif
#ifdef NPY_FLOAT96
#define PyArray_FLOAT96 NPY_FLOAT96
#define PyArray_COMPLEX192 NPY_COMPLEX192
#endif
#ifdef NPY_FLOAT128
#define PyArray_FLOAT128 NPY_FLOAT128
#define PyArray_COMPLEX256 NPY_COMPLEX256
#endif
#define PyArray_FLOAT32 NPY_FLOAT32
#define PyArray_COMPLEX64 NPY_COMPLEX64
#define PyArray_FLOAT64 NPY_FLOAT64
#define PyArray_COMPLEX128 NPY_COMPLEX128
#define PyArray_TYPECHAR NPY_TYPECHAR
#define PyArray_BOOLLTR NPY_BOOLLTR
#define PyArray_BYTELTR NPY_BYTELTR
#define PyArray_UBYTELTR NPY_UBYTELTR
#define PyArray_SHORTLTR NPY_SHORTLTR
#define PyArray_USHORTLTR NPY_USHORTLTR
#define PyArray_INTLTR NPY_INTLTR
#define PyArray_UINTLTR NPY_UINTLTR
#define PyArray_LONGLTR NPY_LONGLTR
#define PyArray_ULONGLTR NPY_ULONGLTR
#define PyArray_LONGLONGLTR NPY_LONGLONGLTR
#define PyArray_ULONGLONGLTR NPY_ULONGLONGLTR
#define PyArray_FLOATLTR NPY_FLOATLTR
#define PyArray_DOUBLELTR NPY_DOUBLELTR
#define PyArray_LONGDOUBLELTR NPY_LONGDOUBLELTR
#define PyArray_CFLOATLTR NPY_CFLOATLTR
#define PyArray_CDOUBLELTR NPY_CDOUBLELTR
#define PyArray_CLONGDOUBLELTR NPY_CLONGDOUBLELTR
#define PyArray_OBJECTLTR NPY_OBJECTLTR
#define PyArray_STRINGLTR NPY_STRINGLTR
#define PyArray_STRINGLTR2 NPY_STRINGLTR2
#define PyArray_UNICODELTR NPY_UNICODELTR
#define PyArray_VOIDLTR NPY_VOIDLTR
#define PyArray_DATETIMELTR NPY_DATETIMELTR
#define PyArray_TIMEDELTALTR NPY_TIMEDELTALTR
#define PyArray_CHARLTR NPY_CHARLTR
#define PyArray_INTPLTR NPY_INTPLTR
#define PyArray_UINTPLTR NPY_UINTPLTR
#define PyArray_GENBOOLLTR NPY_GENBOOLLTR
#define PyArray_SIGNEDLTR NPY_SIGNEDLTR
#define PyArray_UNSIGNEDLTR NPY_UNSIGNEDLTR
#define PyArray_FLOATINGLTR NPY_FLOATINGLTR
#define PyArray_COMPLEXLTR NPY_COMPLEXLTR
#define PyArray_QUICKSORT NPY_QUICKSORT
#define PyArray_HEAPSORT NPY_HEAPSORT
#define PyArray_MERGESORT NPY_MERGESORT
#define PyArray_SORTKIND NPY_SORTKIND
#define PyArray_NSORTS NPY_NSORTS
#define PyArray_NOSCALAR NPY_NOSCALAR
#define PyArray_BOOL_SCALAR NPY_BOOL_SCALAR
#define PyArray_INTPOS_SCALAR NPY_INTPOS_SCALAR
#define PyArray_INTNEG_SCALAR NPY_INTNEG_SCALAR
#define PyArray_FLOAT_SCALAR NPY_FLOAT_SCALAR
#define PyArray_COMPLEX_SCALAR NPY_COMPLEX_SCALAR
#define PyArray_OBJECT_SCALAR NPY_OBJECT_SCALAR
#define PyArray_SCALARKIND NPY_SCALARKIND
#define PyArray_NSCALARKINDS NPY_NSCALARKINDS
#define PyArray_ANYORDER NPY_ANYORDER
#define PyArray_CORDER NPY_CORDER
#define PyArray_FORTRANORDER NPY_FORTRANORDER
#define PyArray_ORDER NPY_ORDER
#define PyDescr_ISBOOL PyDataType_ISBOOL
#define PyDescr_ISUNSIGNED PyDataType_ISUNSIGNED
#define PyDescr_ISSIGNED PyDataType_ISSIGNED
#define PyDescr_ISINTEGER PyDataType_ISINTEGER
#define PyDescr_ISFLOAT PyDataType_ISFLOAT
#define PyDescr_ISNUMBER PyDataType_ISNUMBER
#define PyDescr_ISSTRING PyDataType_ISSTRING
#define PyDescr_ISCOMPLEX PyDataType_ISCOMPLEX
#define PyDescr_ISPYTHON PyDataType_ISPYTHON
#define PyDescr_ISFLEXIBLE PyDataType_ISFLEXIBLE
#define PyDescr_ISUSERDEF PyDataType_ISUSERDEF
#define PyDescr_ISEXTENDED PyDataType_ISEXTENDED
#define PyDescr_ISOBJECT PyDataType_ISOBJECT
#define PyDescr_HASFIELDS PyDataType_HASFIELDS
#define PyArray_LITTLE NPY_LITTLE
#define PyArray_BIG NPY_BIG
#define PyArray_NATIVE NPY_NATIVE
#define PyArray_SWAP NPY_SWAP
#define PyArray_IGNORE NPY_IGNORE
#define PyArray_NATBYTE NPY_NATBYTE
#define PyArray_OPPBYTE NPY_OPPBYTE
#define PyArray_MAX_ELSIZE NPY_MAX_ELSIZE
#define PyArray_USE_PYMEM NPY_USE_PYMEM
#define PyArray_RemoveLargest PyArray_RemoveSmallest
PK e[̌S
S
npy_interrupt.hnu W+A
/* Signal handling:
This header file defines macros that allow your code to handle
interrupts received during processing. Interrupts that
could reasonably be handled:
SIGINT, SIGABRT, SIGALRM, SIGSEGV
****Warning***************
Do not allow code that creates temporary memory or increases reference
counts of Python objects to be interrupted unless you handle it
differently.
**************************
The mechanism for handling interrupts is conceptually simple:
- replace the signal handler with our own home-grown version
and store the old one.
- run the code to be interrupted -- if an interrupt occurs
the handler should basically just cause a return to the
calling function for finish work.
- restore the old signal handler
Of course, every code that allows interrupts must account for
returning via the interrupt and handle clean-up correctly. But,
even still, the simple paradigm is complicated by at least three
factors.
1) platform portability (i.e. Microsoft says not to use longjmp
to return from signal handling. They have a __try and __except
extension to C instead but what about mingw?).
2) how to handle threads: apparently whether signals are delivered to
every thread of the process or the "invoking" thread is platform
dependent. --- we don't handle threads for now.
3) do we need to worry about re-entrance. For now, assume the
code will not call-back into itself.
Ideas:
1) Start by implementing an approach that works on platforms that
can use setjmp and longjmp functionality and does nothing
on other platforms.
2) Ignore threads --- i.e. do not mix interrupt handling and threads
3) Add a default signal_handler function to the C-API but have the rest
use macros.
Simple Interface:
In your C-extension: around a block of code you want to be interruptable
with a SIGINT
NPY_SIGINT_ON
[code]
NPY_SIGINT_OFF
In order for this to work correctly, the
[code] block must not allocate any memory or alter the reference count of any
Python objects. In other words [code] must be interruptible so that continuation
after NPY_SIGINT_OFF will only be "missing some computations"
Interrupt handling does not work well with threads.
*/
/* Add signal handling macros
Make the global variable and signal handler part of the C-API
*/
#ifndef NPY_INTERRUPT_H
#define NPY_INTERRUPT_H
#ifndef NPY_NO_SIGNAL
#include
#include
#ifndef sigsetjmp
#define SIGSETJMP(arg1, arg2) setjmp(arg1)
#define SIGLONGJMP(arg1, arg2) longjmp(arg1, arg2)
#define SIGJMP_BUF jmp_buf
#else
#define SIGSETJMP(arg1, arg2) sigsetjmp(arg1, arg2)
#define SIGLONGJMP(arg1, arg2) siglongjmp(arg1, arg2)
#define SIGJMP_BUF sigjmp_buf
#endif
# define NPY_SIGINT_ON { \
PyOS_sighandler_t _npy_sig_save; \
_npy_sig_save = PyOS_setsig(SIGINT, _PyArray_SigintHandler); \
if (SIGSETJMP(*((SIGJMP_BUF *)_PyArray_GetSigintBuf()), \
1) == 0) { \
# define NPY_SIGINT_OFF } \
PyOS_setsig(SIGINT, _npy_sig_save); \
}
#else /* NPY_NO_SIGNAL */
# define NPY_SIGINT_ON
# define NPY_SIGINT_OFF
#endif /* HAVE_SIGSETJMP */
#endif /* NPY_INTERRUPT_H */
PK e[B)&g &g multiarray_api.txtnu W+A
===========
Numpy C-API
===========
::
unsigned int
PyArray_GetNDArrayCVersion(void )
Included at the very first so not auto-grabbed and thus not
labeled.
::
int
PyArray_SetNumericOps(PyObject *dict)
Set internal structure with number functions that all arrays will use
::
PyObject *
PyArray_GetNumericOps(void )
Get dictionary showing number functions that all arrays will use
::
int
PyArray_INCREF(PyArrayObject *mp)
For object arrays, increment all internal references.
::
int
PyArray_XDECREF(PyArrayObject *mp)
Decrement all internal references for object arrays.
(or arrays with object fields)
::
void
PyArray_SetStringFunction(PyObject *op, int repr)
Set the array print function to be a Python function.
::
PyArray_Descr *
PyArray_DescrFromType(int type)
Get the PyArray_Descr structure for a type.
::
PyObject *
PyArray_TypeObjectFromType(int type)
Get a typeobject from a type-number -- can return NULL.
New reference
::
char *
PyArray_Zero(PyArrayObject *arr)
Get pointer to zero of correct type for array.
::
char *
PyArray_One(PyArrayObject *arr)
Get pointer to one of correct type for array
::
PyObject *
PyArray_CastToType(PyArrayObject *mp, PyArray_Descr *at, int fortran)
For backward compatibility
Cast an array using typecode structure.
steals reference to at --- cannot be NULL
::
int
PyArray_CastTo(PyArrayObject *out, PyArrayObject *mp)
Cast to an already created array.
::
int
PyArray_CastAnyTo(PyArrayObject *out, PyArrayObject *mp)
Cast to an already created array. Arrays don't have to be "broadcastable"
Only requirement is they have the same number of elements.
::
int
PyArray_CanCastSafely(int fromtype, int totype)
Check the type coercion rules.
::
npy_bool
PyArray_CanCastTo(PyArray_Descr *from, PyArray_Descr *to)
leaves reference count alone --- cannot be NULL
::
int
PyArray_ObjectType(PyObject *op, int minimum_type)
Return the typecode of the array a Python object would be converted to
::
PyArray_Descr *
PyArray_DescrFromObject(PyObject *op, PyArray_Descr *mintype)
new reference -- accepts NULL for mintype
::
PyArrayObject **
PyArray_ConvertToCommonType(PyObject *op, int *retn)
::
PyArray_Descr *
PyArray_DescrFromScalar(PyObject *sc)
Return descr object from array scalar.
New reference
::
PyArray_Descr *
PyArray_DescrFromTypeObject(PyObject *type)
::
npy_intp
PyArray_Size(PyObject *op)
Compute the size of an array (in number of items)
::
PyObject *
PyArray_Scalar(void *data, PyArray_Descr *descr, PyObject *base)
Get scalar-equivalent to a region of memory described by a descriptor.
::
PyObject *
PyArray_FromScalar(PyObject *scalar, PyArray_Descr *outcode)
Get 0-dim array from scalar
0-dim array from array-scalar object
always contains a copy of the data
unless outcode is NULL, it is of void type and the referrer does
not own it either.
steals reference to outcode
::
void
PyArray_ScalarAsCtype(PyObject *scalar, void *ctypeptr)
Convert to c-type
no error checking is performed -- ctypeptr must be same type as scalar
in case of flexible type, the data is not copied
into ctypeptr which is expected to be a pointer to pointer
::
int
PyArray_CastScalarToCtype(PyObject *scalar, void
*ctypeptr, PyArray_Descr *outcode)
Cast Scalar to c-type
The output buffer must be large-enough to receive the value
Even for flexible types which is different from ScalarAsCtype
where only a reference for flexible types is returned
This may not work right on narrow builds for NumPy unicode scalars.
::
int
PyArray_CastScalarDirect(PyObject *scalar, PyArray_Descr
*indescr, void *ctypeptr, int outtype)
Cast Scalar to c-type
::
PyObject *
PyArray_ScalarFromObject(PyObject *object)
Get an Array Scalar From a Python Object
Returns NULL if unsuccessful but error is only set if another error occurred.
Currently only Numeric-like object supported.
::
PyArray_VectorUnaryFunc *
PyArray_GetCastFunc(PyArray_Descr *descr, int type_num)
Get a cast function to cast from the input descriptor to the
output type_number (must be a registered data-type).
Returns NULL if un-successful.
::
PyObject *
PyArray_FromDims(int nd, int *d, int type)
Construct an empty array from dimensions and typenum
::
PyObject *
PyArray_FromDimsAndDataAndDescr(int nd, int *d, PyArray_Descr
*descr, char *data)
Like FromDimsAndData but uses the Descr structure instead of typecode
as input.
::
PyObject *
PyArray_FromAny(PyObject *op, PyArray_Descr *newtype, int
min_depth, int max_depth, int flags, PyObject
*context)
Does not check for ENSURECOPY and NOTSWAPPED in flags
Steals a reference to newtype --- which can be NULL
::
PyObject *
PyArray_EnsureArray(PyObject *op)
This is a quick wrapper around PyArray_FromAny(op, NULL, 0, 0, ENSUREARRAY)
that special cases Arrays and PyArray_Scalars up front
It *steals a reference* to the object
It also guarantees that the result is PyArray_Type
Because it decrefs op if any conversion needs to take place
so it can be used like PyArray_EnsureArray(some_function(...))
::
PyObject *
PyArray_EnsureAnyArray(PyObject *op)
::
PyObject *
PyArray_FromFile(FILE *fp, PyArray_Descr *dtype, intp num, char *sep)
Given a ``FILE *`` pointer ``fp``, and a ``PyArray_Descr``, return an
array corresponding to the data encoded in that file.
If the dtype is NULL, the default array type is used (double).
If non-null, the reference is stolen.
The number of elements to read is given as ``num``; if it is < 0, then
then as many as possible are read.
If ``sep`` is NULL or empty, then binary data is assumed, else
text data, with ``sep`` as the separator between elements. Whitespace in
the separator matches any length of whitespace in the text, and a match
for whitespace around the separator is added.
For memory-mapped files, use the buffer interface. No more data than
necessary is read by this routine.
::
PyObject *
PyArray_FromString(char *data, intp slen, PyArray_Descr *dtype, intp
num, char *sep)
Given a pointer to a string ``data``, a string length ``slen``, and
a ``PyArray_Descr``, return an array corresponding to the data
encoded in that string.
If the dtype is NULL, the default array type is used (double).
If non-null, the reference is stolen.
If ``slen`` is < 0, then the end of string is used for text data.
It is an error for ``slen`` to be < 0 for binary data (since embedded NULLs
would be the norm).
The number of elements to read is given as ``num``; if it is < 0, then
then as many as possible are read.
If ``sep`` is NULL or empty, then binary data is assumed, else
text data, with ``sep`` as the separator between elements. Whitespace in
the separator matches any length of whitespace in the text, and a match
for whitespace around the separator is added.
::
PyObject *
PyArray_FromBuffer(PyObject *buf, PyArray_Descr *type, intp
count, intp offset)
::
PyObject *
PyArray_FromIter(PyObject *obj, PyArray_Descr *dtype, intp count)
steals a reference to dtype (which cannot be NULL)
::
PyObject *
PyArray_Return(PyArrayObject *mp)
Return either an array or the appropriate Python object if the array
is 0d and matches a Python type.
::
PyObject *
PyArray_GetField(PyArrayObject *self, PyArray_Descr *typed, int
offset)
Get a subset of bytes from each element of the array
::
int
PyArray_SetField(PyArrayObject *self, PyArray_Descr *dtype, int
offset, PyObject *val)
Set a subset of bytes from each element of the array
::
PyObject *
PyArray_Byteswap(PyArrayObject *self, Bool inplace)
::
PyObject *
PyArray_Resize(PyArrayObject *self, PyArray_Dims *newshape, int
refcheck, NPY_ORDER fortran)
Resize (reallocate data). Only works if nothing else is referencing this
array and it is contiguous. If refcheck is 0, then the reference count is
not checked and assumed to be 1. You still must own this data and have no
weak-references and no base object.
::
int
PyArray_MoveInto(PyArrayObject *dest, PyArrayObject *src)
Move the memory of one array into another.
::
int
PyArray_CopyInto(PyArrayObject *dest, PyArrayObject *src)
Copy an Array into another array -- memory must not overlap.
::
int
PyArray_CopyAnyInto(PyArrayObject *dest, PyArrayObject *src)
Copy an Array into another array -- memory must not overlap
Does not require src and dest to have "broadcastable" shapes
(only the same number of elements).
::
int
PyArray_CopyObject(PyArrayObject *dest, PyObject *src_object)
::
PyObject *
PyArray_NewCopy(PyArrayObject *m1, NPY_ORDER fortran)
Copy an array.
::
PyObject *
PyArray_ToList(PyArrayObject *self)
To List
::
PyObject *
PyArray_ToString(PyArrayObject *self, NPY_ORDER order)
::
int
PyArray_ToFile(PyArrayObject *self, FILE *fp, char *sep, char *format)
To File
::
int
PyArray_Dump(PyObject *self, PyObject *file, int protocol)
::
PyObject *
PyArray_Dumps(PyObject *self, int protocol)
::
int
PyArray_ValidType(int type)
Is the typenum valid?
::
void
PyArray_UpdateFlags(PyArrayObject *ret, int flagmask)
Update Several Flags at once.
::
PyObject *
PyArray_New(PyTypeObject *subtype, int nd, intp *dims, int
type_num, intp *strides, void *data, int itemsize, int
flags, PyObject *obj)
Generic new array creation routine.
::
PyObject *
PyArray_NewFromDescr(PyTypeObject *subtype, PyArray_Descr *descr, int
nd, intp *dims, intp *strides, void *data, int
flags, PyObject *obj)
Generic new array creation routine.
steals a reference to descr (even on failure)
::
PyArray_Descr *
PyArray_DescrNew(PyArray_Descr *base)
base cannot be NULL
::
PyArray_Descr *
PyArray_DescrNewFromType(int type_num)
::
double
PyArray_GetPriority(PyObject *obj, double default_)
Get Priority from object
::
PyObject *
PyArray_IterNew(PyObject *obj)
Get Iterator.
::
PyObject *
PyArray_MultiIterNew(int n, ... )
Get MultiIterator,
::
int
PyArray_PyIntAsInt(PyObject *o)
::
npy_intp
PyArray_PyIntAsIntp(PyObject *o)
::
int
PyArray_Broadcast(PyArrayMultiIterObject *mit)
::
void
PyArray_FillObjectArray(PyArrayObject *arr, PyObject *obj)
Assumes contiguous
::
int
PyArray_FillWithScalar(PyArrayObject *arr, PyObject *obj)
::
npy_bool
PyArray_CheckStrides(int elsize, int nd, intp numbytes, intp
offset, intp *dims, intp *newstrides)
::
PyArray_Descr *
PyArray_DescrNewByteorder(PyArray_Descr *self, char newendian)
returns a copy of the PyArray_Descr structure with the byteorder
altered:
no arguments: The byteorder is swapped (in all subfields as well)
single argument: The byteorder is forced to the given state
(in all subfields as well)
Valid states: ('big', '>') or ('little' or '<')
('native', or '=')
If a descr structure with | is encountered it's own
byte-order is not changed but any fields are:
Deep bytorder change of a data-type descriptor
Leaves reference count of self unchanged --- does not DECREF self ***
::
PyObject *
PyArray_IterAllButAxis(PyObject *obj, int *inaxis)
Get Iterator that iterates over all but one axis (don't use this with
PyArray_ITER_GOTO1D). The axis will be over-written if negative
with the axis having the smallest stride.
::
PyObject *
PyArray_CheckFromAny(PyObject *op, PyArray_Descr *descr, int
min_depth, int max_depth, int requires, PyObject
*context)
steals a reference to descr -- accepts NULL
::
PyObject *
PyArray_FromArray(PyArrayObject *arr, PyArray_Descr *newtype, int
flags)
steals reference to newtype --- acc. NULL
::
PyObject *
PyArray_FromInterface(PyObject *input)
::
PyObject *
PyArray_FromStructInterface(PyObject *input)
::
PyObject *
PyArray_FromArrayAttr(PyObject *op, PyArray_Descr *typecode, PyObject
*context)
::
NPY_SCALARKIND
PyArray_ScalarKind(int typenum, PyArrayObject **arr)
ScalarKind
::
int
PyArray_CanCoerceScalar(int thistype, int neededtype, NPY_SCALARKIND
scalar)
::
PyObject *
PyArray_NewFlagsObject(PyObject *obj)
Get New ArrayFlagsObject
::
npy_bool
PyArray_CanCastScalar(PyTypeObject *from, PyTypeObject *to)
See if array scalars can be cast.
::
int
PyArray_CompareUCS4(npy_ucs4 *s1, npy_ucs4 *s2, size_t len)
::
int
PyArray_RemoveSmallest(PyArrayMultiIterObject *multi)
Adjusts previously broadcasted iterators so that the axis with
the smallest sum of iterator strides is not iterated over.
Returns dimension which is smallest in the range [0,multi->nd).
A -1 is returned if multi->nd == 0.
don't use with PyArray_ITER_GOTO1D because factors are not adjusted
::
int
PyArray_ElementStrides(PyObject *arr)
::
void
PyArray_Item_INCREF(char *data, PyArray_Descr *descr)
::
void
PyArray_Item_XDECREF(char *data, PyArray_Descr *descr)
::
PyObject *
PyArray_FieldNames(PyObject *fields)
Return the tuple of ordered field names from a dictionary.
::
PyObject *
PyArray_Transpose(PyArrayObject *ap, PyArray_Dims *permute)
Return Transpose.
::
PyObject *
PyArray_TakeFrom(PyArrayObject *self0, PyObject *indices0, int
axis, PyArrayObject *ret, NPY_CLIPMODE clipmode)
Take
::
PyObject *
PyArray_PutTo(PyArrayObject *self, PyObject*values0, PyObject
*indices0, NPY_CLIPMODE clipmode)
Put values into an array
::
PyObject *
PyArray_PutMask(PyArrayObject *self, PyObject*values0, PyObject*mask0)
Put values into an array according to a mask.
::
PyObject *
PyArray_Repeat(PyArrayObject *aop, PyObject *op, int axis)
Repeat the array.
::
PyObject *
PyArray_Choose(PyArrayObject *ip, PyObject *op, PyArrayObject
*ret, NPY_CLIPMODE clipmode)
::
int
PyArray_Sort(PyArrayObject *op, int axis, NPY_SORTKIND which)
Sort an array in-place
::
PyObject *
PyArray_ArgSort(PyArrayObject *op, int axis, NPY_SORTKIND which)
ArgSort an array
::
PyObject *
PyArray_SearchSorted(PyArrayObject *op1, PyObject *op2, NPY_SEARCHSIDE
side)
Numeric.searchsorted(a,v)
::
PyObject *
PyArray_ArgMax(PyArrayObject *op, int axis, PyArrayObject *out)
ArgMax
::
PyObject *
PyArray_ArgMin(PyArrayObject *ap, int axis, PyArrayObject *out)
ArgMin
::
PyObject *
PyArray_Reshape(PyArrayObject *self, PyObject *shape)
Reshape
::
PyObject *
PyArray_Newshape(PyArrayObject *self, PyArray_Dims *newdims, NPY_ORDER
fortran)
New shape for an array
::
PyObject *
PyArray_Squeeze(PyArrayObject *self)
return a new view of the array object with all of its unit-length
dimensions squeezed out if needed, otherwise
return the same array.
::
PyObject *
PyArray_View(PyArrayObject *self, PyArray_Descr *type, PyTypeObject
*pytype)
View
steals a reference to type -- accepts NULL
::
PyObject *
PyArray_SwapAxes(PyArrayObject *ap, int a1, int a2)
SwapAxes
::
PyObject *
PyArray_Max(PyArrayObject *ap, int axis, PyArrayObject *out)
Max
::
PyObject *
PyArray_Min(PyArrayObject *ap, int axis, PyArrayObject *out)
Min
::
PyObject *
PyArray_Ptp(PyArrayObject *ap, int axis, PyArrayObject *out)
Ptp
::
PyObject *
PyArray_Mean(PyArrayObject *self, int axis, int rtype, PyArrayObject
*out)
Mean
::
PyObject *
PyArray_Trace(PyArrayObject *self, int offset, int axis1, int
axis2, int rtype, PyArrayObject *out)
Trace
::
PyObject *
PyArray_Diagonal(PyArrayObject *self, int offset, int axis1, int
axis2)
Diagonal
::
PyObject *
PyArray_Clip(PyArrayObject *self, PyObject *min, PyObject
*max, PyArrayObject *out)
Clip
::
PyObject *
PyArray_Conjugate(PyArrayObject *self, PyArrayObject *out)
Conjugate
::
PyObject *
PyArray_Nonzero(PyArrayObject *self)
Nonzero
::
PyObject *
PyArray_Std(PyArrayObject *self, int axis, int rtype, PyArrayObject
*out, int variance)
Set variance to 1 to by-pass square-root calculation and return variance
Std
::
PyObject *
PyArray_Sum(PyArrayObject *self, int axis, int rtype, PyArrayObject
*out)
Sum
::
PyObject *
PyArray_CumSum(PyArrayObject *self, int axis, int rtype, PyArrayObject
*out)
CumSum
::
PyObject *
PyArray_Prod(PyArrayObject *self, int axis, int rtype, PyArrayObject
*out)
Prod
::
PyObject *
PyArray_CumProd(PyArrayObject *self, int axis, int
rtype, PyArrayObject *out)
CumProd
::
PyObject *
PyArray_All(PyArrayObject *self, int axis, PyArrayObject *out)
All
::
PyObject *
PyArray_Any(PyArrayObject *self, int axis, PyArrayObject *out)
Any
::
PyObject *
PyArray_Compress(PyArrayObject *self, PyObject *condition, int
axis, PyArrayObject *out)
Compress
::
PyObject *
PyArray_Flatten(PyArrayObject *a, NPY_ORDER order)
Flatten
::
PyObject *
PyArray_Ravel(PyArrayObject *a, NPY_ORDER fortran)
Ravel
Returns a contiguous array
::
npy_intp
PyArray_MultiplyList(intp *l1, int n)
Multiply a List
::
int
PyArray_MultiplyIntList(int *l1, int n)
Multiply a List of ints
::
void *
PyArray_GetPtr(PyArrayObject *obj, intp*ind)
Produce a pointer into array
::
int
PyArray_CompareLists(intp *l1, intp *l2, int n)
Compare Lists
::
int
PyArray_AsCArray(PyObject **op, void *ptr, intp *dims, int
nd, PyArray_Descr*typedescr)
Simulate a C-array
steals a reference to typedescr -- can be NULL
::
int
PyArray_As1D(PyObject **op, char **ptr, int *d1, int typecode)
Convert to a 1D C-array
::
int
PyArray_As2D(PyObject **op, char ***ptr, int *d1, int *d2, int
typecode)
Convert to a 2D C-array
::
int
PyArray_Free(PyObject *op, void *ptr)
Free pointers created if As2D is called
::
int
PyArray_Converter(PyObject *object, PyObject **address)
Useful to pass as converter function for O& processing in PyArgs_ParseTuple.
This conversion function can be used with the "O&" argument for
PyArg_ParseTuple. It will immediately return an object of array type
or will convert to a CARRAY any other object.
If you use PyArray_Converter, you must DECREF the array when finished
as you get a new reference to it.
::
int
PyArray_IntpFromSequence(PyObject *seq, intp *vals, int maxvals)
PyArray_IntpFromSequence
Returns the number of dimensions or -1 if an error occurred.
vals must be large enough to hold maxvals
::
PyObject *
PyArray_Concatenate(PyObject *op, int axis)
Concatenate
Concatenate an arbitrary Python sequence into an array.
op is a python object supporting the sequence interface.
Its elements will be concatenated together to form a single
multidimensional array. If axis is MAX_DIMS or bigger, then
each sequence object will be flattened before concatenation
::
PyObject *
PyArray_InnerProduct(PyObject *op1, PyObject *op2)
Numeric.innerproduct(a,v)
::
PyObject *
PyArray_MatrixProduct(PyObject *op1, PyObject *op2)
Numeric.matrixproduct(a,v)
just like inner product but does the swapaxes stuff on the fly
::
PyObject *
PyArray_CopyAndTranspose(PyObject *op)
Fast Copy and Transpose
::
PyObject *
PyArray_Correlate(PyObject *op1, PyObject *op2, int mode)
Numeric.correlate(a1,a2,mode)
::
int
PyArray_TypestrConvert(int itemsize, int gentype)
Typestr converter
::
int
PyArray_DescrConverter(PyObject *obj, PyArray_Descr **at)
Get typenum from an object -- None goes to PyArray_DEFAULT
This function takes a Python object representing a type and converts it
to a the correct PyArray_Descr * structure to describe the type.
Many objects can be used to represent a data-type which in NumPy is
quite a flexible concept.
This is the central code that converts Python objects to
Type-descriptor objects that are used throughout numpy.
new reference in *at
::
int
PyArray_DescrConverter2(PyObject *obj, PyArray_Descr **at)
Get typenum from an object -- None goes to NULL
::
int
PyArray_IntpConverter(PyObject *obj, PyArray_Dims *seq)
Get intp chunk from sequence
This function takes a Python sequence object and allocates and
fills in an intp array with the converted values.
Remember to free the pointer seq.ptr when done using
PyDimMem_FREE(seq.ptr)**
::
int
PyArray_BufferConverter(PyObject *obj, PyArray_Chunk *buf)
Get buffer chunk from object
this function takes a Python object which exposes the (single-segment)
buffer interface and returns a pointer to the data segment
You should increment the reference count by one of buf->base
if you will hang on to a reference
You only get a borrowed reference to the object. Do not free the
memory...
::
int
PyArray_AxisConverter(PyObject *obj, int *axis)
Get axis from an object (possibly None) -- a converter function,
::
int
PyArray_BoolConverter(PyObject *object, Bool *val)
Convert an object to true / false
::
int
PyArray_ByteorderConverter(PyObject *obj, char *endian)
Convert object to endian
::
int
PyArray_OrderConverter(PyObject *object, NPY_ORDER *val)
Convert an object to FORTRAN / C / ANY
::
unsigned char
PyArray_EquivTypes(PyArray_Descr *typ1, PyArray_Descr *typ2)
This function returns true if the two typecodes are
equivalent (same basic kind and same itemsize).
::
PyObject *
PyArray_Zeros(int nd, intp *dims, PyArray_Descr *type, int fortran)
Zeros
steal a reference
accepts NULL type
::
PyObject *
PyArray_Empty(int nd, intp *dims, PyArray_Descr *type, int fortran)
Empty
accepts NULL type
steals referenct to type
::
PyObject *
PyArray_Where(PyObject *condition, PyObject *x, PyObject *y)
Where
::
PyObject *
PyArray_Arange(double start, double stop, double step, int type_num)
Arange,
::
PyObject *
PyArray_ArangeObj(PyObject *start, PyObject *stop, PyObject
*step, PyArray_Descr *dtype)
ArangeObj,
this doesn't change the references
::
int
PyArray_SortkindConverter(PyObject *obj, NPY_SORTKIND *sortkind)
Convert object to sort kind
::
PyObject *
PyArray_LexSort(PyObject *sort_keys, int axis)
LexSort an array providing indices that will sort a collection of arrays
lexicographically. The first key is sorted on first, followed by the second key
-- requires that arg"merge"sort is available for each sort_key
Returns an index array that shows the indexes for the lexicographic sort along
the given axis.
::
PyObject *
PyArray_Round(PyArrayObject *a, int decimals, PyArrayObject *out)
Round
::
unsigned char
PyArray_EquivTypenums(int typenum1, int typenum2)
::
int
PyArray_RegisterDataType(PyArray_Descr *descr)
Register Data type
Does not change the reference count of descr
::
int
PyArray_RegisterCastFunc(PyArray_Descr *descr, int
totype, PyArray_VectorUnaryFunc *castfunc)
Register Casting Function
Replaces any function currently stored.
::
int
PyArray_RegisterCanCast(PyArray_Descr *descr, int
totype, NPY_SCALARKIND scalar)
Register a type number indicating that a descriptor can be cast
to it safely
::
void
PyArray_InitArrFuncs(PyArray_ArrFuncs *f)
Initialize arrfuncs to NULL
::
PyObject *
PyArray_IntTupleFromIntp(int len, intp *vals)
PyArray_IntTupleFromIntp
::
int
PyArray_TypeNumFromName(char *str)
::
int
PyArray_ClipmodeConverter(PyObject *object, NPY_CLIPMODE *val)
Convert an object to NPY_RAISE / NPY_CLIP / NPY_WRAP
::
int
PyArray_OutputConverter(PyObject *object, PyArrayObject **address)
Useful to pass as converter function for O& processing in
PyArgs_ParseTuple for output arrays
::
PyObject *
PyArray_BroadcastToShape(PyObject *obj, intp *dims, int nd)
Get Iterator broadcast to a particular shape
::
void
_PyArray_SigintHandler(int signum)
::
void*
_PyArray_GetSigintBuf(void )
::
int
PyArray_DescrAlignConverter(PyObject *obj, PyArray_Descr **at)
Get type-descriptor from an object forcing alignment if possible
None goes to DEFAULT type.
any object with the .fields attribute and/or .itemsize attribute (if the
.fields attribute does not give the total size -- i.e. a partial record
naming). If itemsize is given it must be >= size computed from fields
The .fields attribute must return a convertible dictionary if present.
Result inherits from PyArray_VOID.
::
int
PyArray_DescrAlignConverter2(PyObject *obj, PyArray_Descr **at)
Get type-descriptor from an object forcing alignment if possible
None goes to NULL.
::
int
PyArray_SearchsideConverter(PyObject *obj, void *addr)
Convert object to searchsorted side
::
PyObject *
PyArray_CheckAxis(PyArrayObject *arr, int *axis, int flags)
PyArray_CheckAxis
check that axis is valid
convert 0-d arrays to 1-d arrays
::
npy_intp
PyArray_OverflowMultiplyList(intp *l1, int n)
Multiply a List of Non-negative numbers with over-flow detection.
::
int
PyArray_CompareString(char *s1, char *s2, size_t len)
::
PyObject *
PyArray_MultiIterFromObjects(PyObject **mps, int n, int nadd, ... )
Get MultiIterator from array of Python objects and any additional
PyObject **mps -- array of PyObjects
int n - number of PyObjects in the array
int nadd - number of additional arrays to include in the iterator.
Returns a multi-iterator object.
::
int
PyArray_GetEndianness(void )
::
unsigned int
PyArray_GetNDArrayCFeatureVersion(void )
Returns the built-in (at compilation time) C API version
::
PyObject *
PyArray_Correlate2(PyObject *op1, PyObject *op2, int mode)
correlate(a1,a2,mode)
This function computes the usual correlation (correlate(a1, a2) !=
correlate(a2, a1), and conjugate the second argument for complex inputs
::
PyObject*
PyArray_NeighborhoodIterNew(PyArrayIterObject *x, intp *bounds, int
mode, PyArrayObject*fill)
A Neighborhood Iterator object.
PK e[sUM M arrayscalars.hnu W+A #ifndef _NPY_ARRAYSCALARS_H_
#define _NPY_ARRAYSCALARS_H_
#ifndef _MULTIARRAYMODULE
typedef struct {
PyObject_HEAD
npy_bool obval;
} PyBoolScalarObject;
#endif
typedef struct {
PyObject_HEAD
signed char obval;
} PyByteScalarObject;
typedef struct {
PyObject_HEAD
short obval;
} PyShortScalarObject;
typedef struct {
PyObject_HEAD
int obval;
} PyIntScalarObject;
typedef struct {
PyObject_HEAD
long obval;
} PyLongScalarObject;
typedef struct {
PyObject_HEAD
npy_longlong obval;
} PyLongLongScalarObject;
typedef struct {
PyObject_HEAD
unsigned char obval;
} PyUByteScalarObject;
typedef struct {
PyObject_HEAD
unsigned short obval;
} PyUShortScalarObject;
typedef struct {
PyObject_HEAD
unsigned int obval;
} PyUIntScalarObject;
typedef struct {
PyObject_HEAD
unsigned long obval;
} PyULongScalarObject;
typedef struct {
PyObject_HEAD
npy_ulonglong obval;
} PyULongLongScalarObject;
typedef struct {
PyObject_HEAD
float obval;
} PyFloatScalarObject;
typedef struct {
PyObject_HEAD
double obval;
} PyDoubleScalarObject;
typedef struct {
PyObject_HEAD
npy_longdouble obval;
} PyLongDoubleScalarObject;
typedef struct {
PyObject_HEAD
npy_cfloat obval;
} PyCFloatScalarObject;
typedef struct {
PyObject_HEAD
npy_cdouble obval;
} PyCDoubleScalarObject;
typedef struct {
PyObject_HEAD
npy_clongdouble obval;
} PyCLongDoubleScalarObject;
typedef struct {
PyObject_HEAD
PyObject * obval;
} PyObjectScalarObject;
typedef struct {
PyObject_HEAD
char obval;
} PyScalarObject;
#define PyStringScalarObject PyStringObject
#define PyUnicodeScalarObject PyUnicodeObject
typedef struct {
PyObject_VAR_HEAD
char *obval;
PyArray_Descr *descr;
int flags;
PyObject *base;
} PyVoidScalarObject;
/* Macros
PyScalarObject
PyArrType_Type
are defined in ndarrayobject.h
*/
#define PyArrayScalar_False ((PyObject *)(&(_PyArrayScalar_BoolValues[0])))
#define PyArrayScalar_True ((PyObject *)(&(_PyArrayScalar_BoolValues[1])))
#define PyArrayScalar_FromLong(i) \
((PyObject *)(&(_PyArrayScalar_BoolValues[((i)!=0)])))
#define PyArrayScalar_RETURN_BOOL_FROM_LONG(i) \
return Py_INCREF(PyArrayScalar_FromLong(i)), \
PyArrayScalar_FromLong(i)
#define PyArrayScalar_RETURN_FALSE \
return Py_INCREF(PyArrayScalar_False), \
PyArrayScalar_False
#define PyArrayScalar_RETURN_TRUE \
return Py_INCREF(PyArrayScalar_True), \
PyArrayScalar_True
#define PyArrayScalar_New(cls) \
Py##cls##ArrType_Type.tp_alloc(&Py##cls##ArrType_Type, 0)
#define PyArrayScalar_VAL(obj, cls) \
((Py##cls##ScalarObject *)obj)->obval
#define PyArrayScalar_ASSIGN(obj, cls, val) \
PyArrayScalar_VAL(obj, cls) = val
#endif
PK e[2RE E _neighborhood_iterator_imp.hnu W+A #ifndef _NPY_INCLUDE_NEIGHBORHOOD_IMP
#error You should not include this header directly
#endif
/*
* Private API (here for inline)
*/
static NPY_INLINE int
_PyArrayNeighborhoodIter_IncrCoord(PyArrayNeighborhoodIterObject* iter);
/*
* Update to next item of the iterator
*
* Note: this simply increment the coordinates vector, last dimension
* incremented first , i.e, for dimension 3
* ...
* -1, -1, -1
* -1, -1, 0
* -1, -1, 1
* ....
* -1, 0, -1
* -1, 0, 0
* ....
* 0, -1, -1
* 0, -1, 0
* ....
*/
#define _UPDATE_COORD_ITER(c) \
wb = iter->coordinates[c] < iter->bounds[c][1]; \
if (wb) { \
iter->coordinates[c] += 1; \
return 0; \
} \
else { \
iter->coordinates[c] = iter->bounds[c][0]; \
}
static NPY_INLINE int
_PyArrayNeighborhoodIter_IncrCoord(PyArrayNeighborhoodIterObject* iter)
{
npy_intp i, wb;
for (i = iter->nd - 1; i >= 0; --i) {
_UPDATE_COORD_ITER(i)
}
return 0;
}
/*
* Version optimized for 2d arrays, manual loop unrolling
*/
static NPY_INLINE int
_PyArrayNeighborhoodIter_IncrCoord2D(PyArrayNeighborhoodIterObject* iter)
{
npy_intp wb;
_UPDATE_COORD_ITER(1)
_UPDATE_COORD_ITER(0)
return 0;
}
#undef _UPDATE_COORD_ITER
/*
* Advance to the next neighbour
*/
static NPY_INLINE int
PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject* iter)
{
_PyArrayNeighborhoodIter_IncrCoord (iter);
iter->dataptr = iter->translate((PyArrayIterObject*)iter, iter->coordinates);
return 0;
}
/*
* Reset functions
*/
static NPY_INLINE int
PyArrayNeighborhoodIter_Reset(PyArrayNeighborhoodIterObject* iter)
{
npy_intp i;
for (i = 0; i < iter->nd; ++i) {
iter->coordinates[i] = iter->bounds[i][0];
}
iter->dataptr = iter->translate((PyArrayIterObject*)iter, iter->coordinates);
return 0;
}
PK e[EU1 1 npy_os.hnu W+A #ifndef _NPY_OS_H_
#define _NPY_OS_H_
#if defined(linux) || defined(__linux) || defined(__linux__)
#define NPY_OS_LINUX
#elif defined(__FreeBSD__) || defined(__NetBSD__) || \
defined(__OpenBSD__) || defined(__DragonFly__)
#define NPY_OS_BSD
#ifdef __FreeBSD__
#define NPY_OS_FREEBSD
#elif defined(__NetBSD__)
#define NPY_OS_NETBSD
#elif defined(__OpenBSD__)
#define NPY_OS_OPENBSD
#elif defined(__DragonFly__)
#define NPY_OS_DRAGONFLY
#endif
#elif defined(sun) || defined(__sun)
#define NPY_OS_SOLARIS
#elif defined(__CYGWIN__)
#define NPY_OS_CYGWIN
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
#define NPY_OS_WIN32
#elif defined(__APPLE__)
#define NPY_OS_DARWIN
#else
#define NPY_OS_UNKNOWN
#endif
#endif
PK e[[#S oldnumeric.hnu W+A #include "arrayobject.h"
#ifndef REFCOUNT
# define REFCOUNT NPY_REFCOUNT
# define MAX_ELSIZE 16
#endif
#define PyArray_UNSIGNED_TYPES
#define PyArray_SBYTE PyArray_BYTE
#define PyArray_CopyArray PyArray_CopyInto
#define _PyArray_multiply_list PyArray_MultiplyIntList
#define PyArray_ISSPACESAVER(m) NPY_FALSE
#define PyScalarArray_Check PyArray_CheckScalar
#define CONTIGUOUS NPY_CONTIGUOUS
#define OWN_DIMENSIONS 0
#define OWN_STRIDES 0
#define OWN_DATA NPY_OWNDATA
#define SAVESPACE 0
#define SAVESPACEBIT 0
#undef import_array
#define import_array() { if (_import_array() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import"); } }
PK e[/-2 2 __multiarray_api.hnu W+A
#ifdef _MULTIARRAYMODULE
typedef struct {
PyObject_HEAD
npy_bool obval;
} PyBoolScalarObject;
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyArrayMapIter_Type;
extern NPY_NO_EXPORT PyTypeObject PyArrayNeighborhoodIter_Type;
extern NPY_NO_EXPORT PyBoolScalarObject _PyArrayScalar_BoolValues[2];
#else
NPY_NO_EXPORT PyTypeObject PyArrayMapIter_Type;
NPY_NO_EXPORT PyTypeObject PyArrayNeighborhoodIter_Type;
NPY_NO_EXPORT PyBoolScalarObject _PyArrayScalar_BoolValues[2];
#endif
NPY_NO_EXPORT unsigned int PyArray_GetNDArrayCVersion \
(void);
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyBigArray_Type;
#else
NPY_NO_EXPORT PyTypeObject PyBigArray_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyArray_Type;
#else
NPY_NO_EXPORT PyTypeObject PyArray_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyArrayDescr_Type;
#else
NPY_NO_EXPORT PyTypeObject PyArrayDescr_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyArrayFlags_Type;
#else
NPY_NO_EXPORT PyTypeObject PyArrayFlags_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyArrayIter_Type;
#else
NPY_NO_EXPORT PyTypeObject PyArrayIter_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyArrayMultiIter_Type;
#else
NPY_NO_EXPORT PyTypeObject PyArrayMultiIter_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT int NPY_NUMUSERTYPES;
#else
NPY_NO_EXPORT int NPY_NUMUSERTYPES;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyBoolArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyBoolArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyBoolScalarObject _PyArrayScalar_BoolValues[2];
#else
NPY_NO_EXPORT PyBoolScalarObject _PyArrayScalar_BoolValues[2];
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyGenericArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyGenericArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyNumberArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyNumberArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyIntegerArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyIntegerArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PySignedIntegerArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PySignedIntegerArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyUnsignedIntegerArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyUnsignedIntegerArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyInexactArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyInexactArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyFloatingArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyFloatingArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyComplexFloatingArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyComplexFloatingArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyFlexibleArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyFlexibleArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyCharacterArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyCharacterArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyByteArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyByteArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyShortArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyShortArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyIntArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyIntArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyLongArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyLongArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyLongLongArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyLongLongArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyUByteArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyUByteArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyUShortArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyUShortArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyUIntArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyUIntArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyULongArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyULongArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyULongLongArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyULongLongArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyFloatArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyFloatArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyDoubleArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyDoubleArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyLongDoubleArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyLongDoubleArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyCFloatArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyCFloatArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyCDoubleArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyCDoubleArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyCLongDoubleArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyCLongDoubleArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyObjectArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyObjectArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyStringArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyStringArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyUnicodeArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyUnicodeArrType_Type;
#endif
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
extern NPY_NO_EXPORT PyTypeObject PyVoidArrType_Type;
#else
NPY_NO_EXPORT PyTypeObject PyVoidArrType_Type;
#endif
NPY_NO_EXPORT int PyArray_SetNumericOps \
(PyObject *);
NPY_NO_EXPORT PyObject * PyArray_GetNumericOps \
(void);
NPY_NO_EXPORT int PyArray_INCREF \
(PyArrayObject *);
NPY_NO_EXPORT int PyArray_XDECREF \
(PyArrayObject *);
NPY_NO_EXPORT void PyArray_SetStringFunction \
(PyObject *, int);
NPY_NO_EXPORT PyArray_Descr * PyArray_DescrFromType \
(int);
NPY_NO_EXPORT PyObject * PyArray_TypeObjectFromType \
(int);
NPY_NO_EXPORT char * PyArray_Zero \
(PyArrayObject *);
NPY_NO_EXPORT char * PyArray_One \
(PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_CastToType \
(PyArrayObject *, PyArray_Descr *, int);
NPY_NO_EXPORT int PyArray_CastTo \
(PyArrayObject *, PyArrayObject *);
NPY_NO_EXPORT int PyArray_CastAnyTo \
(PyArrayObject *, PyArrayObject *);
NPY_NO_EXPORT int PyArray_CanCastSafely \
(int, int);
NPY_NO_EXPORT npy_bool PyArray_CanCastTo \
(PyArray_Descr *, PyArray_Descr *);
NPY_NO_EXPORT int PyArray_ObjectType \
(PyObject *, int);
NPY_NO_EXPORT PyArray_Descr * PyArray_DescrFromObject \
(PyObject *, PyArray_Descr *);
NPY_NO_EXPORT PyArrayObject ** PyArray_ConvertToCommonType \
(PyObject *, int *);
NPY_NO_EXPORT PyArray_Descr * PyArray_DescrFromScalar \
(PyObject *);
NPY_NO_EXPORT PyArray_Descr * PyArray_DescrFromTypeObject \
(PyObject *);
NPY_NO_EXPORT npy_intp PyArray_Size \
(PyObject *);
NPY_NO_EXPORT PyObject * PyArray_Scalar \
(void *, PyArray_Descr *, PyObject *);
NPY_NO_EXPORT PyObject * PyArray_FromScalar \
(PyObject *, PyArray_Descr *);
NPY_NO_EXPORT void PyArray_ScalarAsCtype \
(PyObject *, void *);
NPY_NO_EXPORT int PyArray_CastScalarToCtype \
(PyObject *, void *, PyArray_Descr *);
NPY_NO_EXPORT int PyArray_CastScalarDirect \
(PyObject *, PyArray_Descr *, void *, int);
NPY_NO_EXPORT PyObject * PyArray_ScalarFromObject \
(PyObject *);
NPY_NO_EXPORT PyArray_VectorUnaryFunc * PyArray_GetCastFunc \
(PyArray_Descr *, int);
NPY_NO_EXPORT PyObject * PyArray_FromDims \
(int, int *, int);
NPY_NO_EXPORT PyObject * PyArray_FromDimsAndDataAndDescr \
(int, int *, PyArray_Descr *, char *);
NPY_NO_EXPORT PyObject * PyArray_FromAny \
(PyObject *, PyArray_Descr *, int, int, int, PyObject *);
NPY_NO_EXPORT PyObject * PyArray_EnsureArray \
(PyObject *);
NPY_NO_EXPORT PyObject * PyArray_EnsureAnyArray \
(PyObject *);
NPY_NO_EXPORT PyObject * PyArray_FromFile \
(FILE *, PyArray_Descr *, npy_intp, char *);
NPY_NO_EXPORT PyObject * PyArray_FromString \
(char *, npy_intp, PyArray_Descr *, npy_intp, char *);
NPY_NO_EXPORT PyObject * PyArray_FromBuffer \
(PyObject *, PyArray_Descr *, npy_intp, npy_intp);
NPY_NO_EXPORT PyObject * PyArray_FromIter \
(PyObject *, PyArray_Descr *, npy_intp);
NPY_NO_EXPORT PyObject * PyArray_Return \
(PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_GetField \
(PyArrayObject *, PyArray_Descr *, int);
NPY_NO_EXPORT int PyArray_SetField \
(PyArrayObject *, PyArray_Descr *, int, PyObject *);
NPY_NO_EXPORT PyObject * PyArray_Byteswap \
(PyArrayObject *, npy_bool);
NPY_NO_EXPORT PyObject * PyArray_Resize \
(PyArrayObject *, PyArray_Dims *, int, NPY_ORDER);
NPY_NO_EXPORT int PyArray_MoveInto \
(PyArrayObject *, PyArrayObject *);
NPY_NO_EXPORT int PyArray_CopyInto \
(PyArrayObject *, PyArrayObject *);
NPY_NO_EXPORT int PyArray_CopyAnyInto \
(PyArrayObject *, PyArrayObject *);
NPY_NO_EXPORT int PyArray_CopyObject \
(PyArrayObject *, PyObject *);
NPY_NO_EXPORT PyObject * PyArray_NewCopy \
(PyArrayObject *, NPY_ORDER);
NPY_NO_EXPORT PyObject * PyArray_ToList \
(PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_ToString \
(PyArrayObject *, NPY_ORDER);
NPY_NO_EXPORT int PyArray_ToFile \
(PyArrayObject *, FILE *, char *, char *);
NPY_NO_EXPORT int PyArray_Dump \
(PyObject *, PyObject *, int);
NPY_NO_EXPORT PyObject * PyArray_Dumps \
(PyObject *, int);
NPY_NO_EXPORT int PyArray_ValidType \
(int);
NPY_NO_EXPORT void PyArray_UpdateFlags \
(PyArrayObject *, int);
NPY_NO_EXPORT PyObject * PyArray_New \
(PyTypeObject *, int, npy_intp *, int, npy_intp *, void *, int, int, PyObject *);
NPY_NO_EXPORT PyObject * PyArray_NewFromDescr \
(PyTypeObject *, PyArray_Descr *, int, npy_intp *, npy_intp *, void *, int, PyObject *);
NPY_NO_EXPORT PyArray_Descr * PyArray_DescrNew \
(PyArray_Descr *);
NPY_NO_EXPORT PyArray_Descr * PyArray_DescrNewFromType \
(int);
NPY_NO_EXPORT double PyArray_GetPriority \
(PyObject *, double);
NPY_NO_EXPORT PyObject * PyArray_IterNew \
(PyObject *);
NPY_NO_EXPORT PyObject * PyArray_MultiIterNew \
(int, ...);
NPY_NO_EXPORT int PyArray_PyIntAsInt \
(PyObject *);
NPY_NO_EXPORT npy_intp PyArray_PyIntAsIntp \
(PyObject *);
NPY_NO_EXPORT int PyArray_Broadcast \
(PyArrayMultiIterObject *);
NPY_NO_EXPORT void PyArray_FillObjectArray \
(PyArrayObject *, PyObject *);
NPY_NO_EXPORT int PyArray_FillWithScalar \
(PyArrayObject *, PyObject *);
NPY_NO_EXPORT npy_bool PyArray_CheckStrides \
(int, int, npy_intp, npy_intp, npy_intp *, npy_intp *);
NPY_NO_EXPORT PyArray_Descr * PyArray_DescrNewByteorder \
(PyArray_Descr *, char);
NPY_NO_EXPORT PyObject * PyArray_IterAllButAxis \
(PyObject *, int *);
NPY_NO_EXPORT PyObject * PyArray_CheckFromAny \
(PyObject *, PyArray_Descr *, int, int, int, PyObject *);
NPY_NO_EXPORT PyObject * PyArray_FromArray \
(PyArrayObject *, PyArray_Descr *, int);
NPY_NO_EXPORT PyObject * PyArray_FromInterface \
(PyObject *);
NPY_NO_EXPORT PyObject * PyArray_FromStructInterface \
(PyObject *);
NPY_NO_EXPORT PyObject * PyArray_FromArrayAttr \
(PyObject *, PyArray_Descr *, PyObject *);
NPY_NO_EXPORT NPY_SCALARKIND PyArray_ScalarKind \
(int, PyArrayObject **);
NPY_NO_EXPORT int PyArray_CanCoerceScalar \
(int, int, NPY_SCALARKIND);
NPY_NO_EXPORT PyObject * PyArray_NewFlagsObject \
(PyObject *);
NPY_NO_EXPORT npy_bool PyArray_CanCastScalar \
(PyTypeObject *, PyTypeObject *);
NPY_NO_EXPORT int PyArray_CompareUCS4 \
(npy_ucs4 *, npy_ucs4 *, size_t);
NPY_NO_EXPORT int PyArray_RemoveSmallest \
(PyArrayMultiIterObject *);
NPY_NO_EXPORT int PyArray_ElementStrides \
(PyObject *);
NPY_NO_EXPORT void PyArray_Item_INCREF \
(char *, PyArray_Descr *);
NPY_NO_EXPORT void PyArray_Item_XDECREF \
(char *, PyArray_Descr *);
NPY_NO_EXPORT PyObject * PyArray_FieldNames \
(PyObject *);
NPY_NO_EXPORT PyObject * PyArray_Transpose \
(PyArrayObject *, PyArray_Dims *);
NPY_NO_EXPORT PyObject * PyArray_TakeFrom \
(PyArrayObject *, PyObject *, int, PyArrayObject *, NPY_CLIPMODE);
NPY_NO_EXPORT PyObject * PyArray_PutTo \
(PyArrayObject *, PyObject*, PyObject *, NPY_CLIPMODE);
NPY_NO_EXPORT PyObject * PyArray_PutMask \
(PyArrayObject *, PyObject*, PyObject*);
NPY_NO_EXPORT PyObject * PyArray_Repeat \
(PyArrayObject *, PyObject *, int);
NPY_NO_EXPORT PyObject * PyArray_Choose \
(PyArrayObject *, PyObject *, PyArrayObject *, NPY_CLIPMODE);
NPY_NO_EXPORT int PyArray_Sort \
(PyArrayObject *, int, NPY_SORTKIND);
NPY_NO_EXPORT PyObject * PyArray_ArgSort \
(PyArrayObject *, int, NPY_SORTKIND);
NPY_NO_EXPORT PyObject * PyArray_SearchSorted \
(PyArrayObject *, PyObject *, NPY_SEARCHSIDE);
NPY_NO_EXPORT PyObject * PyArray_ArgMax \
(PyArrayObject *, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_ArgMin \
(PyArrayObject *, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Reshape \
(PyArrayObject *, PyObject *);
NPY_NO_EXPORT PyObject * PyArray_Newshape \
(PyArrayObject *, PyArray_Dims *, NPY_ORDER);
NPY_NO_EXPORT PyObject * PyArray_Squeeze \
(PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_View \
(PyArrayObject *, PyArray_Descr *, PyTypeObject *);
NPY_NO_EXPORT PyObject * PyArray_SwapAxes \
(PyArrayObject *, int, int);
NPY_NO_EXPORT PyObject * PyArray_Max \
(PyArrayObject *, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Min \
(PyArrayObject *, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Ptp \
(PyArrayObject *, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Mean \
(PyArrayObject *, int, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Trace \
(PyArrayObject *, int, int, int, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Diagonal \
(PyArrayObject *, int, int, int);
NPY_NO_EXPORT PyObject * PyArray_Clip \
(PyArrayObject *, PyObject *, PyObject *, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Conjugate \
(PyArrayObject *, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Nonzero \
(PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Std \
(PyArrayObject *, int, int, PyArrayObject *, int);
NPY_NO_EXPORT PyObject * PyArray_Sum \
(PyArrayObject *, int, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_CumSum \
(PyArrayObject *, int, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Prod \
(PyArrayObject *, int, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_CumProd \
(PyArrayObject *, int, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_All \
(PyArrayObject *, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Any \
(PyArrayObject *, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Compress \
(PyArrayObject *, PyObject *, int, PyArrayObject *);
NPY_NO_EXPORT PyObject * PyArray_Flatten \
(PyArrayObject *, NPY_ORDER);
NPY_NO_EXPORT PyObject * PyArray_Ravel \
(PyArrayObject *, NPY_ORDER);
NPY_NO_EXPORT npy_intp PyArray_MultiplyList \
(npy_intp *, int);
NPY_NO_EXPORT int PyArray_MultiplyIntList \
(int *, int);
NPY_NO_EXPORT void * PyArray_GetPtr \
(PyArrayObject *, npy_intp*);
NPY_NO_EXPORT int PyArray_CompareLists \
(npy_intp *, npy_intp *, int);
NPY_NO_EXPORT int PyArray_AsCArray \
(PyObject **, void *, npy_intp *, int, PyArray_Descr*);
NPY_NO_EXPORT int PyArray_As1D \
(PyObject **, char **, int *, int);
NPY_NO_EXPORT int PyArray_As2D \
(PyObject **, char ***, int *, int *, int);
NPY_NO_EXPORT int PyArray_Free \
(PyObject *, void *);
NPY_NO_EXPORT int PyArray_Converter \
(PyObject *, PyObject **);
NPY_NO_EXPORT int PyArray_IntpFromSequence \
(PyObject *, npy_intp *, int);
NPY_NO_EXPORT PyObject * PyArray_Concatenate \
(PyObject *, int);
NPY_NO_EXPORT PyObject * PyArray_InnerProduct \
(PyObject *, PyObject *);
NPY_NO_EXPORT PyObject * PyArray_MatrixProduct \
(PyObject *, PyObject *);
NPY_NO_EXPORT PyObject * PyArray_CopyAndTranspose \
(PyObject *);
NPY_NO_EXPORT PyObject * PyArray_Correlate \
(PyObject *, PyObject *, int);
NPY_NO_EXPORT int PyArray_TypestrConvert \
(int, int);
NPY_NO_EXPORT int PyArray_DescrConverter \
(PyObject *, PyArray_Descr **);
NPY_NO_EXPORT int PyArray_DescrConverter2 \
(PyObject *, PyArray_Descr **);
NPY_NO_EXPORT int PyArray_IntpConverter \
(PyObject *, PyArray_Dims *);
NPY_NO_EXPORT int PyArray_BufferConverter \
(PyObject *, PyArray_Chunk *);
NPY_NO_EXPORT int PyArray_AxisConverter \
(PyObject *, int *);
NPY_NO_EXPORT int PyArray_BoolConverter \
(PyObject *, npy_bool *);
NPY_NO_EXPORT int PyArray_ByteorderConverter \
(PyObject *, char *);
NPY_NO_EXPORT int PyArray_OrderConverter \
(PyObject *, NPY_ORDER *);
NPY_NO_EXPORT unsigned char PyArray_EquivTypes \
(PyArray_Descr *, PyArray_Descr *);
NPY_NO_EXPORT PyObject * PyArray_Zeros \
(int, npy_intp *, PyArray_Descr *, int);
NPY_NO_EXPORT PyObject * PyArray_Empty \
(int, npy_intp *, PyArray_Descr *, int);
NPY_NO_EXPORT PyObject * PyArray_Where \
(PyObject *, PyObject *, PyObject *);
NPY_NO_EXPORT PyObject * PyArray_Arange \
(double, double, double, int);
NPY_NO_EXPORT PyObject * PyArray_ArangeObj \
(PyObject *, PyObject *, PyObject *, PyArray_Descr *);
NPY_NO_EXPORT int PyArray_SortkindConverter \
(PyObject *, NPY_SORTKIND *);
NPY_NO_EXPORT PyObject * PyArray_LexSort \
(PyObject *, int);
NPY_NO_EXPORT PyObject * PyArray_Round \
(PyArrayObject *, int, PyArrayObject *);
NPY_NO_EXPORT unsigned char PyArray_EquivTypenums \
(int, int);
NPY_NO_EXPORT int PyArray_RegisterDataType \
(PyArray_Descr *);
NPY_NO_EXPORT int PyArray_RegisterCastFunc \
(PyArray_Descr *, int, PyArray_VectorUnaryFunc *);
NPY_NO_EXPORT int PyArray_RegisterCanCast \
(PyArray_Descr *, int, NPY_SCALARKIND);
NPY_NO_EXPORT void PyArray_InitArrFuncs \
(PyArray_ArrFuncs *);
NPY_NO_EXPORT PyObject * PyArray_IntTupleFromIntp \
(int, npy_intp *);
NPY_NO_EXPORT int PyArray_TypeNumFromName \
(char *);
NPY_NO_EXPORT int PyArray_ClipmodeConverter \
(PyObject *, NPY_CLIPMODE *);
NPY_NO_EXPORT int PyArray_OutputConverter \
(PyObject *, PyArrayObject **);
NPY_NO_EXPORT PyObject * PyArray_BroadcastToShape \
(PyObject *, npy_intp *, int);
NPY_NO_EXPORT void _PyArray_SigintHandler \
(int);
NPY_NO_EXPORT void* _PyArray_GetSigintBuf \
(void);
NPY_NO_EXPORT int PyArray_DescrAlignConverter \
(PyObject *, PyArray_Descr **);
NPY_NO_EXPORT int PyArray_DescrAlignConverter2 \
(PyObject *, PyArray_Descr **);
NPY_NO_EXPORT int PyArray_SearchsideConverter \
(PyObject *, void *);
NPY_NO_EXPORT PyObject * PyArray_CheckAxis \
(PyArrayObject *, int *, int);
NPY_NO_EXPORT npy_intp PyArray_OverflowMultiplyList \
(npy_intp *, int);
NPY_NO_EXPORT int PyArray_CompareString \
(char *, char *, size_t);
NPY_NO_EXPORT PyObject * PyArray_MultiIterFromObjects \
(PyObject **, int, int, ...);
NPY_NO_EXPORT int PyArray_GetEndianness \
(void);
NPY_NO_EXPORT unsigned int PyArray_GetNDArrayCFeatureVersion \
(void);
NPY_NO_EXPORT PyObject * PyArray_Correlate2 \
(PyObject *, PyObject *, int);
NPY_NO_EXPORT PyObject* PyArray_NeighborhoodIterNew \
(PyArrayIterObject *, npy_intp *, int, PyArrayObject*);
#else
#if defined(PY_ARRAY_UNIQUE_SYMBOL)
#define PyArray_API PY_ARRAY_UNIQUE_SYMBOL
#endif
#if defined(NO_IMPORT) || defined(NO_IMPORT_ARRAY)
extern void **PyArray_API;
#else
#if defined(PY_ARRAY_UNIQUE_SYMBOL)
void **PyArray_API;
#else
static void **PyArray_API=NULL;
#endif
#endif
#define PyArray_GetNDArrayCVersion \
(*(unsigned int (*)(void)) \
PyArray_API[0])
#define PyBigArray_Type (*(PyTypeObject *)PyArray_API[1])
#define PyArray_Type (*(PyTypeObject *)PyArray_API[2])
#define PyArrayDescr_Type (*(PyTypeObject *)PyArray_API[3])
#define PyArrayFlags_Type (*(PyTypeObject *)PyArray_API[4])
#define PyArrayIter_Type (*(PyTypeObject *)PyArray_API[5])
#define PyArrayMultiIter_Type (*(PyTypeObject *)PyArray_API[6])
#define NPY_NUMUSERTYPES (*(int *)PyArray_API[7])
#define PyBoolArrType_Type (*(PyTypeObject *)PyArray_API[8])
#define _PyArrayScalar_BoolValues ((PyBoolScalarObject *)PyArray_API[9])
#define PyGenericArrType_Type (*(PyTypeObject *)PyArray_API[10])
#define PyNumberArrType_Type (*(PyTypeObject *)PyArray_API[11])
#define PyIntegerArrType_Type (*(PyTypeObject *)PyArray_API[12])
#define PySignedIntegerArrType_Type (*(PyTypeObject *)PyArray_API[13])
#define PyUnsignedIntegerArrType_Type (*(PyTypeObject *)PyArray_API[14])
#define PyInexactArrType_Type (*(PyTypeObject *)PyArray_API[15])
#define PyFloatingArrType_Type (*(PyTypeObject *)PyArray_API[16])
#define PyComplexFloatingArrType_Type (*(PyTypeObject *)PyArray_API[17])
#define PyFlexibleArrType_Type (*(PyTypeObject *)PyArray_API[18])
#define PyCharacterArrType_Type (*(PyTypeObject *)PyArray_API[19])
#define PyByteArrType_Type (*(PyTypeObject *)PyArray_API[20])
#define PyShortArrType_Type (*(PyTypeObject *)PyArray_API[21])
#define PyIntArrType_Type (*(PyTypeObject *)PyArray_API[22])
#define PyLongArrType_Type (*(PyTypeObject *)PyArray_API[23])
#define PyLongLongArrType_Type (*(PyTypeObject *)PyArray_API[24])
#define PyUByteArrType_Type (*(PyTypeObject *)PyArray_API[25])
#define PyUShortArrType_Type (*(PyTypeObject *)PyArray_API[26])
#define PyUIntArrType_Type (*(PyTypeObject *)PyArray_API[27])
#define PyULongArrType_Type (*(PyTypeObject *)PyArray_API[28])
#define PyULongLongArrType_Type (*(PyTypeObject *)PyArray_API[29])
#define PyFloatArrType_Type (*(PyTypeObject *)PyArray_API[30])
#define PyDoubleArrType_Type (*(PyTypeObject *)PyArray_API[31])
#define PyLongDoubleArrType_Type (*(PyTypeObject *)PyArray_API[32])
#define PyCFloatArrType_Type (*(PyTypeObject *)PyArray_API[33])
#define PyCDoubleArrType_Type (*(PyTypeObject *)PyArray_API[34])
#define PyCLongDoubleArrType_Type (*(PyTypeObject *)PyArray_API[35])
#define PyObjectArrType_Type (*(PyTypeObject *)PyArray_API[36])
#define PyStringArrType_Type (*(PyTypeObject *)PyArray_API[37])
#define PyUnicodeArrType_Type (*(PyTypeObject *)PyArray_API[38])
#define PyVoidArrType_Type (*(PyTypeObject *)PyArray_API[39])
#define PyArray_SetNumericOps \
(*(int (*)(PyObject *)) \
PyArray_API[40])
#define PyArray_GetNumericOps \
(*(PyObject * (*)(void)) \
PyArray_API[41])
#define PyArray_INCREF \
(*(int (*)(PyArrayObject *)) \
PyArray_API[42])
#define PyArray_XDECREF \
(*(int (*)(PyArrayObject *)) \
PyArray_API[43])
#define PyArray_SetStringFunction \
(*(void (*)(PyObject *, int)) \
PyArray_API[44])
#define PyArray_DescrFromType \
(*(PyArray_Descr * (*)(int)) \
PyArray_API[45])
#define PyArray_TypeObjectFromType \
(*(PyObject * (*)(int)) \
PyArray_API[46])
#define PyArray_Zero \
(*(char * (*)(PyArrayObject *)) \
PyArray_API[47])
#define PyArray_One \
(*(char * (*)(PyArrayObject *)) \
PyArray_API[48])
#define PyArray_CastToType \
(*(PyObject * (*)(PyArrayObject *, PyArray_Descr *, int)) \
PyArray_API[49])
#define PyArray_CastTo \
(*(int (*)(PyArrayObject *, PyArrayObject *)) \
PyArray_API[50])
#define PyArray_CastAnyTo \
(*(int (*)(PyArrayObject *, PyArrayObject *)) \
PyArray_API[51])
#define PyArray_CanCastSafely \
(*(int (*)(int, int)) \
PyArray_API[52])
#define PyArray_CanCastTo \
(*(npy_bool (*)(PyArray_Descr *, PyArray_Descr *)) \
PyArray_API[53])
#define PyArray_ObjectType \
(*(int (*)(PyObject *, int)) \
PyArray_API[54])
#define PyArray_DescrFromObject \
(*(PyArray_Descr * (*)(PyObject *, PyArray_Descr *)) \
PyArray_API[55])
#define PyArray_ConvertToCommonType \
(*(PyArrayObject ** (*)(PyObject *, int *)) \
PyArray_API[56])
#define PyArray_DescrFromScalar \
(*(PyArray_Descr * (*)(PyObject *)) \
PyArray_API[57])
#define PyArray_DescrFromTypeObject \
(*(PyArray_Descr * (*)(PyObject *)) \
PyArray_API[58])
#define PyArray_Size \
(*(npy_intp (*)(PyObject *)) \
PyArray_API[59])
#define PyArray_Scalar \
(*(PyObject * (*)(void *, PyArray_Descr *, PyObject *)) \
PyArray_API[60])
#define PyArray_FromScalar \
(*(PyObject * (*)(PyObject *, PyArray_Descr *)) \
PyArray_API[61])
#define PyArray_ScalarAsCtype \
(*(void (*)(PyObject *, void *)) \
PyArray_API[62])
#define PyArray_CastScalarToCtype \
(*(int (*)(PyObject *, void *, PyArray_Descr *)) \
PyArray_API[63])
#define PyArray_CastScalarDirect \
(*(int (*)(PyObject *, PyArray_Descr *, void *, int)) \
PyArray_API[64])
#define PyArray_ScalarFromObject \
(*(PyObject * (*)(PyObject *)) \
PyArray_API[65])
#define PyArray_GetCastFunc \
(*(PyArray_VectorUnaryFunc * (*)(PyArray_Descr *, int)) \
PyArray_API[66])
#define PyArray_FromDims \
(*(PyObject * (*)(int, int *, int)) \
PyArray_API[67])
#define PyArray_FromDimsAndDataAndDescr \
(*(PyObject * (*)(int, int *, PyArray_Descr *, char *)) \
PyArray_API[68])
#define PyArray_FromAny \
(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int, PyObject *)) \
PyArray_API[69])
#define PyArray_EnsureArray \
(*(PyObject * (*)(PyObject *)) \
PyArray_API[70])
#define PyArray_EnsureAnyArray \
(*(PyObject * (*)(PyObject *)) \
PyArray_API[71])
#define PyArray_FromFile \
(*(PyObject * (*)(FILE *, PyArray_Descr *, npy_intp, char *)) \
PyArray_API[72])
#define PyArray_FromString \
(*(PyObject * (*)(char *, npy_intp, PyArray_Descr *, npy_intp, char *)) \
PyArray_API[73])
#define PyArray_FromBuffer \
(*(PyObject * (*)(PyObject *, PyArray_Descr *, npy_intp, npy_intp)) \
PyArray_API[74])
#define PyArray_FromIter \
(*(PyObject * (*)(PyObject *, PyArray_Descr *, npy_intp)) \
PyArray_API[75])
#define PyArray_Return \
(*(PyObject * (*)(PyArrayObject *)) \
PyArray_API[76])
#define PyArray_GetField \
(*(PyObject * (*)(PyArrayObject *, PyArray_Descr *, int)) \
PyArray_API[77])
#define PyArray_SetField \
(*(int (*)(PyArrayObject *, PyArray_Descr *, int, PyObject *)) \
PyArray_API[78])
#define PyArray_Byteswap \
(*(PyObject * (*)(PyArrayObject *, npy_bool)) \
PyArray_API[79])
#define PyArray_Resize \
(*(PyObject * (*)(PyArrayObject *, PyArray_Dims *, int, NPY_ORDER)) \
PyArray_API[80])
#define PyArray_MoveInto \
(*(int (*)(PyArrayObject *, PyArrayObject *)) \
PyArray_API[81])
#define PyArray_CopyInto \
(*(int (*)(PyArrayObject *, PyArrayObject *)) \
PyArray_API[82])
#define PyArray_CopyAnyInto \
(*(int (*)(PyArrayObject *, PyArrayObject *)) \
PyArray_API[83])
#define PyArray_CopyObject \
(*(int (*)(PyArrayObject *, PyObject *)) \
PyArray_API[84])
#define PyArray_NewCopy \
(*(PyObject * (*)(PyArrayObject *, NPY_ORDER)) \
PyArray_API[85])
#define PyArray_ToList \
(*(PyObject * (*)(PyArrayObject *)) \
PyArray_API[86])
#define PyArray_ToString \
(*(PyObject * (*)(PyArrayObject *, NPY_ORDER)) \
PyArray_API[87])
#define PyArray_ToFile \
(*(int (*)(PyArrayObject *, FILE *, char *, char *)) \
PyArray_API[88])
#define PyArray_Dump \
(*(int (*)(PyObject *, PyObject *, int)) \
PyArray_API[89])
#define PyArray_Dumps \
(*(PyObject * (*)(PyObject *, int)) \
PyArray_API[90])
#define PyArray_ValidType \
(*(int (*)(int)) \
PyArray_API[91])
#define PyArray_UpdateFlags \
(*(void (*)(PyArrayObject *, int)) \
PyArray_API[92])
#define PyArray_New \
(*(PyObject * (*)(PyTypeObject *, int, npy_intp *, int, npy_intp *, void *, int, int, PyObject *)) \
PyArray_API[93])
#define PyArray_NewFromDescr \
(*(PyObject * (*)(PyTypeObject *, PyArray_Descr *, int, npy_intp *, npy_intp *, void *, int, PyObject *)) \
PyArray_API[94])
#define PyArray_DescrNew \
(*(PyArray_Descr * (*)(PyArray_Descr *)) \
PyArray_API[95])
#define PyArray_DescrNewFromType \
(*(PyArray_Descr * (*)(int)) \
PyArray_API[96])
#define PyArray_GetPriority \
(*(double (*)(PyObject *, double)) \
PyArray_API[97])
#define PyArray_IterNew \
(*(PyObject * (*)(PyObject *)) \
PyArray_API[98])
#define PyArray_MultiIterNew \
(*(PyObject * (*)(int, ...)) \
PyArray_API[99])
#define PyArray_PyIntAsInt \
(*(int (*)(PyObject *)) \
PyArray_API[100])
#define PyArray_PyIntAsIntp \
(*(npy_intp (*)(PyObject *)) \
PyArray_API[101])
#define PyArray_Broadcast \
(*(int (*)(PyArrayMultiIterObject *)) \
PyArray_API[102])
#define PyArray_FillObjectArray \
(*(void (*)(PyArrayObject *, PyObject *)) \
PyArray_API[103])
#define PyArray_FillWithScalar \
(*(int (*)(PyArrayObject *, PyObject *)) \
PyArray_API[104])
#define PyArray_CheckStrides \
(*(npy_bool (*)(int, int, npy_intp, npy_intp, npy_intp *, npy_intp *)) \
PyArray_API[105])
#define PyArray_DescrNewByteorder \
(*(PyArray_Descr * (*)(PyArray_Descr *, char)) \
PyArray_API[106])
#define PyArray_IterAllButAxis \
(*(PyObject * (*)(PyObject *, int *)) \
PyArray_API[107])
#define PyArray_CheckFromAny \
(*(PyObject * (*)(PyObject *, PyArray_Descr *, int, int, int, PyObject *)) \
PyArray_API[108])
#define PyArray_FromArray \
(*(PyObject * (*)(PyArrayObject *, PyArray_Descr *, int)) \
PyArray_API[109])
#define PyArray_FromInterface \
(*(PyObject * (*)(PyObject *)) \
PyArray_API[110])
#define PyArray_FromStructInterface \
(*(PyObject * (*)(PyObject *)) \
PyArray_API[111])
#define PyArray_FromArrayAttr \
(*(PyObject * (*)(PyObject *, PyArray_Descr *, PyObject *)) \
PyArray_API[112])
#define PyArray_ScalarKind \
(*(NPY_SCALARKIND (*)(int, PyArrayObject **)) \
PyArray_API[113])
#define PyArray_CanCoerceScalar \
(*(int (*)(int, int, NPY_SCALARKIND)) \
PyArray_API[114])
#define PyArray_NewFlagsObject \
(*(PyObject * (*)(PyObject *)) \
PyArray_API[115])
#define PyArray_CanCastScalar \
(*(npy_bool (*)(PyTypeObject *, PyTypeObject *)) \
PyArray_API[116])
#define PyArray_CompareUCS4 \
(*(int (*)(npy_ucs4 *, npy_ucs4 *, size_t)) \
PyArray_API[117])
#define PyArray_RemoveSmallest \
(*(int (*)(PyArrayMultiIterObject *)) \
PyArray_API[118])
#define PyArray_ElementStrides \
(*(int (*)(PyObject *)) \
PyArray_API[119])
#define PyArray_Item_INCREF \
(*(void (*)(char *, PyArray_Descr *)) \
PyArray_API[120])
#define PyArray_Item_XDECREF \
(*(void (*)(char *, PyArray_Descr *)) \
PyArray_API[121])
#define PyArray_FieldNames \
(*(PyObject * (*)(PyObject *)) \
PyArray_API[122])
#define PyArray_Transpose \
(*(PyObject * (*)(PyArrayObject *, PyArray_Dims *)) \
PyArray_API[123])
#define PyArray_TakeFrom \
(*(PyObject * (*)(PyArrayObject *, PyObject *, int, PyArrayObject *, NPY_CLIPMODE)) \
PyArray_API[124])
#define PyArray_PutTo \
(*(PyObject * (*)(PyArrayObject *, PyObject*, PyObject *, NPY_CLIPMODE)) \
PyArray_API[125])
#define PyArray_PutMask \
(*(PyObject * (*)(PyArrayObject *, PyObject*, PyObject*)) \
PyArray_API[126])
#define PyArray_Repeat \
(*(PyObject * (*)(PyArrayObject *, PyObject *, int)) \
PyArray_API[127])
#define PyArray_Choose \
(*(PyObject * (*)(PyArrayObject *, PyObject *, PyArrayObject *, NPY_CLIPMODE)) \
PyArray_API[128])
#define PyArray_Sort \
(*(int (*)(PyArrayObject *, int, NPY_SORTKIND)) \
PyArray_API[129])
#define PyArray_ArgSort \
(*(PyObject * (*)(PyArrayObject *, int, NPY_SORTKIND)) \
PyArray_API[130])
#define PyArray_SearchSorted \
(*(PyObject * (*)(PyArrayObject *, PyObject *, NPY_SEARCHSIDE)) \
PyArray_API[131])
#define PyArray_ArgMax \
(*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \
PyArray_API[132])
#define PyArray_ArgMin \
(*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \
PyArray_API[133])
#define PyArray_Reshape \
(*(PyObject * (*)(PyArrayObject *, PyObject *)) \
PyArray_API[134])
#define PyArray_Newshape \
(*(PyObject * (*)(PyArrayObject *, PyArray_Dims *, NPY_ORDER)) \
PyArray_API[135])
#define PyArray_Squeeze \
(*(PyObject * (*)(PyArrayObject *)) \
PyArray_API[136])
#define PyArray_View \
(*(PyObject * (*)(PyArrayObject *, PyArray_Descr *, PyTypeObject *)) \
PyArray_API[137])
#define PyArray_SwapAxes \
(*(PyObject * (*)(PyArrayObject *, int, int)) \
PyArray_API[138])
#define PyArray_Max \
(*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \
PyArray_API[139])
#define PyArray_Min \
(*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \
PyArray_API[140])
#define PyArray_Ptp \
(*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \
PyArray_API[141])
#define PyArray_Mean \
(*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *)) \
PyArray_API[142])
#define PyArray_Trace \
(*(PyObject * (*)(PyArrayObject *, int, int, int, int, PyArrayObject *)) \
PyArray_API[143])
#define PyArray_Diagonal \
(*(PyObject * (*)(PyArrayObject *, int, int, int)) \
PyArray_API[144])
#define PyArray_Clip \
(*(PyObject * (*)(PyArrayObject *, PyObject *, PyObject *, PyArrayObject *)) \
PyArray_API[145])
#define PyArray_Conjugate \
(*(PyObject * (*)(PyArrayObject *, PyArrayObject *)) \
PyArray_API[146])
#define PyArray_Nonzero \
(*(PyObject * (*)(PyArrayObject *)) \
PyArray_API[147])
#define PyArray_Std \
(*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *, int)) \
PyArray_API[148])
#define PyArray_Sum \
(*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *)) \
PyArray_API[149])
#define PyArray_CumSum \
(*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *)) \
PyArray_API[150])
#define PyArray_Prod \
(*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *)) \
PyArray_API[151])
#define PyArray_CumProd \
(*(PyObject * (*)(PyArrayObject *, int, int, PyArrayObject *)) \
PyArray_API[152])
#define PyArray_All \
(*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \
PyArray_API[153])
#define PyArray_Any \
(*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \
PyArray_API[154])
#define PyArray_Compress \
(*(PyObject * (*)(PyArrayObject *, PyObject *, int, PyArrayObject *)) \
PyArray_API[155])
#define PyArray_Flatten \
(*(PyObject * (*)(PyArrayObject *, NPY_ORDER)) \
PyArray_API[156])
#define PyArray_Ravel \
(*(PyObject * (*)(PyArrayObject *, NPY_ORDER)) \
PyArray_API[157])
#define PyArray_MultiplyList \
(*(npy_intp (*)(npy_intp *, int)) \
PyArray_API[158])
#define PyArray_MultiplyIntList \
(*(int (*)(int *, int)) \
PyArray_API[159])
#define PyArray_GetPtr \
(*(void * (*)(PyArrayObject *, npy_intp*)) \
PyArray_API[160])
#define PyArray_CompareLists \
(*(int (*)(npy_intp *, npy_intp *, int)) \
PyArray_API[161])
#define PyArray_AsCArray \
(*(int (*)(PyObject **, void *, npy_intp *, int, PyArray_Descr*)) \
PyArray_API[162])
#define PyArray_As1D \
(*(int (*)(PyObject **, char **, int *, int)) \
PyArray_API[163])
#define PyArray_As2D \
(*(int (*)(PyObject **, char ***, int *, int *, int)) \
PyArray_API[164])
#define PyArray_Free \
(*(int (*)(PyObject *, void *)) \
PyArray_API[165])
#define PyArray_Converter \
(*(int (*)(PyObject *, PyObject **)) \
PyArray_API[166])
#define PyArray_IntpFromSequence \
(*(int (*)(PyObject *, npy_intp *, int)) \
PyArray_API[167])
#define PyArray_Concatenate \
(*(PyObject * (*)(PyObject *, int)) \
PyArray_API[168])
#define PyArray_InnerProduct \
(*(PyObject * (*)(PyObject *, PyObject *)) \
PyArray_API[169])
#define PyArray_MatrixProduct \
(*(PyObject * (*)(PyObject *, PyObject *)) \
PyArray_API[170])
#define PyArray_CopyAndTranspose \
(*(PyObject * (*)(PyObject *)) \
PyArray_API[171])
#define PyArray_Correlate \
(*(PyObject * (*)(PyObject *, PyObject *, int)) \
PyArray_API[172])
#define PyArray_TypestrConvert \
(*(int (*)(int, int)) \
PyArray_API[173])
#define PyArray_DescrConverter \
(*(int (*)(PyObject *, PyArray_Descr **)) \
PyArray_API[174])
#define PyArray_DescrConverter2 \
(*(int (*)(PyObject *, PyArray_Descr **)) \
PyArray_API[175])
#define PyArray_IntpConverter \
(*(int (*)(PyObject *, PyArray_Dims *)) \
PyArray_API[176])
#define PyArray_BufferConverter \
(*(int (*)(PyObject *, PyArray_Chunk *)) \
PyArray_API[177])
#define PyArray_AxisConverter \
(*(int (*)(PyObject *, int *)) \
PyArray_API[178])
#define PyArray_BoolConverter \
(*(int (*)(PyObject *, npy_bool *)) \
PyArray_API[179])
#define PyArray_ByteorderConverter \
(*(int (*)(PyObject *, char *)) \
PyArray_API[180])
#define PyArray_OrderConverter \
(*(int (*)(PyObject *, NPY_ORDER *)) \
PyArray_API[181])
#define PyArray_EquivTypes \
(*(unsigned char (*)(PyArray_Descr *, PyArray_Descr *)) \
PyArray_API[182])
#define PyArray_Zeros \
(*(PyObject * (*)(int, npy_intp *, PyArray_Descr *, int)) \
PyArray_API[183])
#define PyArray_Empty \
(*(PyObject * (*)(int, npy_intp *, PyArray_Descr *, int)) \
PyArray_API[184])
#define PyArray_Where \
(*(PyObject * (*)(PyObject *, PyObject *, PyObject *)) \
PyArray_API[185])
#define PyArray_Arange \
(*(PyObject * (*)(double, double, double, int)) \
PyArray_API[186])
#define PyArray_ArangeObj \
(*(PyObject * (*)(PyObject *, PyObject *, PyObject *, PyArray_Descr *)) \
PyArray_API[187])
#define PyArray_SortkindConverter \
(*(int (*)(PyObject *, NPY_SORTKIND *)) \
PyArray_API[188])
#define PyArray_LexSort \
(*(PyObject * (*)(PyObject *, int)) \
PyArray_API[189])
#define PyArray_Round \
(*(PyObject * (*)(PyArrayObject *, int, PyArrayObject *)) \
PyArray_API[190])
#define PyArray_EquivTypenums \
(*(unsigned char (*)(int, int)) \
PyArray_API[191])
#define PyArray_RegisterDataType \
(*(int (*)(PyArray_Descr *)) \
PyArray_API[192])
#define PyArray_RegisterCastFunc \
(*(int (*)(PyArray_Descr *, int, PyArray_VectorUnaryFunc *)) \
PyArray_API[193])
#define PyArray_RegisterCanCast \
(*(int (*)(PyArray_Descr *, int, NPY_SCALARKIND)) \
PyArray_API[194])
#define PyArray_InitArrFuncs \
(*(void (*)(PyArray_ArrFuncs *)) \
PyArray_API[195])
#define PyArray_IntTupleFromIntp \
(*(PyObject * (*)(int, npy_intp *)) \
PyArray_API[196])
#define PyArray_TypeNumFromName \
(*(int (*)(char *)) \
PyArray_API[197])
#define PyArray_ClipmodeConverter \
(*(int (*)(PyObject *, NPY_CLIPMODE *)) \
PyArray_API[198])
#define PyArray_OutputConverter \
(*(int (*)(PyObject *, PyArrayObject **)) \
PyArray_API[199])
#define PyArray_BroadcastToShape \
(*(PyObject * (*)(PyObject *, npy_intp *, int)) \
PyArray_API[200])
#define _PyArray_SigintHandler \
(*(void (*)(int)) \
PyArray_API[201])
#define _PyArray_GetSigintBuf \
(*(void* (*)(void)) \
PyArray_API[202])
#define PyArray_DescrAlignConverter \
(*(int (*)(PyObject *, PyArray_Descr **)) \
PyArray_API[203])
#define PyArray_DescrAlignConverter2 \
(*(int (*)(PyObject *, PyArray_Descr **)) \
PyArray_API[204])
#define PyArray_SearchsideConverter \
(*(int (*)(PyObject *, void *)) \
PyArray_API[205])
#define PyArray_CheckAxis \
(*(PyObject * (*)(PyArrayObject *, int *, int)) \
PyArray_API[206])
#define PyArray_OverflowMultiplyList \
(*(npy_intp (*)(npy_intp *, int)) \
PyArray_API[207])
#define PyArray_CompareString \
(*(int (*)(char *, char *, size_t)) \
PyArray_API[208])
#define PyArray_MultiIterFromObjects \
(*(PyObject * (*)(PyObject **, int, int, ...)) \
PyArray_API[209])
#define PyArray_GetEndianness \
(*(int (*)(void)) \
PyArray_API[210])
#define PyArray_GetNDArrayCFeatureVersion \
(*(unsigned int (*)(void)) \
PyArray_API[211])
#define PyArray_Correlate2 \
(*(PyObject * (*)(PyObject *, PyObject *, int)) \
PyArray_API[212])
#define PyArray_NeighborhoodIterNew \
(*(PyObject* (*)(PyArrayIterObject *, npy_intp *, int, PyArrayObject*)) \
PyArray_API[213])
#if !defined(NO_IMPORT_ARRAY) && !defined(NO_IMPORT)
static int
_import_array(void)
{
int st;
PyObject *numpy = PyImport_ImportModule("numpy.core.multiarray");
PyObject *c_api = NULL;
if (numpy == NULL) return -1;
c_api = PyObject_GetAttrString(numpy, "_ARRAY_API");
if (c_api == NULL) {Py_DECREF(numpy); return -1;}
if (PyCObject_Check(c_api)) {
PyArray_API = (void **)PyCObject_AsVoidPtr(c_api);
}
Py_DECREF(c_api);
Py_DECREF(numpy);
if (PyArray_API == NULL) return -1;
/* Perform runtime check of C API version */
if (NPY_VERSION != PyArray_GetNDArrayCVersion()) {
PyErr_Format(PyExc_RuntimeError, "module compiled against "\
"ABI version %x but this version of numpy is %x", \
(int) NPY_VERSION, (int) PyArray_GetNDArrayCVersion());
return -1;
}
if (NPY_FEATURE_VERSION > PyArray_GetNDArrayCFeatureVersion()) {
PyErr_Format(PyExc_RuntimeError, "module compiled against "\
"API version %x but this version of numpy is %x", \
(int) NPY_FEATURE_VERSION, (int) PyArray_GetNDArrayCFeatureVersion());
return -1;
}
/*
* Perform runtime check of endianness and check it matches the one set by
* the headers (npy_endian.h) as a safeguard
*/
st = PyArray_GetEndianness();
if (st == NPY_CPU_UNKNOWN_ENDIAN) {
PyErr_Format(PyExc_RuntimeError, "FATAL: module compiled as unknown endian");
return -1;
}
#if NPY_BYTE_ORDER ==NPY_BIG_ENDIAN
if (st != NPY_CPU_BIG) {
PyErr_Format(PyExc_RuntimeError, "FATAL: module compiled as "\
"big endian, but detected different endianness at runtime");
return -1;
}
#elif NPY_BYTE_ORDER == NPY_LITTLE_ENDIAN
if (st != NPY_CPU_LITTLE) {
PyErr_Format(PyExc_RuntimeError, "FATAL: module compiled as "\
"little endian, but detected different endianness at runtime");
return -1;
}
#endif
return 0;
}
#define import_array() {if (_import_array() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import"); return; } }
#define import_array1(ret) {if (_import_array() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import"); return ret; } }
#define import_array2(msg, ret) {if (_import_array() < 0) {PyErr_Print(); PyErr_SetString(PyExc_ImportError, msg); return ret; } }
#endif
#endif
PK e[F2 2
ufuncobject.hnu W+A #ifndef Py_UFUNCOBJECT_H
#define Py_UFUNCOBJECT_H
#ifdef __cplusplus
extern "C" {
#endif
typedef void (*PyUFuncGenericFunction) (char **, npy_intp *, npy_intp *, void *);
typedef struct {
PyObject_HEAD
int nin, nout, nargs;
int identity;
PyUFuncGenericFunction *functions;
void **data;
int ntypes;
int check_return;
char *name, *types;
char *doc;
void *ptr;
PyObject *obj;
PyObject *userloops;
/* generalized ufunc */
int core_enabled; /* 0 for scalar ufunc; 1 for generalized ufunc */
int core_num_dim_ix; /* number of distinct dimension names in
signature */
/* dimension indices of input/output argument k are stored in
core_dim_ixs[core_offsets[k]..core_offsets[k]+core_num_dims[k]-1] */
int *core_num_dims; /* numbers of core dimensions of each argument */
int *core_dim_ixs; /* dimension indices in a flatted form; indices
are in the range of [0,core_num_dim_ix) */
int *core_offsets; /* positions of 1st core dimensions of each
argument in core_dim_ixs */
char *core_signature; /* signature string for printing purpose */
} PyUFuncObject;
#include "arrayobject.h"
#define UFUNC_ERR_IGNORE 0
#define UFUNC_ERR_WARN 1
#define UFUNC_ERR_RAISE 2
#define UFUNC_ERR_CALL 3
#define UFUNC_ERR_PRINT 4
#define UFUNC_ERR_LOG 5
/* Python side integer mask */
#define UFUNC_MASK_DIVIDEBYZERO 0x07
#define UFUNC_MASK_OVERFLOW 0x3f
#define UFUNC_MASK_UNDERFLOW 0x1ff
#define UFUNC_MASK_INVALID 0xfff
#define UFUNC_SHIFT_DIVIDEBYZERO 0
#define UFUNC_SHIFT_OVERFLOW 3
#define UFUNC_SHIFT_UNDERFLOW 6
#define UFUNC_SHIFT_INVALID 9
/* platform-dependent code translates floating point
status to an integer sum of these values
*/
#define UFUNC_FPE_DIVIDEBYZERO 1
#define UFUNC_FPE_OVERFLOW 2
#define UFUNC_FPE_UNDERFLOW 4
#define UFUNC_FPE_INVALID 8
#define UFUNC_ERR_DEFAULT 0 /* Error mode that avoids look-up (no checking) */
#define UFUNC_OBJ_ISOBJECT 1
#define UFUNC_OBJ_NEEDS_API 2
/* Default user error mode */
#define UFUNC_ERR_DEFAULT2 \
(UFUNC_ERR_PRINT << UFUNC_SHIFT_DIVIDEBYZERO) + \
(UFUNC_ERR_PRINT << UFUNC_SHIFT_OVERFLOW) + \
(UFUNC_ERR_PRINT << UFUNC_SHIFT_INVALID)
/* Only internal -- not exported, yet*/
typedef struct {
/* Multi-iterator portion --- needs to be present in this order
to work with PyArray_Broadcast */
PyObject_HEAD
int numiter;
npy_intp size;
npy_intp index;
int nd;
npy_intp dimensions[NPY_MAXDIMS];
PyArrayIterObject *iters[NPY_MAXARGS];
/* End of Multi-iterator portion */
/* The ufunc */
PyUFuncObject *ufunc;
/* The error handling */
int errormask; /* Integer showing desired error handling */
PyObject *errobj; /* currently a tuple with
(string, func or obj with write method or None)
*/
int first;
/* Specific function and data to use */
PyUFuncGenericFunction function;
void *funcdata;
/* Loop method */
int meth;
/* Whether we need to copy to a buffer or not.*/
int needbuffer[NPY_MAXARGS];
int leftover;
int ninnerloops;
int lastdim;
/* Whether or not to swap */
int swap[NPY_MAXARGS];
/* Buffers for the loop */
char *buffer[NPY_MAXARGS];
int bufsize;
npy_intp bufcnt;
char *dptr[NPY_MAXARGS];
/* For casting */
char *castbuf[NPY_MAXARGS];
PyArray_VectorUnaryFunc *cast[NPY_MAXARGS];
/* usually points to buffer but when a cast is to be
done it switches for that argument to castbuf.
*/
char *bufptr[NPY_MAXARGS];
/* Steps filled in from iters or sizeof(item)
depending on loop method.
*/
npy_intp steps[NPY_MAXARGS];
int obj; /* This loop uses object arrays or needs the Python API */
/* Flags: UFUNC_OBJ_ISOBJECT, UFUNC_OBJ_NEEDS_API */
int notimplemented; /* The loop caused notimplemented */
int objfunc; /* This loop calls object functions
(an inner-loop function with argument types */
/* generalized ufunc */
npy_intp *core_dim_sizes; /* stores sizes of core dimensions;
contains 1 + core_num_dim_ix elements */
npy_intp *core_strides; /* strides of loop and core dimensions */
} PyUFuncLoopObject;
/* Could make this more clever someday */
#define UFUNC_MAXIDENTITY 32
typedef struct {
PyObject_HEAD
PyArrayIterObject *it;
PyArrayObject *ret;
PyArrayIterObject *rit; /* Needed for Accumulate */
int outsize;
npy_intp index;
npy_intp size;
char idptr[UFUNC_MAXIDENTITY];
/* The ufunc */
PyUFuncObject *ufunc;
/* The error handling */
int errormask;
PyObject *errobj;
int first;
PyUFuncGenericFunction function;
void *funcdata;
int meth;
int swap;
char *buffer;
int bufsize;
char *castbuf;
PyArray_VectorUnaryFunc *cast;
char *bufptr[3];
npy_intp steps[3];
npy_intp N;
int instrides;
int insize;
char *inptr;
/* For copying small arrays */
PyObject *decref;
int obj;
int retbase;
} PyUFuncReduceObject;
#if NPY_ALLOW_THREADS
#define NPY_LOOP_BEGIN_THREADS do {if (!(loop->obj & UFUNC_OBJ_NEEDS_API)) _save = PyEval_SaveThread();} while (0)
#define NPY_LOOP_END_THREADS do {if (!(loop->obj & UFUNC_OBJ_NEEDS_API)) PyEval_RestoreThread(_save);} while (0)
#else
#define NPY_LOOP_BEGIN_THREADS
#define NPY_LOOP_END_THREADS
#endif
#define PyUFunc_One 1
#define PyUFunc_Zero 0
#define PyUFunc_None -1
#define UFUNC_REDUCE 0
#define UFUNC_ACCUMULATE 1
#define UFUNC_REDUCEAT 2
#define UFUNC_OUTER 3
typedef struct {
int nin;
int nout;
PyObject *callable;
} PyUFunc_PyFuncData;
/* A linked-list of function information for
user-defined 1-d loops.
*/
typedef struct _loop1d_info {
PyUFuncGenericFunction func;
void *data;
int *arg_types;
struct _loop1d_info *next;
} PyUFunc_Loop1d;
#include "__ufunc_api.h"
#define UFUNC_PYVALS_NAME "UFUNC_PYVALS"
#define UFUNC_CHECK_ERROR(arg) \
do {if ((((arg)->obj & UFUNC_OBJ_NEEDS_API) && PyErr_Occurred()) || \
((arg)->errormask && \
PyUFunc_checkfperr((arg)->errormask, \
(arg)->errobj, \
&(arg)->first))) \
goto fail;} while (0)
/* This code checks the IEEE status flags in a platform-dependent way */
/* Adapted from Numarray */
#if (defined(__unix__) || defined(unix)) && !defined(USG)
#include
#endif
/* OSF/Alpha (Tru64) ---------------------------------------------*/
#if defined(__osf__) && defined(__alpha)
#include
#define UFUNC_CHECK_STATUS(ret) { \
unsigned long fpstatus; \
\
fpstatus = ieee_get_fp_control(); \
/* clear status bits as well as disable exception mode if on */ \
ieee_set_fp_control( 0 ); \
ret = ((IEEE_STATUS_DZE & fpstatus) ? UFUNC_FPE_DIVIDEBYZERO : 0) \
| ((IEEE_STATUS_OVF & fpstatus) ? UFUNC_FPE_OVERFLOW : 0) \
| ((IEEE_STATUS_UNF & fpstatus) ? UFUNC_FPE_UNDERFLOW : 0) \
| ((IEEE_STATUS_INV & fpstatus) ? UFUNC_FPE_INVALID : 0); \
}
/* MS Windows -----------------------------------------------------*/
#elif defined(_MSC_VER)
#include
/* Clear the floating point exception default of Borland C++ */
#if defined(__BORLANDC__)
#define UFUNC_NOFPE _control87(MCW_EM, MCW_EM);
#endif
#define UFUNC_CHECK_STATUS(ret) { \
int fpstatus = (int) _clearfp(); \
\
ret = ((SW_ZERODIVIDE & fpstatus) ? UFUNC_FPE_DIVIDEBYZERO : 0) \
| ((SW_OVERFLOW & fpstatus) ? UFUNC_FPE_OVERFLOW : 0) \
| ((SW_UNDERFLOW & fpstatus) ? UFUNC_FPE_UNDERFLOW : 0) \
| ((SW_INVALID & fpstatus) ? UFUNC_FPE_INVALID : 0); \
}
/* Solaris --------------------------------------------------------*/
/* --------ignoring SunOS ieee_flags approach, someone else can
** deal with that! */
#elif defined(sun) || defined(__BSD__) || defined(__OpenBSD__) || (defined(__FreeBSD__) && (__FreeBSD_version < 502114)) || defined(__NetBSD__)
#include
#define UFUNC_CHECK_STATUS(ret) { \
int fpstatus; \
\
fpstatus = (int) fpgetsticky(); \
ret = ((FP_X_DZ & fpstatus) ? UFUNC_FPE_DIVIDEBYZERO : 0) \
| ((FP_X_OFL & fpstatus) ? UFUNC_FPE_OVERFLOW : 0) \
| ((FP_X_UFL & fpstatus) ? UFUNC_FPE_UNDERFLOW : 0) \
| ((FP_X_INV & fpstatus) ? UFUNC_FPE_INVALID : 0); \
(void) fpsetsticky(0); \
}
#elif defined(__GLIBC__) || defined(__APPLE__) || defined(__CYGWIN__) || defined(__MINGW32__) || (defined(__FreeBSD__) && (__FreeBSD_version >= 502114))
#if defined(__GLIBC__) || defined(__APPLE__) || defined(__MINGW32__) || defined(__FreeBSD__)
#include
#elif defined(__CYGWIN__)
#include "fenv/fenv.c"
#endif
#define UFUNC_CHECK_STATUS(ret) { \
int fpstatus = (int) fetestexcept(FE_DIVBYZERO | FE_OVERFLOW | \
FE_UNDERFLOW | FE_INVALID); \
ret = ((FE_DIVBYZERO & fpstatus) ? UFUNC_FPE_DIVIDEBYZERO : 0) \
| ((FE_OVERFLOW & fpstatus) ? UFUNC_FPE_OVERFLOW : 0) \
| ((FE_UNDERFLOW & fpstatus) ? UFUNC_FPE_UNDERFLOW : 0) \
| ((FE_INVALID & fpstatus) ? UFUNC_FPE_INVALID : 0); \
(void) feclearexcept(FE_DIVBYZERO | FE_OVERFLOW | \
FE_UNDERFLOW | FE_INVALID); \
}
#define generate_divbyzero_error() feraiseexcept(FE_DIVBYZERO)
#define generate_overflow_error() feraiseexcept(FE_OVERFLOW)
#elif defined(_AIX)
#include
#include
#define UFUNC_CHECK_STATUS(ret) { \
fpflag_t fpstatus; \
\
fpstatus = fp_read_flag(); \
ret = ((FP_DIV_BY_ZERO & fpstatus) ? UFUNC_FPE_DIVIDEBYZERO : 0) \
| ((FP_OVERFLOW & fpstatus) ? UFUNC_FPE_OVERFLOW : 0) \
| ((FP_UNDERFLOW & fpstatus) ? UFUNC_FPE_UNDERFLOW : 0) \
| ((FP_INVALID & fpstatus) ? UFUNC_FPE_INVALID : 0); \
fp_swap_flag(0); \
}
#define generate_divbyzero_error() fp_raise_xcp(FP_DIV_BY_ZERO)
#define generate_overflow_error() fp_raise_xcp(FP_OVERFLOW)
#else
#define NO_FLOATING_POINT_SUPPORT
#define UFUNC_CHECK_STATUS(ret) { \
ret = 0; \
}
#endif
/* These should really be altered to just set the corresponding bit
in the floating point status flag. Need to figure out how to do that
on all the platforms...
*/
#if !defined(generate_divbyzero_error)
static int numeric_zero2 = 0;
static void generate_divbyzero_error(void) {
double dummy;
dummy = 1./numeric_zero2;
if (dummy) /* to prevent optimizer from eliminating expression */
return;
else /* should never be called */
numeric_zero2 += 1;
return;
}
#endif
#if !defined(generate_overflow_error)
static double numeric_two = 2.0;
static void generate_overflow_error(void) {
double dummy;
dummy = pow(numeric_two,1000);
if (dummy)
return;
else
numeric_two += 0.1;
return;
return;
}
#endif
/* Make sure it gets defined if it isn't already */
#ifndef UFUNC_NOFPE
#define UFUNC_NOFPE
#endif
#ifdef __cplusplus
}
#endif
#endif /* !Py_UFUNCOBJECT_H */
PK e[ ndarrayobject.hnu W+A /*
* DON'T INCLUDE THIS DIRECTLY.
*/
#ifndef NPY_NDARRAYOBJECT_H
#define NPY_NDARRAYOBJECT_H
#ifdef __cplusplus
#define CONFUSE_EMACS {
#define CONFUSE_EMACS2 }
extern "C" CONFUSE_EMACS
#undef CONFUSE_EMACS
#undef CONFUSE_EMACS2
/* ... otherwise a semi-smart identer (like emacs) tries to indent
everything when you're typing */
#endif
/* This is auto-generated by the installer */
#include "numpyconfig.h"
#ifdef NPY_ENABLE_SEPARATE_COMPILATION
#define NPY_NO_EXPORT NPY_VISIBILITY_HIDDEN
#else
#define NPY_NO_EXPORT static
#endif
/* Only use thread if configured in config and python supports it */
#if defined WITH_THREAD && !NPY_NO_SMP
#define NPY_ALLOW_THREADS 1
#else
#define NPY_ALLOW_THREADS 0
#endif
#include "npy_endian.h"
#include "utils.h"
/* There are several places in the code where an array of dimensions is
* allocated statically. This is the size of that static allocation.
*
* The array creation itself could have arbitrary dimensions but
* all the places where static allocation is used would need to
* be changed to dynamic (including inside of several structures)
*/
#define NPY_MAXDIMS 32
#define NPY_MAXARGS 32
/* Used for Converter Functions "O&" code in ParseTuple */
#define NPY_FAIL 0
#define NPY_SUCCEED 1
/* Binary compatibility version number. This number is increased
whenever the C-API is changed such that binary compatibility is
broken, i.e. whenever a recompile of extension modules is
needed. */
#define NPY_VERSION NPY_ABI_VERSION
/* Minor API version. This number is increased whenever a change is
made to the C-API -- whether it breaks binary compatibility or not.
Some changes, such as adding a function pointer to the end of the
function table, can be made without breaking binary compatibility.
In this case, only the NPY_FEATURE_VERSION (*not* NPY_VERSION)
would be increased. Whenever binary compatibility is broken, both
NPY_VERSION and NPY_FEATURE_VERSION should be increased.
*/
#define NPY_FEATURE_VERSION NPY_API_VERSION
#include "npy_common.h"
enum NPY_TYPES { NPY_BOOL=0,
NPY_BYTE, NPY_UBYTE,
NPY_SHORT, NPY_USHORT,
NPY_INT, NPY_UINT,
NPY_LONG, NPY_ULONG,
NPY_LONGLONG, NPY_ULONGLONG,
NPY_FLOAT, NPY_DOUBLE, NPY_LONGDOUBLE,
NPY_CFLOAT, NPY_CDOUBLE, NPY_CLONGDOUBLE,
NPY_OBJECT=17,
NPY_STRING, NPY_UNICODE,
NPY_VOID,
NPY_NTYPES,
NPY_NOTYPE,
NPY_CHAR, /* special flag */
NPY_USERDEF=256 /* leave room for characters */
};
#define NPY_METADATA_DTSTR "__frequency__"
/* basetype array priority */
#define NPY_PRIORITY 0.0
/* default subtype priority */
#define NPY_SUBTYPE_PRIORITY 1.0
/* default scalar priority */
#define NPY_SCALAR_PRIORITY -1000000.0
/* How many floating point types are there */
#define NPY_NUM_FLOATTYPE 3
/* We need to match npy_intp to a signed integer of the same size as
a pointer variable. npy_uintp to the equivalent unsigned integer
*/
/* These characters correspond to the array type and the
struct module */
/* except 'p' -- signed integer for pointer type */
enum NPY_TYPECHAR { NPY_BOOLLTR = '?',
NPY_BYTELTR = 'b',
NPY_UBYTELTR = 'B',
NPY_SHORTLTR = 'h',
NPY_USHORTLTR = 'H',
NPY_INTLTR = 'i',
NPY_UINTLTR = 'I',
NPY_LONGLTR = 'l',
NPY_ULONGLTR = 'L',
NPY_LONGLONGLTR = 'q',
NPY_ULONGLONGLTR = 'Q',
NPY_FLOATLTR = 'f',
NPY_DOUBLELTR = 'd',
NPY_LONGDOUBLELTR = 'g',
NPY_CFLOATLTR = 'F',
NPY_CDOUBLELTR = 'D',
NPY_CLONGDOUBLELTR = 'G',
NPY_OBJECTLTR = 'O',
NPY_STRINGLTR = 'S',
NPY_STRINGLTR2 = 'a',
NPY_UNICODELTR = 'U',
NPY_VOIDLTR = 'V',
NPY_DATETIMELTR = 'M',
NPY_TIMEDELTALTR = 'm',
NPY_CHARLTR = 'c',
/* No Descriptor, just a define -- this let's
Python users specify an array of integers
large enough to hold a pointer on the platform*/
NPY_INTPLTR = 'p',
NPY_UINTPLTR = 'P',
NPY_GENBOOLLTR ='b',
NPY_SIGNEDLTR = 'i',
NPY_UNSIGNEDLTR = 'u',
NPY_FLOATINGLTR = 'f',
NPY_COMPLEXLTR = 'c'
};
typedef enum {
NPY_QUICKSORT=0,
NPY_HEAPSORT=1,
NPY_MERGESORT=2
} NPY_SORTKIND;
#define NPY_NSORTS (NPY_MERGESORT + 1)
typedef enum {
NPY_SEARCHLEFT=0,
NPY_SEARCHRIGHT=1
} NPY_SEARCHSIDE;
#define NPY_NSEARCHSIDES (NPY_SEARCHRIGHT + 1)
typedef enum {
NPY_NOSCALAR=-1,
NPY_BOOL_SCALAR,
NPY_INTPOS_SCALAR,
NPY_INTNEG_SCALAR,
NPY_FLOAT_SCALAR,
NPY_COMPLEX_SCALAR,
NPY_OBJECT_SCALAR
} NPY_SCALARKIND;
#define NPY_NSCALARKINDS (NPY_OBJECT_SCALAR + 1)
typedef enum {
NPY_ANYORDER=-1,
NPY_CORDER=0,
NPY_FORTRANORDER=1
} NPY_ORDER;
typedef enum {
NPY_CLIP=0,
NPY_WRAP=1,
NPY_RAISE=2
} NPY_CLIPMODE;
typedef enum {
NPY_FR_Y,
NPY_FR_M,
NPY_FR_W,
NPY_FR_B,
NPY_FR_D,
NPY_FR_h,
NPY_FR_m,
NPY_FR_s,
NPY_FR_ms,
NPY_FR_us,
NPY_FR_ns,
NPY_FR_ps,
NPY_FR_fs,
NPY_FR_as
} NPY_DATETIMEUNIT;
#define NPY_DATETIME_NUMUNITS (NPY_FR_as + 1)
#define NPY_DATETIME_DEFAULTUNIT NPY_FR_us
#define NPY_STR_Y "Y"
#define NPY_STR_M "M"
#define NPY_STR_W "W"
#define NPY_STR_B "B"
#define NPY_STR_D "D"
#define NPY_STR_h "h"
#define NPY_STR_m "m"
#define NPY_STR_s "s"
#define NPY_STR_ms "ms"
#define NPY_STR_us "us"
#define NPY_STR_ns "ns"
#define NPY_STR_ps "ps"
#define NPY_STR_fs "fs"
#define NPY_STR_as "as"
/* This is to typedef npy_intp to the appropriate pointer size for this
* platform. Py_intptr_t, Py_uintptr_t are defined in pyport.h. */
typedef Py_intptr_t npy_intp;
typedef Py_uintptr_t npy_uintp;
#define NPY_SIZEOF_INTP NPY_SIZEOF_PY_INTPTR_T
#define NPY_SIZEOF_UINTP NPY_SIZEOF_PY_INTPTR_T
#ifdef constchar
#undef constchar
#endif
#if (PY_VERSION_HEX < 0x02050000)
#ifndef PY_SSIZE_T_MIN
typedef int Py_ssize_t;
#define PY_SSIZE_T_MAX INT_MAX
#define PY_SSIZE_T_MIN INT_MIN
#endif
#define NPY_SSIZE_T_PYFMT "i"
#undef PyIndex_Check
#define constchar const char
#define PyIndex_Check(op) 0
#else
#define NPY_SSIZE_T_PYFMT "n"
#define constchar char
#endif
#if NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_INT
#define NPY_INTP NPY_INT
#define NPY_UINTP NPY_UINT
#define PyIntpArrType_Type PyIntArrType_Type
#define PyUIntpArrType_Type PyUIntArrType_Type
#define NPY_MAX_INTP NPY_MAX_INT
#define NPY_MIN_INTP NPY_MIN_INT
#define NPY_MAX_UINTP NPY_MAX_UINT
#define NPY_INTP_FMT "d"
#elif NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_LONG
#define NPY_INTP NPY_LONG
#define NPY_UINTP NPY_ULONG
#define PyIntpArrType_Type PyLongArrType_Type
#define PyUIntpArrType_Type PyULongArrType_Type
#define NPY_MAX_INTP NPY_MAX_LONG
#define NPY_MIN_INTP MIN_LONG
#define NPY_MAX_UINTP NPY_MAX_ULONG
#define NPY_INTP_FMT "ld"
#elif defined(PY_LONG_LONG) && (NPY_SIZEOF_PY_INTPTR_T == NPY_SIZEOF_LONGLONG)
#define NPY_INTP NPY_LONGLONG
#define NPY_UINTP NPY_ULONGLONG
#define PyIntpArrType_Type PyLongLongArrType_Type
#define PyUIntpArrType_Type PyULongLongArrType_Type
#define NPY_MAX_INTP NPY_MAX_LONGLONG
#define NPY_MIN_INTP NPY_MIN_LONGLONG
#define NPY_MAX_UINTP NPY_MAX_ULONGLONG
#define NPY_INTP_FMT "Ld"
#endif
/* We can only use C99 formats for npy_int_p if it is the same as intp_t, hence
* the condition on HAVE_UNITPTR_T */
#if (NPY_USE_C99_FORMATS) == 1 \
&& (defined HAVE_UINTPTR_T) \
&& (defined HAVE_INTTYPES_H)
#include
#undef NPY_INTP_FMT
#define NPY_INTP_FMT PRIdPTR
#endif
#define NPY_ERR(str) fprintf(stderr, #str); fflush(stderr);
#define NPY_ERR2(str) fprintf(stderr, str); fflush(stderr);
#define NPY_STRINGIFY(x) #x
#define NPY_TOSTRING(x) NPY_STRINGIFY(x)
/* Macros to define how array, and dimension/strides data is
allocated.
*/
/* Data buffer */
#define PyDataMem_NEW(size) ((char *)malloc(size))
#define PyDataMem_FREE(ptr) free(ptr)
#define PyDataMem_RENEW(ptr,size) ((char *)realloc(ptr,size))
#define NPY_USE_PYMEM 1
#if NPY_USE_PYMEM == 1
#define PyArray_malloc PyMem_Malloc
#define PyArray_free PyMem_Free
#define PyArray_realloc PyMem_Realloc
#else
#define PyArray_malloc malloc
#define PyArray_free free
#define PyArray_realloc realloc
#endif
/* Dimensions and strides */
#define PyDimMem_NEW(size) \
((npy_intp *)PyArray_malloc(size*sizeof(npy_intp)))
#define PyDimMem_FREE(ptr) PyArray_free(ptr)
#define PyDimMem_RENEW(ptr,size) \
((npy_intp *)PyArray_realloc(ptr,size*sizeof(npy_intp)))
/* forward declaration */
struct _PyArray_Descr;
/* These must deal with unaligned and swapped data if necessary */
typedef PyObject * (PyArray_GetItemFunc) (void *, void *);
typedef int (PyArray_SetItemFunc)(PyObject *, void *, void *);
typedef void (PyArray_CopySwapNFunc)(void *, npy_intp, void *, npy_intp,
npy_intp, int, void *);
typedef void (PyArray_CopySwapFunc)(void *, void *, int, void *);
typedef npy_bool (PyArray_NonzeroFunc)(void *, void *);
/* These assume aligned and notswapped data -- a buffer will be
used before or contiguous data will be obtained
*/
typedef int (PyArray_CompareFunc)(const void *, const void *, void *);
typedef int (PyArray_ArgFunc)(void*, npy_intp, npy_intp*, void *);
typedef void (PyArray_DotFunc)(void *, npy_intp, void *, npy_intp, void *,
npy_intp, void *);
typedef void (PyArray_VectorUnaryFunc)(void *, void *, npy_intp, void *,
void *);
/* XXX the ignore argument should be removed next time the API version
is bumped. It used to be the separator. */
typedef int (PyArray_ScanFunc)(FILE *fp, void *dptr,
char *ignore, struct _PyArray_Descr *);
typedef int (PyArray_FromStrFunc)(char *s, void *dptr, char **endptr,
struct _PyArray_Descr *);
typedef int (PyArray_FillFunc)(void *, npy_intp, void *);
typedef int (PyArray_SortFunc)(void *, npy_intp, void *);
typedef int (PyArray_ArgSortFunc)(void *, npy_intp *, npy_intp, void *);
typedef int (PyArray_FillWithScalarFunc)(void *, npy_intp, void *, void *);
typedef int (PyArray_ScalarKindFunc)(void *);
typedef void (PyArray_FastClipFunc)(void *in, npy_intp n_in, void *min,
void *max, void *out);
typedef void (PyArray_FastPutmaskFunc)(void *in, void *mask, npy_intp n_in,
void *values, npy_intp nv);
typedef int (PyArray_FastTakeFunc)(void *dest, void *src, npy_intp *indarray,
npy_intp nindarray, npy_intp n_outer,
npy_intp m_middle, npy_intp nelem,
NPY_CLIPMODE clipmode);
typedef struct {
npy_intp *ptr;
int len;
} PyArray_Dims;
typedef struct {
/* Functions to cast to all other standard types*/
/* Can have some NULL entries */
PyArray_VectorUnaryFunc *cast[NPY_NTYPES];
/* The next four functions *cannot* be NULL */
/* Functions to get and set items with standard
Python types -- not array scalars */
PyArray_GetItemFunc *getitem;
PyArray_SetItemFunc *setitem;
/* Copy and/or swap data. Memory areas may not overlap */
/* Use memmove first if they might */
PyArray_CopySwapNFunc *copyswapn;
PyArray_CopySwapFunc *copyswap;
/* Function to compare items */
/* Can be NULL
*/
PyArray_CompareFunc *compare;
/* Function to select largest
Can be NULL
*/
PyArray_ArgFunc *argmax;
/* Function to compute dot product */
/* Can be NULL */
PyArray_DotFunc *dotfunc;
/* Function to scan an ASCII file and
place a single value plus possible separator
Can be NULL
*/
PyArray_ScanFunc *scanfunc;
/* Function to read a single value from a string */
/* and adjust the pointer; Can be NULL */
PyArray_FromStrFunc *fromstr;
/* Function to determine if data is zero or not */
/* If NULL a default version is */
/* used at Registration time. */
PyArray_NonzeroFunc *nonzero;
/* Used for arange. Can be NULL.*/
PyArray_FillFunc *fill;
/* Function to fill arrays with scalar values
Can be NULL*/
PyArray_FillWithScalarFunc *fillwithscalar;
/* Sorting functions; Can be NULL*/
PyArray_SortFunc *sort[NPY_NSORTS];
PyArray_ArgSortFunc *argsort[NPY_NSORTS];
/* Dictionary of additional casting functions
PyArray_VectorUnaryFuncs
which can be populated to support casting
to other registered types. Can be NULL*/
PyObject *castdict;
/* Functions useful for generalizing
the casting rules. Can be NULL;
*/
PyArray_ScalarKindFunc *scalarkind;
int **cancastscalarkindto;
int *cancastto;
PyArray_FastClipFunc *fastclip;
PyArray_FastPutmaskFunc *fastputmask;
PyArray_FastTakeFunc *fasttake;
} PyArray_ArrFuncs;
/* The item must be reference counted when it is inserted or extracted. */
#define NPY_ITEM_REFCOUNT 0x01
/* Same as needing REFCOUNT */
#define NPY_ITEM_HASOBJECT 0x01
/* Convert to list for pickling */
#define NPY_LIST_PICKLE 0x02
/* The item is a POINTER */
#define NPY_ITEM_IS_POINTER 0x04
/* memory needs to be initialized for this data-type */
#define NPY_NEEDS_INIT 0x08
/* operations need Python C-API so don't give-up thread. */
#define NPY_NEEDS_PYAPI 0x10
/* Use f.getitem when extracting elements of this data-type */
#define NPY_USE_GETITEM 0x20
/* Use f.setitem when setting creating 0-d array from this data-type.*/
#define NPY_USE_SETITEM 0x40
/* define NPY_IS_COMPLEX */
/* These are inherited for global data-type if any data-types in the field
have them */
#define NPY_FROM_FIELDS (NPY_NEEDS_INIT | NPY_LIST_PICKLE | \
NPY_ITEM_REFCOUNT | NPY_NEEDS_PYAPI)
#define NPY_OBJECT_DTYPE_FLAGS (NPY_LIST_PICKLE | NPY_USE_GETITEM | \
NPY_ITEM_IS_POINTER | NPY_ITEM_REFCOUNT | \
NPY_NEEDS_INIT | NPY_NEEDS_PYAPI)
#define PyDataType_FLAGCHK(dtype, flag) \
(((dtype)->hasobject & (flag)) == (flag))
#define PyDataType_REFCHK(dtype) \
PyDataType_FLAGCHK(dtype, NPY_ITEM_REFCOUNT)
/* Change dtype hasobject to 32-bit in 1.1 and change its name */
typedef struct _PyArray_Descr {
PyObject_HEAD
PyTypeObject *typeobj; /* the type object representing an
instance of this type -- should not
be two type_numbers with the same type
object. */
char kind; /* kind for this type */
char type; /* unique-character representing this type */
char byteorder; /* '>' (big), '<' (little), '|'
(not-applicable), or '=' (native). */
char hasobject; /* non-zero if it has object arrays
in fields */
int type_num; /* number representing this type */
int elsize; /* element size for this type */
int alignment; /* alignment needed for this type */
struct _arr_descr \
*subarray; /* Non-NULL if this type is
is an array (C-contiguous)
of some other type
*/
PyObject *fields; /* The fields dictionary for this type */
/* For statically defined descr this
is always Py_None */
PyObject *names; /* An ordered tuple of field names or NULL
if no fields are defined */
PyArray_ArrFuncs *f; /* a table of functions specific for each
basic data descriptor */
PyObject *metadata; /* Metadata about this dtype */
} PyArray_Descr;
typedef struct _arr_descr {
PyArray_Descr *base;
PyObject *shape; /* a tuple */
} PyArray_ArrayDescr;
/*
The main array object structure. It is recommended to use the macros
defined below (PyArray_DATA and friends) access fields here, instead
of the members themselves.
*/
typedef struct PyArrayObject {
PyObject_HEAD
char *data; /* pointer to raw data buffer */
int nd; /* number of dimensions, also called ndim */
npy_intp *dimensions; /* size in each dimension */
npy_intp *strides; /* bytes to jump to get to the
next element in each dimension */
PyObject *base; /* This object should be decref'd
upon deletion of array */
/* For views it points to the original array */
/* For creation from buffer object it points
to an object that shold be decref'd on
deletion */
/* For UPDATEIFCOPY flag this is an array
to-be-updated upon deletion of this one */
PyArray_Descr *descr; /* Pointer to type structure */
int flags; /* Flags describing array -- see below*/
PyObject *weakreflist; /* For weakreferences */
} PyArrayObject;
#define NPY_AO PyArrayObject
#define fortran fortran_ /* For some compilers */
/* Array Flags Object */
typedef struct PyArrayFlagsObject {
PyObject_HEAD
PyObject *arr;
int flags;
} PyArrayFlagsObject;
/* Mirrors buffer object to ptr */
typedef struct {
PyObject_HEAD
PyObject *base;
void *ptr;
npy_intp len;
int flags;
} PyArray_Chunk;
#define PyDataType_GetDatetimeMetaData(descr) ((descr->metadata == NULL) ? NULL : ((PyArray_DatetimeMetaData *)(PyCObject_AsVoidPtr(PyDict_GetItemString(descr->metadata, NPY_METADATA_DTSTR)))))
typedef int (PyArray_FinalizeFunc)(PyArrayObject *, PyObject *);
/* Means c-style contiguous (last index varies the fastest). The
data elements right after each other. */
#define NPY_CONTIGUOUS 0x0001
/* set if array is a contiguous Fortran array: the first index
varies the fastest in memory (strides array is reverse of
C-contiguous array)*/
#define NPY_FORTRAN 0x0002
#define NPY_C_CONTIGUOUS NPY_CONTIGUOUS
#define NPY_F_CONTIGUOUS NPY_FORTRAN
/*
Note: all 0-d arrays are CONTIGUOUS and FORTRAN contiguous. If a
1-d array is CONTIGUOUS it is also FORTRAN contiguous
*/
/* If set, the array owns the data: it will be free'd when the array
is deleted. */
#define NPY_OWNDATA 0x0004
/* An array never has the next four set; they're only used as parameter
flags to the the various FromAny functions */
/* Cause a cast to occur regardless of whether or not it is safe. */
#define NPY_FORCECAST 0x0010
/* Always copy the array. Returned arrays are always CONTIGUOUS, ALIGNED,
and WRITEABLE. */
#define NPY_ENSURECOPY 0x0020
/* Make sure the returned array is a base-class ndarray */
#define NPY_ENSUREARRAY 0x0040
/* Make sure that the strides are in units of the element size
Needed for some operations with record-arrays.
*/
#define NPY_ELEMENTSTRIDES 0x0080
/* Array data is aligned on the appropiate memory address for the
type stored according to how the compiler would align things
(e.g., an array of integers (4 bytes each) starts on
a memory address that's a multiple of 4) */
#define NPY_ALIGNED 0x0100
/* Array data has the native endianness */
#define NPY_NOTSWAPPED 0x0200
/* Array data is writeable */
#define NPY_WRITEABLE 0x0400
/* If this flag is set, then base contains a pointer to an array of
the same size that should be updated with the current contents of
this array when this array is deallocated
*/
#define NPY_UPDATEIFCOPY 0x1000
/* This flag is for the array interface */
#define NPY_ARR_HAS_DESCR 0x0800
#define NPY_BEHAVED (NPY_ALIGNED | NPY_WRITEABLE)
#define NPY_BEHAVED_NS (NPY_ALIGNED | NPY_WRITEABLE | NPY_NOTSWAPPED)
#define NPY_CARRAY (NPY_CONTIGUOUS | NPY_BEHAVED)
#define NPY_CARRAY_RO (NPY_CONTIGUOUS | NPY_ALIGNED)
#define NPY_FARRAY (NPY_FORTRAN | NPY_BEHAVED)
#define NPY_FARRAY_RO (NPY_FORTRAN | NPY_ALIGNED)
#define NPY_DEFAULT NPY_CARRAY
#define NPY_IN_ARRAY NPY_CARRAY_RO
#define NPY_OUT_ARRAY NPY_CARRAY
#define NPY_INOUT_ARRAY (NPY_CARRAY | NPY_UPDATEIFCOPY)
#define NPY_IN_FARRAY NPY_FARRAY_RO
#define NPY_OUT_FARRAY NPY_FARRAY
#define NPY_INOUT_FARRAY (NPY_FARRAY | NPY_UPDATEIFCOPY)
#define NPY_UPDATE_ALL (NPY_CONTIGUOUS | NPY_FORTRAN | NPY_ALIGNED)
/* Size of internal buffers used for alignment */
/* Make BUFSIZE a multiple of sizeof(cdouble) -- ususally 16 */
/* So that ufunc buffers are aligned */
#define NPY_MIN_BUFSIZE ((int)sizeof(cdouble))
#define NPY_MAX_BUFSIZE (((int)sizeof(cdouble))*1000000)
#define NPY_BUFSIZE 10000
/* #define NPY_BUFSIZE 80*/
#define PyArray_MAX(a,b) (((a)>(b))?(a):(b))
#define PyArray_MIN(a,b) (((a)<(b))?(a):(b))
#define PyArray_CLT(p,q) ((((p).real==(q).real) ? ((p).imag < (q).imag) : \
((p).real < (q).real)))
#define PyArray_CGT(p,q) ((((p).real==(q).real) ? ((p).imag > (q).imag) : \
((p).real > (q).real)))
#define PyArray_CLE(p,q) ((((p).real==(q).real) ? ((p).imag <= (q).imag) : \
((p).real <= (q).real)))
#define PyArray_CGE(p,q) ((((p).real==(q).real) ? ((p).imag >= (q).imag) : \
((p).real >= (q).real)))
#define PyArray_CEQ(p,q) (((p).real==(q).real) && ((p).imag == (q).imag))
#define PyArray_CNE(p,q) (((p).real!=(q).real) || ((p).imag != (q).imag))
/*
* C API: consists of Macros and functions. The MACROS are defined here.
*/
#define PyArray_CHKFLAGS(m, FLAGS) \
((((PyArrayObject *)(m))->flags & (FLAGS)) == (FLAGS))
#define PyArray_ISCONTIGUOUS(m) PyArray_CHKFLAGS(m, NPY_CONTIGUOUS)
#define PyArray_ISWRITEABLE(m) PyArray_CHKFLAGS(m, NPY_WRITEABLE)
#define PyArray_ISALIGNED(m) PyArray_CHKFLAGS(m, NPY_ALIGNED)
#if NPY_ALLOW_THREADS
#define NPY_BEGIN_ALLOW_THREADS Py_BEGIN_ALLOW_THREADS
#define NPY_END_ALLOW_THREADS Py_END_ALLOW_THREADS
#define NPY_BEGIN_THREADS_DEF PyThreadState *_save=NULL;
#define NPY_BEGIN_THREADS _save = PyEval_SaveThread();
#define NPY_END_THREADS do {if (_save) PyEval_RestoreThread(_save);} while (0);
#define NPY_BEGIN_THREADS_DESCR(dtype) \
do {if (!(PyDataType_FLAGCHK(dtype, NPY_NEEDS_PYAPI))) \
NPY_BEGIN_THREADS;} while (0);
#define NPY_END_THREADS_DESCR(dtype) \
do {if (!(PyDataType_FLAGCHK(dtype, NPY_NEEDS_PYAPI))) \
NPY_END_THREADS; } while (0);
#define NPY_ALLOW_C_API_DEF PyGILState_STATE __save__;
#define NPY_ALLOW_C_API __save__ = PyGILState_Ensure();
#define NPY_DISABLE_C_API PyGILState_Release(__save__);
#else
#define NPY_BEGIN_ALLOW_THREADS
#define NPY_END_ALLOW_THREADS
#define NPY_BEGIN_THREADS_DEF
#define NPY_BEGIN_THREADS
#define NPY_END_THREADS
#define NPY_BEGIN_THREADS_DESCR(dtype)
#define NPY_END_THREADS_DESCR(dtype)
#define NPY_ALLOW_C_API_DEF
#define NPY_ALLOW_C_API
#define NPY_DISABLE_C_API
#endif
/*****************************
* Basic iterator object
*****************************/
/* FWD declaration */
typedef struct PyArrayIterObject_tag PyArrayIterObject;
/* type of the function which translates a set of coordinates to a pointer to
* the data */
typedef char* (*npy_iter_get_dataptr_t)(PyArrayIterObject* iter, npy_intp*);
struct PyArrayIterObject_tag {
PyObject_HEAD
int nd_m1; /* number of dimensions - 1 */
npy_intp index, size;
npy_intp coordinates[NPY_MAXDIMS];/* N-dimensional loop */
npy_intp dims_m1[NPY_MAXDIMS]; /* ao->dimensions - 1 */
npy_intp strides[NPY_MAXDIMS]; /* ao->strides or fake */
npy_intp backstrides[NPY_MAXDIMS];/* how far to jump back */
npy_intp factors[NPY_MAXDIMS]; /* shape factors */
PyArrayObject *ao;
char *dataptr; /* pointer to current item*/
npy_bool contiguous;
npy_intp bounds[NPY_MAXDIMS][2];
npy_intp limits[NPY_MAXDIMS][2];
npy_intp limits_sizes[NPY_MAXDIMS];
npy_iter_get_dataptr_t translate;
} ;
/* Iterator API */
#define PyArrayIter_Check(op) PyObject_TypeCheck(op, &PyArrayIter_Type)
#define _PyAIT(it) ((PyArrayIterObject *)(it))
#define PyArray_ITER_RESET(it) { \
_PyAIT(it)->index = 0; \
_PyAIT(it)->dataptr = _PyAIT(it)->ao->data; \
memset(_PyAIT(it)->coordinates, 0, \
(_PyAIT(it)->nd_m1+1)*sizeof(npy_intp)); \
}
#define _PyArray_ITER_NEXT1(it) { \
(it)->dataptr += _PyAIT(it)->strides[0]; \
(it)->coordinates[0]++; \
}
#define _PyArray_ITER_NEXT2(it) { \
if ((it)->coordinates[1] < (it)->dims_m1[1]) { \
(it)->coordinates[1]++; \
(it)->dataptr += (it)->strides[1]; \
} \
else { \
(it)->coordinates[1] = 0; \
(it)->coordinates[0]++; \
(it)->dataptr += (it)->strides[0] - \
(it)->backstrides[1]; \
} \
}
#define _PyArray_ITER_NEXT3(it) { \
if ((it)->coordinates[2] < (it)->dims_m1[2]) { \
(it)->coordinates[2]++; \
(it)->dataptr += (it)->strides[2]; \
} \
else { \
(it)->coordinates[2] = 0; \
(it)->dataptr -= (it)->backstrides[2]; \
if ((it)->coordinates[1] < (it)->dims_m1[1]) { \
(it)->coordinates[1]++; \
(it)->dataptr += (it)->strides[1]; \
} \
else { \
(it)->coordinates[1] = 0; \
(it)->coordinates[0]++; \
(it)->dataptr += (it)->strides[0] - \
(it)->backstrides[1]; \
} \
} \
}
#define PyArray_ITER_NEXT(it) { \
_PyAIT(it)->index++; \
if (_PyAIT(it)->nd_m1 == 0) { \
_PyArray_ITER_NEXT1(_PyAIT(it)); \
} \
else if (_PyAIT(it)->contiguous) \
_PyAIT(it)->dataptr += _PyAIT(it)->ao->descr->elsize; \
else if (_PyAIT(it)->nd_m1 == 1) { \
_PyArray_ITER_NEXT2(_PyAIT(it)); \
} \
else { \
int __npy_i; \
for (__npy_i=_PyAIT(it)->nd_m1; __npy_i >= 0; __npy_i--) { \
if (_PyAIT(it)->coordinates[__npy_i] < \
_PyAIT(it)->dims_m1[__npy_i]) { \
_PyAIT(it)->coordinates[__npy_i]++; \
_PyAIT(it)->dataptr += \
_PyAIT(it)->strides[__npy_i]; \
break; \
} \
else { \
_PyAIT(it)->coordinates[__npy_i] = 0; \
_PyAIT(it)->dataptr -= \
_PyAIT(it)->backstrides[__npy_i]; \
} \
} \
} \
}
#define PyArray_ITER_GOTO(it, destination) { \
int __npy_i; \
_PyAIT(it)->index = 0; \
_PyAIT(it)->dataptr = _PyAIT(it)->ao->data; \
for (__npy_i = _PyAIT(it)->nd_m1; __npy_i>=0; __npy_i--) { \
if (destination[__npy_i] < 0) { \
destination[__npy_i] += \
_PyAIT(it)->dims_m1[__npy_i]+1; \
} \
_PyAIT(it)->dataptr += destination[__npy_i] * \
_PyAIT(it)->strides[__npy_i]; \
_PyAIT(it)->coordinates[__npy_i] = \
destination[__npy_i]; \
_PyAIT(it)->index += destination[__npy_i] * \
( __npy_i==_PyAIT(it)->nd_m1 ? 1 : \
_PyAIT(it)->dims_m1[__npy_i+1]+1) ; \
} \
}
#define PyArray_ITER_GOTO1D(it, ind) { \
int __npy_i; \
npy_intp __npy_ind = (npy_intp) (ind); \
if (__npy_ind < 0) __npy_ind += _PyAIT(it)->size; \
_PyAIT(it)->index = __npy_ind; \
if (_PyAIT(it)->nd_m1 == 0) { \
_PyAIT(it)->dataptr = _PyAIT(it)->ao->data + \
__npy_ind * _PyAIT(it)->strides[0]; \
} \
else if (_PyAIT(it)->contiguous) \
_PyAIT(it)->dataptr = _PyAIT(it)->ao->data + \
__npy_ind * _PyAIT(it)->ao->descr->elsize; \
else { \
_PyAIT(it)->dataptr = _PyAIT(it)->ao->data; \
for (__npy_i = 0; __npy_i<=_PyAIT(it)->nd_m1; \
__npy_i++) { \
_PyAIT(it)->dataptr += \
(__npy_ind / _PyAIT(it)->factors[__npy_i]) \
* _PyAIT(it)->strides[__npy_i]; \
__npy_ind %= _PyAIT(it)->factors[__npy_i]; \
} \
} \
}
#define PyArray_ITER_DATA(it) ((void *)(_PyAIT(it)->dataptr))
#define PyArray_ITER_NOTDONE(it) (_PyAIT(it)->index < _PyAIT(it)->size)
/*
Any object passed to PyArray_Broadcast must be binary compatible with
this structure.
*/
typedef struct {
PyObject_HEAD
int numiter; /* number of iters */
npy_intp size; /* broadcasted size */
npy_intp index; /* current index */
int nd; /* number of dims */
npy_intp dimensions[NPY_MAXDIMS]; /* dimensions */
PyArrayIterObject *iters[NPY_MAXARGS]; /* iterators */
} PyArrayMultiIterObject;
#define _PyMIT(m) ((PyArrayMultiIterObject *)(m))
#define PyArray_MultiIter_RESET(multi) { \
int __npy_mi; \
_PyMIT(multi)->index = 0; \
for (__npy_mi=0; __npy_mi < _PyMIT(multi)->numiter; __npy_mi++) { \
PyArray_ITER_RESET(_PyMIT(multi)->iters[__npy_mi]); \
} \
}
#define PyArray_MultiIter_NEXT(multi) { \
int __npy_mi; \
_PyMIT(multi)->index++; \
for (__npy_mi=0; __npy_mi < _PyMIT(multi)->numiter; __npy_mi++) { \
PyArray_ITER_NEXT(_PyMIT(multi)->iters[__npy_mi]); \
} \
}
#define PyArray_MultiIter_GOTO(multi, dest) { \
int __npy_mi; \
for (__npy_mi=0; __npy_mi < _PyMIT(multi)->numiter; __npy_mi++) { \
PyArray_ITER_GOTO(_PyMIT(multi)->iters[__npy_mi], dest); \
} \
_PyMIT(multi)->index = _PyMIT(multi)->iters[0]->index; \
}
#define PyArray_MultiIter_GOTO1D(multi, ind) { \
int __npy_mi; \
for (__npy_mi=0; __npy_mi < _PyMIT(multi)->numiter; __npy_mi++) { \
PyArray_ITER_GOTO1D(_PyMIT(multi)->iters[__npy_mi], ind); \
} \
_PyMIT(multi)->index = _PyMIT(multi)->iters[0]->index; \
}
#define PyArray_MultiIter_DATA(multi, i) \
((void *)(_PyMIT(multi)->iters[i]->dataptr))
#define PyArray_MultiIter_NEXTi(multi, i) \
PyArray_ITER_NEXT(_PyMIT(multi)->iters[i])
#define PyArray_MultiIter_NOTDONE(multi) \
(_PyMIT(multi)->index < _PyMIT(multi)->size)
/* Store the information needed for fancy-indexing over an array */
typedef struct {
PyObject_HEAD
/* Multi-iterator portion --- needs to be present in this order to
work with PyArray_Broadcast */
int numiter; /* number of index-array
iterators */
npy_intp size; /* size of broadcasted
result */
npy_intp index; /* current index */
int nd; /* number of dims */
npy_intp dimensions[NPY_MAXDIMS]; /* dimensions */
PyArrayIterObject *iters[NPY_MAXDIMS]; /* index object
iterators */
PyArrayIterObject *ait; /* flat Iterator for
underlying array */
/* flat iterator for subspace (when numiter < nd) */
PyArrayIterObject *subspace;
/* if subspace iteration, then this is the array of
axes in the underlying array represented by the
index objects */
int iteraxes[NPY_MAXDIMS];
/* if subspace iteration, the these are the coordinates
to the start of the subspace.
*/
npy_intp bscoord[NPY_MAXDIMS];
PyObject *indexobj; /* creating obj */
int consec;
char *dataptr;
} PyArrayMapIterObject;
enum {
NPY_NEIGHBORHOOD_ITER_ZERO_PADDING,
NPY_NEIGHBORHOOD_ITER_ONE_PADDING,
NPY_NEIGHBORHOOD_ITER_CONSTANT_PADDING,
NPY_NEIGHBORHOOD_ITER_CIRCULAR_PADDING,
NPY_NEIGHBORHOOD_ITER_MIRROR_PADDING
};
typedef struct {
PyObject_HEAD
/*
* PyArrayIterObject part: keep this in this exact order
*/
int nd_m1; /* number of dimensions - 1 */
npy_intp index, size;
npy_intp coordinates[NPY_MAXDIMS];/* N-dimensional loop */
npy_intp dims_m1[NPY_MAXDIMS]; /* ao->dimensions - 1 */
npy_intp strides[NPY_MAXDIMS]; /* ao->strides or fake */
npy_intp backstrides[NPY_MAXDIMS];/* how far to jump back */
npy_intp factors[NPY_MAXDIMS]; /* shape factors */
PyArrayObject *ao;
char *dataptr; /* pointer to current item*/
npy_bool contiguous;
npy_intp bounds[NPY_MAXDIMS][2];
npy_intp limits[NPY_MAXDIMS][2];
npy_intp limits_sizes[NPY_MAXDIMS];
npy_iter_get_dataptr_t translate;
/*
* New members
*/
npy_intp nd;
/* Dimensions is the dimension of the array */
npy_intp dimensions[NPY_MAXDIMS];
/* Neighborhood points coordinates are computed relatively to the point pointed
* by _internal_iter */
PyArrayIterObject* _internal_iter;
/* To keep a reference to the representation of the constant value for
* constant padding */
char* constant;
int mode;
} PyArrayNeighborhoodIterObject;
/*
* Neighborhood iterator API
*/
/* General: those work for any mode */
static NPY_INLINE int
PyArrayNeighborhoodIter_Reset(PyArrayNeighborhoodIterObject* iter);
static NPY_INLINE int
PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject* iter);
#if 0
static NPY_INLINE int
PyArrayNeighborhoodIter_Next2D(PyArrayNeighborhoodIterObject* iter);
#endif
/* Include inline implementations - functions defined there are not considered
* public API */
#define _NPY_INCLUDE_NEIGHBORHOOD_IMP
#include "_neighborhood_iterator_imp.h"
#undef _NPY_INCLUDE_NEIGHBORHOOD_IMP
/* The default array type
*/
#define NPY_DEFAULT_TYPE NPY_DOUBLE
#define PyArray_DEFAULT NPY_DEFAULT_TYPE
/* All sorts of useful ways to look into a PyArrayObject.
These are the recommended over casting to PyArrayObject and accessing
the members directly.
*/
#define PyArray_NDIM(obj) (((PyArrayObject *)(obj))->nd)
#define PyArray_ISONESEGMENT(m) (PyArray_NDIM(m) == 0 || \
PyArray_CHKFLAGS(m, NPY_CONTIGUOUS) || \
PyArray_CHKFLAGS(m, NPY_FORTRAN))
#define PyArray_ISFORTRAN(m) (PyArray_CHKFLAGS(m, NPY_FORTRAN) && \
(PyArray_NDIM(m) > 1))
#define PyArray_FORTRAN_IF(m) ((PyArray_CHKFLAGS(m, NPY_FORTRAN) ? \
NPY_FORTRAN : 0))
#define FORTRAN_IF PyArray_FORTRAN_IF
#define PyArray_DATA(obj) ((void *)(((PyArrayObject *)(obj))->data))
#define PyArray_BYTES(obj) (((PyArrayObject *)(obj))->data)
#define PyArray_DIMS(obj) (((PyArrayObject *)(obj))->dimensions)
#define PyArray_STRIDES(obj) (((PyArrayObject *)(obj))->strides)
#define PyArray_DIM(obj,n) (PyArray_DIMS(obj)[n])
#define PyArray_STRIDE(obj,n) (PyArray_STRIDES(obj)[n])
#define PyArray_BASE(obj) (((PyArrayObject *)(obj))->base)
#define PyArray_DESCR(obj) (((PyArrayObject *)(obj))->descr)
#define PyArray_FLAGS(obj) (((PyArrayObject *)(obj))->flags)
#define PyArray_ITEMSIZE(obj) (((PyArrayObject *)(obj))->descr->elsize)
#define PyArray_TYPE(obj) (((PyArrayObject *)(obj))->descr->type_num)
#define PyArray_GETITEM(obj,itemptr) \
((PyArrayObject *)(obj))->descr->f->getitem((char *)(itemptr), \
(PyArrayObject *)(obj))
#define PyArray_SETITEM(obj,itemptr,v) \
((PyArrayObject *)(obj))->descr->f->setitem((PyObject *)(v), \
(char *)(itemptr), \
(PyArrayObject *)(obj))
#define PyTypeNum_ISBOOL(type) ((type) == NPY_BOOL)
#define PyTypeNum_ISUNSIGNED(type) (((type) == NPY_UBYTE) || \
((type) == NPY_USHORT) || \
((type) == NPY_UINT) || \
((type) == NPY_ULONG) || \
((type) == NPY_ULONGLONG))
#define PyTypeNum_ISSIGNED(type) (((type) == NPY_BYTE) || \
((type) == NPY_SHORT) || \
((type) == NPY_INT) || \
((type) == NPY_LONG) || \
((type) == NPY_LONGLONG))
#define PyTypeNum_ISINTEGER(type) (((type) >= NPY_BYTE) && \
((type) <= NPY_ULONGLONG))
#define PyTypeNum_ISFLOAT(type) (((type) >= NPY_FLOAT) && \
((type) <= NPY_LONGDOUBLE))
#define PyTypeNum_ISNUMBER(type) ((type) <= NPY_CLONGDOUBLE)
#define PyTypeNum_ISSTRING(type) (((type) == NPY_STRING) || \
((type) == NPY_UNICODE))
#define PyTypeNum_ISCOMPLEX(type) (((type) >= NPY_CFLOAT) && \
((type) <= NPY_CLONGDOUBLE))
#define PyTypeNum_ISPYTHON(type) (((type) == NPY_LONG) || \
((type) == NPY_DOUBLE) || \
((type) == NPY_CDOUBLE) || \
((type) == NPY_BOOL) || \
((type) == NPY_OBJECT ))
#define PyTypeNum_ISFLEXIBLE(type) (((type) >=NPY_STRING) && \
((type) <=NPY_VOID))
#define PyTypeNum_ISDATETIME(type) (((type) >=NPY_DATETIME) && \
((type) <=NPY_TIMEDELTA))
#define PyTypeNum_ISUSERDEF(type) (((type) >= NPY_USERDEF) && \
((type) < NPY_USERDEF+ \
NPY_NUMUSERTYPES))
#define PyTypeNum_ISEXTENDED(type) (PyTypeNum_ISFLEXIBLE(type) || \
PyTypeNum_ISUSERDEF(type))
#define PyTypeNum_ISOBJECT(type) ((type) == NPY_OBJECT)
#define PyDataType_ISBOOL(obj) PyTypeNum_ISBOOL(_PyADt(obj))
#define PyDataType_ISUNSIGNED(obj) PyTypeNum_ISUNSIGNED(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_ISSIGNED(obj) PyTypeNum_ISSIGNED(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_ISINTEGER(obj) PyTypeNum_ISINTEGER(((PyArray_Descr*)(obj))->type_num )
#define PyDataType_ISFLOAT(obj) PyTypeNum_ISFLOAT(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_ISNUMBER(obj) PyTypeNum_ISNUMBER(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_ISSTRING(obj) PyTypeNum_ISSTRING(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_ISCOMPLEX(obj) PyTypeNum_ISCOMPLEX(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_ISPYTHON(obj) PyTypeNum_ISPYTHON(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_ISFLEXIBLE(obj) PyTypeNum_ISFLEXIBLE(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_ISDATETIME(obj) PyTypeNum_ISDATETIME(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_ISUSERDEF(obj) PyTypeNum_ISUSERDEF(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_ISEXTENDED(obj) PyTypeNum_ISEXTENDED(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_ISOBJECT(obj) PyTypeNum_ISOBJECT(((PyArray_Descr*)(obj))->type_num)
#define PyDataType_HASFIELDS(obj) (((PyArray_Descr *)(obj))->names != NULL)
#define PyArray_ISBOOL(obj) PyTypeNum_ISBOOL(PyArray_TYPE(obj))
#define PyArray_ISUNSIGNED(obj) PyTypeNum_ISUNSIGNED(PyArray_TYPE(obj))
#define PyArray_ISSIGNED(obj) PyTypeNum_ISSIGNED(PyArray_TYPE(obj))
#define PyArray_ISINTEGER(obj) PyTypeNum_ISINTEGER(PyArray_TYPE(obj))
#define PyArray_ISFLOAT(obj) PyTypeNum_ISFLOAT(PyArray_TYPE(obj))
#define PyArray_ISNUMBER(obj) PyTypeNum_ISNUMBER(PyArray_TYPE(obj))
#define PyArray_ISSTRING(obj) PyTypeNum_ISSTRING(PyArray_TYPE(obj))
#define PyArray_ISCOMPLEX(obj) PyTypeNum_ISCOMPLEX(PyArray_TYPE(obj))
#define PyArray_ISPYTHON(obj) PyTypeNum_ISPYTHON(PyArray_TYPE(obj))
#define PyArray_ISFLEXIBLE(obj) PyTypeNum_ISFLEXIBLE(PyArray_TYPE(obj))
#define PyArray_ISDATETIME(obj) PyTypeNum_ISDATETIME(PyArray_TYPE(obj))
#define PyArray_ISUSERDEF(obj) PyTypeNum_ISUSERDEF(PyArray_TYPE(obj))
#define PyArray_ISEXTENDED(obj) PyTypeNum_ISEXTENDED(PyArray_TYPE(obj))
#define PyArray_ISOBJECT(obj) PyTypeNum_ISOBJECT(PyArray_TYPE(obj))
#define PyArray_HASFIELDS(obj) PyDataType_HASFIELDS(PyArray_DESCR(obj))
/* FIXME: This should check for a flag on the data-type
that states whether or not it is variable length.
Because the ISFLEXIBLE check is hard-coded to the
built-in data-types.
*/
#define PyArray_ISVARIABLE(obj) PyTypeNum_ISFLEXIBLE(PyArray_TYPE(obj))
#define PyArray_SAFEALIGNEDCOPY(obj) (PyArray_ISALIGNED(obj) && !PyArray_ISVARIABLE(obj))
#define NPY_LITTLE '<'
#define NPY_BIG '>'
#define NPY_NATIVE '='
#define NPY_SWAP 's'
#define NPY_IGNORE '|'
#if NPY_BYTE_ORDER == NPY_BIG_ENDIAN
#define NPY_NATBYTE NPY_BIG
#define NPY_OPPBYTE NPY_LITTLE
#else
#define NPY_NATBYTE NPY_LITTLE
#define NPY_OPPBYTE NPY_BIG
#endif
#define PyArray_ISNBO(arg) ((arg) != NPY_OPPBYTE)
#define PyArray_IsNativeByteOrder PyArray_ISNBO
#define PyArray_ISNOTSWAPPED(m) PyArray_ISNBO(PyArray_DESCR(m)->byteorder)
#define PyArray_ISBYTESWAPPED(m) (!PyArray_ISNOTSWAPPED(m))
#define PyArray_FLAGSWAP(m, flags) (PyArray_CHKFLAGS(m, flags) && \
PyArray_ISNOTSWAPPED(m))
#define PyArray_ISCARRAY(m) PyArray_FLAGSWAP(m, NPY_CARRAY)
#define PyArray_ISCARRAY_RO(m) PyArray_FLAGSWAP(m, NPY_CARRAY_RO)
#define PyArray_ISFARRAY(m) PyArray_FLAGSWAP(m, NPY_FARRAY)
#define PyArray_ISFARRAY_RO(m) PyArray_FLAGSWAP(m, NPY_FARRAY_RO)
#define PyArray_ISBEHAVED(m) PyArray_FLAGSWAP(m, NPY_BEHAVED)
#define PyArray_ISBEHAVED_RO(m) PyArray_FLAGSWAP(m, NPY_ALIGNED)
#define PyDataType_ISNOTSWAPPED(d) PyArray_ISNBO(((PyArray_Descr *)(d))->byteorder)
#define PyDataType_ISBYTESWAPPED(d) (!PyDataType_ISNOTSWAPPED(d))
/* This is the form of the struct that's returned pointed by the
PyCObject attribute of an array __array_struct__. See
http://numpy.scipy.org/array_interface.shtml for the full
documentation. */
typedef struct {
int two; /* contains the integer 2 as a sanity check */
int nd; /* number of dimensions */
char typekind; /* kind in array --- character code of typestr */
int itemsize; /* size of each element */
int flags; /* how should be data interpreted. Valid
flags are CONTIGUOUS (1), FORTRAN (2),
ALIGNED (0x100), NOTSWAPPED (0x200), and
WRITEABLE (0x400).
ARR_HAS_DESCR (0x800) states that arrdescr
field is present in structure */
npy_intp *shape; /* A length-nd array of shape information */
npy_intp *strides; /* A length-nd array of stride information */
void *data; /* A pointer to the first element of the array */
PyObject *descr; /* A list of fields or NULL (ignored if flags
does not have ARR_HAS_DESCR flag set) */
} PyArrayInterface;
/* Includes the "function" C-API -- these are all stored in a
list of pointers --- one for each file
The two lists are concatenated into one in multiarray.
They are available as import_array()
*/
#include "__multiarray_api.h"
/* C-API that requries previous API to be defined */
#define PyArray_DescrCheck(op) ((op)->ob_type == &PyArrayDescr_Type)
#define PyArray_Check(op) PyObject_TypeCheck(op, &PyArray_Type)
#define PyArray_CheckExact(op) ((op)->ob_type == &PyArray_Type)
#define PyArray_HasArrayInterfaceType(op, type, context, out) \
((((out)=PyArray_FromStructInterface(op)) != Py_NotImplemented) || \
(((out)=PyArray_FromInterface(op)) != Py_NotImplemented) || \
(((out)=PyArray_FromArrayAttr(op, type, context)) != \
Py_NotImplemented))
#define PyArray_HasArrayInterface(op, out) \
PyArray_HasArrayInterfaceType(op, NULL, NULL, out)
#define PyArray_IsZeroDim(op) (PyArray_Check(op) && (PyArray_NDIM(op) == 0))
#define PyArray_IsScalar(obj, cls) \
(PyObject_TypeCheck(obj, &Py##cls##ArrType_Type))
#define PyArray_CheckScalar(m) (PyArray_IsScalar(m, Generic) || \
PyArray_IsZeroDim(m))
#define PyArray_IsPythonNumber(obj) \
(PyInt_Check(obj) || PyFloat_Check(obj) || PyComplex_Check(obj) || \
PyLong_Check(obj) || PyBool_Check(obj))
#define PyArray_IsPythonScalar(obj) \
(PyArray_IsPythonNumber(obj) || PyString_Check(obj) || \
PyUnicode_Check(obj))
#define PyArray_IsAnyScalar(obj) \
(PyArray_IsScalar(obj, Generic) || PyArray_IsPythonScalar(obj))
#define PyArray_CheckAnyScalar(obj) (PyArray_IsPythonScalar(obj) || \
PyArray_CheckScalar(obj))
#define PyArray_IsIntegerScalar(obj) (PyInt_Check(obj) \
|| PyLong_Check(obj) \
|| PyArray_IsScalar((obj), Integer))
#define PyArray_GETCONTIGUOUS(m) (PyArray_ISCONTIGUOUS(m) ? \
Py_INCREF(m), (m) : \
(PyArrayObject *)(PyArray_Copy(m)))
#define PyArray_SAMESHAPE(a1,a2) ((PyArray_NDIM(a1) == PyArray_NDIM(a2)) && \
PyArray_CompareLists(PyArray_DIMS(a1), \
PyArray_DIMS(a2), \
PyArray_NDIM(a1)))
#define PyArray_SIZE(m) PyArray_MultiplyList(PyArray_DIMS(m), PyArray_NDIM(m))
#define PyArray_NBYTES(m) (PyArray_ITEMSIZE(m) * PyArray_SIZE(m))
#define PyArray_FROM_O(m) PyArray_FromAny(m, NULL, 0, 0, 0, NULL)
#define PyArray_FROM_OF(m,flags) PyArray_CheckFromAny(m, NULL, 0, 0, flags, \
NULL)
#define PyArray_FROM_OT(m,type) PyArray_FromAny(m, \
PyArray_DescrFromType(type), 0, 0, 0, NULL);
#define PyArray_FROM_OTF(m, type, flags) \
PyArray_FromAny(m, PyArray_DescrFromType(type), 0, 0, \
(((flags) & NPY_ENSURECOPY) ? \
((flags) | NPY_DEFAULT) : (flags)), NULL)
#define PyArray_FROMANY(m, type, min, max, flags) \
PyArray_FromAny(m, PyArray_DescrFromType(type), min, max, \
(((flags) & NPY_ENSURECOPY) ? \
(flags) | NPY_DEFAULT : (flags)), NULL)
#define PyArray_ZEROS(m, dims, type, fortran) \
PyArray_Zeros(m, dims, PyArray_DescrFromType(type), fortran)
#define PyArray_EMPTY(m, dims, type, fortran) \
PyArray_Empty(m, dims, PyArray_DescrFromType(type), fortran)
#define PyArray_FILLWBYTE(obj, val) memset(PyArray_DATA(obj), val, \
PyArray_NBYTES(obj))
#define PyArray_REFCOUNT(obj) (((PyObject *)(obj))->ob_refcnt)
#define NPY_REFCOUNT PyArray_REFCOUNT
#define NPY_MAX_ELSIZE (2 * NPY_SIZEOF_LONGDOUBLE)
#define PyArray_ContiguousFromAny(op, type, min_depth, max_depth) \
PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
max_depth, NPY_DEFAULT, NULL)
#define PyArray_EquivArrTypes(a1, a2) \
PyArray_EquivTypes(PyArray_DESCR(a1), PyArray_DESCR(a2))
#define PyArray_EquivByteorders(b1, b2) \
(((b1) == (b2)) || (PyArray_ISNBO(b1) == PyArray_ISNBO(b2)))
#define PyArray_SimpleNew(nd, dims, typenum) \
PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, NULL, 0, 0, NULL)
#define PyArray_SimpleNewFromData(nd, dims, typenum, data) \
PyArray_New(&PyArray_Type, nd, dims, typenum, NULL, \
data, 0, NPY_CARRAY, NULL)
#define PyArray_SimpleNewFromDescr(nd, dims, descr) \
PyArray_NewFromDescr(&PyArray_Type, descr, nd, dims, \
NULL, NULL, 0, NULL)
#define PyArray_ToScalar(data, arr) \
PyArray_Scalar(data, PyArray_DESCR(arr), (PyObject *)arr)
/* These might be faster without the dereferencing of obj
going on inside -- of course an optimizing compiler should
inline the constants inside a for loop making it a moot point
*/
#define PyArray_GETPTR1(obj, i) ((void *)(PyArray_BYTES(obj) + \
(i)*PyArray_STRIDES(obj)[0]))
#define PyArray_GETPTR2(obj, i, j) ((void *)(PyArray_BYTES(obj) + \
(i)*PyArray_STRIDES(obj)[0] + \
(j)*PyArray_STRIDES(obj)[1]))
#define PyArray_GETPTR3(obj, i, j, k) ((void *)(PyArray_BYTES(obj) + \
(i)*PyArray_STRIDES(obj)[0] + \
(j)*PyArray_STRIDES(obj)[1] + \
(k)*PyArray_STRIDES(obj)[2]))
#define PyArray_GETPTR4(obj, i, j, k, l) ((void *)(PyArray_BYTES(obj) + \
(i)*PyArray_STRIDES(obj)[0] + \
(j)*PyArray_STRIDES(obj)[1] + \
(k)*PyArray_STRIDES(obj)[2] + \
(l)*PyArray_STRIDES(obj)[3]))
#define PyArray_XDECREF_ERR(obj) \
if (obj && (PyArray_FLAGS(obj) & NPY_UPDATEIFCOPY)) { \
PyArray_FLAGS(PyArray_BASE(obj)) |= NPY_WRITEABLE; \
PyArray_FLAGS(obj) &= ~NPY_UPDATEIFCOPY; \
} \
Py_XDECREF(obj)
#define PyArray_DESCR_REPLACE(descr) do { \
PyArray_Descr *_new_; \
_new_ = PyArray_DescrNew(descr); \
Py_XDECREF(descr); \
descr = _new_; \
} while(0)
/* Copy should always return contiguous array */
#define PyArray_Copy(obj) PyArray_NewCopy(obj, NPY_CORDER)
#define PyArray_FromObject(op, type, min_depth, max_depth) \
PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
max_depth, NPY_BEHAVED | NPY_ENSUREARRAY, NULL)
#define PyArray_ContiguousFromObject(op, type, min_depth, max_depth) \
PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
max_depth, NPY_DEFAULT | NPY_ENSUREARRAY, NULL)
#define PyArray_CopyFromObject(op, type, min_depth, max_depth) \
PyArray_FromAny(op, PyArray_DescrFromType(type), min_depth, \
max_depth, NPY_ENSURECOPY | NPY_DEFAULT | \
NPY_ENSUREARRAY, NULL)
#define PyArray_Cast(mp, type_num) \
PyArray_CastToType(mp, PyArray_DescrFromType(type_num), 0)
#define PyArray_Take(ap, items, axis) \
PyArray_TakeFrom(ap, items, axis, NULL, NPY_RAISE)
#define PyArray_Put(ap, items, values) \
PyArray_PutTo(ap, items, values, NPY_RAISE)
/* Compatibility with old Numeric stuff -- don't use in new code */
#define PyArray_FromDimsAndData(nd, d, type, data) \
PyArray_FromDimsAndDataAndDescr(nd, d, PyArray_DescrFromType(type), \
data)
#include "old_defines.h"
/*
Check to see if this key in the dictionary is the "title"
entry of the tuple (i.e. a duplicate dictionary entry in the fields
dict.
*/
#define NPY_TITLE_KEY(key, value) ((PyTuple_GET_SIZE((value))==3) && \
(PyTuple_GET_ITEM((value), 2) == (key)))
/* Define python version independent deprecation macro */
#if PY_VERSION_HEX >= 0x02050000
#define DEPRECATE(msg) PyErr_WarnEx(PyExc_DeprecationWarning,msg,1)
#else
#define DEPRECATE(msg) PyErr_Warn(PyExc_DeprecationWarning,msg)
#endif
#ifdef __cplusplus
}
#endif
#endif /* NPY_NDARRAYOBJECT_H */
PK e[2@2 2
npy_math.hnu W+A #ifndef __NPY_MATH_C99_H_
#define __NPY_MATH_C99_H_
#include
#include
/*
* NAN and INFINITY like macros (same behavior as glibc for NAN, same as C99
* for INFINITY)
*
* XXX: I should test whether INFINITY and NAN are available on the platform
*/
NPY_INLINE static float __npy_inff(void)
{
const union { npy_uint32 __i; float __f;} __bint = {0x7f800000UL};
return __bint.__f;
}
NPY_INLINE static float __npy_nanf(void)
{
const union { npy_uint32 __i; float __f;} __bint = {0x7fc00000UL};
return __bint.__f;
}
NPY_INLINE static float __npy_pzerof(void)
{
const union { npy_uint32 __i; float __f;} __bint = {0x00000000UL};
return __bint.__f;
}
NPY_INLINE static float __npy_nzerof(void)
{
const union { npy_uint32 __i; float __f;} __bint = {0x80000000UL};
return __bint.__f;
}
#define NPY_INFINITYF __npy_inff()
#define NPY_NANF __npy_nanf()
#define NPY_PZEROF __npy_pzerof()
#define NPY_NZEROF __npy_nzerof()
#define NPY_INFINITY ((npy_double)NPY_INFINITYF)
#define NPY_NAN ((npy_double)NPY_NANF)
#define NPY_PZERO ((npy_double)NPY_PZEROF)
#define NPY_NZERO ((npy_double)NPY_NZEROF)
#define NPY_INFINITYL ((npy_longdouble)NPY_INFINITYF)
#define NPY_NANL ((npy_longdouble)NPY_NANF)
#define NPY_PZEROL ((npy_longdouble)NPY_PZEROF)
#define NPY_NZEROL ((npy_longdouble)NPY_NZEROF)
/*
* Useful constants
*/
#define NPY_E 2.718281828459045235360287471352662498 /* e */
#define NPY_LOG2E 1.442695040888963407359924681001892137 /* log_2 e */
#define NPY_LOG10E 0.434294481903251827651128918916605082 /* log_10 e */
#define NPY_LOGE2 0.693147180559945309417232121458176568 /* log_e 2 */
#define NPY_LOGE10 2.302585092994045684017991454684364208 /* log_e 10 */
#define NPY_PI 3.141592653589793238462643383279502884 /* pi */
#define NPY_PI_2 1.570796326794896619231321691639751442 /* pi/2 */
#define NPY_PI_4 0.785398163397448309615660845819875721 /* pi/4 */
#define NPY_1_PI 0.318309886183790671537767526745028724 /* 1/pi */
#define NPY_2_PI 0.636619772367581343075535053490057448 /* 2/pi */
#define NPY_EULER 0.577215664901532860606512090082402431 /* Euler constant */
#define NPY_SQRT2 1.414213562373095048801688724209698079 /* sqrt(2) */
#define NPY_SQRT1_2 0.707106781186547524400844362104849039 /* 1/sqrt(2) */
#define NPY_Ef 2.718281828459045235360287471352662498F /* e */
#define NPY_LOG2Ef 1.442695040888963407359924681001892137F /* log_2 e */
#define NPY_LOG10Ef 0.434294481903251827651128918916605082F /* log_10 e */
#define NPY_LOGE2f 0.693147180559945309417232121458176568F /* log_e 2 */
#define NPY_LOGE10f 2.302585092994045684017991454684364208F /* log_e 10 */
#define NPY_PIf 3.141592653589793238462643383279502884F /* pi */
#define NPY_PI_2f 1.570796326794896619231321691639751442F /* pi/2 */
#define NPY_PI_4f 0.785398163397448309615660845819875721F /* pi/4 */
#define NPY_1_PIf 0.318309886183790671537767526745028724F /* 1/pi */
#define NPY_2_PIf 0.636619772367581343075535053490057448F /* 2/pi */
#define NPY_EULERf 0.577215664901532860606512090082402431F /* Euler constan*/
#define NPY_SQRT2f 1.414213562373095048801688724209698079F /* sqrt(2) */
#define NPY_SQRT1_2f 0.707106781186547524400844362104849039F /* 1/sqrt(2) */
#define NPY_El 2.718281828459045235360287471352662498L /* e */
#define NPY_LOG2El 1.442695040888963407359924681001892137L /* log_2 e */
#define NPY_LOG10El 0.434294481903251827651128918916605082L /* log_10 e */
#define NPY_LOGE2l 0.693147180559945309417232121458176568L /* log_e 2 */
#define NPY_LOGE10l 2.302585092994045684017991454684364208L /* log_e 10 */
#define NPY_PIl 3.141592653589793238462643383279502884L /* pi */
#define NPY_PI_2l 1.570796326794896619231321691639751442L /* pi/2 */
#define NPY_PI_4l 0.785398163397448309615660845819875721L /* pi/4 */
#define NPY_1_PIl 0.318309886183790671537767526745028724L /* 1/pi */
#define NPY_2_PIl 0.636619772367581343075535053490057448L /* 2/pi */
#define NPY_EULERl 0.577215664901532860606512090082402431L /* Euler constan*/
#define NPY_SQRT2l 1.414213562373095048801688724209698079L /* sqrt(2) */
#define NPY_SQRT1_2l 0.707106781186547524400844362104849039L /* 1/sqrt(2) */
/*
* C99 double math funcs
*/
double npy_sin(double x);
double npy_cos(double x);
double npy_tan(double x);
double npy_sinh(double x);
double npy_cosh(double x);
double npy_tanh(double x);
double npy_asin(double x);
double npy_acos(double x);
double npy_atan(double x);
double npy_aexp(double x);
double npy_alog(double x);
double npy_asqrt(double x);
double npy_afabs(double x);
double npy_log(double x);
double npy_log10(double x);
double npy_exp(double x);
double npy_sqrt(double x);
double npy_fabs(double x);
double npy_ceil(double x);
double npy_fmod(double x, double y);
double npy_floor(double x);
double npy_expm1(double x);
double npy_log1p(double x);
double npy_hypot(double x, double y);
double npy_acosh(double x);
double npy_asinh(double xx);
double npy_atanh(double x);
double npy_rint(double x);
double npy_trunc(double x);
double npy_exp2(double x);
double npy_log2(double x);
double npy_atan2(double x, double y);
double npy_pow(double x, double y);
double npy_modf(double x, double* y);
double npy_copysign(double x, double y);
double npy_nextafter(double x, double y);
double npy_spacing(double x);
/*
* IEEE 754 fpu handling. Those are guaranteed to be macros
*/
#ifndef NPY_HAVE_DECL_ISNAN
#define npy_isnan(x) ((x) != (x))
#else
#define npy_isnan(x) isnan((x))
#endif
#ifndef NPY_HAVE_DECL_ISFINITE
#define npy_isfinite(x) !npy_isnan((x) + (-x))
#else
#define npy_isfinite(x) isfinite((x))
#endif
#ifndef NPY_HAVE_DECL_ISINF
#define npy_isinf(x) (!npy_isfinite(x) && !npy_isnan(x))
#else
#define npy_isinf(x) isinf((x))
#endif
#ifndef NPY_HAVE_DECL_SIGNBIT
int _npy_signbit_f(float x);
int _npy_signbit_d(double x);
int _npy_signbit_ld(npy_longdouble x);
#define npy_signbit(x) \
(sizeof (x) == sizeof (long double) ? _npy_signbit_ld (x) \
: sizeof (x) == sizeof (double) ? _npy_signbit_d (x) \
: _npy_signbit_f (x))
#else
#define npy_signbit(x) signbit((x))
#endif
/*
* float C99 math functions
*/
float npy_sinf(float x);
float npy_cosf(float x);
float npy_tanf(float x);
float npy_sinhf(float x);
float npy_coshf(float x);
float npy_tanhf(float x);
float npy_fabsf(float x);
float npy_floorf(float x);
float npy_ceilf(float x);
float npy_rintf(float x);
float npy_truncf(float x);
float npy_sqrtf(float x);
float npy_log10f(float x);
float npy_logf(float x);
float npy_expf(float x);
float npy_expm1f(float x);
float npy_asinf(float x);
float npy_acosf(float x);
float npy_atanf(float x);
float npy_asinhf(float x);
float npy_acoshf(float x);
float npy_atanhf(float x);
float npy_log1pf(float x);
float npy_exp2f(float x);
float npy_log2f(float x);
float npy_atan2f(float x, float y);
float npy_hypotf(float x, float y);
float npy_powf(float x, float y);
float npy_fmodf(float x, float y);
float npy_modff(float x, float* y);
float npy_copysignf(float x, float y);
float npy_nextafterf(float x, float y);
float npy_spacingf(float x);
/*
* float C99 math functions
*/
npy_longdouble npy_sinl(npy_longdouble x);
npy_longdouble npy_cosl(npy_longdouble x);
npy_longdouble npy_tanl(npy_longdouble x);
npy_longdouble npy_sinhl(npy_longdouble x);
npy_longdouble npy_coshl(npy_longdouble x);
npy_longdouble npy_tanhl(npy_longdouble x);
npy_longdouble npy_fabsl(npy_longdouble x);
npy_longdouble npy_floorl(npy_longdouble x);
npy_longdouble npy_ceill(npy_longdouble x);
npy_longdouble npy_rintl(npy_longdouble x);
npy_longdouble npy_truncl(npy_longdouble x);
npy_longdouble npy_sqrtl(npy_longdouble x);
npy_longdouble npy_log10l(npy_longdouble x);
npy_longdouble npy_logl(npy_longdouble x);
npy_longdouble npy_expl(npy_longdouble x);
npy_longdouble npy_expm1l(npy_longdouble x);
npy_longdouble npy_asinl(npy_longdouble x);
npy_longdouble npy_acosl(npy_longdouble x);
npy_longdouble npy_atanl(npy_longdouble x);
npy_longdouble npy_asinhl(npy_longdouble x);
npy_longdouble npy_acoshl(npy_longdouble x);
npy_longdouble npy_atanhl(npy_longdouble x);
npy_longdouble npy_log1pl(npy_longdouble x);
npy_longdouble npy_exp2l(npy_longdouble x);
npy_longdouble npy_log2l(npy_longdouble x);
npy_longdouble npy_atan2l(npy_longdouble x, npy_longdouble y);
npy_longdouble npy_hypotl(npy_longdouble x, npy_longdouble y);
npy_longdouble npy_powl(npy_longdouble x, npy_longdouble y);
npy_longdouble npy_fmodl(npy_longdouble x, npy_longdouble y);
npy_longdouble npy_modfl(npy_longdouble x, npy_longdouble* y);
npy_longdouble npy_copysignl(npy_longdouble x, npy_longdouble y);
npy_longdouble npy_nextafterl(npy_longdouble x, npy_longdouble y);
npy_longdouble npy_spacingl(npy_longdouble x);
/*
* Non standard functions
*/
double npy_deg2rad(double x);
double npy_rad2deg(double x);
double npy_logaddexp(double x, double y);
double npy_logaddexp2(double x, double y);
float npy_deg2radf(float x);
float npy_rad2degf(float x);
float npy_logaddexpf(float x, float y);
float npy_logaddexp2f(float x, float y);
npy_longdouble npy_deg2radl(npy_longdouble x);
npy_longdouble npy_rad2degl(npy_longdouble x);
npy_longdouble npy_logaddexpl(npy_longdouble x, npy_longdouble y);
npy_longdouble npy_logaddexp2l(npy_longdouble x, npy_longdouble y);
#define npy_degrees npy_rad2deg
#define npy_degreesf npy_rad2degf
#define npy_degreesl npy_rad2degl
#define npy_radians npy_deg2rad
#define npy_radiansf npy_deg2radf
#define npy_radiansl npy_deg2radl
/*
* Complex declarations
*/
/*
* C99 specifies that complex numbers have the same representation as
* an array of two elements, where the first element is the real part
* and the second element is the imaginary part.
*/
#define __NPY_CPACK_IMP(x, y, type, ctype) \
union { \
ctype z; \
type a[2]; \
} z1;; \
\
z1.a[0] = (x); \
z1.a[1] = (y); \
\
return z1.z;
static NPY_INLINE npy_cdouble npy_cpack(double x, double y)
{
__NPY_CPACK_IMP(x, y, double, npy_cdouble);
}
static NPY_INLINE npy_cfloat npy_cpackf(float x, float y)
{
__NPY_CPACK_IMP(x, y, float, npy_cfloat);
}
static NPY_INLINE npy_clongdouble npy_cpackl(npy_longdouble x, npy_longdouble y)
{
__NPY_CPACK_IMP(x, y, npy_longdouble, npy_clongdouble);
}
#undef __NPY_CPACK_IMP
/*
* Same remark as above, but in the other direction: extract first/second
* member of complex number, assuming a C99-compatible representation
*
* Those are defineds as static inline, and such as a reasonable compiler would
* most likely compile this to one or two instructions (on CISC at least)
*/
#define __NPY_CEXTRACT_IMP(z, index, type, ctype) \
union { \
ctype z; \
type a[2]; \
} __z_repr; \
__z_repr.z = z; \
\
return __z_repr.a[index];
static NPY_INLINE double npy_creal(npy_cdouble z)
{
__NPY_CEXTRACT_IMP(z, 0, double, npy_cdouble);
}
static NPY_INLINE double npy_cimag(npy_cdouble z)
{
__NPY_CEXTRACT_IMP(z, 1, double, npy_cdouble);
}
static NPY_INLINE float npy_crealf(npy_cfloat z)
{
__NPY_CEXTRACT_IMP(z, 0, float, npy_cfloat);
}
static NPY_INLINE float npy_cimagf(npy_cfloat z)
{
__NPY_CEXTRACT_IMP(z, 1, float, npy_cfloat);
}
static NPY_INLINE npy_longdouble npy_creall(npy_clongdouble z)
{
__NPY_CEXTRACT_IMP(z, 0, npy_longdouble, npy_clongdouble);
}
static NPY_INLINE npy_longdouble npy_cimagl(npy_clongdouble z)
{
__NPY_CEXTRACT_IMP(z, 1, npy_longdouble, npy_clongdouble);
}
#undef __NPY_CEXTRACT_IMP
/*
* Double precision complex functions
*/
double npy_cabs(npy_cdouble z);
double npy_carg(npy_cdouble z);
npy_cdouble npy_cexp(npy_cdouble z);
npy_cdouble npy_clog(npy_cdouble z);
npy_cdouble npy_cpow(npy_cdouble x, npy_cdouble y);
npy_cdouble npy_csqrt(npy_cdouble z);
npy_cdouble npy_ccos(npy_cdouble z);
npy_cdouble npy_csin(npy_cdouble z);
/*
* Single precision complex functions
*/
float npy_cabsf(npy_cfloat z);
float npy_cargf(npy_cfloat z);
npy_cfloat npy_cexpf(npy_cfloat z);
npy_cfloat npy_clogf(npy_cfloat z);
npy_cfloat npy_cpowf(npy_cfloat x, npy_cfloat y);
npy_cfloat npy_csqrtf(npy_cfloat z);
npy_cfloat npy_ccosf(npy_cfloat z);
npy_cfloat npy_csinf(npy_cfloat z);
/*
* Extended precision complex functions
*/
npy_longdouble npy_cabsl(npy_clongdouble z);
npy_longdouble npy_cargl(npy_clongdouble z);
npy_clongdouble npy_cexpl(npy_clongdouble z);
npy_clongdouble npy_clogl(npy_clongdouble z);
npy_clongdouble npy_cpowl(npy_clongdouble x, npy_clongdouble y);
npy_clongdouble npy_csqrtl(npy_clongdouble z);
npy_clongdouble npy_ccosl(npy_clongdouble z);
npy_clongdouble npy_csinl(npy_clongdouble z);
#endif
PK e[
mw w npy_common.hnu W+A #ifndef _NPY_COMMON_H_
#define _NPY_COMMON_H_
/* This is auto-generated */
#include "numpyconfig.h"
#if defined(_MSC_VER)
#define NPY_INLINE __inline
#elif defined(__GNUC__)
#define NPY_INLINE inline
#else
#define NPY_INLINE
#endif
/* enums for detected endianness */
enum {
NPY_CPU_UNKNOWN_ENDIAN,
NPY_CPU_LITTLE,
NPY_CPU_BIG
};
/* Some platforms don't define bool, long long, or long double.
Handle that here.
*/
#define NPY_BYTE_FMT "hhd"
#define NPY_UBYTE_FMT "hhu"
#define NPY_SHORT_FMT "hd"
#define NPY_USHORT_FMT "hu"
#define NPY_INT_FMT "d"
#define NPY_UINT_FMT "u"
#define NPY_LONG_FMT "ld"
#define NPY_ULONG_FMT "lu"
#define NPY_FLOAT_FMT "g"
#define NPY_DOUBLE_FMT "g"
#ifdef PY_LONG_LONG
typedef PY_LONG_LONG npy_longlong;
typedef unsigned PY_LONG_LONG npy_ulonglong;
# ifdef _MSC_VER
# define NPY_LONGLONG_FMT "I64d"
# define NPY_ULONGLONG_FMT "I64u"
# define NPY_LONGLONG_SUFFIX(x) (x##i64)
# define NPY_ULONGLONG_SUFFIX(x) (x##Ui64)
# else
/* #define LONGLONG_FMT "lld" Another possible variant
#define ULONGLONG_FMT "llu"
#define LONGLONG_FMT "qd" -- BSD perhaps?
#define ULONGLONG_FMT "qu"
*/
# define NPY_LONGLONG_FMT "Ld"
# define NPY_ULONGLONG_FMT "Lu"
# define NPY_LONGLONG_SUFFIX(x) (x##LL)
# define NPY_ULONGLONG_SUFFIX(x) (x##ULL)
# endif
#else
typedef long npy_longlong;
typedef unsigned long npy_ulonglong;
# define NPY_LONGLONG_SUFFIX(x) (x##L)
# define NPY_ULONGLONG_SUFFIX(x) (x##UL)
#endif
typedef unsigned char npy_bool;
#define NPY_FALSE 0
#define NPY_TRUE 1
#if NPY_SIZEOF_LONGDOUBLE == NPY_SIZEOF_DOUBLE
typedef double npy_longdouble;
#define NPY_LONGDOUBLE_FMT "g"
#else
typedef long double npy_longdouble;
#define NPY_LONGDOUBLE_FMT "Lg"
#endif
#ifndef Py_USING_UNICODE
#error Must use Python with unicode enabled.
#endif
typedef signed char npy_byte;
typedef unsigned char npy_ubyte;
typedef unsigned short npy_ushort;
typedef unsigned int npy_uint;
typedef unsigned long npy_ulong;
/* These are for completeness */
typedef float npy_float;
typedef double npy_double;
typedef short npy_short;
typedef int npy_int;
typedef long npy_long;
/*
* Disabling C99 complex usage: a lot of C code in numpy/scipy rely on being
* able to do .real/.imag. Will have to convert code first.
*/
#if 0
#if defined(NPY_USE_C99_COMPLEX) && defined(NPY_HAVE_COMPLEX_DOUBLE)
typedef complex npy_cdouble;
#else
typedef struct { double real, imag; } npy_cdouble;
#endif
#if defined(NPY_USE_C99_COMPLEX) && defined(NPY_HAVE_COMPLEX_FLOAT)
typedef complex float npy_cfloat;
#else
typedef struct { float real, imag; } npy_cfloat;
#endif
#if defined(NPY_USE_C99_COMPLEX) && defined(NPY_HAVE_COMPLEX_LONG_DOUBLE)
typedef complex long double npy_clongdouble;
#else
typedef struct {npy_longdouble real, imag;} npy_clongdouble;
#endif
#endif
#if NPY_SIZEOF_COMPLEX_DOUBLE != 2 * NPY_SIZEOF_DOUBLE
#error npy_cdouble definition is not compatible with C99 complex definition ! \
Please contact Numpy maintainers and give detailed information about your \
compiler and platform
#endif
typedef struct { double real, imag; } npy_cdouble;
#if NPY_SIZEOF_COMPLEX_FLOAT != 2 * NPY_SIZEOF_FLOAT
#error npy_cfloat definition is not compatible with C99 complex definition ! \
Please contact Numpy maintainers and give detailed information about your \
compiler and platform
#endif
typedef struct { float real, imag; } npy_cfloat;
#if NPY_SIZEOF_COMPLEX_LONGDOUBLE != 2 * NPY_SIZEOF_LONGDOUBLE
#error npy_clongdouble definition is not compatible with C99 complex definition ! \
Please contact Numpy maintainers and give detailed information about your \
compiler and platform
#endif
typedef struct { npy_longdouble real, imag; } npy_clongdouble;
/*
* numarray-style bit-width typedefs
*/
#define NPY_MAX_INT8 127
#define NPY_MIN_INT8 -128
#define NPY_MAX_UINT8 255
#define NPY_MAX_INT16 32767
#define NPY_MIN_INT16 -32768
#define NPY_MAX_UINT16 65535
#define NPY_MAX_INT32 2147483647
#define NPY_MIN_INT32 (-NPY_MAX_INT32 - 1)
#define NPY_MAX_UINT32 4294967295U
#define NPY_MAX_INT64 NPY_LONGLONG_SUFFIX(9223372036854775807)
#define NPY_MIN_INT64 (-NPY_MAX_INT64 - NPY_LONGLONG_SUFFIX(1))
#define NPY_MAX_UINT64 NPY_ULONGLONG_SUFFIX(18446744073709551615)
#define NPY_MAX_INT128 NPY_LONGLONG_SUFFIX(85070591730234615865843651857942052864)
#define NPY_MIN_INT128 (-NPY_MAX_INT128 - NPY_LONGLONG_SUFFIX(1))
#define NPY_MAX_UINT128 NPY_ULONGLONG_SUFFIX(170141183460469231731687303715884105728)
#define NPY_MAX_INT256 NPY_LONGLONG_SUFFIX(57896044618658097711785492504343953926634992332820282019728792003956564819967)
#define NPY_MIN_INT256 (-NPY_MAX_INT256 - NPY_LONGLONG_SUFFIX(1))
#define NPY_MAX_UINT256 NPY_ULONGLONG_SUFFIX(115792089237316195423570985008687907853269984665640564039457584007913129639935)
#define NPY_MIN_DATETIME NPY_MIN_INT64
#define NPY_MAX_DATETIME NPY_MAX_INT64
#define NPY_MIN_TIMEDELTA NPY_MIN_INT64
#define NPY_MAX_TIMEDELTA NPY_MAX_INT64
/* Need to find the number of bits for each type and
make definitions accordingly.
C states that sizeof(char) == 1 by definition
So, just using the sizeof keyword won't help.
It also looks like Python itself uses sizeof(char) quite a
bit, which by definition should be 1 all the time.
Idea: Make Use of CHAR_BIT which should tell us how many
BITS per CHARACTER
*/
/* Include platform definitions -- These are in the C89/90 standard */
#include
#define NPY_MAX_BYTE SCHAR_MAX
#define NPY_MIN_BYTE SCHAR_MIN
#define NPY_MAX_UBYTE UCHAR_MAX
#define NPY_MAX_SHORT SHRT_MAX
#define NPY_MIN_SHORT SHRT_MIN
#define NPY_MAX_USHORT USHRT_MAX
#define NPY_MAX_INT INT_MAX
#ifndef INT_MIN
#define INT_MIN (-INT_MAX - 1)
#endif
#define NPY_MIN_INT INT_MIN
#define NPY_MAX_UINT UINT_MAX
#define NPY_MAX_LONG LONG_MAX
#define NPY_MIN_LONG LONG_MIN
#define NPY_MAX_ULONG ULONG_MAX
#define NPY_SIZEOF_DATETIME 8
#define NPY_SIZEOF_TIMEDELTA 8
#define NPY_BITSOF_BOOL (sizeof(npy_bool)*CHAR_BIT)
#define NPY_BITSOF_CHAR CHAR_BIT
#define NPY_BITSOF_SHORT (NPY_SIZEOF_SHORT * CHAR_BIT)
#define NPY_BITSOF_INT (NPY_SIZEOF_INT * CHAR_BIT)
#define NPY_BITSOF_LONG (NPY_SIZEOF_LONG * CHAR_BIT)
#define NPY_BITSOF_LONGLONG (NPY_SIZEOF_LONGLONG * CHAR_BIT)
#define NPY_BITSOF_FLOAT (NPY_SIZEOF_FLOAT * CHAR_BIT)
#define NPY_BITSOF_DOUBLE (NPY_SIZEOF_DOUBLE * CHAR_BIT)
#define NPY_BITSOF_LONGDOUBLE (NPY_SIZEOF_LONGDOUBLE * CHAR_BIT)
#define NPY_BITSOF_DATETIME (NPY_SIZEOF_DATETIME * CHAR_BIT)
#define NPY_BITSOF_TIMEDELTA (NPY_SIZEOF_TIMEDELTA * CHAR_BIT)
#if NPY_BITSOF_LONG == 8
#define NPY_INT8 NPY_LONG
#define NPY_UINT8 NPY_ULONG
typedef long npy_int8;
typedef unsigned long npy_uint8;
#define PyInt8ScalarObject PyLongScalarObject
#define PyInt8ArrType_Type PyLongArrType_Type
#define PyUInt8ScalarObject PyULongScalarObject
#define PyUInt8ArrType_Type PyULongArrType_Type
#define NPY_INT8_FMT NPY_LONG_FMT
#define NPY_UINT8_FMT NPY_ULONG_FMT
#elif NPY_BITSOF_LONG == 16
#define NPY_INT16 NPY_LONG
#define NPY_UINT16 NPY_ULONG
typedef long npy_int16;
typedef unsigned long npy_uint16;
#define PyInt16ScalarObject PyLongScalarObject
#define PyInt16ArrType_Type PyLongArrType_Type
#define PyUInt16ScalarObject PyULongScalarObject
#define PyUInt16ArrType_Type PyULongArrType_Type
#define NPY_INT16_FMT NPY_LONG_FMT
#define NPY_UINT16_FMT NPY_ULONG_FMT
#elif NPY_BITSOF_LONG == 32
#define NPY_INT32 NPY_LONG
#define NPY_UINT32 NPY_ULONG
typedef long npy_int32;
typedef unsigned long npy_uint32;
typedef unsigned long npy_ucs4;
#define PyInt32ScalarObject PyLongScalarObject
#define PyInt32ArrType_Type PyLongArrType_Type
#define PyUInt32ScalarObject PyULongScalarObject
#define PyUInt32ArrType_Type PyULongArrType_Type
#define NPY_INT32_FMT NPY_LONG_FMT
#define NPY_UINT32_FMT NPY_ULONG_FMT
#elif NPY_BITSOF_LONG == 64
#define NPY_INT64 NPY_LONG
#define NPY_UINT64 NPY_ULONG
typedef long npy_int64;
typedef unsigned long npy_uint64;
#define PyInt64ScalarObject PyLongScalarObject
#define PyInt64ArrType_Type PyLongArrType_Type
#define PyUInt64ScalarObject PyULongScalarObject
#define PyUInt64ArrType_Type PyULongArrType_Type
#define NPY_INT64_FMT NPY_LONG_FMT
#define NPY_UINT64_FMT NPY_ULONG_FMT
#define MyPyLong_FromInt64 PyLong_FromLong
#define MyPyLong_AsInt64 PyLong_AsLong
#elif NPY_BITSOF_LONG == 128
#define NPY_INT128 NPY_LONG
#define NPY_UINT128 NPY_ULONG
typedef long npy_int128;
typedef unsigned long npy_uint128;
#define PyInt128ScalarObject PyLongScalarObject
#define PyInt128ArrType_Type PyLongArrType_Type
#define PyUInt128ScalarObject PyULongScalarObject
#define PyUInt128ArrType_Type PyULongArrType_Type
#define NPY_INT128_FMT NPY_LONG_FMT
#define NPY_UINT128_FMT NPY_ULONG_FMT
#endif
#if NPY_BITSOF_LONGLONG == 8
# ifndef NPY_INT8
# define NPY_INT8 NPY_LONGLONG
# define NPY_UINT8 NPY_ULONGLONG
typedef npy_longlong npy_int8;
typedef npy_ulonglong npy_uint8;
# define PyInt8ScalarObject PyLongLongScalarObject
# define PyInt8ArrType_Type PyLongLongArrType_Type
# define PyUInt8ScalarObject PyULongLongScalarObject
# define PyUInt8ArrType_Type PyULongLongArrType_Type
#define NPY_INT8_FMT NPY_LONGLONG_FMT
#define NPY_UINT8_FMT NPY_ULONGLONG_FMT
# endif
# define NPY_MAX_LONGLONG NPY_MAX_INT8
# define NPY_MIN_LONGLONG NPY_MIN_INT8
# define NPY_MAX_ULONGLONG NPY_MAX_UINT8
#elif NPY_BITSOF_LONGLONG == 16
# ifndef NPY_INT16
# define NPY_INT16 NPY_LONGLONG
# define NPY_UINT16 NPY_ULONGLONG
typedef npy_longlong npy_int16;
typedef npy_ulonglong npy_uint16;
# define PyInt16ScalarObject PyLongLongScalarObject
# define PyInt16ArrType_Type PyLongLongArrType_Type
# define PyUInt16ScalarObject PyULongLongScalarObject
# define PyUInt16ArrType_Type PyULongLongArrType_Type
#define NPY_INT16_FMT NPY_LONGLONG_FMT
#define NPY_UINT16_FMT NPY_ULONGLONG_FMT
# endif
# define NPY_MAX_LONGLONG NPY_MAX_INT16
# define NPY_MIN_LONGLONG NPY_MIN_INT16
# define NPY_MAX_ULONGLONG NPY_MAX_UINT16
#elif NPY_BITSOF_LONGLONG == 32
# ifndef NPY_INT32
# define NPY_INT32 NPY_LONGLONG
# define NPY_UINT32 NPY_ULONGLONG
typedef npy_longlong npy_int32;
typedef npy_ulonglong npy_uint32;
typedef npy_ulonglong npy_ucs4;
# define PyInt32ScalarObject PyLongLongScalarObject
# define PyInt32ArrType_Type PyLongLongArrType_Type
# define PyUInt32ScalarObject PyULongLongScalarObject
# define PyUInt32ArrType_Type PyULongLongArrType_Type
#define NPY_INT32_FMT NPY_LONGLONG_FMT
#define NPY_UINT32_FMT NPY_ULONGLONG_FMT
# endif
# define NPY_MAX_LONGLONG NPY_MAX_INT32
# define NPY_MIN_LONGLONG NPY_MIN_INT32
# define NPY_MAX_ULONGLONG NPY_MAX_UINT32
#elif NPY_BITSOF_LONGLONG == 64
# ifndef NPY_INT64
# define NPY_INT64 NPY_LONGLONG
# define NPY_UINT64 NPY_ULONGLONG
typedef npy_longlong npy_int64;
typedef npy_ulonglong npy_uint64;
# define PyInt64ScalarObject PyLongLongScalarObject
# define PyInt64ArrType_Type PyLongLongArrType_Type
# define PyUInt64ScalarObject PyULongLongScalarObject
# define PyUInt64ArrType_Type PyULongLongArrType_Type
#define NPY_INT64_FMT NPY_LONGLONG_FMT
#define NPY_UINT64_FMT NPY_ULONGLONG_FMT
# define MyPyLong_FromInt64 PyLong_FromLongLong
# define MyPyLong_AsInt64 PyLong_AsLongLong
# endif
# define NPY_MAX_LONGLONG NPY_MAX_INT64
# define NPY_MIN_LONGLONG NPY_MIN_INT64
# define NPY_MAX_ULONGLONG NPY_MAX_UINT64
#elif NPY_BITSOF_LONGLONG == 128
# ifndef NPY_INT128
# define NPY_INT128 NPY_LONGLONG
# define NPY_UINT128 NPY_ULONGLONG
typedef npy_longlong npy_int128;
typedef npy_ulonglong npy_uint128;
# define PyInt128ScalarObject PyLongLongScalarObject
# define PyInt128ArrType_Type PyLongLongArrType_Type
# define PyUInt128ScalarObject PyULongLongScalarObject
# define PyUInt128ArrType_Type PyULongLongArrType_Type
#define NPY_INT128_FMT NPY_LONGLONG_FMT
#define NPY_UINT128_FMT NPY_ULONGLONG_FMT
# endif
# define NPY_MAX_LONGLONG NPY_MAX_INT128
# define NPY_MIN_LONGLONG NPY_MIN_INT128
# define NPY_MAX_ULONGLONG NPY_MAX_UINT128
#elif NPY_BITSOF_LONGLONG == 256
# define NPY_INT256 NPY_LONGLONG
# define NPY_UINT256 NPY_ULONGLONG
typedef npy_longlong npy_int256;
typedef npy_ulonglong npy_uint256;
# define PyInt256ScalarObject PyLongLongScalarObject
# define PyInt256ArrType_Type PyLongLongArrType_Type
# define PyUInt256ScalarObject PyULongLongScalarObject
# define PyUInt256ArrType_Type PyULongLongArrType_Type
#define NPY_INT256_FMT NPY_LONGLONG_FMT
#define NPY_UINT256_FMT NPY_ULONGLONG_FMT
# define NPY_MAX_LONGLONG NPY_MAX_INT256
# define NPY_MIN_LONGLONG NPY_MIN_INT256
# define NPY_MAX_ULONGLONG NPY_MAX_UINT256
#endif
#if NPY_BITSOF_INT == 8
#ifndef NPY_INT8
#define NPY_INT8 NPY_INT
#define NPY_UINT8 NPY_UINT
typedef int npy_int8;
typedef unsigned int npy_uint8;
# define PyInt8ScalarObject PyIntScalarObject
# define PyInt8ArrType_Type PyIntArrType_Type
# define PyUInt8ScalarObject PyUIntScalarObject
# define PyUInt8ArrType_Type PyUIntArrType_Type
#define NPY_INT8_FMT NPY_INT_FMT
#define NPY_UINT8_FMT NPY_UINT_FMT
#endif
#elif NPY_BITSOF_INT == 16
#ifndef NPY_INT16
#define NPY_INT16 NPY_INT
#define NPY_UINT16 NPY_UINT
typedef int npy_int16;
typedef unsigned int npy_uint16;
# define PyInt16ScalarObject PyIntScalarObject
# define PyInt16ArrType_Type PyIntArrType_Type
# define PyUInt16ScalarObject PyIntUScalarObject
# define PyUInt16ArrType_Type PyIntUArrType_Type
#define NPY_INT16_FMT NPY_INT_FMT
#define NPY_UINT16_FMT NPY_UINT_FMT
#endif
#elif NPY_BITSOF_INT == 32
#ifndef NPY_INT32
#define NPY_INT32 NPY_INT
#define NPY_UINT32 NPY_UINT
typedef int npy_int32;
typedef unsigned int npy_uint32;
typedef unsigned int npy_ucs4;
# define PyInt32ScalarObject PyIntScalarObject
# define PyInt32ArrType_Type PyIntArrType_Type
# define PyUInt32ScalarObject PyUIntScalarObject
# define PyUInt32ArrType_Type PyUIntArrType_Type
#define NPY_INT32_FMT NPY_INT_FMT
#define NPY_UINT32_FMT NPY_UINT_FMT
#endif
#elif NPY_BITSOF_INT == 64
#ifndef NPY_INT64
#define NPY_INT64 NPY_INT
#define NPY_UINT64 NPY_UINT
typedef int npy_int64;
typedef unsigned int npy_uint64;
# define PyInt64ScalarObject PyIntScalarObject
# define PyInt64ArrType_Type PyIntArrType_Type
# define PyUInt64ScalarObject PyUIntScalarObject
# define PyUInt64ArrType_Type PyUIntArrType_Type
#define NPY_INT64_FMT NPY_INT_FMT
#define NPY_UINT64_FMT NPY_UINT_FMT
# define MyPyLong_FromInt64 PyLong_FromLong
# define MyPyLong_AsInt64 PyLong_AsLong
#endif
#elif NPY_BITSOF_INT == 128
#ifndef NPY_INT128
#define NPY_INT128 NPY_INT
#define NPY_UINT128 NPY_UINT
typedef int npy_int128;
typedef unsigned int npy_uint128;
# define PyInt128ScalarObject PyIntScalarObject
# define PyInt128ArrType_Type PyIntArrType_Type
# define PyUInt128ScalarObject PyUIntScalarObject
# define PyUInt128ArrType_Type PyUIntArrType_Type
#define NPY_INT128_FMT NPY_INT_FMT
#define NPY_UINT128_FMT NPY_UINT_FMT
#endif
#endif
#if NPY_BITSOF_SHORT == 8
#ifndef NPY_INT8
#define NPY_INT8 NPY_SHORT
#define NPY_UINT8 NPY_USHORT
typedef short npy_int8;
typedef unsigned short npy_uint8;
# define PyInt8ScalarObject PyShortScalarObject
# define PyInt8ArrType_Type PyShortArrType_Type
# define PyUInt8ScalarObject PyUShortScalarObject
# define PyUInt8ArrType_Type PyUShortArrType_Type
#define NPY_INT8_FMT NPY_SHORT_FMT
#define NPY_UINT8_FMT NPY_USHORT_FMT
#endif
#elif NPY_BITSOF_SHORT == 16
#ifndef NPY_INT16
#define NPY_INT16 NPY_SHORT
#define NPY_UINT16 NPY_USHORT
typedef short npy_int16;
typedef unsigned short npy_uint16;
# define PyInt16ScalarObject PyShortScalarObject
# define PyInt16ArrType_Type PyShortArrType_Type
# define PyUInt16ScalarObject PyUShortScalarObject
# define PyUInt16ArrType_Type PyUShortArrType_Type
#define NPY_INT16_FMT NPY_SHORT_FMT
#define NPY_UINT16_FMT NPY_USHORT_FMT
#endif
#elif NPY_BITSOF_SHORT == 32
#ifndef NPY_INT32
#define NPY_INT32 NPY_SHORT
#define NPY_UINT32 NPY_USHORT
typedef short npy_int32;
typedef unsigned short npy_uint32;
typedef unsigned short npy_ucs4;
# define PyInt32ScalarObject PyShortScalarObject
# define PyInt32ArrType_Type PyShortArrType_Type
# define PyUInt32ScalarObject PyUShortScalarObject
# define PyUInt32ArrType_Type PyUShortArrType_Type
#define NPY_INT32_FMT NPY_SHORT_FMT
#define NPY_UINT32_FMT NPY_USHORT_FMT
#endif
#elif NPY_BITSOF_SHORT == 64
#ifndef NPY_INT64
#define NPY_INT64 NPY_SHORT
#define NPY_UINT64 NPY_USHORT
typedef short npy_int64;
typedef unsigned short npy_uint64;
# define PyInt64ScalarObject PyShortScalarObject
# define PyInt64ArrType_Type PyShortArrType_Type
# define PyUInt64ScalarObject PyUShortScalarObject
# define PyUInt64ArrType_Type PyUShortArrType_Type
#define NPY_INT64_FMT NPY_SHORT_FMT
#define NPY_UINT64_FMT NPY_USHORT_FMT
# define MyPyLong_FromInt64 PyLong_FromLong
# define MyPyLong_AsInt64 PyLong_AsLong
#endif
#elif NPY_BITSOF_SHORT == 128
#ifndef NPY_INT128
#define NPY_INT128 NPY_SHORT
#define NPY_UINT128 NPY_USHORT
typedef short npy_int128;
typedef unsigned short npy_uint128;
# define PyInt128ScalarObject PyShortScalarObject
# define PyInt128ArrType_Type PyShortArrType_Type
# define PyUInt128ScalarObject PyUShortScalarObject
# define PyUInt128ArrType_Type PyUShortArrType_Type
#define NPY_INT128_FMT NPY_SHORT_FMT
#define NPY_UINT128_FMT NPY_USHORT_FMT
#endif
#endif
#if NPY_BITSOF_CHAR == 8
#ifndef NPY_INT8
#define NPY_INT8 NPY_BYTE
#define NPY_UINT8 NPY_UBYTE
typedef signed char npy_int8;
typedef unsigned char npy_uint8;
# define PyInt8ScalarObject PyByteScalarObject
# define PyInt8ArrType_Type PyByteArrType_Type
# define PyUInt8ScalarObject PyUByteScalarObject
# define PyUInt8ArrType_Type PyUByteArrType_Type
#define NPY_INT8_FMT NPY_BYTE_FMT
#define NPY_UINT8_FMT NPY_UBYTE_FMT
#endif
#elif NPY_BITSOF_CHAR == 16
#ifndef NPY_INT16
#define NPY_INT16 NPY_BYTE
#define NPY_UINT16 NPY_UBYTE
typedef signed char npy_int16;
typedef unsigned char npy_uint16;
# define PyInt16ScalarObject PyByteScalarObject
# define PyInt16ArrType_Type PyByteArrType_Type
# define PyUInt16ScalarObject PyUByteScalarObject
# define PyUInt16ArrType_Type PyUByteArrType_Type
#define NPY_INT16_FMT NPY_BYTE_FMT
#define NPY_UINT16_FMT NPY_UBYTE_FMT
#endif
#elif NPY_BITSOF_CHAR == 32
#ifndef NPY_INT32
#define NPY_INT32 NPY_BYTE
#define NPY_UINT32 NPY_UBYTE
typedef signed char npy_int32;
typedef unsigned char npy_uint32;
typedef unsigned char npy_ucs4;
# define PyInt32ScalarObject PyByteScalarObject
# define PyInt32ArrType_Type PyByteArrType_Type
# define PyUInt32ScalarObject PyUByteScalarObject
# define PyUInt32ArrType_Type PyUByteArrType_Type
#define NPY_INT32_FMT NPY_BYTE_FMT
#define NPY_UINT32_FMT NPY_UBYTE_FMT
#endif
#elif NPY_BITSOF_CHAR == 64
#ifndef NPY_INT64
#define NPY_INT64 NPY_BYTE
#define NPY_UINT64 NPY_UBYTE
typedef signed char npy_int64;
typedef unsigned char npy_uint64;
# define PyInt64ScalarObject PyByteScalarObject
# define PyInt64ArrType_Type PyByteArrType_Type
# define PyUInt64ScalarObject PyUByteScalarObject
# define PyUInt64ArrType_Type PyUByteArrType_Type
#define NPY_INT64_FMT NPY_BYTE_FMT
#define NPY_UINT64_FMT NPY_UBYTE_FMT
# define MyPyLong_FromInt64 PyLong_FromLong
# define MyPyLong_AsInt64 PyLong_AsLong
#endif
#elif NPY_BITSOF_CHAR == 128
#ifndef NPY_INT128
#define NPY_INT128 NPY_BYTE
#define NPY_UINT128 NPY_UBYTE
typedef signed char npy_int128;
typedef unsigned char npy_uint128;
# define PyInt128ScalarObject PyByteScalarObject
# define PyInt128ArrType_Type PyByteArrType_Type
# define PyUInt128ScalarObject PyUByteScalarObject
# define PyUInt128ArrType_Type PyUByteArrType_Type
#define NPY_INT128_FMT NPY_BYTE_FMT
#define NPY_UINT128_FMT NPY_UBYTE_FMT
#endif
#endif
#if NPY_BITSOF_DOUBLE == 16
#ifndef NPY_FLOAT16
#define NPY_FLOAT16 NPY_DOUBLE
#define NPY_COMPLEX32 NPY_CDOUBLE
typedef double npy_float16;
typedef npy_cdouble npy_complex32;
# define PyFloat16ScalarObject PyDoubleScalarObject
# define PyComplex32ScalarObject PyCDoubleScalarObject
# define PyFloat16ArrType_Type PyDoubleArrType_Type
# define PyComplex32ArrType_Type PyCDoubleArrType_Type
#define NPY_FLOAT16_FMT NPY_DOUBLE_FMT
#define NPY_COMPLEX32_FMT NPY_CDOUBLE_FMT
#endif
#elif NPY_BITSOF_DOUBLE == 32
#ifndef NPY_FLOAT32
#define NPY_FLOAT32 NPY_DOUBLE
#define NPY_COMPLEX64 NPY_CDOUBLE
typedef double npy_float32;
typedef npy_cdouble npy_complex64;
# define PyFloat32ScalarObject PyDoubleScalarObject
# define PyComplex64ScalarObject PyCDoubleScalarObject
# define PyFloat32ArrType_Type PyDoubleArrType_Type
# define PyComplex64ArrType_Type PyCDoubleArrType_Type
#define NPY_FLOAT32_FMT NPY_DOUBLE_FMT
#define NPY_COMPLEX64_FMT NPY_CDOUBLE_FMT
#endif
#elif NPY_BITSOF_DOUBLE == 64
#ifndef NPY_FLOAT64
#define NPY_FLOAT64 NPY_DOUBLE
#define NPY_COMPLEX128 NPY_CDOUBLE
typedef double npy_float64;
typedef npy_cdouble npy_complex128;
# define PyFloat64ScalarObject PyDoubleScalarObject
# define PyComplex128ScalarObject PyCDoubleScalarObject
# define PyFloat64ArrType_Type PyDoubleArrType_Type
# define PyComplex128ArrType_Type PyCDoubleArrType_Type
#define NPY_FLOAT64_FMT NPY_DOUBLE_FMT
#define NPY_COMPLEX128_FMT NPY_CDOUBLE_FMT
#endif
#elif NPY_BITSOF_DOUBLE == 80
#ifndef NPY_FLOAT80
#define NPY_FLOAT80 NPY_DOUBLE
#define NPY_COMPLEX160 NPY_CDOUBLE
typedef double npy_float80;
typedef npy_cdouble npy_complex160;
# define PyFloat80ScalarObject PyDoubleScalarObject
# define PyComplex160ScalarObject PyCDoubleScalarObject
# define PyFloat80ArrType_Type PyDoubleArrType_Type
# define PyComplex160ArrType_Type PyCDoubleArrType_Type
#define NPY_FLOAT80_FMT NPY_DOUBLE_FMT
#define NPY_COMPLEX160_FMT NPY_CDOUBLE_FMT
#endif
#elif NPY_BITSOF_DOUBLE == 96
#ifndef NPY_FLOAT96
#define NPY_FLOAT96 NPY_DOUBLE
#define NPY_COMPLEX192 NPY_CDOUBLE
typedef double npy_float96;
typedef npy_cdouble npy_complex192;
# define PyFloat96ScalarObject PyDoubleScalarObject
# define PyComplex192ScalarObject PyCDoubleScalarObject
# define PyFloat96ArrType_Type PyDoubleArrType_Type
# define PyComplex192ArrType_Type PyCDoubleArrType_Type
#define NPY_FLOAT96_FMT NPY_DOUBLE_FMT
#define NPY_COMPLEX192_FMT NPY_CDOUBLE_FMT
#endif
#elif NPY_BITSOF_DOUBLE == 128
#ifndef NPY_FLOAT128
#define NPY_FLOAT128 NPY_DOUBLE
#define NPY_COMPLEX256 NPY_CDOUBLE
typedef double npy_float128;
typedef npy_cdouble npy_complex256;
# define PyFloat128ScalarObject PyDoubleScalarObject
# define PyComplex256ScalarObject PyCDoubleScalarObject
# define PyFloat128ArrType_Type PyDoubleArrType_Type
# define PyComplex256ArrType_Type PyCDoubleArrType_Type
#define NPY_FLOAT128_FMT NPY_DOUBLE_FMT
#define NPY_COMPLEX256_FMT NPY_CDOUBLE_FMT
#endif
#endif
#if NPY_BITSOF_FLOAT == 16
#ifndef NPY_FLOAT16
#define NPY_FLOAT16 NPY_FLOAT
#define NPY_COMPLEX32 NPY_CFLOAT
typedef float npy_float16;
typedef npy_cfloat npy_complex32;
# define PyFloat16ScalarObject PyFloatScalarObject
# define PyComplex32ScalarObject PyCFloatScalarObject
# define PyFloat16ArrType_Type PyFloatArrType_Type
# define PyComplex32ArrType_Type PyCFloatArrType_Type
#define NPY_FLOAT16_FMT NPY_FLOAT_FMT
#define NPY_COMPLEX32_FMT NPY_CFLOAT_FMT
#endif
#elif NPY_BITSOF_FLOAT == 32
#ifndef NPY_FLOAT32
#define NPY_FLOAT32 NPY_FLOAT
#define NPY_COMPLEX64 NPY_CFLOAT
typedef float npy_float32;
typedef npy_cfloat npy_complex64;
# define PyFloat32ScalarObject PyFloatScalarObject
# define PyComplex64ScalarObject PyCFloatScalarObject
# define PyFloat32ArrType_Type PyFloatArrType_Type
# define PyComplex64ArrType_Type PyCFloatArrType_Type
#define NPY_FLOAT32_FMT NPY_FLOAT_FMT
#define NPY_COMPLEX64_FMT NPY_CFLOAT_FMT
#endif
#elif NPY_BITSOF_FLOAT == 64
#ifndef NPY_FLOAT64
#define NPY_FLOAT64 NPY_FLOAT
#define NPY_COMPLEX128 NPY_CFLOAT
typedef float npy_float64;
typedef npy_cfloat npy_complex128;
# define PyFloat64ScalarObject PyFloatScalarObject
# define PyComplex128ScalarObject PyCFloatScalarObject
# define PyFloat64ArrType_Type PyFloatArrType_Type
# define PyComplex128ArrType_Type PyCFloatArrType_Type
#define NPY_FLOAT64_FMT NPY_FLOAT_FMT
#define NPY_COMPLEX128_FMT NPY_CFLOAT_FMT
#endif
#elif NPY_BITSOF_FLOAT == 80
#ifndef NPY_FLOAT80
#define NPY_FLOAT80 NPY_FLOAT
#define NPY_COMPLEX160 NPY_CFLOAT
typedef float npy_float80;
typedef npy_cfloat npy_complex160;
# define PyFloat80ScalarObject PyFloatScalarObject
# define PyComplex160ScalarObject PyCFloatScalarObject
# define PyFloat80ArrType_Type PyFloatArrType_Type
# define PyComplex160ArrType_Type PyCFloatArrType_Type
#define NPY_FLOAT80_FMT NPY_FLOAT_FMT
#define NPY_COMPLEX160_FMT NPY_CFLOAT_FMT
#endif
#elif NPY_BITSOF_FLOAT == 96
#ifndef NPY_FLOAT96
#define NPY_FLOAT96 NPY_FLOAT
#define NPY_COMPLEX192 NPY_CFLOAT
typedef float npy_float96;
typedef npy_cfloat npy_complex192;
# define PyFloat96ScalarObject PyFloatScalarObject
# define PyComplex192ScalarObject PyCFloatScalarObject
# define PyFloat96ArrType_Type PyFloatArrType_Type
# define PyComplex192ArrType_Type PyCFloatArrType_Type
#define NPY_FLOAT96_FMT NPY_FLOAT_FMT
#define NPY_COMPLEX192_FMT NPY_CFLOAT_FMT
#endif
#elif NPY_BITSOF_FLOAT == 128
#ifndef NPY_FLOAT128
#define NPY_FLOAT128 NPY_FLOAT
#define NPY_COMPLEX256 NPY_CFLOAT
typedef float npy_float128;
typedef npy_cfloat npy_complex256;
# define PyFloat128ScalarObject PyFloatScalarObject
# define PyComplex256ScalarObject PyCFloatScalarObject
# define PyFloat128ArrType_Type PyFloatArrType_Type
# define PyComplex256ArrType_Type PyCFloatArrType_Type
#define NPY_FLOAT128_FMT NPY_FLOAT_FMT
#define NPY_COMPLEX256_FMT NPY_CFLOAT_FMT
#endif
#endif
#if NPY_BITSOF_LONGDOUBLE == 16
#ifndef NPY_FLOAT16
#define NPY_FLOAT16 NPY_LONGDOUBLE
#define NPY_COMPLEX32 NPY_CLONGDOUBLE
typedef npy_longdouble npy_float16;
typedef npy_clongdouble npy_complex32;
# define PyFloat16ScalarObject PyLongDoubleScalarObject
# define PyComplex32ScalarObject PyCLongDoubleScalarObject
# define PyFloat16ArrType_Type PyLongDoubleArrType_Type
# define PyComplex32ArrType_Type PyCLongDoubleArrType_Type
#define NPY_FLOAT16_FMT NPY_LONGDOUBLE_FMT
#define NPY_COMPLEX32_FMT NPY_CLONGDOUBLE_FMT
#endif
#elif NPY_BITSOF_LONGDOUBLE == 32
#ifndef NPY_FLOAT32
#define NPY_FLOAT32 NPY_LONGDOUBLE
#define NPY_COMPLEX64 NPY_CLONGDOUBLE
typedef npy_longdouble npy_float32;
typedef npy_clongdouble npy_complex64;
# define PyFloat32ScalarObject PyLongDoubleScalarObject
# define PyComplex64ScalarObject PyCLongDoubleScalarObject
# define PyFloat32ArrType_Type PyLongDoubleArrType_Type
# define PyComplex64ArrType_Type PyCLongDoubleArrType_Type
#define NPY_FLOAT32_FMT NPY_LONGDOUBLE_FMT
#define NPY_COMPLEX64_FMT NPY_CLONGDOUBLE_FMT
#endif
#elif NPY_BITSOF_LONGDOUBLE == 64
#ifndef NPY_FLOAT64
#define NPY_FLOAT64 NPY_LONGDOUBLE
#define NPY_COMPLEX128 NPY_CLONGDOUBLE
typedef npy_longdouble npy_float64;
typedef npy_clongdouble npy_complex128;
# define PyFloat64ScalarObject PyLongDoubleScalarObject
# define PyComplex128ScalarObject PyCLongDoubleScalarObject
# define PyFloat64ArrType_Type PyLongDoubleArrType_Type
# define PyComplex128ArrType_Type PyCLongDoubleArrType_Type
#define NPY_FLOAT64_FMT NPY_LONGDOUBLE_FMT
#define NPY_COMPLEX128_FMT NPY_CLONGDOUBLE_FMT
#endif
#elif NPY_BITSOF_LONGDOUBLE == 80
#ifndef NPY_FLOAT80
#define NPY_FLOAT80 NPY_LONGDOUBLE
#define NPY_COMPLEX160 NPY_CLONGDOUBLE
typedef npy_longdouble npy_float80;
typedef npy_clongdouble npy_complex160;
# define PyFloat80ScalarObject PyLongDoubleScalarObject
# define PyComplex160ScalarObject PyCLongDoubleScalarObject
# define PyFloat80ArrType_Type PyLongDoubleArrType_Type
# define PyComplex160ArrType_Type PyCLongDoubleArrType_Type
#define NPY_FLOAT80_FMT NPY_LONGDOUBLE_FMT
#define NPY_COMPLEX160_FMT NPY_CLONGDOUBLE_FMT
#endif
#elif NPY_BITSOF_LONGDOUBLE == 96
#ifndef NPY_FLOAT96
#define NPY_FLOAT96 NPY_LONGDOUBLE
#define NPY_COMPLEX192 NPY_CLONGDOUBLE
typedef npy_longdouble npy_float96;
typedef npy_clongdouble npy_complex192;
# define PyFloat96ScalarObject PyLongDoubleScalarObject
# define PyComplex192ScalarObject PyCLongDoubleScalarObject
# define PyFloat96ArrType_Type PyLongDoubleArrType_Type
# define PyComplex192ArrType_Type PyCLongDoubleArrType_Type
#define NPY_FLOAT96_FMT NPY_LONGDOUBLE_FMT
#define NPY_COMPLEX192_FMT NPY_CLONGDOUBLE_FMT
#endif
#elif NPY_BITSOF_LONGDOUBLE == 128
#ifndef NPY_FLOAT128
#define NPY_FLOAT128 NPY_LONGDOUBLE
#define NPY_COMPLEX256 NPY_CLONGDOUBLE
typedef npy_longdouble npy_float128;
typedef npy_clongdouble npy_complex256;
# define PyFloat128ScalarObject PyLongDoubleScalarObject
# define PyComplex256ScalarObject PyCLongDoubleScalarObject
# define PyFloat128ArrType_Type PyLongDoubleArrType_Type
# define PyComplex256ArrType_Type PyCLongDoubleArrType_Type
#define NPY_FLOAT128_FMT NPY_LONGDOUBLE_FMT
#define NPY_COMPLEX256_FMT NPY_CLONGDOUBLE_FMT
#endif
#elif NPY_BITSOF_LONGDOUBLE == 256
#define NPY_FLOAT256 NPY_LONGDOUBLE
#define NPY_COMPLEX512 NPY_CLONGDOUBLE
typedef npy_longdouble npy_float256;
typedef npy_clongdouble npy_complex512;
# define PyFloat256ScalarObject PyLongDoubleScalarObject
# define PyComplex512ScalarObject PyCLongDoubleScalarObject
# define PyFloat256ArrType_Type PyLongDoubleArrType_Type
# define PyComplex512ArrType_Type PyCLongDoubleArrType_Type
#define NPY_FLOAT256_FMT NPY_LONGDOUBLE_FMT
#define NPY_COMPLEX512_FMT NPY_CLONGDOUBLE_FMT
#endif
/* datetime typedefs */
typedef npy_int64 npy_timedelta;
typedef npy_int64 npy_datetime;
#define NPY_DATETIME_FMT NPY_INT64_FMT
#define NPY_TIMEDELTA_FMT NPY_INT64_FMT
/* End of typedefs for numarray style bit-width names */
#endif
PK e[Yp
arrayobject.hnu W+A
/* This expects the following variables to be defined (besides
the usual ones from pyconfig.h
SIZEOF_LONG_DOUBLE -- sizeof(long double) or sizeof(double) if no
long double is present on platform.
CHAR_BIT -- number of bits in a char (usually 8)
(should be in limits.h)
*/
#ifndef Py_ARRAYOBJECT_H
#define Py_ARRAYOBJECT_H
#include "ndarrayobject.h"
#ifdef NPY_NO_PREFIX
#include "noprefix.h"
#endif
#include "npy_interrupt.h"
#endif
PK e[$
,m# # npy_endian.hnu W+A PK e[O! !
_ __ufunc_api.hnu W+A PK e[p
& npy_cpu.hnu W+A PK e[ee e
[4 ufunc_api.txtnu W+A PK e[wu
C numpyconfig.hnu W+A PK e[R%s s 6F _numpyconfig.hnu W+A PK e[yt t I utils.hnu W+A PK e[a: :
L noprefix.hnu W+A PK e[/&1 1
f old_defines.hnu W+A PK e[̌S
S
t} npy_interrupt.hnu W+A PK e[B)&g &g multiarray_api.txtnu W+A PK e[sUM M n arrayscalars.hnu W+A PK e[2RE E _neighborhood_iterator_imp.hnu W+A PK e[EU1 1 npy_os.hnu W+A PK e[[#S oldnumeric.hnu W+A PK e[/-2 2 __multiarray_api.hnu W+A PK e[F2 2
O ufuncobject.hnu W+A PK e[ > ndarrayobject.hnu W+A PK e[2@2 2
q npy_math.hnu W+A PK e[
mw w t npy_common.hnu W+A PK e[Yp
F arrayobject.hnu W+A PK X