API массивов

Структура массива и доступ к данным

Эти макросы обращаются к членам структуры PyArrayObject. Аргумент arr может быть любым объектом PyObject *, который напрямую интерпретируется как PyArrayObject * (любой экземпляр типа PyArray_Type и его подтипов).

int PyArray_NDIM(PyArrayObject *arr)

Количество измерений в массиве.

npy_intp *PyArray_DIMS(PyArrayObject *arr)

Возвращает указатель на размеры/форму массива. Количество элементов совпадает с количеством измерений массива.

npy_intp *PyArray_SHAPE(PyArrayObject *arr)

Новое в версии 1.7.

Синоним для PyArray_DIMS, названный для согласованности с использованием «shape» в Python.

void *PyArray_DATA(PyArrayObject *arr)

char *PyArray_BYTES(PyArrayObject *arr)

Эти два макроса похожи и получают указатель на буфер данных массива. Первый макрос можно (и следует) назначить конкретному указателю, а второй предназначен для универсальной обработки. Если вы не гарантируете непрерывность и/или выравнивание массива, убедитесь, что вы понимаете, как получить доступ к данным в массиве, чтобы избежать проблем с памятью и/или выравниванием.

npy_intp *PyArray_STRIDES(PyArrayObject* arr)

Возвращает указатель на шаги массива. Количество элементов совпадает с количеством измерений массива.

npy_intp PyArray_DIM(PyArrayObject* arr, int n)

Возвращает размер в n измерении.

npy_intp PyArray_STRIDE(PyArrayObject* arr, int n)

Возвращает шаг в n измерении.

PyObject *PyArray_BASE(PyArrayObject* arr)

Возвращает базовый объект массива. В большинстве случаев это объект, владеющий памятью, на которую указывает массив.

Если вы создаёте массив с помощью API C и указываете собственную память, вы должны использовать функцию PyArray_SetBaseObject для задания базового объекта, владеющего памятью.

Если установлен флаг NPY_ARRAY_UPDATEIFCOPY, у него другое значение, а именно база — это массив, в который будет скопирован текущий массив при уничтожении. Это перегрузка свойства базы для двух функций, вероятно, изменится в будущих версиях NumPy.

PyArray_Descr *PyArray_DESCR(PyArrayObject* arr)

Возвращает заимствованную ссылку на свойство dtype массива.

PyArray_Descr *PyArray_DTYPE(PyArrayObject* arr)

Новое в версии 1.7.

Синоним для PyArray_DESCR, названный для согласованности с использованием «dtype» в Python.

void PyArray_ENABLEFLAGS(PyArrayObject* arr, int flags)

Новое в версии 1.7.

Включает указанные флаги массива. Эта функция не выполняет проверку и предполагает, что вы знаете, что делаете.

void PyArray_CLEARFLAGS(PyArrayObject* arr, int flags)

Новое в версии 1.7.

Сбрасывает указанные флаги массива. Эта функция не выполняет проверку и предполагает, что вы знаете, что делаете.

int PyArray_FLAGS(PyArrayObject* arr)

npy_intp PyArray_ITEMSIZE(PyArrayObject* arr)

Возвращает размер элемента для элементов этого массива.

Обратите внимание, что в старом API, который был устаревшим в версии 1.7, эта функция имела тип возвращаемого значения int.

int PyArray_TYPE(PyArrayObject* arr)

Возвращает (встроенный) тип данных для элементов этого массива.

PyObject *PyArray_GETITEM(PyArrayObject* arr, void* itemptr)

Получает объект Python из ndarray, arr, в позиции, на которую указывает itemptr. Возвращает NULL в случае ошибки.

int PyArray_SETITEM(PyArrayObject* arr, void* itemptr, PyObject* obj)

Преобразует obj и помещает его в ndarray, arr, в указанную позицию itemptr. Возвращает -1, если произошла ошибка, или 0 в случае успеха.

npy_intp PyArray_SIZE(PyArrayObject* arr)

Возвращает общий размер (количество элементов) массива.

npy_intp PyArray_Size(PyArrayObject* obj)

Возвращает 0, если obj не является подклассом bigndarray. В противном случае возвращает общее количество элементов в массиве. Более безопасная версия PyArray_SIZE (obj).

npy_intp PyArray_NBYTES(PyArrayObject* arr)

Возвращает общее количество байтов, занимаемых массивом.

Доступ к данным

Эти функции и макросы обеспечивают лёгкий доступ к элементам ndarray из C. Они работают со всеми массивами. Однако при доступе к данным в массиве, если они не в машинном порядке байтов, не выровнены или не доступны для записи, необходимо соблюдать осторожность. Другими словами, соблюдайте состояние флагов, если не знаете, что делаете, или заранее не гарантировали, что массив доступен для записи, выровнен и в машинном порядке байтов с помощью PyArray_FromAny. Если вы хотите обработать все типы массивов, функция copyswap для каждого типа полезна для обработки некорректных массивов. Некоторые платформы (например, Solaris) не любят невыровненные данные и аварийно завершат работу, если вы обратитесь к невыровненному указателю. Другие платформы (например, x86 Linux) просто будут работать медленнее с невыровненными данными.

void* PyArray_GetPtr(PyArrayObject* aobj, npy_intp* ind)

Возвращает указатель на данные ndarray, aobj, по N-мерному индексу, заданному массивом ind (размер которого должен быть не меньше aobj ->nd). Возможно, вам нужно преобразовать возвращённый указатель к типу данных ndarray.

void* PyArray_GETPTR1(PyArrayObject* obj, npy_intp i)

void* PyArray_GETPTR2(PyArrayObject* obj, npy_intp i, npy_intp j)

void* PyArray_GETPTR3(PyArrayObject* obj, npy_intp i, npy_intp j, npy_intp k)

void* PyArray_GETPTR4(PyArrayObject* obj, npy_intp i, npy_intp j, npy_intp k, npy_intp l)

Быстрый, встроенный доступ к элементу по заданным координатам в ndarray, obj, который должен иметь соответственно 1, 2, 3 или 4 измерения (это не проверяется). Соответствующие координаты i, j, k и l могут быть любыми целыми числами, но будут интерпретированы как npy_intp. Возможно, вам нужно преобразовать возвращённый указатель к типу данных ndarray.

Создание массивов

Из ничего

PyObject* PyArray_NewFromDescr(PyTypeObject* subtype, PyArray_Descr* descr, int nd, npy_intp* dims, npy_intp* strides, void* data, int flags, PyObject* obj)

Эта функция заимствует ссылку на descr.

Это основная функция создания массивов. Большинство новых массивов создаются с помощью этой гибкой функции.

Возвращаемый объект — это объект типа Python subtype, который должен быть подтипом PyArray_Type. Массив имеет nd измерений, описанных в dims. Описание типа данных нового массива — descr.

Если subtype — подкласс массива, а не базовый &PyArray_Type, то obj — объект, который передаётся в метод __array_finalize__ подкласса.

Если data — NULL, то будет выделена новая память, и flags может быть ненулевым, чтобы указать на фортрановски-непрерывный массив. Если data не NULL, то предполагается, что он указывает на используемую память массива, и аргумент flags используется в качестве новых флагов массива (кроме состояния флагов NPY_OWNDATA и NPY_ARRAY_UPDATEIFCOPY нового массива, которые будут сброшены).

Кроме того, если data не NULL, то можно также предоставить strides. Если strides — NULL, то шаги массива вычисляются как непрерывные по стилю C (по умолчанию) или непрерывные по стилю Fortran (flags не нулевой для data = NULL или flags & NPY_ARRAY_F_CONTIGUOUS не нулевой для не-NULL data). Любые предоставленные dims и strides копируются в новые выделенные массивы размеров и шагов для нового объекта массива.

PyObject* PyArray_NewLikeArray(PyArrayObject* prototype, NPY_ORDER order, PyArray_Descr* descr, int subok)

Добавлено в версии 1.6.

Эта функция заимствует ссылку на descr, если она не равна NULL.

Эта процедура создания массива позволяет удобно создавать новый массив, соответствующий формату и расположению памяти существующего массива, возможно, изменяя расположение и/или тип данных.

Когда order равен NPY_ANYORDER, порядок результата равен NPY_FORTRANORDER, если prototype является массивом Fortran, и NPY_CORDER в противном случае. Когда order равен NPY_KEEPORDER, порядок результата соответствует порядку prototype, даже если оси prototype не упорядочены по C или Fortran.

Если descr равно NULL, используется тип данных prototype.

Если subok равно 1, новый созданный массив будет использовать подтип prototype для создания нового массива, в противном случае он создаст массив базового класса.

PyObject* PyArray_New(PyTypeObject* subtype, int nd, npy_intp* dims, int type_num, npy_intp* strides, void* data, int itemsize, int flags, PyObject* obj)

Это аналогично PyArray_DescrNew (...) за исключением того, что вы указываете описатель типа данных с помощью type_num и itemsize, где type_num соответствует встроенному (или определяемому пользователем) типу. Если размер типа всегда одинаковый, то itemsize игнорируется. В противном случае, itemsize указывает конкретный размер этого массива.

PyObject* PyArray_SimpleNew(int nd, npy_intp* dims, int typenum)

Создает новый неинициализированный массив типа typenum, размер которого в каждой из nd размерностей задаётся целочисленным массивом dims. Эта функция не может использоваться для создания массива с гибким типом (размер элемента не задан).

PyObject* PyArray_SimpleNewFromData(int nd, npy_intp* dims, int typenum, void* data)

Создаёт оболочку массива вокруг data, на который указывает указанный указатель. Флаги массива будут иметь значение по умолчанию, что область данных корректна и непрерывна в стиле C. Форма массива задаётся массивом dims длины nd. Тип данных массива указывается параметром typenum.

PyObject* PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, PyArray_Descr* descr)

Эта функция заимствует ссылку на descr, если она не равна NULL.

Создаёт новый массив с предоставленным описателем типа данных descr с формой, определяемой nd и dims.

PyArray_FILLWBYTE(PyObject* obj, int val)

Заполняет массив, на который указывает obj —который должен быть (подклассом) bigndarray—содержимым val (вычисленным как байт). Этот макрос использует memset, поэтому obj должен быть непрерывным.

PyObject* PyArray_Zeros(int nd, npy_intp* dims, PyArray_Descr* dtype, int fortran)

Конструирует новый nd-мерный массив с формой, заданной dims, и типом данных, заданным dtype. Если fortran не равно нулю, создаётся массив в порядке Fortran, в противном случае — в порядке C. Заполняет память нулями (или объектом 0, если dtype соответствует NPY_OBJECT).

PyObject* PyArray_ZEROS(int nd, npy_intp* dims, int type_num, int fortran)

Макроформа PyArray_Zeros, которая принимает номер типа вместо объекта типа данных.

PyObject* PyArray_Empty(int nd, npy_intp* dims, PyArray_Descr* dtype, int fortran)

Конструирует новый nd-мерный массив с формой, заданной dims, и типом данных, заданным dtype. Если fortran не равно нулю, создаётся массив в порядке Fortran, в противном случае — в порядке C. Массив не инициализирован, если тип данных не соответствует NPY_OBJECT, в этом случае массив заполняется Py_None.

PyObject* PyArray_EMPTY(int nd, npy_intp* dims, int typenum, int fortran)

Макроформа PyArray_Empty, которая принимает номер типа typenum вместо объекта типа данных.

PyObject* PyArray_Arange(double start, double stop, double step, int typenum)

Конструирует новый 1-мерный массив типа typenum, который изменяется от start до stop (исключая) с шагом step. Эквивалентно arange (start, stop, step, dtype).

PyObject* PyArray_ArangeObj(PyObject* start, PyObject* stop, PyObject* step, PyArray_Descr* descr)

Конструирует новый 1-мерный массив типа, определяемого descr, который изменяется от start до stop (исключая) с шагом step. Эквивалентно arange( start, stop, step, typenum ).

int PyArray_SetBaseObject(PyArrayObject* arr, PyObject* obj)

Добавлено в версии 1.7.

Эта функция заимствует ссылку на obj и устанавливает её как свойство base для arr.

Если вы создаёте массив, передавая собственный буфер памяти в качестве параметра, вам нужно установить свойство base массива, чтобы обеспечить надлежащий срок службы буфера памяти.

Возвращает 0 при успехе, -1 при ошибке.

Если предоставленный объект является массивом, эта функция проходит по цепочке указателей base таким образом, что каждый массив указывает на владельца памяти непосредственно. После установки base, его нельзя изменить на другое значение.

От других объектов

PyObject* PyArray_FromAny(PyObject* op, PyArray_Descr* dtype, int min_depth, int max_depth, int requirements, PyObject* context)

Это основная функция, используемая для получения массива из любого вложенного последовательности или объекта, который экспонирует интерфейс массива, op. Параметры позволяют указать требуемый тип данных dtype, минимальное (min_depth) и максимальное (max_depth) количество допустимых измерений, а также другие требования к массиву. Аргумент dtype должен быть структурой PyArray_Descr, указывающей желаемый тип данных (включая требуемый порядок байтов). Аргумент dtype может быть NULL, что означает, что любой тип данных (и порядок байтов) приемлем. Если в flags отсутствует NPY_ARRAY_FORCECAST, этот вызов сгенерирует ошибку, если тип данных не может быть безопасно получен из объекта. Если вы хотите использовать NULL для dtype и гарантировать, что массив не переставлен, используйте PyArray_CheckFromAny. Значение 0 для любого из параметров глубины приводит к игнорированию параметра. Любой из следующих флагов массива может быть добавлен (например, с помощью |), чтобы получить аргумент требования. Если ваш код может обрабатывать общие (например, с шагом, переставленные или невыровненные массивы), то требования могут быть 0. Кроме того, если op не является массивом (или не экспонирует интерфейс массива), то будет создан новый массив (и заполнен из op с использованием протокола последовательности). Новый массив будет иметь флаги NPY_ARRAY_DEFAULT. Аргумент context передается методу __array__ op и используется только в том случае, если массив создается таким образом. Почти всегда этот параметр равен NULL.

В версиях NumPy 1.6 и ранее следующие флаги не имели в себе пространства имен макросов _ARRAY_. Такая форма имен констант устарела в версии 1.7.

NPY_ARRAY_C_CONTIGUOUS

Убедитесь, что возвращаемый массив является непрерывным в стиле C.

NPY_ARRAY_F_CONTIGUOUS

Убедитесь, что возвращаемый массив является непрерывным в стиле Fortran.

NPY_ARRAY_ALIGNED

Убедитесь, что возвращаемый массив выровнен на правильных границах для его типа данных. Выровненный массив имеет указатель данных и каждый множитель шага кратным множителю выравнивания для описателя типа данных.

NPY_ARRAY_WRITEABLE

Убедитесь, что к возвращаемому массиву можно записать.

NPY_ARRAY_ENSURECOPY

Убедитесь, что создана копия op. Если этот флаг отсутствует, данные не копируются, если это возможно избежать.

NPY_ARRAY_ENSUREARRAY

Убедитесь, что результат является базовым массивом ndarray или bigndarray. По умолчанию, если op является экземпляром подкласса bigndarray, возвращается экземпляр того же самого подкласса. Если этот флаг установлен, вместо этого будет возвращен объект ndarray.

NPY_ARRAY_FORCECAST

Принудительно выполните преобразование к выходному типу, даже если это невозможно сделать безопасно. Без этого флага преобразование данных произойдет только в том случае, если это можно сделать безопасно, иначе генерируется ошибка.

NPY_ARRAY_UPDATEIFCOPY

