#include <numpy/npy_common.h>
#include <numpy/npy_cpu.h>
#include <numpy/ndarraytypes.h>
#include <limits.h>
#include "ucsnarrow.h"

Defines
#define	error_converting(x) (((x) == -1) && PyErr_Occurred())
#define	NPY_BEGIN_THREADS_NDITER(iter)
#define	NPY_CBLAS_CHUNK NPY_MAX_INTP
Functions
NPY_NO_EXPORT int	PyArray_DTypeFromObject (PyObject obj, int maxdims, PyArray_Descr *out_dtype)
NPY_NO_EXPORT int	PyArray_DTypeFromObjectHelper (PyObject obj, int maxdims, PyArray_Descr *out_dtype, int string_status)
NPY_NO_EXPORT PyObject *	PyArray_GetAttrString_SuppressException (PyObject v, char name)
NPY_NO_EXPORT PyArray_Descr *	_array_find_python_scalar_type (PyObject *op)
NPY_NO_EXPORT PyArray_Descr *	_array_typedescr_fromstr (char *str)
NPY_NO_EXPORT char *	index2ptr (PyArrayObject *mp, npy_intp i)
NPY_NO_EXPORT int	_zerofill (PyArrayObject *ret)
NPY_NO_EXPORT int	_IsAligned (PyArrayObject *ap)
NPY_NO_EXPORT npy_bool	_IsWriteable (PyArrayObject *ap)
NPY_NO_EXPORT PyObject *	convert_shape_to_string (npy_intp n, npy_intp vals, char ending)
NPY_NO_EXPORT void	dot_alignment_error (PyArrayObject a, int i, PyArrayObject b, int j)
NPY_NO_EXPORT int	_unpack_field (PyObject value, PyArray_Descr descr, npy_intp offset)
NPY_NO_EXPORT int	_may_have_objects (PyArray_Descr *dtype)
static NPY_INLINE int	check_and_adjust_index (npy_intp index, npy_intp max_item, int axis, PyThreadState _save)
static NPY_INLINE int	npy_is_aligned (const void *p, const npy_uintp alignment)
static NPY_INLINE char *	npy_memchr (char haystack, char needle, npy_intp stride, npy_intp size, npy_intp psubloopsize, int invert)
static NPY_INLINE int	_is_basic_python_type (PyObject *obj)
static NPY_INLINE int	blas_stride (npy_intp stride, unsigned itemsize)

Define Documentation

#define error_converting ( x ) (((x) == -1) && PyErr_Occurred())

#define NPY_BEGIN_THREADS_NDITER ( iter )

#define NPY_CBLAS_CHUNK NPY_MAX_INTP

Define a chunksize for CBLAS. CBLAS counts in integers.

Referenced by CFLOAT_vdot(), and VOID_compare().

Function Documentation

NPY_NO_EXPORT PyArray_Descr* _array_find_python_scalar_type ( PyObject * op )

Returns NULL without setting an exception if no scalar is matched, a new dtype reference otherwise.

bools are a subclass of int

check to see if integer can fit into a longlong or ulonglong: and return that --- otherwise return object

References NPY_LONG, and PyArray_DescrFromType().

NPY_NO_EXPORT PyArray_Descr* _array_typedescr_fromstr ( char * c_str )

new reference

References PyArray_STRIDES.

static NPY_INLINE int _is_basic_python_type ( PyObject * obj ) [static]

Basic number types

Basic sequence types

References npy_is_aligned().

Referenced by PyArray_GetAttrString_SuppressException().

NPY_NO_EXPORT int _IsAligned ( PyArrayObject * ap )

alignment 1 types should have a efficient alignment for copy loops

power of two sizes may be loaded in larger moves

if not power of two it will be accessed bytewise

<

not NPY_RELAXED_STRIDES_CHECKING

<

not NPY_RELAXED_STRIDES_CHECKING

Referenced by PyArray_UpdateFlags().

NPY_NO_EXPORT npy_bool _IsWriteable ( PyArrayObject * ap )

If we own our own data, then no-problem

Get to the final base object If it is a writeable array, then return TRUE If we can find an array object or a writeable buffer object as the final base object or a string object (for pickling support memory savings).

this last could be removed if a proper pickleable buffer was added to Python.

