/usr/lib/python2.7/dist-packages/numpy/core/include/numpy/ufuncobject.h is in python-numpy 1:1.12.1-3.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 | #ifndef Py_UFUNCOBJECT_H
#define Py_UFUNCOBJECT_H
#include <numpy/npy_math.h>
#include <numpy/npy_common.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* The legacy generic inner loop for a standard element-wise or
* generalized ufunc.
*/
typedef void (*PyUFuncGenericFunction)
(char **args,
npy_intp *dimensions,
npy_intp *strides,
void *innerloopdata);
/*
* The most generic one-dimensional inner loop for
* a masked standard element-wise ufunc. "Masked" here means that it skips
* doing calculations on any items for which the maskptr array has a true
* value.
*/
typedef void (PyUFunc_MaskedStridedInnerLoopFunc)(
char **dataptrs, npy_intp *strides,
char *maskptr, npy_intp mask_stride,
npy_intp count,
NpyAuxData *innerloopdata);
/* Forward declaration for the type resolver and loop selector typedefs */
struct _tagPyUFuncObject;
/*
* Given the operands for calling a ufunc, should determine the
* calculation input and output data types and return an inner loop function.
* This function should validate that the casting rule is being followed,
* and fail if it is not.
*
* For backwards compatibility, the regular type resolution function does not
* support auxiliary data with object semantics. The type resolution call
* which returns a masked generic function returns a standard NpyAuxData
* object, for which the NPY_AUXDATA_FREE and NPY_AUXDATA_CLONE macros
* work.
*
* ufunc: The ufunc object.
* casting: The 'casting' parameter provided to the ufunc.
* operands: An array of length (ufunc->nin + ufunc->nout),
* with the output parameters possibly NULL.
* type_tup: Either NULL, or the type_tup passed to the ufunc.
* out_dtypes: An array which should be populated with new
* references to (ufunc->nin + ufunc->nout) new
* dtypes, one for each input and output. These
* dtypes should all be in native-endian format.
*
* Should return 0 on success, -1 on failure (with exception set),
* or -2 if Py_NotImplemented should be returned.
*/
typedef int (PyUFunc_TypeResolutionFunc)(
struct _tagPyUFuncObject *ufunc,
NPY_CASTING casting,
PyArrayObject **operands,
PyObject *type_tup,
PyArray_Descr **out_dtypes);
/*
* Given an array of DTypes as returned by the PyUFunc_TypeResolutionFunc,
* and an array of fixed strides (the array will contain NPY_MAX_INTP for
* strides which are not necessarily fixed), returns an inner loop
* with associated auxiliary data.
*
* For backwards compatibility, there is a variant of the inner loop
* selection which returns an inner loop irrespective of the strides,
* and with a void* static auxiliary data instead of an NpyAuxData *
* dynamically allocatable auxiliary data.
*
* ufunc: The ufunc object.
* dtypes: An array which has been populated with dtypes,
* in most cases by the type resolution funciton
* for the same ufunc.
* fixed_strides: For each input/output, either the stride that
* will be used every time the function is called
* or NPY_MAX_INTP if the stride might change or
* is not known ahead of time. The loop selection
* function may use this stride to pick inner loops
* which are optimized for contiguous or 0-stride
* cases.
* out_innerloop: Should be populated with the correct ufunc inner
* loop for the given type.
* out_innerloopdata: Should be populated with the void* data to
* be passed into the out_innerloop function.
* out_needs_api: If the inner loop needs to use the Python API,
* should set the to 1, otherwise should leave
* this untouched.
*/
typedef int (PyUFunc_LegacyInnerLoopSelectionFunc)(
struct _tagPyUFuncObject *ufunc,
PyArray_Descr **dtypes,
PyUFuncGenericFunction *out_innerloop,
void **out_innerloopdata,
int *out_needs_api);
typedef int (PyUFunc_MaskedInnerLoopSelectionFunc)(
struct _tagPyUFuncObject *ufunc,
PyArray_Descr **dtypes,
PyArray_Descr *mask_dtype,
npy_intp *fixed_strides,
npy_intp fixed_mask_stride,
PyUFunc_MaskedStridedInnerLoopFunc **out_innerloop,
NpyAuxData **out_innerloopdata,
int *out_needs_api);
typedef struct _tagPyUFuncObject {
PyObject_HEAD
/*
* nin: Number of inputs
* nout: Number of outputs
* nargs: Always nin + nout (Why is it stored?)
*/
int nin, nout, nargs;
/* Identity for reduction, either PyUFunc_One or PyUFunc_Zero */
int identity;
/* Array of one-dimensional core loops */
PyUFuncGenericFunction *functions;
/* Array of funcdata that gets passed into the functions */
void **data;
/* The number of elements in 'functions' and 'data' */
int ntypes;
/* Used to be unused field 'check_return' */
int reserved1;
/* The name of the ufunc */
const char *name;
/* Array of type numbers, of size ('nargs' * 'ntypes') */
char *types;
/* Documentation string */
const char *doc;
void *ptr;
PyObject *obj;
PyObject *userloops;
/* generalized ufunc parameters */
/* 0 for scalar ufunc; 1 for generalized ufunc */
int core_enabled;
/* number of distinct dimension names in signature */
int core_num_dim_ix;
/*
* dimension indices of input/output argument k are stored in
* core_dim_ixs[core_offsets[k]..core_offsets[k]+core_num_dims[k]-1]
*/
/* numbers of core dimensions of each argument */
int *core_num_dims;
/*
* dimension indices in a flatted form; indices
* are in the range of [0,core_num_dim_ix)
*/
int *core_dim_ixs;
/*
* positions of 1st core dimensions of each
* argument in core_dim_ixs
*/
int *core_offsets;
/* signature string for printing purpose */
char *core_signature;
/*
* A function which resolves the types and fills an array
* with the dtypes for the inputs and outputs.
*/
PyUFunc_TypeResolutionFunc *type_resolver;
/*
* A function which returns an inner loop written for
* NumPy 1.6 and earlier ufuncs. This is for backwards
* compatibility, and may be NULL if inner_loop_selector
* is specified.
*/
PyUFunc_LegacyInnerLoopSelectionFunc *legacy_inner_loop_selector;
/*
* This was blocked off to be the "new" inner loop selector in 1.7,
* but this was never implemented. (This is also why the above
* selector is called the "legacy" selector.)
*/
void *reserved2;
/*
* A function which returns a masked inner loop for the ufunc.
*/
PyUFunc_MaskedInnerLoopSelectionFunc *masked_inner_loop_selector;
/*
* List of flags for each operand when ufunc is called by nditer object.
* These flags will be used in addition to the default flags for each
* operand set by nditer object.
*/
npy_uint32 *op_flags;
/*
* List of global flags used when ufunc is called by nditer object.
* These flags will be used in addition to the default global flags
* set by nditer object.
*/
npy_uint32 iter_flags;
} 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
#define UFUNC_OBJ_ISOBJECT 1
#define UFUNC_OBJ_NEEDS_API 2
/* Default user error mode */
#define UFUNC_ERR_DEFAULT \
(UFUNC_ERR_WARN << UFUNC_SHIFT_DIVIDEBYZERO) + \
(UFUNC_ERR_WARN << UFUNC_SHIFT_OVERFLOW) + \
(UFUNC_ERR_WARN << UFUNC_SHIFT_INVALID)
#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
/*
* UFunc has unit of 0, and the order of operations can be reordered
* This case allows reduction with multiple axes at once.
*/
#define PyUFunc_Zero 0
/*
* UFunc has unit of 1, and the order of operations can be reordered
* This case allows reduction with multiple axes at once.
*/
#define PyUFunc_One 1
/*
* UFunc has unit of -1, and the order of operations can be reordered
* This case allows reduction with multiple axes at once. Intended for
* bitwise_and reduction.
*/
#define PyUFunc_MinusOne 2
/*
* UFunc has no unit, and the order of operations cannot be reordered.
* This case does not allow reduction with multiple axes at once.
*/
#define PyUFunc_None -1
/*
* UFunc has no unit, and the order of operations can be reordered
* This case allows reduction with multiple axes at once.
*/
#define PyUFunc_ReorderableNone -2
#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;
int nargs;
PyArray_Descr **arg_dtypes;
} 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)
/* keep in sync with ieee754.c.src */
#if defined(sun) || defined(__BSD__) || defined(__OpenBSD__) || \
(defined(__FreeBSD__) && (__FreeBSD_version < 502114)) || \
defined(__NetBSD__) || \
defined(__GLIBC__) || defined(__APPLE__) || \
defined(__CYGWIN__) || defined(__MINGW32__) || \
(defined(__FreeBSD__) && (__FreeBSD_version >= 502114)) || \
defined(_AIX) || \
defined(_MSC_VER) || \
defined(__osf__) && defined(__alpha)
#else
#define NO_FLOATING_POINT_SUPPORT
#endif
/*
* THESE MACROS ARE DEPRECATED.
* Use npy_set_floatstatus_* in the npymath library.
*/
#define UFUNC_FPE_DIVIDEBYZERO NPY_FPE_DIVIDEBYZERO
#define UFUNC_FPE_OVERFLOW NPY_FPE_OVERFLOW
#define UFUNC_FPE_UNDERFLOW NPY_FPE_UNDERFLOW
#define UFUNC_FPE_INVALID NPY_FPE_INVALID
#define UFUNC_CHECK_STATUS(ret) \
{ \
ret = npy_clear_floatstatus(); \
}
#define generate_divbyzero_error() npy_set_floatstatus_divbyzero()
#define generate_overflow_error() npy_set_floatstatus_overflow()
/* Make sure it gets defined if it isn't already */
#ifndef UFUNC_NOFPE
/* Clear the floating point exception default of Borland C++ */
#if defined(__BORLANDC__)
#define UFUNC_NOFPE _control87(MCW_EM, MCW_EM);
#else
#define UFUNC_NOFPE
#endif
#endif
#ifdef __cplusplus
}
#endif
#endif /* !Py_UFUNCOBJECT_H */
|