Если op уже является массивом, но не удовлетворяет требованиям, то создается копия (которая удовлетворит требованиям). Если этот флаг присутствует, и копия (объекта, который уже является массивом) должна быть создана, то соответствующий флаг NPY_ARRAY_UPDATEIFCOPY устанавливается в возвращаемой копии, и op делается только для чтения. Когда возвращаемая копия удаляется (предположительно после завершения вычислений), ее содержимое копируется обратно в op, и массив op снова делается доступным для записи. Если op изначально недоступен для записи, генерируется ошибка. Если op не является массивом, то этот флаг не имеет эффекта.

NPY_ARRAY_BEHAVED

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE

NPY_ARRAY_CARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_CARRAY_RO

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_FARRAY_RO

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_DEFAULT

NPY_ARRAY_CARRAY

NPY_ARRAY_IN_ARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_IN_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_OUT_ARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED

NPY_ARRAY_OUT_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED

NPY_ARRAY_INOUT_ARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED | NPY_ARRAY_UPDATEIFCOPY

NPY_ARRAY_INOUT_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED | NPY_ARRAY_UPDATEIFCOPY

int PyArray_GetArrayParamsFromObject(PyObject* op, PyArray_Descr* requested_dtype, npy_bool writeable, PyArray_Descr** out_dtype, int* out_ndim, npy_intp* out_dims, PyArrayObject** out_arr, PyObject* context)

Добавлена в версии 1.6.

Извлекает параметры массива для просмотра/преобразования произвольного PyObject* в массив NumPy. Это позволяет обнаружить «врождённый тип и форму» списка Python из списков, не фактически преобразуя его в массив. PyArray_FromAny вызывает эту функцию для анализа входных данных.

В некоторых случаях, таких как структурированные массивы и интерфейс __array__, для осмысления объекта необходим тип данных. В этом случае предоставьте Descr для ‘requested_dtype’, иначе предоставьте NULL. Эта ссылка не воруется. Также, если запрашиваемый dtype не изменяет интерпретацию входных данных, out_dtype всё равно получит «врождённый» dtype объекта, а не dtype, переданный в ‘requested_dtype’.

Если необходимо записать в значение в ‘op’, установите boolean ‘writeable’ в 1. Это вызывает ошибку, когда ‘op’ является скаляром, списком списков или другим недоступным для записи ‘op’. Это отличается от передачи NPY_ARRAY_WRITEABLE в PyArray_FromAny, где изменяемый массив может быть копией входных данных.

При возвращении успеха (0 значение возврата), либо out_arr заполняется не-NULL PyArrayObject, и остальные параметры не тронуты, либо out_arr заполняется NULL, и остальные параметры заполняются.

Типичное использование:

PyArrayObject *arr = NULL;
PyArray_Descr *dtype = NULL;
int ndim = 0;
npy_intp dims[NPY_MAXDIMS];

if (PyArray_GetArrayParamsFromObject(op, NULL, 1, &dtype,
                                    &ndim, &dims, &arr, NULL) < 0) {
    return NULL;
}
if (arr == NULL) {
    ... validate/change dtype, validate flags, ndim, etc ...
    // Could make custom strides here too
    arr = PyArray_NewFromDescr(&PyArray_Type, dtype, ndim,
                                dims, NULL,
                                fortran ? NPY_ARRAY_F_CONTIGUOUS : 0,
                                NULL);
    if (arr == NULL) {
        return NULL;
    }
    if (PyArray_CopyObject(arr, op) < 0) {
        Py_DECREF(arr);
        return NULL;
    }
}
else {
    ... in this case the other parameters weren't filled, just
        validate and possibly copy arr itself ...
}
... use arr ...

PyObject* PyArray_CheckFromAny(PyObject* op, PyArray_Descr* dtype, int min_depth, int max_depth, int requirements, PyObject* context)

Практически идентичен PyArray_FromAny (...) за исключением того, что требования могут содержать NPY_ARRAY_NOTSWAPPED (переопределяя спецификацию в dtype) и NPY_ARRAY_ELEMENTSTRIDES, указывающее, что массив должен быть выровнен в том смысле, что шаги являются кратными размеру элемента.

В версиях NumPy 1.6 и более ранних следующих флагов не было в пространстве имён _ARRAY_ макроса. Такая форма имён констант устарела в 1.7.

NPY_ARRAY_NOTSWAPPED

Убедитесь, что возвращаемый массив имеет описатель типа данных в порядке байтов машины, переопределяя любые спецификации в аргументе dtype. Обычно требование порядка байтов определяется аргументом dtype. Если этот флаг установлен, а аргумент dtype не указывает на описатель порядка байтов машины (или равен NULL, а объект уже является массивом с описателем типа данных, не находящимся в порядке байтов машины), тогда создается новый описатель типа данных и используется с полем порядка байтов, установленным в родной.

NPY_ARRAY_BEHAVED_NS

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE | NPY_ARRAY_NOTSWAPPED

NPY_ARRAY_ELEMENTSTRIDES

Убедитесь, что шаги возвращаемого массива являются кратными размеру элемента.

PyObject* PyArray_FromArray(PyArrayObject* op, PyArray_Descr* newtype, int requirements)

Специальный случай PyArray_FromAny в случае, когда op уже является массивом, но он должен быть определенного типа newtype (включая порядок байтов) или имеет определенные требования.

PyObject* PyArray_FromStructInterface(PyObject* op)

Возвращает объект ndarray из объекта Python, который экспонирует атрибут __array_struct__ и следует протоколу интерфейса массива. Если объект не содержит этот атрибут, то возвращается заимствованная ссылка на Py_NotImplemented.

PyObject* PyArray_FromInterface(PyObject* op)

Возвращает объект ndarray из объекта Python, который экспонирует атрибут __array_interface__ в соответствии с протоколом интерфейса массива. Если объект не содержит этот атрибут, то возвращается заимствованная ссылка на Py_NotImplemented.

PyObject* PyArray_FromArrayAttr(PyObject* op, PyArray_Descr* dtype, PyObject* context)

Возвращает объект ndarray из объекта Python, который экспонирует метод __array__. Метод __array__ может принимать 0, 1 или 2 аргумента ([dtype, context]), где context используется для передачи информации о том, откуда вызван метод __array__ (в настоящее время используется только в ufuncs).

PyObject* PyArray_ContiguousFromAny(PyObject* op, int typenum, int min_depth, int max_depth)

Эта функция возвращает (стиль C) непрерывный и корректный массив функций из любой вложенной последовательности или объекта, экспортирующего интерфейс массива, op, типа, заданного перечисленной typenum, минимальной глубины min_depth и максимальной глубины max_depth. Эквивалентно вызову PyArray_FromAny с требованиями, установленными в NPY_ARRAY_DEFAULT, и членом type_num аргумента типа, установленным в typenum.

PyObject *PyArray_FromObject(PyObject *op, int typenum, int min_depth, int max_depth)

Возвращает выровненный и в порядке байтов по умолчанию массив из любой вложенной последовательности или объекта, экспортирующего интерфейс массива, op, заданного перечисленным типом. Минимальное число измерений массива задается min_depth, а максимальное — max_depth. Это эквивалентно вызову PyArray_FromAny с требованиями, установленными в BEHAVED.

PyObject* PyArray_EnsureArray(PyObject* op)

Эта функция заимствует ссылку на op и гарантирует, что op является базовым классом ndarray. Она обрабатывает скаляры массива, но в противном случае вызывает PyArray_FromAny (op, NULL, 0, 0, NPY_ARRAY_ENSUREARRAY, NULL).

PyObject* PyArray_FromString(char* string, npy_intp slen, PyArray_Descr* dtype, npy_intp num, char* sep)

Создаёт одномерный массив ndarray одного типа из двоичного или (ASCII) текстового string длины slen. Тип данных создаваемого массива задаётся dtype. Если num равно -1, то копируется вся строка, и возвращается массив соответствующего размера, иначе num — это количество элементов для копирования из строки. Если sep равно NULL (или “”), то строка интерпретируется как байты двоичных данных, иначе подстроки, разделенные sep, преобразуются в элементы типа данных dtype. Некоторые типы данных могут быть нечитаемы в текстовом режиме, и при этом будет вызвано исключение. Все ошибки возвращают NULL.

PyObject* PyArray_FromFile(FILE* fp, PyArray_Descr* dtype, npy_intp num, char* sep)

Создаёт одномерный массив ndarray одного типа из двоичного или текстового файла. Открытый указатель файла fp, тип данных создаваемого массива dtype. Он должен соответствовать данным в файле. Если num равно -1, то читается до конца файла и возвращается массив соответствующего размера, иначе num — количество элементов для чтения. Если sep равно NULL (или “”), то чтение происходит в двоичном режиме, иначе чтение происходит в текстовом режиме с разделителем sep. Некоторые типы данных не могут быть прочитаны в текстовом режиме, и в этом случае возникает ошибка.

PyObject* PyArray_FromBuffer(PyObject* buf, PyArray_Descr* dtype, npy_intp count, npy_intp offset)

Создаёт одномерный массив ndarray одного типа из объекта, buf, который экспортирует протокол буфера (или имеет атрибут __buffer__, возвращающий объект, экспортирующий протокол буфера). Сначала будет проверена возможность записи в буфер, а затем — только чтения. Флаг NPY_ARRAY_WRITEABLE возвращаемого массива отразит, какой из них был успешен. Данные предполагаются начинаться в позиции offset байт от начала памяти для объекта. Тип данных в буфере интерпретируется в соответствии с описателем типа данных, dtype.. Если count отрицательно, то он будет определён из размера буфера и запрашиваемого itemsize, иначе count представляет, сколько элементов должно быть преобразовано из буфера.

int PyArray_CopyInto(PyArrayObject* dest, PyArrayObject* src)

Копирует данные из исходного массива, src, в целевой массив, dest, выполняя преобразование типа данных при необходимости. Если произошла ошибка, возвращается -1 (иначе 0). Форма src должна быть совместима с формой dest. Области данных dest и src не должны перекрываться.

int PyArray_MoveInto(PyArrayObject* dest, PyArrayObject* src)

Перемещает данные из исходного массива, src, в целевой массив, dest, выполняя преобразование типа данных при необходимости. Если произошла ошибка, возвращается -1 (иначе 0). Форма src должна быть совместима с формой dest. Области данных dest и src могут перекрываться.

PyArrayObject* PyArray_GETCONTIGUOUS(PyObject* op)

Если op уже (стиль C) непрерывный и корректный, то просто возвращается ссылка, иначе возвращается (непрерывный и корректный) копию массива. Параметр op должен быть (подклассом) ndarray, и проверки на это не производится.

PyObject* PyArray_FROM_O(PyObject* obj)

Преобразует obj в ndarray. Аргумент может быть любой вложенной последовательностью или объектом, экспортирующим интерфейс массива. Это макроформа PyArray_FromAny с использованием NULL, 0, 0, 0 для других аргументов. Ваш код должен уметь обрабатывать любой описатель типа данных и любую комбинацию флагов данных, чтобы использовать этот макрос.

PyObject* PyArray_FROM_OF(PyObject* obj, int requirements)

Аналогично PyArray_FROM_O, за исключением того, что может принимать аргумент requirements, указывающий свойства, которые должен иметь результирующий массив. Доступные требования, которые могут быть применены, это NPY_ARRAY_C_CONTIGUOUS, NPY_ARRAY_F_CONTIGUOUS, NPY_ARRAY_ALIGNED, NPY_ARRAY_WRITEABLE, NPY_ARRAY_NOTSWAPPED, NPY_ARRAY_ENSURECOPY, NPY_ARRAY_UPDATEIFCOPY, NPY_ARRAY_FORCECAST и NPY_ARRAY_ENSUREARRAY. Также можно использовать стандартные комбинации флагов:

PyObject* PyArray_FROM_OT(PyObject* obj, int typenum)

Аналогично PyArray_FROM_O, за исключением того, что может принимать аргумент typenum, указывающий тип-число возвращаемого массива.

PyObject* PyArray_FROM_OTF(PyObject* obj, int typenum, int requirements)

Комбинация PyArray_FROM_OF и PyArray_FROM_OT, позволяющая предоставить как аргумент typenum, так и flags.

PyObject* PyArray_FROMANY(PyObject* obj, int typenum, int min, int max, int requirements)

Аналогично PyArray_FromAny, за исключением того, что тип данных задаётся с помощью типа-числа. PyArray_DescrFromType (typenum) передаётся непосредственно в PyArray_FromAny. Эта макрокоманда также добавляет NPY_ARRAY_DEFAULT к требованиям, если NPY_ARRAY_ENSURECOPY передаётся как требования.

PyObject *PyArray_CheckAxis(PyObject* obj, int* axis, int requirements)

Инкапсулирует функциональность функций и методов, которые принимают ключевое слово axis= и правильно работают с None в качестве аргумента axis. Входной массив — obj, в то время как *axis — это преобразованное целое число (так что >=MAXDIMS — это значение None), а requirements предоставляет необходимые свойства obj. Выход представляет собой преобразованную версию входных данных, так что требования выполняются, и при необходимости происходит сглаживание. При выводе отрицательные значения *axis преобразуются, и новое значение проверяется на соответствие форме obj.

Работа с типами

Общий контроль типа Python

PyArray_Check(op)

Возвращает истинное значение, если op — это объект Python, тип которого является подтипом PyArray_Type.

PyArray_CheckExact(op)

Возвращает истинное значение, если op — это объект Python с типом PyArray_Type.

PyArray_HasArrayInterface(op, out)

Если op реализует какую-либо часть интерфейса массива, то out будет содержать новую ссылку на недавно созданный массив ndarray с использованием интерфейса, или out будет содержать NULL в случае ошибки во время преобразования. В противном случае out будет содержать заимствованную ссылку на Py_NotImplemented, и никакое условие ошибки не устанавливается.

PyArray_HasArrayInterfaceType(op, type, context, out)

Если op реализует какую-либо часть интерфейса массива, то out будет содержать новую ссылку на недавно созданный массив ndarray с использованием интерфейса, или out будет содержать NULL в случае ошибки во время преобразования. В противном случае out будет содержать заимствованную ссылку на Py_NotImplemented, и никакое условие ошибки не устанавливается. Эта версия позволяет задавать тип и контекст в части интерфейса массива, которая ищет атрибут __array__.

PyArray_IsZeroDim(op)

Возвращает истинное значение, если op является экземпляром (подкласса) PyArray_Type и имеет 0 измерений.

PyArray_IsScalar(op, cls)

Возвращает истинное значение, если op является экземпляром Py{cls}ArrType_Type.

PyArray_CheckScalar(op)

Возвращает истинное значение, если op является либо скалярным массивом (экземпляр подтипа PyGenericArr_Type), либо экземпляром (подкласса) PyArray_Type с размерностью 0.

PyArray_IsPythonNumber(op)

Возвращает истинное значение, если op является экземпляром встроенного числового типа (int, float, complex, long, bool)

PyArray_IsPythonScalar(op)

Возвращает истинное значение, если op — это встроенный скалярный объект Python (int, float, complex, str, unicode, long, bool).

PyArray_IsAnyScalar(op)

Возвращает истинное значение, если op является либо скалярным объектом Python (см. PyArray_IsPythonScalar), либо скалярным массивом (экземпляр подтипа PyGenericArr_Type).

PyArray_CheckAnyScalar(op)

Возвращает истинное значение, если op является скалярным объектом Python (см. PyArray_IsPythonScalar), скалярным массивом (экземпляр подтипа PyGenericArr_Type) или экземпляром подтипа PyArray_Type с размерностью 0.

Проверка типа данных

Для макросов typenum аргумент — это целое число, представляющее перечисление типов данных массива. Для макросов проверки типа массива аргумент должен быть PyObject *, который может быть непосредственно интерпретирован как PyArrayObject *.

