Интерфейс массивов (Array 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, используемый для согласованности с использованием «формы» в 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)

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

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

Если установлен флаг NPY_ARRAY_UPDATEIFCOPY, у него другое значение, а именно, base — это массив, в который будет скопирован текущий массив при уничтожении. Это перегрузка свойства base для двух функций, вероятно, изменится в будущих версиях 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 может быть отличным от нуля, чтобы указать на массив с непрерывностью по стилю Fortran. Если 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. Эта функция не может использоваться для создания массива с гибким типом (нет заданного itemsize).

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)

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

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

Создаёт новый одномерный массив типа, определяемого 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 так, что каждый массив указывает на владельца памяти напрямую. После установки базового значения его нельзя изменить на другое значение.

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

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 отсутствует FORCECAST, этот вызов сгенерирует ошибку, если тип данных нельзя безопасно получить из объекта. Если вы хотите использовать NULL для dtype и гарантировать, что массив не переставлен, используйте PyArray_CheckFromAny. Значение 0 для любого из параметров глубины приводит к игнорированию параметра. Любые из следующих флагов массива могут быть добавлены (например, с использованием |), чтобы получить аргумент requirements. Если ваш код может обрабатывать общие (например, с шагом, с переставленными байтами или невыровненные массивы), то requirements может быть 0. Кроме того, если op не является массивом (или не предоставляет интерфейс массива), то будет создан новый массив (и заполнен из op с использованием протокола последовательности). Новый массив будет иметь NPY_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. Эта ссылка не захватывается. Также, если запрашиваемый тип данных не изменяет интерпретацию входных данных, out_dtype все равно получит «врождённый» тип данных объекта, а не тип данных, переданный в ‘requested_dtype’.

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

При возвращении успеха (0 в качестве возвращаемого значения), либо out_arr заполняется ненулевым 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 (...) за исключением того, что requirements может содержать 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 (включая порядок байтов) или имеет определённые requirements.

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_DEFAULT, и членом type_num аргумента типа, установленным на typenum.

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

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

PyObject* PyArray_EnsureArray(PyObject* op)

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

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 отрицательно, он будет определён из размера буфера и запрошенного размера элемента, в противном случае 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_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)

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

PyArray_CheckExact(op)

Возвращает true, если 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)

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

PyArray_IsScalar(op, cls)

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

PyArray_CheckScalar(op)

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

PyArray_IsPythonNumber(op)

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

PyArray_IsPythonScalar(op)

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

PyArray_IsAnyScalar(op)

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

PyArray_CheckAnyScalar(op)

Возвращает true, если 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)

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

PyArray_ISBYTESWAPPED(m)

Возвращает true, если область данных 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 ) равны или эквивалентны по своему определению родного порядка байтов. Таким образом, на машине с малым порядком байтов NPY_LITTLE и NPY_NATIVE эквивалентны, в то время как на машине с большим порядком байтов они не эквивалентны.

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

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-битные числа с плавающей точкой, даже если это может привести к потере точности для больших целых чисел, чтобы не распространять использование long double без явных запросов. Гибкие типы массивов не проверяются по их длинам с помощью этой функции.

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 для комбинирования скаляров и массивов, чтобы определить выходной тип набора операндов. Это тот же тип результата, который производят ufuncs. Конкретный алгоритм, используемый, следующий.

Категории определяются путем проверки, является ли булевая, целочисленная (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 представляет собой объект, который будет преобразован в массив. Возвращаемое значение — это перечисленное значение typenumber, которое представляет тип данных, которым должен обладать 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), и все массивы в нём должны быть освобождены ‘d, иначе произойдёт утечка памяти. Пример использования приведен в нижеследующем шаблоне кода:

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 сам имеет поля с типами данных, содержащими объекты, все поля объектов будут уменьшать счётчик ссылок '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. Флаги массивов используются для указания того, что можно сказать о данных, связанных с массивом.

В версиях 1.6 и более ранних версий NumPy, в именах констант отсутствовал префикс _ARRAY_. Эта форма имён констант устарела в версии 1.7.

NPY_ARRAY_C_CONTIGUOUS

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

NPY_ARRAY_F_CONTIGUOUS

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

NPY_ARRAY_OWNDATA

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

NPY_ARRAY_ALIGNED

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

NPY_ARRAY_WRITEABLE

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

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

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 , который может быть любым из 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 плюс размер элемента нового типа массива должны быть меньше 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 print, показывающая, как элементы должны быть записаны.

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-строку и возвращает её. Используется предоставленный протокол 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. В настоящее время он не оказывает влияния. В конечном итоге он может использоваться для определения того, как операция изменения размера должна интерпретировать данные при построении массива с другой размерностью.

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)

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

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 и так далее. Это эквивалентно команде Python lexsort(sort_keys, axis). Из-за того, как работает сортировка слиянием, убедитесь, что вы понимаете порядок, в котором должны находиться 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-й, перед ним, а все элементы, равные или большие, — после. Порядок всех элементов внутри разделов не определён. Если 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 двумерных массивов, определяемых 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, которые истинны.