MW: I think it would better to disallow switching from READONLY

to WRITEABLE like this...

here so pickle support works seamlessly and unpickled array can be set and reset writeable -- could be abused --

References convert_shape_to_string(), PyArray_DIM, PyArray_DIMS, PyArray_NDIM, PyUString_Format, and PyUString_FromString.

Referenced by PyArray_UpdateFlags().

NPY_NO_EXPORT int _may_have_objects ( PyArray_Descr * dtype )

check whether arrays with datatype dtype might have object fields. This will only happen for structured dtypes (which may have hidden objects even if the HASOBJECT flag is false), object dtypes, or subarray dtypes whose base type is either of these.

Referenced by array_nbytes_get().

NPY_NO_EXPORT int _unpack_field	(	PyObject *	value,
		PyArray_Descr **	descr,
		npy_intp *	offset
	)

unpack tuple of dtype->fields (descr, offset, title[not-needed])

@param "value" should be the tuple.

@return "descr" will be set to the field's dtype @return "offset" will be set to the field's offset

returns -1 on failure, 0 on success.

Referenced by STRING_copyswapn().

NPY_NO_EXPORT int _zerofill ( PyArrayObject * ret )

References PyArray_BASE, PyArray_CHKFLAGS, and PyArray_ISWRITEABLE.

static NPY_INLINE int blas_stride	(	npy_intp	stride,
		unsigned	itemsize
	)		`[static]`