PyTypeNum_ISUNSIGNED(num)

PyDataType_ISUNSIGNED(descr)

PyArray_ISUNSIGNED(obj)

Тип представляет беззнаковое целое число.

PyTypeNum_ISSIGNED(num)

PyDataType_ISSIGNED(descr)

PyArray_ISSIGNED(obj)

Тип представляет знаковое целое число.

PyTypeNum_ISINTEGER(num)

PyDataType_ISINTEGER(descr)

PyArray_ISINTEGER(obj)

Тип представляет любое целое число.

PyTypeNum_ISFLOAT(num)

PyDataType_ISFLOAT(descr)

PyArray_ISFLOAT(obj)

Тип представляет любое число с плавающей точкой.

PyTypeNum_ISCOMPLEX(num)

PyDataType_ISCOMPLEX(descr)

PyArray_ISCOMPLEX(obj)

Тип представляет любое комплексное число с плавающей точкой.

PyTypeNum_ISNUMBER(num)

PyDataType_ISNUMBER(descr)

PyArray_ISNUMBER(obj)

Тип представляет любое целое число, число с плавающей точкой или комплексное число с плавающей точкой.

PyTypeNum_ISSTRING(num)

PyDataType_ISSTRING(descr)

PyArray_ISSTRING(obj)

Тип представляет тип данных строки.

PyTypeNum_ISPYTHON(num)

PyDataType_ISPYTHON(descr)

PyArray_ISPYTHON(obj)

Тип представляет перечисление, соответствующее одному из стандартных скаляров Python (bool, int, float или complex).

PyTypeNum_ISFLEXIBLE(num)

PyDataType_ISFLEXIBLE(descr)

PyArray_ISFLEXIBLE(obj)

Тип представляет один из гибких типов массивов ( NPY_STRING, NPY_UNICODE или NPY_VOID ).

PyTypeNum_ISUSERDEF(num)

PyDataType_ISUSERDEF(descr)

PyArray_ISUSERDEF(obj)

Тип представляет пользовательский тип.

PyTypeNum_ISEXTENDED(num)

PyDataType_ISEXTENDED(descr)

PyArray_ISEXTENDED(obj)

Тип является либо гибким, либо пользовательским.

PyTypeNum_ISOBJECT(num)

PyDataType_ISOBJECT(descr)

PyArray_ISOBJECT(obj)

Тип представляет тип данных объекта.

PyTypeNum_ISBOOL(num)

PyDataType_ISBOOL(descr)

PyArray_ISBOOL(obj)

Тип представляет булевский тип данных.

PyDataType_HASFIELDS(descr)

PyArray_HASFIELDS(obj)

Тип содержит связанные с ним поля.

PyArray_ISNOTSWAPPED(m)

Возвращает истину, если область данных ndarray m находится в порядке байтов машины в соответствии с описателем типа данных массива.

PyArray_ISBYTESWAPPED(m)

Возвращает истину, если область данных ndarray m не находится в порядке байтов машины в соответствии с описателем типа данных массива.

Bool PyArray_EquivTypes(PyArray_Descr* type1, PyArray_Descr* type2)

Возвращает NPY_TRUE, если типы type1 и type2 фактически представляют эквивалентные типы для данной платформы (член fortran каждого типа игнорируется). Например, на 32-битных платформах NPY_LONG и NPY_INT эквивалентны. В противном случае возвращает NPY_FALSE.

Bool PyArray_EquivArrTypes(PyArrayObject* a1, PyArrayObject * a2)

Возвращает NPY_TRUE, если массивы a1 и a2 имеют эквивалентные типы для данной платформы.

Bool PyArray_EquivTypenums(int typenum1, int typenum2)

Специальный случай PyArray_EquivTypes (...) который не принимает гибкие типы данных, но может быть проще в вызове.

int PyArray_EquivByteorders({byteorder} b1, {byteorder} b2)

Истина, если символы порядка байтов ( NPY_LITTLE, NPY_BIG, NPY_NATIVE, NPY_IGNORE ) равны или эквивалентны по своему определению родного порядка байтов. Таким образом, на машине с порядком байтов little-endian NPY_LITTLE и NPY_NATIVE эквивалентны, где они не эквивалентны на машине с порядком байтов big-endian.

Преобразование типов данных

PyObject* PyArray_Cast(PyArrayObject* arr, int typenum)

В основном для обратной совместимости с Numeric C-API и для простых преобразований в негибкие типы. Возвращает новый массив объектов с элементами из arr, преобразованными в тип данных typenum, который должен быть одним из перечисленных типов и не должен быть гибким типом.

PyObject* PyArray_CastToType(PyArrayObject* arr, PyArray_Descr* type, int fortran)

Возвращает новый массив указанного типа, преобразуя элементы из arr соответствующим образом. Аргумент fortran задает порядок выходного массива.

int PyArray_CastTo(PyArrayObject* out, PyArrayObject* in)

Начиная с версии 1.6, эта функция просто вызывает PyArray_CopyInto, которая обрабатывает преобразование.

Преобразует элементы массива in в массив out. Выходной массив должен быть изменяемым, иметь целое кратное количество элементов входного массива (в выходной массив может быть помещено более одной копии), и иметь тип данных, являющийся одним из встроенных типов. Возвращает 0 при успехе и -1 при ошибке.

PyArray_VectorUnaryFunc* PyArray_GetCastFunc(PyArray_Descr* from, int totype)

Возвращает функцию низкого уровня преобразования для преобразования из данного описателя в число встроенного типа. Если функция преобразования не существует, возвращает NULL и устанавливает ошибку. Использование этой функции вместо прямого доступа к from ->f->cast позволит поддерживать любые пользовательские функции преобразования, добавленные в словарь преобразований описателя.

int PyArray_CanCastSafely(int fromtype, int totype)

Возвращает ненулевое значение, если массив типа данных fromtype может быть преобразован в массив типа данных totype без потери информации. Исключением является то, что 64-битные целые числа разрешается преобразовывать в 64-битные числа с плавающей запятой, даже если это может привести к потере точности для больших целых чисел, чтобы не распространять использование длинных двойных чисел без явных запросов. Гибкие типы массивов не проверяются в соответствии с их длинами с помощью этой функции.

int PyArray_CanCastTo(PyArray_Descr* fromtype, PyArray_Descr* totype)

PyArray_CanCastTypeTo заменяет эту функцию в NumPy 1.6 и более поздних версиях.

Эквивалентно PyArray_CanCastTypeTo(fromtype, totype, NPY_SAFE_CASTING).

int PyArray_CanCastTypeTo(PyArray_Descr* fromtype, PyArray_Descr* totype, NPY_CASTING casting)

Новое в версии 1.6.

Возвращает ненулевое значение, если массив типа данных fromtype (который может включать гибкие типы) может быть безопасно преобразован в массив типа данных totype (который может включать гибкие типы) в соответствии с правилом преобразования casting. Для простых типов с NPY_SAFE_CASTING это в основном обертка вокруг PyArray_CanCastSafely, но для гибких типов, таких как строки или unicode, она генерирует результаты, учитывая их размеры. Целые и вещественные типы могут быть преобразованы в строковый или unicode-тип только с помощью NPY_SAFE_CASTING, если строковый или unicode-тип достаточно большой, чтобы вместить максимальное значение целого/вещественного типа, из которого производится преобразование.

int PyArray_CanCastArrayTo(PyArrayObject* arr, PyArray_Descr* totype, NPY_CASTING casting)

Новое в версии 1.6.

Возвращает ненулевое значение, если arr может быть преобразован в totype в соответствии с правилом преобразования, указанным в casting. Если arr является скаляром массива, его значение учитывается, а ненулевое значение также возвращается, когда значение не будет переполнять или усекаться до целого при преобразовании в меньший тип.

Это почти то же самое, что результат PyArray_CanCastTypeTo(PyArray_MinScalarType(arr), totype, casting), но это также обрабатывает особый случай, возникающий из-за того, что множество значений uint не является подмножеством значений int для типов с одинаковым количеством бит.

PyArray_Descr* PyArray_MinScalarType(PyArrayObject* arr)

Новое в версии 1.6.

Если arr является массивом, возвращает его описатель типа данных, но если arr является скаляром массива (имеет 0 измерений), он находит тип данных наименьшего размера, в который значение может быть преобразовано без переполнения или усечения до целого.

Эта функция не будет понижать комплексные числа до вещественных или что-либо до логических, но будет понижать целое число со знаком до целого числа без знака, когда скалярное значение положительное.

PyArray_Descr* PyArray_PromoteTypes(PyArray_Descr* type1, PyArray_Descr* type2)

Новое в версии 1.6.

Находит тип данных наименьшего размера и вида, в который type1 и type2 могут быть безопасно преобразованы. Эта функция симметричная и ассоциативная. Строковый или unicode результат будет иметь правильный размер для хранения максимального значения входных типов, преобразованных в строку или unicode.

PyArray_Descr* PyArray_ResultType(npy_intp narrs, PyArrayObject**arrs, npy_intp ndtypes, PyArray_Descr**dtypes)

Новое в версии 1.6.

Это применяет повышение типа ко всем входным данным, используя правила NumPy для объединения скаляров и массивов, чтобы определить выходной тип набора операндов. Это тот же тип результата, который производят ufunc. Конкретный используемый алгоритм следующий.

Категории определяются путем проверки, являются ли булевы, целые (int/uint) или числа с плавающей запятой (float/complex) максимальным видом всех массивов и скаляров.

Если есть только скаляры или максимальная категория скаляров выше максимальной категории массивов, типы данных объединяются с помощью PyArray_PromoteTypes для получения возвращаемого значения.

В противном случае вызывается PyArray_MinScalarType для каждого массива, а полученные типы данных объединяются с помощью PyArray_PromoteTypes для получения возвращаемого значения.

Множество значений int не является подмножеством значений uint для типов с одинаковым количеством бит, что не отражается в PyArray_MinScalarType, но обрабатывается как особый случай в PyArray_ResultType.

int PyArray_ObjectType(PyObject* op, int mintype)

Эта функция устарела и заменена на PyArray_MinScalarType и/или PyArray_ResultType.

Эта функция полезна для определения общего типа, к которому могут быть преобразованы два или более массивов. Она работает только для массивов негибких типов, так как не передаётся информация о размере элемента. Аргумент mintype представляет собой минимально допустимый тип, а op — объект, который будет преобразован в массив. Возвращаемое значение — перечислительный номер типа, представляющий тип данных, который должен иметь op.

void PyArray_ArrayType(PyObject* op, PyArray_Descr* mintype, PyArray_Descr* outtype)

Эта функция устарела и заменена на PyArray_ResultType.

Эта функция работает аналогично PyArray_ObjectType (...) за исключением того, что она обрабатывает гибкие массивы. Аргумент mintype может иметь член itemsize, а аргумент outtype будет иметь член itemsize, по крайней мере, такой же большой, но, возможно, больше, в зависимости от объекта op.

PyArrayObject** PyArray_ConvertToCommonType(PyObject* op, int* n)

Функциональность, предоставляемая этой функцией, в значительной степени устарела и заменена итератором NpyIter, введённым в версии 1.6, с флагом NPY_ITER_COMMON_DTYPE или с одинаковым параметром dtype для всех операндов.

Преобразует последовательность Python-объектов, содержащихся в op, в массив ndarrays, каждый из которых имеет тот же тип данных. Тип выбирается на основе номера типа (выбирается тип с большим номером по сравнению с меньшим), игнорируя объекты, которые являются только скалярами. Длина последовательности возвращается в n, а возвращаемым значением является массив длиной n указателей на PyArrayObject (или NULL в случае ошибки). Возвращённый массив должен быть освобождён вызывающей стороной этой функции (с помощью PyDataMem_FREE), и все объекты массивов в нём DECREF должны быть освобождены, иначе произойдёт утечка памяти. Приведённый ниже пример показывает типичное использование:

mps = PyArray_ConvertToCommonType(obj, &n);
if (mps==NULL) return NULL;
{code}
<before return>
for (i=0; i<n; i++) Py_DECREF(mps[i]);
PyDataMem_FREE(mps);
{return}

char* PyArray_Zero(PyArrayObject* arr)

Указатель на недавно созданную память размером arr->itemsize, содержащую представление 0 для данного типа. Возвращённый указатель ret должен быть освобождён с помощью PyDataMem_FREE (ret), когда он больше не нужен.

char* PyArray_One(PyArrayObject* arr)

Указатель на недавно созданную память размером arr->itemsize, содержащую представление 1 для данного типа. Возвращённый указатель ret должен быть освобождён с помощью PyDataMem_FREE (ret), когда он больше не нужен.

int PyArray_ValidType(int typenum)

Возвращает NPY_TRUE, если typenum представляет собой действительный номер типа (встроенный, пользовательский или код символа). В противном случае функция возвращает NPY_FALSE.

Новые типы данных

void PyArray_InitArrFuncs(PyArray_ArrFuncs* f)

Инициализирует все указатели на функции и члены до NULL.

int PyArray_RegisterDataType(PyArray_Descr* dtype)

Регистрирует тип данных как новый пользовательский тип данных для массивов. Тип должен иметь большинство своих элементов, заполненных данными. Это не всегда проверяется, и ошибки могут привести к сегментум ошибкам. В частности, член typeobj структуры dtype должен быть заполнен Python-типом с фиксированным размером элемента, который соответствует члену elsize в dtype. Также член f должен содержать необходимые функции: nonzero, copyswap, copyswapn, getitem, setitem и cast (некоторые из функций cast могут быть NULL , если поддержка не требуется). Для избежания путаницы следует выбрать уникальный код символа типа, но это не навязывается и не используется внутри.

Возвращается номер пользовательского типа, который однозначно идентифицирует тип. Указатель на новую структуру затем можно получить из PyArray_DescrFromType с использованием возвращённого номера типа. Возвращается -1 в случае ошибки. Если этот dtype уже был зарегистрирован (проверка осуществляется только по адресу указателя), возвращается ранее назначенный номер типа.

int PyArray_RegisterCastFunc(PyArray_Descr* descr, int totype, PyArray_VectorUnaryFunc* castfunc)

Регистрирует функцию низкоуровневого преобразования castfunc для преобразования из типа данных descr в данный номер типа данных totype. Любая старая функция преобразования перезаписывается. На успешное выполнение возвращается 0, в случае ошибки возвращается -1.

int PyArray_RegisterCanCast(PyArray_Descr* descr, int totype, NPY_SCALARKIND scalar)

Регистрирует номер типа данных totype как преобразуемый из объекта типа данных descr заданного scalar типа. Используйте scalar = NPY_NOSCALAR для регистрации возможности безопасного преобразования массива типа данных descr к типу данных с номером типа totype.

Специальные функции для NPY_OBJECT

int PyArray_INCREF(PyArrayObject* op)

Используется для массива op, содержащего любые Python-объекты. Увеличивает счётчик ссылок каждого объекта в массиве в соответствии с типом данных op. Возвращает -1 в случае ошибки, в противном случае возвращает 0.

void PyArray_Item_INCREF(char* ptr, PyArray_Descr* dtype)

Функция для увеличения счётчика ссылок всех объектов по адресу ptr в соответствии с типом данных dtype. Если ptr — начало структурированного типа с объектом в любом смещении, то это (рекурсивно) увеличит счётчик ссылок всех подобных объектам элементов в структурированном типе.

int PyArray_XDECREF(PyArrayObject* op)

Используется для массива op, содержащего любые Python-объекты. Уменьшает счётчик ссылок каждого объекта в массиве в соответствии с типом данных op. Нормальное возвращаемое значение — 0. Возвращает -1 в случае ошибки.