Вычисление

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.

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

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

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

Эквивалентно ndarray.ptp (self, axis). Возвращает разницу между наибольшим элементом self вдоль axis и наименьшим элементом self вдоль axis.

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 для 2-мерных массивов, определяемых переменными axis1 и axis2. Положительное смещение выбирает диагонали выше главной диагонали. Отрицательное смещение выбирает диагонали ниже главной диагонали.

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 приводят к округлению до ближайших десятков, сотен и т. д. Если 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). Возвращает 1-мерный вектор сумм элементов в self вдоль axis. Вычисление суммы выполняется после преобразования данных к типу данных rtype.

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

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

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

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

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

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

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

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

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

Эквивалентно ndarray.any (self, axis). Возвращает массив с элементами True для каждого 1-мерного подмассива 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 для 1-, 2- и 3-мерных ndarrays.

Параметры:

op – Адрес любого объекта Python. Этот объект Python будет заменён эквивалентным корректным, непрерывным ndarray в стиле C указанного типа данных, заданного двумя последними аргументами. Убедитесь, что заимствование ссылки к входному объекту таким образом оправдано. ptr – Адрес переменной (ctype* для 1-мерного, ctype** для 2-мерного или ctype*** для 3-мерного), где ctype – эквивалентный тип C для типа данных. По возвращении ptr будет адресоваться как 1-мерный, 2-мерный или 3-мерный массив. 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. Для 2-мерных массивов это матричное произведение. Ни один массив не сопрягается.

PyObject* PyArray_MatrixProduct2(PyObject* obj1, PyObject* obj, PyObject* 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)

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

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

Вычисляет 1-мерную корреляцию 1-мерных массивов 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, которая использует обычное определение корреляции для 1-мерных массивов. Корреляция вычисляется в каждой точке вывода путём умножения 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 auxadata */
    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, эти итераторы массивов устарели и заменены новым итератором массивов, 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, ...)

Упрощённый интерфейс для расширения. Эта функция принимает количество массивов для расширения, а затем дополнительные ( 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, которые правильно расширяют свои входные данные, а затем вызывают одношаговую 1-мерную версию процедуры как внутренний цикл. Эта 1-мерная версия обычно оптимизирована для скорости, и по этой причине цикл должен выполняться по оси, которая не потребует больших прыжков шага.

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

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

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

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

Ожидается, что аргумент 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[-3] будет 1, x[4] будет 4, x[5] будет 1 и т. д...
• NPY_NEIGHBORHOOD_ITER_CIRCULAR_PADDING: циклическое заполнение. Значения вне границ будут такими, как если бы массив повторялся. Например, для массива [1, 2, 3, 4], x[-2] будет 3, x[-3] будет 4, x[4] будет 1, x[5] будет 2 и т. д...

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

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

Оценивается как истинное, если 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. Все ссылки на объекты типов данных (в членах subdescr и fields объекта типа данных) также изменяются (рекурсивно). Если встречается порядок байтов 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) истинно, то счётчик ссылок увеличивается, и ссылка помещается в 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

Используя эти #define, вы можете использовать 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 определён перед #include этого файла.

Проверка версии 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)

New in version 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, 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-ошибки), если один из присваиваемых объектов не является вызываемым.

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. Системный менеджер памяти используется, когда NPY_USE_PYMEM равно 0, если NPY_USE_PYMEM равно 1, используется менеджер памяти Python.

Поддержка многопоточности

Эти макросы имеют смысл только если NPY_ALLOW_THREADS имеет значение True во время компиляции модуля расширения. В противном случае эти макросы эквивалентны пробелам. Python использует единый глобальный интерпретаторский замок (GIL) для каждого Python-процесса, так что только один поток может выполняться одновременно (даже на многоядерных машинах). При вызове компилированной функции, которая может занимать много времени для вычисления (и не имеет побочных эффектов для других потоков, таких как обновление глобальных переменных), GIL должен быть освобождён, чтобы другие Python-потоки могли работать, пока выполняются длительные вычисления. Это можно сделать, используя две группы макросов. Как правило, если в блоке кода используется один макрос из группы, все макросы из этой группы должны использоваться в том же блоке кода. В настоящее время NPY_ALLOW_THREADS определено как python-определённая константа 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. Должен соответствовать макросу .. c:macro::NPY_END_THREADS для повторного получения GIL.

Группа 2

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

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__ (преобразованный в double) объекта 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)

DECREF’s объект массива, у которого может быть установлен флаг 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

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

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

NPY_NO_CASTING

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

NPY_EQUIV_CASTING

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

NPY_SAFE_CASTING

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

NPY_SAME_KIND_CASTING

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

NPY_UNSAFE_CASTING

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