Convert NumPy stride to BLAS stride. Returns 0 if conversion cannot be done (BLAS won't handle negative or zero strides the way we want).

Should probably check pointer alignment also, but this may cause problems if we require complex to be 16 byte aligned.

Referenced by CFLOAT_vdot(), and VOID_compare().

static NPY_INLINE int check_and_adjust_index	(	npy_intp *	index,
		npy_intp	max_item,
		int	axis,
		PyThreadState *	_save
	)		`[static]`

Returns -1 and sets an exception if *index is an invalid index for an array of size max_item, otherwise adjusts it in place to be 0 <= *index < max_item, and returns 0. 'axis' should be the array axis that is being indexed over, if known. If unknown, use -1. If _save is NULL it is assumed the GIL is taken If _save is not NULL it is assumed the GIL is not taken and it is acquired in the case of an error

System Message: WARNING/2 (<string>, line 1); backlink Inline emphasis start-string without end-string.

Check that index is valid, taking into account negative indices

Try to be as clear as possible about what went wrong.

adjust negative indices

References NPY_INTP_FMT.

Referenced by _nonzero_indices(), parse_index_entry(), PyArray_Nonzero(), PyArray_TakeFrom(), and PyArray_TransferMaskedStridedToNDim().

NPY_NO_EXPORT PyObject* convert_shape_to_string	(	npy_intp	n,
		npy_intp *	vals,
		char *	ending
	)

Convert an array shape to a string such as "(1, 2)".

@param Dimensionality of the shape @param npy_intp pointer to shape array @param String to append after the shape <cite>(1, 2)s</cite>.

@return Python unicode string

Negative dimension indicates "newaxis", which can be discarded for printing if it's a leading dimension. Find the first non-"newaxis" dimension.

Referenced by _IsWriteable().

NPY_NO_EXPORT void dot_alignment_error	(	PyArrayObject *	a,
		int	i,
		PyArrayObject *	b,
		int	j
	)

Sets ValueError with "matrices not aligned" message for np.dot and friends when a.shape[i] should match b.shape[j], but doesn't.

Referenced by array_vdot().

NPY_NO_EXPORT char* index2ptr	(	PyArrayObject *	mp,
		npy_intp	i
	)

static NPY_INLINE int npy_is_aligned	(	const void *	p,
		const npy_uintp	alignment
	)		`[static]`

return true if pointer is aligned to 'alignment'

alignment is usually a power of two the test is faster than a direct modulo

Referenced by _BOOL(), _is_basic_python_type(), and raw_array_assign_scalar().

static NPY_INLINE char* npy_memchr	(	char *	haystack,
		char	needle,
		npy_intp	stride,
		npy_intp	size,
		npy_intp *	psubloopsize,
		int	invert
	)		`[static]`

memchr with stride and invert argument intended for small searches where a call out to libc memchr is costly. stride must be a multiple of size. compared to memchr it returns one stride past end instead of NULL if needle is not found.

this is usually the path to determine elements to process, performance less important here. memchr has large setup cost if 0 byte is close to start.

usually find elements to skip path

iterate until last multiple of 4

handle rest

References NPY_CPU_HAVE_UNALIGNED_ACCESS.

Referenced by PyUFunc_MixedDivisionTypeResolver().

NPY_NO_EXPORT int PyArray_DTypeFromObject	(	PyObject *	obj,
		int	maxdims,
		PyArray_Descr **	out_dtype
	)

Recursively examines the object to determine an appropriate dtype to use for converting to an ndarray.

'obj' is the object to be converted to an ndarray.

'maxdims' is the maximum recursion depth.

'out_dtype' should be either NULL or a minimal starting dtype when the function is called. It is updated with the results of type promotion. This dtype does not get updated when processing NA objects.

Returns 0 on success, -1 on failure.

Recursively examines the object to determine an appropriate dtype to use for converting to an ndarray.

'obj' is the object to be converted to an ndarray.

'maxdims' is the maximum recursion depth.

'out_dtype' should be either NULL or a minimal starting dtype when the function is called. It is updated with the results of type promotion. This dtype does not get updated when processing NA objects. This is reset to NULL on failure.

Returns 0 on success, -1 on failure.

References promote_types(), PyArray_Check, and PyArray_DESCR.

Referenced by _is_default_descr().

NPY_NO_EXPORT int PyArray_DTypeFromObjectHelper	(	PyObject *	obj,
		int	maxdims,
		PyArray_Descr **	out_dtype,
		int	string_status
	)

types for sequence handling

Check if it's an ndarray

See if it's a python None

Check if it's a NumPy scalar

Check if it's a Python scalar

Check if it's an ASCII string

If it's already a big enough string, don't bother type promoting

Check if it's a Unicode string

If it's already a big enough unicode object, don't bother type promoting

PEP 3118 buffer interface

The array interface

The array struct interface

The old buffer interface

The __array__ attribute

If we reached the maximum recursion depth without hitting one of the above cases, and obj isn't a sequence-like object, the output dtype should be either OBJECT or a user-defined type.

Note that some libraries define sequence-like classes but want them to be treated as objects, and they expect numpy to treat it as an object if __len__ is not defined.

Recursive case, first check the sequence contains only one type

all types are the same and scalar, one recursive call is enough

TODO: we could add longs if we add a range check

Recursive call for each sequence item

Set 'out_dtype' if it's NULL

Do type promotion with 'out_dtype'

References NPY_OBJECT, promote_types(), and PyArray_DescrFromType().

NPY_NO_EXPORT PyObject* PyArray_GetAttrString_SuppressException	(	PyObject *	obj,
		char *	name
	)

The casting to use for implicit assignment operations resulting from in-place operations (like +=) and out= arguments. (Notice that this variable is misnamed, but it's part of the public API so I'm not sure we can just change it. Maybe someone should try and see if anyone notices.

In numpy 1.6 and earlier, this was NPY_UNSAFE_CASTING. In a future release, it will become NPY_SAME_KIND_CASTING. Right now, during the transitional period, we continue to follow the NPY_UNSAFE_CASTING rules (to avoid breaking people's code), but we also check for whether the cast would be allowed under the NPY_SAME_KIND_CASTING rules, and if not we issue a warning (that people's code will be broken in a future release.)

PyArray_GetAttrString_SuppressException:

Stripped down version of PyObject_GetAttrString, avoids lookups for None, tuple, and List objects, and doesn't create a PyErr since this code ignores it.

This can be much faster then PyObject_GetAttrString where exceptions are not used by caller.

'obj' is the object to search for attribute.

'name' is the attribute to search for.

Returns attribute value on success, 0 on failure.

We do not need to check for special attributes on trivial types

Attribute referenced by (char *)name

System Message: WARNING/2 (<string>, line 1); backlink Inline emphasis start-string without end-string.

Attribute referenced by (PyObject *)name

System Message: WARNING/2 (<string>, line 1); backlink Inline emphasis start-string without end-string.

References _is_basic_python_type().

Defines

Functions

Define Documentation

Function Documentation