void PyArray_Item_XDECREF(char* ptr, PyArray_Descr* dtype)

Функция для уменьшения счётчика ссылок всех объектов-подобных элементов по адресу ptr, как указано в типе данных dtype. Она работает рекурсивно, так что если dtype сам имеет поля с типами данных, содержащими объекты-подобные элементы, все подобные объекты-поля будут XDECREF 'd.

void PyArray_FillObjectArray(PyArrayObject* arr, PyObject* obj)

Заполняет недавно созданный массив одним значением obj во всех позициях структуры с объектами типа данных. Проверка не выполняется, но arr должен иметь тип данных NPY_OBJECT и быть односегментным и неинициализированным (никаких предыдущих объектов в позиции). Используйте PyArray_DECREF (arr), если нужно уменьшить счётчики ссылок всех элементов массива объектов перед вызовом этой функции.

Флаги массивов

Атрибут flags структуры PyArrayObject содержит важную информацию о памяти, используемой массивом (на который указывает член data). Эта информация о флагах должна храниться точно, иначе могут возникнуть странные результаты и даже ошибки сегментации.

Существует 6 (битовых) флагов, описывающих область памяти, используемой буфером данных. Эти константы определены в arrayobject.h и определяют битовую позицию флага. Python предоставляет удобный интерфейс на основе атрибутов, а также интерфейс наподобие словаря для получения (и, при необходимости, установки) этих флагов.

Области памяти всех типов могут быть указаны массивом ndarray, что делает эти флаги необходимыми. Если вы получаете произвольный PyArrayObject в коде C, вы должны быть осведомлены о флагах, которые установлены. Если вам нужно гарантировать определённый тип массива (например, NPY_ARRAY_C_CONTIGUOUS и NPY_ARRAY_BEHAVED), передайте эти требования в функцию PyArray_FromAny.

Основные флаги массива

У ndarray может быть сегмент данных, который не является простым смежным блоком хорошо обработанной памяти, которую вы можете изменить. Он может быть не выровнен по границам слов (очень важно на некоторых платформах). Его данные могут быть в другом порядке байтов, чем понимает машина. Он может быть не доступен для записи. Он может быть в порядке Fortran-contiguous.

Флаги массива используются для указания того, что можно сказать о данных, связанных с массивом.

В версиях NumPy 1.6 и более ранних версиях следующие флаги не имели префикса _ARRAY_.

NPY_ARRAY_C_CONTIGUOUS

Область данных находится в порядке, непрерывном в стиле C (индекс последнего элемента изменяется быстрее всего).

NPY_ARRAY_F_CONTIGUOUS

Область данных находится в порядке, непрерывном в стиле Fortran (индекс первого элемента изменяется быстрее всего).

NPY_ARRAY_OWNDATA

Область данных принадлежит этому массиву.

NPY_ARRAY_ALIGNED

Область данных и все элементы массива правильно выровнены.

NPY_ARRAY_WRITEABLE

К области данных можно записать.

Обратите внимание, что вышеуказанные 3 флага определены таким образом, что новый, хорошо себя ведущий массив имеет эти флаги, установленные как true.

NPY_ARRAY_UPDATEIFCOPY

Область данных представляет собой (хорошо себя ведущую) копию, чья информация должна быть передана обратно в исходный массив при удалении этого массива.

Это специальный флаг, который устанавливается, если этот массив представляет копию, сделанную потому, что пользователь потребовал определённых флагов в PyArray_FromAny, и необходимо было сделать копию другого массива (и пользователь попросил установить этот флаг в такой ситуации). Атрибут base затем указывает на «плохой» массив (который устанавливается read_only). Когда массив с этим флагом удаляется, он скопирует своё содержимое обратно в «плохой» массив (с приведением типов, если необходимо) и сбросит «плохой» массив на NPY_ARRAY_WRITEABLE. Если «плохой» массив изначально не был NPY_ARRAY_WRITEABLE, тогда PyArray_FromAny вернул бы ошибку, потому что NPY_ARRAY_UPDATEIFCOPY не мог бы быть выполнен.

PyArray_UpdateFlags (obj, flags) обновит obj->flags для flags, который может быть любым из NPY_ARRAY_C_CONTIGUOUS, NPY_ARRAY_F_CONTIGUOUS, NPY_ARRAY_ALIGNED или NPY_ARRAY_WRITEABLE.

Комбинации флагов массива

NPY_ARRAY_BEHAVED

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE

NPY_ARRAY_CARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_CARRAY_RO

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_BEHAVED

NPY_ARRAY_FARRAY_RO

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_DEFAULT

NPY_ARRAY_CARRAY

NPY_ARRAY_UPDATE_ALL

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

Флаги-константы

Эти константы используются в PyArray_FromAny (и его макроформах) для указания желаемых свойств нового массива.

NPY_ARRAY_FORCECAST

Преобразование к нужному типу, даже если это невозможно без потери информации.

NPY_ARRAY_ENSURECOPY

Убедиться, что полученный массив является копией исходного.

NPY_ARRAY_ENSUREARRAY

Убедиться, что результирующий объект является фактическим ndarray (или bigndarray), а не подклассом.

NPY_ARRAY_NOTSWAPPED

Используется только в PyArray_CheckFromAny для переопределения порядка байтов объекта типа данных, переданного в качестве аргумента.

NPY_ARRAY_BEHAVED_NS

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE | NPY_ARRAY_NOTSWAPPED

Проверка флагов

Для всех этих макросов arr должен быть экземпляром (подкласса) PyArray_Type, но проверка не выполняется.

PyArray_CHKFLAGS(arr, flags)

Первый параметр, arr, должен быть ndarray или подклассом. Параметр flags должен быть целым числом, представляющим комбинацию битовых флагов, которые может иметь массив: NPY_ARRAY_C_CONTIGUOUS, NPY_ARRAY_F_CONTIGUOUS, NPY_ARRAY_OWNDATA, NPY_ARRAY_ALIGNED, NPY_ARRAY_WRITEABLE, NPY_ARRAY_UPDATEIFCOPY.

PyArray_IS_C_CONTIGUOUS(arr)

Возвращает true, если arr является непрерывным в стиле C.

PyArray_IS_F_CONTIGUOUS(arr)

Возвращает true, если arr является непрерывным в стиле Fortran.

PyArray_ISFORTRAN(arr)

Возвращает true, если arr является непрерывным в стиле Fortran и не непрерывным в стиле C. PyArray_IS_F_CONTIGUOUS — правильный способ проверки непрерывности в стиле Fortran.

PyArray_ISWRITEABLE(arr)

Возвращает true, если к области данных arr можно записать.

PyArray_ISALIGNED(arr)

Возвращает true, если область данных arr правильно выровнена на машине.

PyArray_ISBEHAVED(arr)

Возвращает true, если область данных arr выровнена, доступна для записи и имеет порядок байтов машины в соответствии с её описателем.

PyArray_ISBEHAVED_RO(arr)

Возвращает true, если область данных arr выровнена и имеет порядок байтов машины.

PyArray_ISCARRAY(arr)

Возвращает true, если область данных arr непрерывна в стиле C и PyArray_ISBEHAVED (arr) равно true.

PyArray_ISFARRAY(arr)

Возвращает true, если область данных arr непрерывна в стиле Fortran и PyArray_ISBEHAVED (arr) равно true.

PyArray_ISCARRAY_RO(arr)

Возвращает true, если область данных arr непрерывна в стиле C, выровнена и имеет порядок байтов машины.

PyArray_ISFARRAY_RO(arr)

Возвращает true, если область данных arr непрерывна в стиле Fortran, выровнена и имеет порядок байтов машины.

PyArray_ISONESEGMENT(arr)

Возвращает true, если область данных arr состоит из одного (непрерывного в стиле C или Fortran) сегмента.

void PyArray_UpdateFlags(PyArrayObject* arr, int flagmask)

Флаги массива NPY_ARRAY_C_CONTIGUOUS, NPY_ARRAY_ALIGNED и NPY_ARRAY_F_CONTIGUOUS могут быть «вычислены» из объекта массива. Эта функция обновляет один или несколько из этих флагов arr, как указано в flagmask, выполняя необходимое вычисление.

Альтернативный API методов массива

Преобразование

PyObject* PyArray_GetField(PyArrayObject* self, PyArray_Descr* dtype, int offset)

Эквивалентно ndarray.getfield (self, dtype, offset). Возвращает новый массив заданного типа dtype, используя данные из текущего массива по указанному смещению offset в байтах. Смещение offset плюс размер элемента нового типа массива dtype должны быть меньше self ->descr->elsize, иначе генерируется ошибка. Используются те же размеры и шаги, что и в исходном массиве. Поэтому эта функция имеет эффект возвращения поля из структурированного массива. Но она также может использоваться для выбора определённых байтов или групп байтов из любого типа массива.

int PyArray_SetField(PyArrayObject* self, PyArray_Descr* dtype, int offset, PyObject* val)

Эквивалентно ndarray.setfield (self, val, dtype, offset ). Устанавливает поле, начиная со смещения offset в байтах и заданного типа dtype, в значение val. Смещение offset плюс dtype ->elsize должны быть меньше self ->descr->elsize, иначе генерируется ошибка. В противном случае аргумент val преобразуется в массив и копируется в указанное поле. При необходимости, элементы val повторяются для заполнения целевого массива. Однако, количество элементов в целевом массиве должно быть целым кратным количеству элементов в val.

PyObject* PyArray_Byteswap(PyArrayObject* self, Bool inplace)

Эквивалентно ndarray.byteswap (self, inplace). Возвращает массив, область данных которого переставлена байтами. Если inplace отлично от нуля, то перестановка байтов выполняется на месте, и возвращается ссылка на self. В противном случае создаётся копия с переставленными байтами, и self остаётся неизменным.

PyObject* PyArray_NewCopy(PyArrayObject* old, NPY_ORDER order)

Эквивалентно ndarray.copy (self, fortran). Создаёт копию массива old. Возвращаемый массив всегда выровнен и доступен для записи с данными, интерпретируемыми так же, как в исходном массиве. Если order равен NPY_CORDER, возвращается массив, выровненный по стилю C. Если order равен NPY_FORTRANORDER, возвращается массив, выровненный по стилю Fortran. Если order равен NPY_ANYORDER, возвращаемый массив выровнен по стилю Fortran только если исходный массив также выровнен по стилю Fortran, в противном случае он выровнен по стилю C.

PyObject* PyArray_ToList(PyArrayObject* self)

Эквивалентно ndarray.tolist (self). Возвращает вложенный Python-список из self.

PyObject* PyArray_ToString(PyArrayObject* self, NPY_ORDER order)

Эквивалентно ndarray.tobytes (self, order). Возвращает байты этого массива в виде Python-строки.

PyObject* PyArray_ToFile(PyArrayObject* self, FILE* fp, char* sep, char* format)

Записывает содержимое self в указатель файла fp в порядке, выровненном по стилю C. Записывает данные в виде двоичных байтов, если sep – это пустая строка или NULL. В противном случае записывает содержимое self как текст, используя строку sep в качестве разделителя элементов. Каждый элемент будет записан в файл. Если строка format не равна NULL или пустой строке, то это Python-строка формата для вывода, показывающая, как должны быть записаны элементы.

int PyArray_Dump(PyObject* self, PyObject* file, int protocol)

Записывает объект в self в указанный файл file (либо строка, либо Python-объект файла). Если file – Python-строка, она рассматривается как имя файла, которое затем открывается в двоичном режиме. Используется указанный протокол protocol (если protocol отрицательный, используется наивысший доступный). Это простой обёртку над cPickle.dump(self, file, protocol).

PyObject* PyArray_Dumps(PyObject* self, int protocol)

Записывает объект в self в Python-строку и возвращает её. Используется предоставленный протокол Pickle protocol (или наивысший доступный, если protocol отрицательный).

int PyArray_FillWithScalar(PyArrayObject* arr, PyObject* obj)

Заполняет массив arr заданным скалярным объектом obj. Объект сначала преобразуется к типу данных arr, а затем копируется в каждую ячейку. Возвращается -1, если произошла ошибка, иначе 0.

PyObject* PyArray_View(PyArrayObject* self, PyArray_Descr* dtype, PyTypeObject *ptype)

Эквивалентно ndarray.view (self, dtype). Возвращает новый вид массива self, возможно, с другим типом данных dtype и другим подклассом массива ptype.

Если dtype равен NULL, возвращаемый массив будет иметь тот же тип данных, что и self. Новый тип данных должен быть совместим с размером self. Либо размеры элементов должны быть идентичными, либо self должен быть односегментным, и общее количество байтов должно быть одинаковым. В последнем случае размерности возвращаемого массива будут изменены в последней (или первой для массивов, выровненных по стилю Fortran) размерности. Область данных возвращаемого массива и self точно совпадают.

Изменение формы

PyObject* PyArray_Newshape(PyArrayObject* self, PyArray_Dims* newshape, NPY_ORDER order)

В результате будет новый массив (ссылаящийся на ту же область памяти, что и self, если возможно), но имеющий форму, заданную newshape. Если новая форма не совместима с шагами self, то будет возвращена копия массива с новой заданной формой.

PyObject* PyArray_Reshape(PyArrayObject* self, PyObject* shape)

Эквивалентно ndarray.reshape (self, shape), где shape – последовательность. Преобразует shape в структуру PyArray_Dims и вызывает PyArray_Newshape внутри. Для обратной совместимости – не рекомендуется.

PyObject* PyArray_Squeeze(PyArrayObject* self)

Эквивалентно ndarray.squeeze (self). Возвращает новый вид self со всеми размерностями длиной 1, удалёнными из формы.

PyObject* PyArray_SwapAxes(PyArrayObject* self, int a1, int a2)

Эквивалентно ndarray.swapaxes (self, a1, a2). Возвращаемый массив – новый вид данных в self с переставленными осями a1 и a2.

PyObject* PyArray_Resize(PyArrayObject* self, PyArray_Dims* newshape, int refcheck, NPY_ORDER fortran)

Эквивалентно ndarray.resize (self, newshape, refcheck = refcheck, order= fortran ). Эта функция работает только с односегментными массивами. Она изменяет форму self на месте и перевыделит память для self, если newshape имеет другое общее число элементов, чем старая форма. Если необходимо перевыделение, то self должен владеть своими данными, self - >base==NULL, self - >weakrefs==NULL, и (если refcheck не равен 0) не должен ссылаться на какой-либо другой массив. Аргумент fortran может быть NPY_ANYORDER, NPY_CORDER или NPY_FORTRANORDER. В настоящее время он не оказывает никакого влияния. В конечном счёте, он мог бы использоваться для определения того, как операция изменения размера должна интерпретировать данные при построении массива с различными размерностями. Возвращает None при успехе и NULL при ошибке.

PyObject* PyArray_Transpose(PyArrayObject* self, PyArray_Dims* permute)

Эквивалентно ndarray.transpose (self, permute). Переставляет оси объекта ndarray self в соответствии со структурой данных permute и возвращает результат. Если permute – NULL, то результирующий массив имеет оси, переставленные в обратном порядке. Например, если self имеет форму , и permute .ptr равно (0,2,1), то форма результата равна . Если permute равно NULL, то форма результата равна .

PyObject* PyArray_Flatten(PyArrayObject* self, NPY_ORDER order)

Эквивалентно ndarray.flatten (self, order). Возвращает одномерную копию массива. Если order равен NPY_FORTRANORDER, элементы сканируются в порядке Fortran (первое измерение изменяется быстрее всего). Если order равен NPY_CORDER, элементы self сканируются в порядке C (последнее измерение изменяется быстрее всего). Если order равен NPY_ANYORDER, то результат PyArray_ISFORTRAN (self) используется для определения порядка раскладывания.

PyObject* PyArray_Ravel(PyArrayObject* self, NPY_ORDER order)

Эквивалентно self.ravel(order). Имеет ту же базовую функциональность, что и PyArray_Flatten (self, order), за исключением случая, когда order равен 0, а self является C-стилевым непрерывным массивом. В этом случае форма массива изменяется, но копия не создаётся.

Выбор и манипулирование элементами

PyObject* PyArray_TakeFrom(PyArrayObject* self, PyObject* indices, int axis, PyArrayObject* ret, NPY_CLIPMODE clipmode)

Эквивалентно ndarray.take (self, indices, axis, ret, clipmode), за исключением того, что axis = None в Python достигается установкой axis = NPY_MAXDIMS в C. Извлечение элементов из self, указанных целыми числами в indices вдоль заданной оси axis. Аргумент clipmode может принимать значения NPY_RAISE, NPY_WRAP или NPY_CLIP для указания обработки индексов, выходящих за пределы. Аргумент ret может указать выходной массив, вместо создания его внутри функции.

PyObject* PyArray_PutTo(PyArrayObject* self, PyObject* values, PyObject* indices, NPY_CLIPMODE clipmode)

Эквивалентно self.put(values, indices, clipmode). Размещение значений values в self по соответствующим (сглаженным) индексам indices. Если values слишком мал, он будет повторяться по мере необходимости.

PyObject* PyArray_PutMask(PyArrayObject* self, PyObject* values, PyObject* mask)

Размещение значений values в self в тех позициях, где соответствующие позиции (с использованием сглаженного контекста) в mask равны true. Массивы mask и self должны иметь одинаковое общее количество элементов. Если values слишком мал, он будет повторяться по мере необходимости.

PyObject* PyArray_Repeat(PyArrayObject* self, PyObject* op, int axis)

Эквивалентно ndarray.repeat (self, op, axis). Копирование элементов self, по op раз вдоль заданной оси axis. Либо op - это скалярное целое число, либо последовательность длиной self ->dimensions[ axis ], указывающая, сколько раз следует повторить каждый элемент вдоль оси.

PyObject* PyArray_Choose(PyArrayObject* self, PyObject* op, PyArrayObject* ret, NPY_CLIPMODE clipmode)

Эквивалентно ndarray.choose (self, op, ret, clipmode). Создание нового массива путём выбора элементов из последовательности массивов в op на основе целых значений в self. Все массивы должны быть совместимы с одинаковой формой, а элементы в self должны быть в диапазоне от 0 до len(op). Выходные данные помещаются в ret, если он не NULL, в противном случае создаётся новый массив. Аргумент clipmode определяет поведение, когда элементы в self не находятся в диапазоне от 0 до len(op).

NPY_RAISE

вызывает ValueError;

NPY_WRAP

значения < 0 обёртываются, добавляя len(op), а значения >=len(op) обёртываются, вычитая len(op), пока они не окажутся в диапазоне;

NPY_CLIP

все значения обрезаются до области [0, len(op)).

PyObject* PyArray_Sort(PyArrayObject* self, int axis)

Эквивалентно ndarray.sort (self, axis). Возвращает массив с элементами self, отсортированными вдоль оси axis.

PyObject* PyArray_ArgSort(PyArrayObject* self, int axis)

Эквивалентно ndarray.argsort (self, axis). Возвращает массив индексов, такой что выбор этих индексов вдоль заданной axis вернёт отсортированную версию self. Если self ->descr является типом данных с определёнными полями, то self->descr->names используется для определения порядка сортировки. Сравнение, где первое поле равно, использует второе поле и так далее. Для изменения порядка сортировки структурированного массива создайте новый тип данных с другим порядком имён и постройте представление массива с этим новым типом данных.

PyObject* PyArray_LexSort(PyObject* sort_keys, int axis)

Принимая последовательность массивов (sort_keys) одинаковой формы, возвращает массив индексов (аналогичный PyArray_ArgSort (...)), которые сортируют массивы лексикографически. Лексикографическая сортировка указывает, что когда два ключа оказываются равными, порядок определяется сравнением последующих ключей. Для типов данных требуется определять слияние сортировки (оставляющее одинаковые элементы без изменения). Сортировка выполняется путём сортировки индексов сначала по первому sort_key, затем по второму sort_key и так далее. Это эквивалентно команде lexsort(sort_keys, axis) Python. Из-за того, как работает слияние сортировки, убедитесь, что вы понимаете порядок, в котором должны стоять sort_keys (обратный по сравнению с порядком, который вы использовали бы при сравнении двух элементов).

Если эти массивы собраны в структурированном массиве, то PyArray_Sort (...) также может использоваться для сортировки массива напрямую.

PyObject* PyArray_SearchSorted(PyArrayObject* self, PyObject* values, NPY_SEARCHSIDE side, PyObject* perm)

Эквивалентно ndarray.searchsorted (self, values, side, perm). Предполагая, что self является одномерным массивом в порядке возрастания, тогда выходной массив имеет такую же форму, что и values, и содержит индексы, такие что, если элементы в values были вставлены перед индексами, порядок self сохранился бы. Проверка на то, что self отсортирован в порядке возрастания, не выполняется.

Аргумент side указывает, должен ли возвращаемый индекс быть индексом первого подходящего местоположения (если NPY_SEARCHLEFT) или последнего (если NPY_SEARCHRIGHT).

Аргумент sorter, если не NULL, должен быть одномерным массивом целых индексов той же длины, что и self, который сортирует его в порядке возрастания. Обычно это результат вызова PyArray_ArgSort (...). Используется бинарный поиск для нахождения необходимых точек вставки.

int PyArray_Partition(PyArrayObject *self, PyArrayObject * ktharray, int axis, NPY_SELECTKIND which)

Эквивалентно ndarray.partition (self, ktharray, axis, kind). Разделяет массив так, что значения элемента, индексированного ktharray, находятся в тех позициях, где они бы находились, если бы массив был полностью отсортирован, и помещает все элементы, меньшие, чем k-й, перед, а все элементы, равные или большие, после k-го элемента. Порядок всех элементов внутри разделов не определён. Если self->descr является типом данных с определёнными полями, то self->descr->names используется для определения порядка сортировки. Сравнение, где первое поле равно, использует второе поле и так далее. Для изменения порядка сортировки структурированного массива создайте новый тип данных с другим порядком имён и постройте представление массива с этим новым типом данных. Возвращает ноль в случае успеха и -1 в случае неудачи.

PyObject* PyArray_ArgPartition(PyArrayObject *op, PyArrayObject * ktharray, int axis, NPY_SELECTKIND which)

Эквивалентно ndarray.argpartition (self, ktharray, axis, kind). Возвращает массив индексов, такой что выбор этих индексов вдоль заданной axis вернёт раздробленную версию self.

PyObject* PyArray_Diagonal(PyArrayObject* self, int offset, int axis1, int axis2)

Эквивалентно ndarray.diagonal (self, offset, axis1, axis2 ). Возвращает диагональ с смещением offset 2-мерных массивов, определённых axis1 и axis2.

npy_intp PyArray_CountNonzero(PyArrayObject* self)

Добавлено в версии 1.6.

Считает количество ненулевых элементов в массиве self.

PyObject* PyArray_Nonzero(PyArrayObject* self)

Эквивалентно ndarray.nonzero (self). Возвращает кортеж массивов индексов, которые выбирают элементы self, отличные от нуля. Если (nd= PyArray_NDIM ( self ))==1, то возвращается единственный массив индексов. Массивы индексов имеют тип данных NPY_INTP. Если возвращается кортеж (nd 1), то его длина равна nd.

PyObject* PyArray_Compress(PyArrayObject* self, PyObject* condition, int axis, PyArrayObject* out)

Эквивалентно ndarray.compress (self, condition, axis ). Возвращает элементы по оси axis, соответствующие элементам condition, которые равны true.

Вычисление

PyObject* PyArray_ArgMax(PyArrayObject* self, int axis, PyArrayObject* out)

Эквивалентно ndarray.argmax (self, axis). Возвращает индекс максимального элемента self по оси axis.

PyObject* PyArray_ArgMin(PyArrayObject* self, int axis, PyArrayObject* out)

Эквивалентно ndarray.argmin (self, axis). Возвращает индекс минимального элемента self по оси axis.

PyObject* PyArray_Max(PyArrayObject* self, int axis, PyArrayObject* out)

Эквивалентно ndarray.max (self, axis). Возвращает максимальный элемент self по заданной оси axis. Если результат — одиночный элемент, возвращается скаляр NumPy, а не массив ndarray.

PyObject* PyArray_Min(PyArrayObject* self, int axis, PyArrayObject* out)

Эквивалентно ndarray.min (self, axis). Возвращает минимальный элемент self по заданной оси axis. Если результат — одиночный элемент, возвращается скаляр NumPy, а не массив ndarray.

PyObject* PyArray_Ptp(PyArrayObject* self, int axis, PyArrayObject* out)

Эквивалентно ndarray.ptp (self, axis). Возвращает разницу между максимальным элементом self по оси axis и минимальным элементом self по оси axis. Если результат — одиночный элемент, возвращается скаляр NumPy, а не массив ndarray.

PyObject* PyArray_Mean(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

Эквивалентно ndarray.mean (self, axis, rtype). Возвращает среднее значение элементов по заданной оси axis, используя перечисленный тип rtype в качестве типа данных для суммирования. Поведение суммирования по умолчанию достигается с использованием NPY_NOTYPE для rtype.

PyObject* PyArray_Trace(PyArrayObject* self, int offset, int axis1, int axis2, int rtype, PyArrayObject* out)

Эквивалентно ndarray.trace (self, offset, axis1, axis2, rtype). Возвращает сумму (используя rtype как тип данных для суммирования) по диагональным элементам с offset смещением двумерных массивов, определяемых переменными axis1 и axis2. Положительное значение offset выбирает диагонали выше главной диагонали. Отрицательное значение offset выбирает диагонали ниже главной диагонали.

PyObject* PyArray_Clip(PyArrayObject* self, PyObject* min, PyObject* max)

Эквивалентно ndarray.clip (self, min, max). Обрезает массив self так, что значения, большие чем max, устанавливаются в max, а значения, меньшие чем min, устанавливаются в min.

PyObject* PyArray_Conjugate(PyArrayObject* self)

Эквивалентно ndarray.conjugate (self). Возвращает комплексно сопряженное значение self. Если self не имеет комплексного типа данных, возвращается self со ссылкой.

PyObject* PyArray_Round(PyArrayObject* self, int decimals, PyArrayObject* out)

Эквивалентно ndarray.round (self, decimals, out). Возвращает массив с элементами, округлёнными до ближайшего десятичного разряда. Десятичный разряд определяется цифрой, так что отрицательные значения decimals вызывают округление к ближайшим 10, 100 и т. д. Если out NULL, то выходной массив создается, в противном случае результат помещается в out, который должен иметь правильный размер и тип.

PyObject* PyArray_Std(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

Эквивалентно ndarray.std (self, axis, rtype). Возвращает стандартное отклонение, используя данные по оси axis, преобразованные к типу данных rtype.

PyObject* PyArray_Sum(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

Эквивалентно ndarray.sum (self, axis, rtype). Возвращает одномерные суммы элементов self по оси axis. Вычисляет сумму после преобразования данных к типу данных rtype.

PyObject* PyArray_CumSum(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

Эквивалентно ndarray.cumsum (self, axis, rtype). Возвращает накопительные одномерные суммы элементов self по оси axis. Вычисляет сумму после преобразования данных к типу данных rtype.

PyObject* PyArray_Prod(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

Эквивалентно ndarray.prod (self, axis, rtype). Возвращает одномерные произведения элементов self по оси axis. Вычисляет произведение после преобразования данных к типу данных rtype.

PyObject* PyArray_CumProd(PyArrayObject* self, int axis, int rtype, PyArrayObject* out)

Эквивалентно ndarray.cumprod (self, axis, rtype). Возвращает одномерные накопительные произведения элементов в self по оси axis. Вычисляет произведение после преобразования данных к типу данных rtype.

PyObject* PyArray_All(PyArrayObject* self, int axis, PyArrayObject* out)

Эквивалентно ndarray.all (self, axis). Возвращает массив с элементами True для каждого одномерного подмассива self по оси axis, где все элементы равны True.

PyObject* PyArray_Any(PyArrayObject* self, int axis, PyArrayObject* out)

Эквивалентно ndarray.any (self, axis). Возвращает массив с элементами True для каждого одномерного подмассива self по оси axis, где любой из элементов равен True.

Функции

Функции массивов

int PyArray_AsCArray(PyObject** op, void* ptr, npy_intp* dims, int nd, int typenum, int itemsize)

Иногда бывает полезно получить доступ к многомерному массиву как к многомерному массиву в стиле C, чтобы алгоритмы можно было реализовать с помощью синтаксиса a[i][j][k] языка C. Эта функция возвращает указатель ptr, который моделирует массив в стиле C для одномерных, двумерных и трехмерных массивов.

Параметры:

op – Адрес любого объекта Python. Этот объект Python будет заменён эквивалентным корректным, непрерывным в стиле C, массивом ndarray заданного типа данных, указанного в последних двух аргументах. Убедитесь, что взятие ссылки на входной объект таким способом оправдано. ptr – Адрес переменной (ctype* для 1-мерного, ctype** для 2-мерного или ctype*** для 3-мерного), где ctype — эквивалентный тип C для типа данных. После возврата ptr можно адресовать как одномерный, двумерный или трехмерный массив. dims – Массив вывода, содержащий форму объекта массива. Этот массив задаёт границы любого цикла, который будет выполнен. nd – Размерность массива (1, 2 или 3). typenum – Ожидаемый тип данных массива. itemsize – Этот аргумент необходим только тогда, когда typenum представляет собой гибкий массив. В противном случае он должен быть равен 0.

int PyArray_Free(PyObject* op, void* ptr)

Необходимо вызывать с теми же объектами и областями памяти, возвращенными из PyArray_AsCArray (...). Эта функция очищает память, которая в противном случае могла бы утечь.

PyObject* PyArray_Concatenate(PyObject* obj, int axis)

Объединяет последовательность объектов в obj вместе вдоль axis в один массив. Если размеры или типы несовместимы, возникает ошибка.

PyObject* PyArray_InnerProduct(PyObject* obj1, PyObject* obj2)

Вычисляет произведение-сумму по последним измерениям obj1 и obj2. Ни один массив не сопрягается.

PyObject* PyArray_MatrixProduct(PyObject* obj1, PyObject* obj)

Вычисляет произведение-сумму по последнему измерению obj1 и предпоследнему измерению obj2. Для двумерных массивов это матричное произведение. Ни один массив не сопрягается.

PyObject* PyArray_MatrixProduct2(PyObject* obj1, PyObject* obj, PyArrayObject* out)

Добавлена в версии 1.6.

То же, что и PyArray_MatrixProduct, но результат хранится в out. Массив вывода должен иметь правильную форму, тип и быть непрерывным в стиле C, в противном случае возникает исключение.

PyObject* PyArray_EinsteinSum(char* subscripts, npy_intp nop, PyArrayObject** op_in, PyArray_Descr* dtype, NPY_ORDER order, NPY_CASTING casting, PyArrayObject* out)

Добавлена в версии 1.6.

Применяет соглашение об эйнштейновской сумме к предоставленным массивам операндов, возвращая новый массив или помещая результат в out. Строка в subscripts представляет собой список индексных букв, разделённых запятыми. Количество операндов находится в nop, а op_in — массив, содержащий эти операнды. Тип данных результата можно принудительно задать с помощью dtype, порядок вывода можно принудительно задать с помощью order (NPY_KEEPORDER рекомендуется), и когда задан dtype, casting указывает, насколько гибким должно быть преобразование данных.

См. функцию einsum для получения более подробной информации.

PyObject* PyArray_CopyAndTranspose(PyObject * op)

Специализированная функция копирования и транспонирования, которая работает только для двумерных массивов. Возвращаемый массив является транспонированной копией op.

PyObject* PyArray_Correlate(PyObject* op1, PyObject* op2, int mode)

Вычисляет одномерную корреляцию одномерных массивов op1 и op2. Корреляция вычисляется в каждой точке вывода путём умножения op1 на сдвинутую версию op2 и суммирования результата. В результате сдвига необходимые значения за пределами заданного диапазона op1 и op2 интерпретируются как нули. Режим определяет, сколько сдвигов вернуть: 0 — вернуть только сдвиги, для которых не нужно было предполагать нулевые значения; 1 — вернуть объект такого же размера, как op1; 2 — вернуть все возможные сдвиги (принимается любое перекрытие).

Примечания

Это не вычисляет обычную корреляцию: если op2 больше op1, аргументы меняются местами, а сопряжение никогда не берётся для комплексных массивов. См. PyArray_Correlate2 для обычной корреляции обработки сигналов.

PyObject* PyArray_Correlate2(PyObject* op1, PyObject* op2, int mode)

Обновлённая версия PyArray_Correlate, которая использует обычное определение корреляции для одномерных массивов. Корреляция вычисляется в каждой точке вывода путём умножения op1 на сдвинутую версию op2 и суммирования результата. В результате сдвига необходимые значения за пределами заданного диапазона op1 и op2 интерпретируются как нули. Режим определяет, сколько сдвигов вернуть: 0 — вернуть только сдвиги, для которых не нужно было предполагать нулевые значения; 1 — вернуть объект такого же размера, как op1; 2 — вернуть все возможные сдвиги (принимается любое перекрытие).

Примечания

Вычислить z следующим образом:

z[k] = sum_n op1[n] * conj(op2[n+k])

PyObject* PyArray_Where(PyObject* condition, PyObject* x, PyObject* y)

Если и x и y являются NULL, то возвращается PyArray_Nonzero (condition). В противном случае, и x, и y должны быть заданы, и возвращаемый объект имеет форму, подобную condition, и содержит элементы x и y, где condition соответственно True или False.

Другие функции

Bool PyArray_CheckStrides(int elsize, int nd, npy_intp numbytes, npy_intp* dims, npy_intp* newstrides)

Определяет, является ли newstrides массивом смещений, совместимым с памятью nd-мерного массива с формой dims и размером элемента elsize. Массив newstrides проверяется на предмет того, будет ли перескакивание на указанное количество байтов в каждом направлении означать перескакивание более чем на numbytes, что является предполагаемым размером сегмента доступной памяти. Если numbytes равно 0, тогда вычисляется эквивалентное numbytes, предполагая, что nd, dims и elsize относятся к массиву с одним сегментом. Возвращает NPY_TRUE, если newstrides приемлемо, в противном случае возвращает NPY_FALSE.

npy_intp PyArray_MultiplyList(npy_intp* seq, int n)

int PyArray_MultiplyIntList(int* seq, int n)

Обе эти функции умножают массив целых чисел длиной n, seq, и возвращают результат. Проверка на переполнение не выполняется.

int PyArray_CompareLists(npy_intp* l1, npy_intp* l2, int n)

При заданных двух массивах целых чисел длиной n, l1 и l2, возвращает 1, если списки идентичны; в противном случае возвращает 0.

Вспомогательные данные со смыслом объекта

NpyAuxData

При работе с более сложными типами данных, состоящими из других типов данных, таких как тип данных struct, создание внутренних циклов, манипулирующих типами данных, требует передачи дополнительных данных. NumPy поддерживает эту идею через структуру NpyAuxData, навязывая несколько соглашений, чтобы это было возможно.

Определение NpyAuxData аналогично определению класса в C++, но семантика объекта должна отслеживаться вручную, поскольку API написан на C. Вот пример функции, которая удваивает элемент, используя функцию копирования элемента в качестве примитива:

typedef struct {
    NpyAuxData base;
    ElementCopier_Func *func;
    NpyAuxData *funcdata;
} eldoubler_aux_data;

void free_element_doubler_aux_data(NpyAuxData *data)
{
    eldoubler_aux_data *d = (eldoubler_aux_data *)data;
    /* Free the memory owned by this auxdata */
    NPY_AUXDATA_FREE(d->funcdata);
    PyArray_free(d);
}

NpyAuxData *clone_element_doubler_aux_data(NpyAuxData *data)
{
    eldoubler_aux_data *ret = PyArray_malloc(sizeof(eldoubler_aux_data));
    if (ret == NULL) {
        return NULL;
    }

    /* Raw copy of all data */
    memcpy(ret, data, sizeof(eldoubler_aux_data));

    /* Fix up the owned auxdata so we have our own copy */
    ret->funcdata = NPY_AUXDATA_CLONE(ret->funcdata);
    if (ret->funcdata == NULL) {
        PyArray_free(ret);
        return NULL;
    }

    return (NpyAuxData *)ret;
}

NpyAuxData *create_element_doubler_aux_data(
                            ElementCopier_Func *func,
                            NpyAuxData *funcdata)
{
    eldoubler_aux_data *ret = PyArray_malloc(sizeof(eldoubler_aux_data));
    if (ret == NULL) {
        PyErr_NoMemory();
        return NULL;
    }
    memset(&ret, 0, sizeof(eldoubler_aux_data));
    ret->base->free = &free_element_doubler_aux_data;
    ret->base->clone = &clone_element_doubler_aux_data;
    ret->func = func;
    ret->funcdata = funcdata;

    return (NpyAuxData *)ret;
}

NpyAuxData_FreeFunc

Тип указателя функции для функций освобождения NpyAuxData.

NpyAuxData_CloneFunc

Тип указателя функции для функций клонирования NpyAuxData. Эти функции никогда не должны устанавливать исключение Python при ошибке, потому что они могут вызываться из многопоточного контекста.

NPY_AUXDATA_FREE(auxdata)

Макрос, который вычисляет функцию освобождения auxdata должным образом, ничего не делает, если auxdata равен NULL.

NPY_AUXDATA_CLONE(auxdata)

Макрос, который вычисляет функцию клонирования auxdata должным образом, возвращая глубокую копию вспомогательных данных.

Итераторы массивов

Начиная с NumPy 1.6.0, эти итераторы массивов устарели, заменены новым итератором массива NpyIter.

Итератор массива — простой способ быстро и эффективно получить доступ к элементам N-мерного массива. Раздел 2 содержит более подробное описание и примеры этого полезного подхода к циклическому перебору массива.

PyObject* PyArray_IterNew(PyObject* arr)

Возвращает объект итератора массива из массива arr. Это эквивалентно arr. flat. Объект итератора массива позволяет легко циклически перебирать N-мерный несмежный массив в непрерывном стиле C.

PyObject* PyArray_IterAllButAxis(PyObject* arr, int *axis)

Возвращает итератор массива, который будет перебирать все оси, кроме указанной в *axis. Возвращённый итератор не может использоваться с PyArray_ITER_GOTO1D. Этот итератор можно использовать для написания чего-то подобного тому, что делают ufuncs, где цикл по наибольшей оси выполняется отдельной подпрограммой. Если *axis отрицательный, то *axis будет установлен на ось с наименьшим шагом, и эта ось будет использована.

PyObject *PyArray_BroadcastToShape(PyObject* arr, npy_intp *dimensions, int nd)

Возвращает итератор массива, который транслируется для итерации как массив формы, заданной dimensions и nd.

int PyArrayIter_Check(PyObject* op)

Возвращает True, если op является итератором массива (или экземпляром подкласса типа итератора массива).

void PyArray_ITER_RESET(PyObject* iterator)

Сбрасывает iterator в начало массива.

void PyArray_ITER_NEXT(PyObject* iterator)

Увеличивает индекс и члены dataptr iterator, чтобы указать на следующий элемент массива. Если массив не является (стиле C) непрерывным, также увеличивает массив N-мерных координат.

void *PyArray_ITER_DATA(PyObject* iterator)

Указатель на текущий элемент массива.

void PyArray_ITER_GOTO(PyObject* iterator, npy_intp* destination)

Устанавливает индекс iterator, члены dataptr и координаты в положение в массиве, указанное N-мерным массивом C, destination, размер которого должен быть не меньше iterator ->nd_m1+1.

PyArray_ITER_GOTO1D(PyObject* iterator, npy_intp index)

Устанавливает индекс iterator и dataptr в положение в массиве, указанное целым числом index, которое указывает на элемент в массиве, уплощённом по стилю C.

int PyArray_ITER_NOTDONE(PyObject* iterator)

Возвращает TRUE, пока итератор не пройдёт по всем элементам, иначе FALSE.

Трансляция (множественные итераторы)

PyObject* PyArray_MultiIterNew(int num, ...)

Упрощённый интерфейс трансляции. Эта функция принимает количество массивов для трансляции, а затем дополнительные аргументы num ( PyObject * ). Эти аргументы преобразуются в массивы, и создаются итераторы. Затем вызывается PyArray_Broadcast на полученном объекте многомерного итератора. Затем возвращается результирующий объект транслированного многомерного итератора. Далее можно выполнить транслированную операцию с помощью одного цикла и с помощью PyArray_MultiIter_NEXT (..)

void PyArray_MultiIter_RESET(PyObject* multi)

Сбрасывает все итераторы в начало в объекте многомерного итератора multi.

void PyArray_MultiIter_NEXT(PyObject* multi)

Переводит каждый итератор в объекте многомерного итератора multi на следующий (транслированный) элемент.

void *PyArray_MultiIter_DATA(PyObject* multi, int i)

Возвращает указатель на данные i итератора в объекте многомерного итератора.

void PyArray_MultiIter_NEXTi(PyObject* multi, int i)

Переводит указатель только i итератора.

void PyArray_MultiIter_GOTO(PyObject* multi, npy_intp* destination)

Переводит каждый итератор в объекте многомерного итератора multi в заданное -мерное destination, где — количество измерений в транслированном массиве.

void PyArray_MultiIter_GOTO1D(PyObject* multi, npy_intp index)

Переводит каждый итератор в объекте многомерного итератора multi в соответствующее положение index в уплощенном транслированном массиве.

int PyArray_MultiIter_NOTDONE(PyObject* multi)

Возвращает TRUE, пока многомерный итератор не прошёл по всем элементам (результата трансляции), иначе FALSE.

int PyArray_Broadcast(PyArrayMultiIterObject* mit)

Эта функция обобщает правила трансляции. Контейнер mit должен уже содержать итераторы для всех массивов, которые необходимо транслировать. По возвращении эти итераторы будут скорректированы так, чтобы итерация по каждому из них одновременно выполняла трансляцию. Возвращается отрицательное число, если произошла ошибка.

int PyArray_RemoveSmallest(PyArrayMultiIterObject* mit)

Эта функция принимает объект многомерного итератора, который был ранее «транслирован», находит измерение с наименьшей «суммой шагов» в транслированном результате и адаптирует все итераторы таким образом, чтобы не перебирать это измерение (эффективно делая их длиной 1 в этом измерении). Возвращает соответствующее измерение, если mit ->nd равно 0, то возвращается -1. Эта функция полезна для построения подобных ufunc процедур, которые правильно транслируют свои входные данные, а затем вызывают одномерную версию процедуры со строками как внутренний цикл. Эта одномерная версия обычно оптимизирована для скорости, и по этой причине цикл должен выполняться по оси, которая не потребует больших скачков шагов.

Итератор окрестностей

Итераторы окрестностей являются подклассами объекта итератора и могут использоваться для итерации по окружению точки. Например, вы можете перебирать каждый воксел 3D изображения, а для каждого такого воксела перебирать гиперкуб. Итератор окрестностей автоматически обрабатывает границы, что делает этот вид кода гораздо проще написать, чем ручную обработку границ, за счёт небольшого накладных расходов.

PyObject* PyArray_NeighborhoodIterNew(PyArrayIterObject* iter, npy_intp bounds, int mode, PyArrayObject* fill_value)

Эта функция создаёт новый итератор окрестностей из существующего итератора. Окрестность будет вычислена относительно позиции, в настоящее время указываемой iter, границы определяют форму итератора окрестностей, а аргумент режима — режим обработки границ.

Аргумент bounds ожидается как массив (2 * iter->ao->nd), например, диапазон bound[2*i]->bounds[2*i+1] определяет диапазон, в котором нужно пройти для измерения i (обе границы включены в пройденные координаты). Границы должны быть упорядочены для каждого измерения (bounds[2*i] <= bounds[2*i+1]).

Режим должен быть одним из:

• NPY_NEIGHBORHOOD_ITER_ZERO_PADDING: заполнение нулями. Значения вне границ будут 0.
• NPY_NEIGHBORHOOD_ITER_ONE_PADDING: заполнение единицами, Значения вне границ будут 1.
• NPY_NEIGHBORHOOD_ITER_CONSTANT_PADDING: заполнение константой. Значения вне границ будут такими же, как первый элемент в fill_value.
• NPY_NEIGHBORHOOD_ITER_MIRROR_PADDING: заполнение зеркальным отражением. Значения вне границ будут такими, как если бы элементы массива были отражены. Например, для массива [1, 2, 3, 4], x[-2] будет 2, x[-2] будет 1, x[4] будет 4, x[5] будет 1 и т. д...
• NPY_NEIGHBORHOOD_ITER_CIRCULAR_PADDING: циклическое заполнение. Значения вне границ будут такими, как если бы массив повторялся. Например, для массива [1, 2, 3, 4], x[-2] будет 3, x[-2] будет 4, x[4] будет 1, x[5] будет 2 и т. д...

Если режим — заполнение константой (NPY_NEIGHBORHOOD_ITER_CONSTANT_PADDING), fill_value должен указывать на объект массива, который содержит значение заполнения (первый элемент будет значением заполнения, если массив содержит более одного элемента). В других случаях fill_value может быть NULL.

• Итератор ссылается на iter
• Возвращает NULL при ошибке (в этом случае счётчик ссылок iter не изменяется)
• Сам iter может быть итератором окрестностей: это может быть полезно для автоматической обработки границ
• Возвращаемый объектом этой функции объект можно использовать как обычный итератор
• Если позиция iter изменена, любое последующее обращение к PyArrayNeighborhoodIter_Next имеет неопределённое поведение, и необходимо вызвать PyArrayNeighborhoodIter_Reset.

PyArrayIterObject \*iter;
PyArrayNeighborhoodIterObject \*neigh_iter;
iter = PyArray_IterNew(x);

//For a 3x3 kernel
bounds = {-1, 1, -1, 1};
neigh_iter = (PyArrayNeighborhoodIterObject*)PyArrayNeighborhoodIter_New(
     iter, bounds, NPY_NEIGHBORHOOD_ITER_ZERO_PADDING, NULL);

for(i = 0; i < iter->size; ++i) {
     for (j = 0; j < neigh_iter->size; ++j) {
             // Walk around the item currently pointed by iter->dataptr
             PyArrayNeighborhoodIter_Next(neigh_iter);
     }

     // Move to the next point of iter
     PyArrayIter_Next(iter);
     PyArrayNeighborhoodIter_Reset(neigh_iter);
}

int PyArrayNeighborhoodIter_Reset(PyArrayNeighborhoodIterObject* iter)

Сбрасывает позицию итератора в первую точку окрестности. Это следует делать всякий раз, когда изменяется аргумент iter, предоставленный в PyArray_NeighborhoodIterObject (см. пример)

int PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject* iter)

После этого вызова iter->dataptr указывает на следующую точку окрестности. Вызов этой функции после посещения каждой точки окрестности неопределён.

Массивы-скаляры

PyObject* PyArray_Return(PyArrayObject* arr)

Эта функция захватывает ссылку на arr.

Эта функция проверяет, является ли arr массивом размерности 0, и, если да, возвращает соответствующий скаляр массива. Она должна использоваться всякий раз, когда могут возвращаться массивы размерности 0.

PyObject* PyArray_Scalar(void* data, PyArray_Descr* dtype, PyObject* itemsize)

Возвращает объект скаляра массива заданного перечисленного typenum и itemsize, копируя из памяти, указанной data. Если swap ненулевое, эта функция переупорядочит байты, если это необходимо для типа данных, поскольку массивы-скаляры всегда имеют правильный порядок байтов машины.

PyObject* PyArray_ToScalar(void* data, PyArrayObject* arr)

Возвращает объект массива-скаляра типа и размера элемента, указанных объектом массива arr, скопированный из памяти, указанной data, и с перестановкой байтов, если данные в arr не находятся в порядке байтов машины.

PyObject* PyArray_FromScalar(PyObject* scalar, PyArray_Descr* outcode)

Возвращает массив размерности 0 типа, определяемого outcode из scalar, который должен быть объектом массива-скаляра. Если outcode равен NULL, то тип определяется из scalar.

void PyArray_ScalarAsCtype(PyObject* scalar, void* ctypeptr)

Возвращает в ctypeptr указатель на фактическое значение в скаляре массива. Проверка ошибок не выполняется, поэтому scalar должен быть объектом скаляра массива, а ctypeptr должен иметь достаточно места для хранения правильного типа. Для типов с гибким размером указатель на данные копируется в память ctypeptr, для всех остальных типов фактические данные копируются в адрес, на который указывает ctypeptr.

void PyArray_CastScalarToCtype(PyObject* scalar, void* ctypeptr, PyArray_Descr* outcode)

Возвращает данные (преобразованные к типу данных, указанному outcode) из скаляра массива scalar в память, указанную ctypeptr (которая должна быть достаточно большой для обработки входящих данных).

PyObject* PyArray_TypeObjectFromType(int type)

Возвращает объект скалярного типа по номеру типа type. Эквивалентно PyArray_DescrFromType (type)->typeobj, за исключением учета ссылок и проверки ошибок. Возвращает новую ссылку на объект typeobject при успехе или NULL при неудаче.

NPY_SCALARKIND PyArray_ScalarKind(int typenum, PyArrayObject** arr)

Обратитесь к функции PyArray_MinScalarType для альтернативного механизма, введенного в NumPy 1.6.0.

Возвращает тип скаляра, представленного typenum и массивом в *arr (если arr не NULL). Массив предполагается ранга 0 и используется только в том случае, если typenum представляет целое число со знаком. Если arr не NULL и первый элемент отрицательный, то возвращается NPY_INTNEG_SCALAR, в противном случае — NPY_INTPOS_SCALAR. Возможные возвращаемые значения — NPY_{kind}_SCALAR, где {kind} может быть INTPOS, INTNEG, FLOAT, COMPLEX, BOOL или OBJECT. NPY_NOSCALAR также является перечислимым значением NPY_SCALARKIND переменные могут принимать.

int PyArray_CanCoerceScalar(char thistype, char neededtype, NPY_SCALARKIND scalar)

См. функцию PyArray_ResultType для подробностей о продвижении типов NumPy, обновленных в NumPy 1.6.0.

Реализует правила приведения скаляров. Скаляры неявно приводятся от thistype к neededtype только если эта функция возвращает ненулевое значение. Если скаляр NPY_NOSCALAR, то эта функция эквивалентна PyArray_CanCastSafely. Правило заключается в том, что скаляры одного вида могут быть приведены к массивам того же вида. Это означает, что скаляры высокой точности никогда не приведут к повышению точности массивов того же вида.

Описатели типов данных

int PyArray_DescrCheck(PyObject* obj)

Возвращает true, если obj является объектом типа данных ( PyArray_Descr *).

PyArray_Descr* PyArray_DescrNew(PyArray_Descr* obj)

Возвращает новый объект типа данных, скопированный из obj (ссылки на поля просто обновляются, так что новый объект указывает на тот же словарь полей, если таковой имеется).

PyArray_Descr* PyArray_DescrNewFromType(int typenum)

Создает новый объект типа данных из встроенного (или зарегистрированного пользователем) типа данных, указанного typenum. Все встроенные типы не должны иметь измененных полей. Это создает новую копию структуры PyArray_Descr, чтобы вы могли заполнить ее соответствующим образом. Эта функция особенно необходима для гибких типов данных, которым нужен новый член elsize, чтобы иметь смысл при построении массивов.

PyArray_Descr* PyArray_DescrNewByteorder(PyArray_Descr* obj, char newendian)

Создает новый объект типа данных с порядком байтов, установленным в соответствии с newendian. Все ссылки на объекты типа данных (в членах поддескриптора и полей объекта типа данных) также изменяются (рекурсивно). Если встречается порядок байтов NPY_IGNORE, он остается без изменений. Если newendian равен NPY_SWAP, то все порядки байтов меняются местами. Другие допустимые значения newendian — NPY_NATIVE, NPY_LITTLE и NPY_BIG, которые все заставляют возвращаемый описатель типа данных (и все его ссылки на описатели типа данных) иметь соответствующий порядок байтов.

PyArray_Descr* PyArray_DescrFromObject(PyObject* op, PyArray_Descr* mintype)

Определяет подходящий объект типа данных из объекта op (который должен быть объектом «вложенной» последовательности) и минимальным описателем типа данных mintype (который может быть NULL). Похож по поведению на array(op).dtype. Не путайте эту функцию с PyArray_DescrConverter. Эта функция по сути просматривает все объекты в (вложенной) последовательности и определяет тип данных по элементам, которые она находит.

PyArray_Descr* PyArray_DescrFromScalar(PyObject* scalar)

Возвращает объект типа данных из объекта скаляра массива. Проверка того, что scalar является скаляром массива, не выполняется. Если подходящий тип данных определить невозможно, по умолчанию возвращается тип данных NPY_OBJECT.

PyArray_Descr* PyArray_DescrFromType(int typenum)

Возвращает объект типа данных, соответствующий typenum. typenum может быть одним из перечислимых типов, кодом символа для одного из перечислимых типов или пользовательским типом.

int PyArray_DescrConverter(PyObject* obj, PyArray_Descr** dtype)

Преобразует любой совместимый объект Python obj в объект типа данных dtype. Большое количество объектов Python можно преобразовать в объекты типа данных. См. Объекты типов данных (dtype) для полного описания. Эта версия преобразователя преобразует объекты None в объект типа данных NPY_DEFAULT_TYPE. Эта функция может использоваться с символом «O&» в обработке PyArg_ParseTuple.

int PyArray_DescrConverter2(PyObject* obj, PyArray_Descr** dtype)

Преобразует любой совместимый объект Python obj в объект типа данных dtype. Эта версия преобразователя преобразует объекты None таким образом, что возвращаемый тип данных равен NULL. Эта функция также может использоваться с символом «O&» в обработке PyArg_ParseTuple.

int Pyarray_DescrAlignConverter(PyObject* obj, PyArray_Descr** dtype)

Подобно PyArray_DescrConverter, за исключением того, что она выравнивает объекты типа C-структур по границам слов так же, как это делает компилятор.

int Pyarray_DescrAlignConverter2(PyObject* obj, PyArray_Descr** dtype)

Подобно PyArray_DescrConverter2, за исключением того, что она выравнивает объекты типа C-структур по границам слов так же, как это делает компилятор.

PyObject *PyArray_FieldNames(PyObject* dict)

Из словаря полей dict, например, прикрепленного к объекту типа данных, создается упорядоченный список имён полей, аналогичный тому, который хранится в поле names объекта PyArray_Descr.

Утилиты преобразования

Для использования с PyArg_ParseTuple

Все эти функции могут использоваться в PyArg_ParseTuple (...) с форматом спецификатора «O&», чтобы автоматически преобразовать любой объект Python в необходимый объект C. Все эти функции возвращают NPY_SUCCEED при успехе и NPY_FAIL при неудаче. Первый аргумент всех этих функций — объект Python. Второй аргумент — **адрес** типа C, в который преобразуется объект Python.

int PyArray_Converter(PyObject* obj, PyObject** address)

Преобразует любой объект Python в PyArrayObject. Если PyArray_Check (obj) равно TRUE, то увеличивается счетчик ссылок, и ссылка помещается в address. Если obj не массив, то преобразуйте его в массив с помощью PyArray_FromAny. В любом случае вы должны DECREF объекта, возвращаемого этой процедурой в address, когда закончите с ним.

int PyArray_OutputConverter(PyObject* obj, PyArrayObject** address)

Это по умолчанию преобразователь выходных массивов, передаваемых функциям. Если obj равен Py_None или NULL, то *address будет NULL, но вызов будет успешным. Если PyArray_Check (obj) истинно, то оно будет возвращено в *address без увеличения счетчика ссылок.

int PyArray_IntpConverter(PyObject* obj, PyArray_Dims* seq)

Преобразует любую последовательность Python, obj, меньшую чем NPY_MAXDIMS, в массив C целых чисел npy_intp. Объект Python также может быть единственным числом. Переменная seq — указатель на структуру с членами ptr и len. При успешном возврате seq ->ptr содержит указатель на память, которую необходимо освободить, чтобы избежать утечки памяти. Ограничение размера памяти позволяет удобно использовать этот преобразователь для последовательностей, предназначенных для интерпретации как форм массива.

int PyArray_BufferConverter(PyObject* obj, PyArray_Chunk* buf)

Преобразует любой объект Python, obj, с интерфейсом буфера (единственный сегмент) в переменную с членами, которые подробно описывают использование объектом фрагмента памяти. Переменная buf — указатель на структуру с членами base, ptr, len и flags. Структура PyArray_Chunk совместима с объектом буфера Python (через член len на 32-разрядных платформах и член ptr на 64-разрядных платформах или в Python 2.5). При возврате член base устанавливается в obj (или в base, если obj уже является объектом буфера, указывающим на другой объект). Если вам нужно удержать память, убедитесь, что вы увеличили счетчик ссылок base. Фрагмент памяти указан членом buf ->ptr и имеет длину buf ->len. Член flags переменной buf равен NPY_BEHAVED_RO с установленным флагом NPY_ARRAY_WRITEABLE, если obj имеет интерфейс записи буфера.

int PyArray_AxisConverter(PyObject * obj, int* axis)

Преобразует объект Python, obj, представляющий аргумент оси, в соответствующее значение для передачи функциям, принимающим целочисленную ось. В частности, если obj равно None, axis устанавливается в NPY_MAXDIMS, что правильно интерпретируется функциями C-API, принимающими аргументы оси.

int PyArray_BoolConverter(PyObject* obj, Bool* value)

Преобразует любой объект Python, obj, в NPY_TRUE или NPY_FALSE и помещает результат в value.

int PyArray_ByteorderConverter(PyObject* obj, char* endian)

Преобразует строки Python в соответствующий символ порядка байтов: ‘>’, ‘<’, ‘s’, ‘=’, или ‘|’.

int PyArray_SortkindConverter(PyObject* obj, NPY_SORTKIND* sort)

Преобразует строки Python в один из NPY_QUICKSORT (начинается с ‘q’ или ‘Q’), NPY_HEAPSORT (начинается с ‘h’ или ‘H’), или NPY_MERGESORT (начинается с ‘m’ или ‘M’).

int PyArray_SearchsideConverter(PyObject* obj, NPY_SEARCHSIDE* side)

Преобразует строки Python в один из NPY_SEARCHLEFT (начинается с ‘l’ или ‘L’), или NPY_SEARCHRIGHT (начинается с ‘r’ или ‘R’).

int PyArray_OrderConverter(PyObject* obj, NPY_ORDER* order)

Преобразует строки Python ‘C’, ‘F’, ‘A’, и ‘K’ в перечисление NPY_ORDER NPY_CORDER, NPY_FORTRANORDER, NPY_ANYORDER и NPY_KEEPORDER.

int PyArray_CastingConverter(PyObject* obj, NPY_CASTING* casting)

Преобразует строки Python ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, и ‘unsafe’ в перечисление NPY_CASTING NPY_NO_CASTING, NPY_EQUIV_CASTING, NPY_SAFE_CASTING, NPY_SAME_KIND_CASTING и NPY_UNSAFE_CASTING.

int PyArray_ClipmodeConverter(PyObject* object, NPY_CLIPMODE* val)

Преобразует строки Python ‘clip’, ‘wrap’, и ‘raise’ в перечисление NPY_CLIPMODE NPY_CLIP, NPY_WRAP и NPY_RAISE.

int PyArray_ConvertClipmodeSequence(PyObject* object, NPY_CLIPMODE* modes, int n)

Преобразует последовательность режимов обрезки или один режим обрезки в массив C значений NPY_CLIPMODE. Количество режимов обрезки n должно быть известно до вызова этой функции. Эта функция предоставляется для поддержки функций, позволяющих использовать различные режимы обрезки для каждого измерения.

Другие преобразования

int PyArray_PyIntAsInt(PyObject* op)

Преобразует все типы объектов Python (включая массивы и скаляры массивов) в стандартное целое число. При ошибке возвращается -1 и устанавливается исключение. Вам может пригодиться макрос:

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

npy_intp PyArray_PyIntAsIntp(PyObject* op)

Преобразует все типы объектов Python (включая массивы и скаляры массивов) в целое число размера указателя платформы. При ошибке возвращается -1 и устанавливается исключение.

int PyArray_IntpFromSequence(PyObject* seq, npy_intp* vals, int maxvals)

Преобразует любую последовательность Python (или одно число Python), переданную как seq, в целые числа размера указателя (до maxvals) и помещает их в массив vals. Последовательность может быть меньше, чем maxvals, так как количество преобразованных объектов возвращается.

int PyArray_TypestrConvert(int itemsize, int gentype)

Преобразует символы типа строки (с itemsize) в базовые перечисленные типы данных. Признаются и преобразуются символы типа строки, соответствующие целым числам со знаком и без знака, числам с плавающей точкой и числам с плавающей точкой комплексного типа. Другие значения gentype возвращаются. Эту функцию можно использовать для преобразования, например, строки ‘f4’ в NPY_FLOAT32.

Разное

Импорт API

Для использования C-API из другого модуля расширения необходимо использовать команду import_array (). Если модуль расширения полностью содержится в одном файле .c, то этого достаточно. Однако если модуль расширения включает несколько файлов, где необходим C-API, то необходимо выполнить некоторые дополнительные шаги.

void import_array(void)

Эта функция должна вызываться в секции инициализации модуля, который будет использовать C-API. Она импортирует модуль, где хранится таблица указателей на функции, и указывает правильную переменную на неё.

PY_ARRAY_UNIQUE_SYMBOL

NO_IMPORT_ARRAY

Используя эти #определения, вы можете использовать C-API в нескольких файлах для одного модуля расширения. В каждом файле вы должны определить PY_ARRAY_UNIQUE_SYMBOL некоторым именем, которое будет содержать C-API (например myextension_ARRAY_API). Это должно быть сделано до включения файла numpy/arrayobject.h. В процедуре инициализации модуля вы вызываете import_array (). Кроме того, в файлах, не содержащих подпрограмму инициализации модуля, необходимо определить NO_IMPORT_ARRAY перед включением numpy/arrayobject.h.

Предположим, у меня есть два файла coolmodule.c и coolhelper.c, которые необходимо скомпилировать и связать в один модуль расширения. Предположим, что coolmodule.c содержит необходимую функцию инициализации модуля initcool (с вызовом функции import_array()). Тогда в coolmodule.c вверху будет:

#define PY_ARRAY_UNIQUE_SYMBOL cool_ARRAY_API
#include numpy/arrayobject.h

С другой стороны, coolhelper.c вверху будет содержать:

#define NO_IMPORT_ARRAY
#define PY_ARRAY_UNIQUE_SYMBOL cool_ARRAY_API
#include numpy/arrayobject.h

Вы также можете поместить две последние строки в файл заголовков модуля расширения, если убедитесь, что NO_IMPORT_ARRAY определен перед включением этого файла.

Проверка версии API

Поскольку модули расширения Python используются не так, как обычные библиотеки на большинстве платформ, некоторые ошибки не могут быть автоматически обнаружены во время компиляции или даже во время выполнения. Например, если вы создаете расширение с использованием функции, доступной только для numpy >= 1.3.0, и позже импортируете расширение с numpy 1.2, вы не получите ошибку импорта (но почти наверняка получите ошибку сегментации при вызове функции). Вот почему предоставляются несколько функций для проверки версий numpy. Макросы NPY_VERSION и NPY_FEATURE_VERSION соответствуют версии numpy, используемой для построения расширения, в то время как версии, возвращаемые функциями PyArray_GetNDArrayCVersion и PyArray_GetNDArrayCFeatureVersion, соответствуют версии numpy во время выполнения.

Правила совместимости ABI и API можно обобщить следующим образом:

• Всякий раз, когда NPY_VERSION != PyArray_GetNDArrayCVersion, расширение необходимо перекомпилировать (несовместимость ABI).
• NPY_VERSION == PyArray_GetNDArrayCVersion и NPY_FEATURE_VERSION <= PyArray_GetNDArrayCFeatureVersion означает обратную совместимость изменений.

Несовместимость ABI автоматически определяется в каждой версии numpy. Обнаружение несовместимости API было добавлено в numpy 1.4.0. Если вы хотите поддерживать множество различных версий numpy с одним двоичным файлом расширения, необходимо скомпилировать ваше расширение с минимально возможным значением NPY_FEATURE_VERSION.

unsigned int PyArray_GetNDArrayCVersion(void)

Эта функция просто возвращает значение NPY_VERSION. NPY_VERSION изменяется всякий раз, когда происходит необратная совместимость на уровне ABI. Однако, поскольку она находится в C-API, сравнение результата этой функции со значением, определённым в текущем заголовке, позволяет проверить, изменился ли C-API, что требует перекомпиляции модулей расширения, использующих C-API. Это автоматически проверяется в функции import_array.

unsigned int PyArray_GetNDArrayCFeatureVersion(void)

Добавлена в версии 1.4.0.

Эта функция просто возвращает значение NPY_FEATURE_VERSION. NPY_FEATURE_VERSION изменяется всякий раз, когда изменяется API (например, добавлена функция). Изменённое значение не всегда требует перекомпиляции.

Внутренняя гибкость

int PyArray_SetNumericOps(PyObject* dict)

NumPy хранит внутреннюю таблицу Python-вызываемых объектов, которые используются для реализации арифметических операций для массивов, а также некоторых методов вычисления массивов. Эта функция позволяет пользователю заменить все или некоторые из этих Python-объектов своими версиями. Ключи словаря dict — это имена функций для замены, а соответствующее значение — Python-вызываемый объект для использования. Следует быть осторожным, чтобы функция, используемая для замены внутренней операции над массивом, сама не вызывала эту внутреннюю операцию над массивом (если вы не разработали функцию для обработки этого), иначе может возникнуть неопределённая рекурсия (возможно, приведшая к сбою программы). Имена ключей, представляющие операции, которые можно заменить:

add, subtract, multiply, divide, remainder, power, square, reciprocal, ones_like, sqrt, negative, positive, absolute, invert, left_shift, right_shift, bitwise_and, bitwise_xor, bitwise_or, less, less_equal, equal, not_equal, greater, greater_equal, floor_divide, true_divide, logical_or, logical_and, floor, ceil, maximum, minimum, rint.

Эти функции включены сюда, потому что они используются по крайней мере один раз в методах объекта массива. Функция возвращает -1 (без установки Python Error), если один из присваиваемых объектов не является вызываемым.

PyObject* PyArray_GetNumericOps(void)

Возвращает Python-словарь, содержащий вызываемые Python-объекты, хранящиеся во внутренней таблице арифметических операций. Ключи этого словаря указаны в объяснении для PyArray_SetNumericOps.

void PyArray_SetStringFunction(PyObject* op, int repr)

Эта функция позволяет изменить методы tp_str и tp_repr объекта массива на любую Python-функцию. Таким образом, вы можете изменить поведение всех массивов при вызове str(arr) или repr(arr) из Python. Функция, которая должна быть вызвана, передаётся как op. Если repr отлично от нуля, эта функция будет вызвана в ответ на repr(arr), иначе — в ответ на str(arr). Проверка на то, является ли op вызываемой, не выполняется. Переданный в op вызываемый объект должен ожидать аргумент массива и должен возвращать строку для печати.

Управление памятью

char* PyDataMem_NEW(size_t nbytes)

PyDataMem_FREE(char* ptr)

char* PyDataMem_RENEW(void * ptr, size_t newbytes)

Макросы для выделения, освобождения и перераспределения памяти. Эти макросы используются во внутренней работе для создания массивов.

npy_intp* PyDimMem_NEW(nd)

PyDimMem_FREE(npy_intp* ptr)

npy_intp* PyDimMem_RENEW(npy_intp* ptr, npy_intp newnd)

Макросы для выделения, освобождения и перераспределения памяти для размеров и шагов.

PyArray_malloc(nbytes)

PyArray_free(ptr)

PyArray_realloc(ptr, nbytes)

Эти макросы используют различные менеджеры памяти в зависимости от константы NPY_USE_PYMEM. Системный malloc используется, когда NPY_USE_PYMEM равно 0, если NPY_USE_PYMEM равно 1, тогда используется менеджер памяти Python.

Поддержка потоков

Эти макросы имеют смысл только если NPY_ALLOW_THREADS имеет значение True во время компиляции модуля расширения. В противном случае эти макросы эквивалентны пробелу. Python использует единый глобальный интерпретаторский замок (GIL) для каждого процесса Python, поэтому только один поток может выполняться за раз (даже на многоядерных машинах). При вызове компилированной функции, которая может занимать много времени для вычисления (и не имеет побочных эффектов для других потоков, таких как обновление глобальных переменных), GIL следует освободить, чтобы другие потоки Python могли выполняться, пока выполняются трудоёмкие вычисления. Это можно сделать, используя две группы макросов. Как правило, если в блоке кода используется один макрос из группы, все макросы из этой группы должны использоваться в этом же блоке кода. В настоящее время NPY_ALLOW_THREADS определён как константа python-defined WITH_THREADS, если переменная окружения NPY_NOSMP не установлена, в противном случае NPY_ALLOW_THREADS определён как 0.

Группа 1

Эта группа используется для вызова кода, который может занимать некоторое время, но не использует вызовы Python C-API. Таким образом, во время его вычисления следует освободить GIL.

NPY_BEGIN_ALLOW_THREADS

Эквивалентно Py_BEGIN_ALLOW_THREADS, за исключением того, что для определения того, заменит ли макрос пробел или нет, используется NPY_ALLOW_THREADS.

NPY_END_ALLOW_THREADS

Эквивалентно Py_END_ALLOW_THREADS, за исключением того, что для определения того, заменит ли макрос пробел или нет, используется NPY_ALLOW_THREADS.

NPY_BEGIN_THREADS_DEF

Разместите в области объявления переменных. Этот макрос настраивает переменную, необходимую для хранения состояния Python.

NPY_BEGIN_THREADS

Разместите непосредственно перед кодом, который не нуждается в интерпретаторе Python (нет вызовов Python C-API). Этот макрос сохраняет состояние Python и освобождает GIL.

NPY_END_THREADS

Разместите непосредственно после кода, который не нуждается в интерпретаторе Python. Этот макрос приобретает GIL и восстанавливает состояние Python из сохранённой переменной.

NPY_BEGIN_THREADS_DESCR(PyArray_Descr *dtype)

Полезно для освобождения GIL только в том случае, если dtype не содержит произвольных Python-объектов, которые могут потребовать интерпретатора Python во время выполнения цикла. Эквивалентно

NPY_END_THREADS_DESCR(PyArray_Descr *dtype)

Полезно для восстановления GIL в ситуациях, когда он был освобождён с помощью формы BEGIN этого макроса.

NPY_BEGIN_THREADS_THRESHOLDED(int loop_size)

Полезно для освобождения GIL только в том случае, если loop_size превышает минимальный порог, в настоящее время установленный в 500. Должен быть согласован с NPY_END_THREADS для восстановления GIL.

Группа 2

Эта группа используется для повторного получения Python GIL после его освобождения. Например, предположим, что GIL был освобождён (с помощью предыдущих вызовов), и затем какой-то путь в коде (возможно, в другой подпрограмме) требует использования Python C-API, тогда эти макросы полезны для получения GIL. Эти макросы выполняют по существу обратное действие для предыдущих трёх (приобретение LOCK, сохраняя его состояние) и затем повторное освобождение его с сохранённым состоянием.

NPY_ALLOW_C_API_DEF

Разместите в области объявления переменных, чтобы настроить необходимую переменную.

NPY_ALLOW_C_API

Разместите перед кодом, который нуждается в вызове Python C-API (когда известно, что GIL уже освобождён).

NPY_DISABLE_C_API

Разместите после кода, который нуждается в вызове Python C-API (чтобы повторно освободить GIL).

Приоритет

NPY_PRIORITY

Приоритет по умолчанию для массивов.

NPY_SUBTYPE_PRIORITY

Приоритет по умолчанию для подтипов.

NPY_SCALAR_PRIORITY

Приоритет по умолчанию для скаляров (очень малый)

double PyArray_GetPriority(PyObject* obj, double def)

Возвращает атрибут __array_priority__ (преобразованный в двойное значение) объекта obj или def, если атрибут с таким именем не существует. Быстрое возвращение, которое избегает поиска атрибута, предоставляется для объектов типа PyArray_Type.

Буферы по умолчанию

NPY_BUFSIZE

Размер буферов по умолчанию, задаваемых пользователем.

NPY_MIN_BUFSIZE

Минимальный размер буферов, задаваемых пользователем.

NPY_MAX_BUFSIZE

Максимальный размер разрешенных буферов, задаваемых пользователем.

Другие константы

NPY_NUM_FLOATTYPE

Количество типов с плавающей запятой

NPY_MAXDIMS

Максимальное количество измерений, разрешенных в массивах.

NPY_VERSION

Текущая версия объекта ndarray (проверьте, определена ли эта переменная, чтобы убедиться, что используется заголовок numpy/arrayobject.h).

NPY_FALSE

Определено как 0 для использования с Bool.

NPY_TRUE

Определено как 1 для использования с Bool.

NPY_FAIL

Значение возврата функций-конвертеров, которые вызываются с синтаксисом “O&” в функциях типа PyArg_ParseTuple.

NPY_SUCCEED

Значение возврата успешных функций-конвертеров, которые вызываются с синтаксисом “O&” в функциях типа PyArg_ParseTuple.

Разные макросы

PyArray_SAMESHAPE(a1, a2)

Принимает значение True, если массивы a1 и a2 имеют одинаковую форму.

PyArray_MAX(a, b)

Возвращает максимальное значение из a и b. Если (a) или (b) являются выражениями, они вычисляются дважды.

PyArray_MIN(a, b)

Возвращает минимальное значение из a и b. Если (a) или (b) являются выражениями, они вычисляются дважды.

PyArray_CLT(a, b)

PyArray_CGT(a, b)

PyArray_CLE(a, b)

PyArray_CGE(a, b)

PyArray_CEQ(a, b)

PyArray_CNE(a, b)

Реализует комплексные сравнения между двумя комплексными числами (структурами с членами real и imag) с использованием определения NumPy порядка, которое является лексикографическим: сравниваются вещественные части сначала, а затем комплексные части, если вещественные части равны.

PyArray_REFCOUNT(PyObject* op)

Возвращает счетчик ссылок любого объекта Python.

PyArray_XDECREF_ERR(PyObject *obj)

Уменьшает счетчик ссылок на объект массива, который может иметь установленный флаг NPY_ARRAY_UPDATEIFCOPY, без копирования содержимого обратно в исходный массив. Сбрасывает флаг NPY_ARRAY_WRITEABLE в базовом объекте. Это полезно для восстановления из состояния ошибки, когда используется NPY_ARRAY_UPDATEIFCOPY.

Перечисления

NPY_SORTKIND

Специальный тип переменной, который может принимать значения NPY_{KIND} где {KIND} это

QUICKSORT, HEAPSORT, MERGESORT

NPY_NSORTS

Определено как количество видов сортировки.

NPY_SCALARKIND

Специальный тип переменной, указывающий количество «видов» скаляров, учитываемых при определении правил преобразования скаляров. Эта переменная может принимать значения NPY_{KIND} где {KIND} может быть

NOSCALAR, BOOL_SCALAR, INTPOS_SCALAR, INTNEG_SCALAR, FLOAT_SCALAR, COMPLEX_SCALAR, OBJECT_SCALAR

NPY_NSCALARKINDS

Определено как количество видов скаляров (без учета NPY_NOSCALAR).

NPY_ORDER

Тип перечисления, указывающий порядок элементов, в котором должен интерпретироваться массив. При создании нового массива обычно используются только NPY_CORDER и NPY_FORTRANORDER, а при наличии одного или нескольких входных данных порядок может основываться на них.

NPY_ANYORDER

Порядок Fortran, если все входные данные имеют порядок Fortran, иначе C.

NPY_CORDER

Порядок C.

NPY_FORTRANORDER

Порядок Fortran.

NPY_KEEPORDER

Порядок, максимально приближенный к порядку входных данных, даже если входные данные не имеют порядка C или Fortran.

NPY_CLIPMODE

Тип переменной, указывающий вид обрезки, который должен применяться в некоторых функциях.

NPY_RAISE

Значение по умолчанию для большинства операций, генерирует исключение, если индекс находится вне границ.

NPY_CLIP

Обрезает индекс до допустимого диапазона, если он находится вне границ.

NPY_WRAP

Оборачивает индекс до допустимого диапазона, если он находится вне границ.

NPY_CASTING

New in version 1.6.

Тип перечисления, указывающий, насколько разрешительными должны быть преобразования данных. Это используется итератором, добавленным в NumPy 1.6, и предназначено для более широкого использования в будущей версии.

NPY_NO_CASTING

Разрешить только идентичные типы.

NPY_EQUIV_CASTING

Разрешить идентичные типы и преобразования, включающие перестановку байтов.

NPY_SAFE_CASTING

Разрешить только преобразования, которые не приведут к округлениям, усечениям или другим изменениям значений.

NPY_SAME_KIND_CASTING

Разрешить любые безопасные преобразования и преобразования между типами одного и того же вида. Например, float64 -> float32 разрешено с этим правилом.

NPY_UNSAFE_CASTING

Разрешить любые преобразования, независимо от того, какой вид потери данных может произойти.