Массивный 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-мерному индексу, заданному c-массивом, 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)

New in version 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 (исключая stop) с шагом step. Эквивалентно arange (start, stop, step, dtype).

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

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

int PyArray_SetBaseObject(PyArrayObject* arr, PyObject* obj)

New in version 1.7.

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

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

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

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

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

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

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

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

При возвращении успеха (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__ (в настоящее время используется только в ufunc).

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 аргумента type, установленным на 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 отрицательно, то он будет определён из размера буфера и запрашиваемого itemsize, иначе count определяет количество элементов, которые должны быть преобразованы из буфера.

int PyArray_CopyInto(PyArrayObject* dest, PyArrayObject* src)

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

int PyArray_MoveInto(PyArrayObject* dest, PyArrayObject* src)

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

PyArrayObject* PyArray_GETCONTIGUOUS(PyObject* op)

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

PyObject* PyArray_FROM_O(PyObject* obj)

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

PyObject* PyArray_FROM_OF(PyObject* obj, int requirements)

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

PyObject* PyArray_FROM_OT(PyObject* obj, int typenum)

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

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

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

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

Аналогично PyArray_FromAny, за исключением того, что тип данных задается с помощью номера типа. PyArray_DescrFromType (typenum) передается непосредственно в PyArray_FromAny. Эта макрокоманда также добавляет NPY_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 ) равны или эквивалентны относительно их задания родного порядка байтов. Таким образом, на машине с порядком байтов little-endian NPY_LITTLE и NPY_NATIVE эквивалентны, в то время как на машине с порядком байтов big-endian они не эквивалентны.

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

PyObject* PyArray_Cast(PyArrayObject* arr, int typenum)

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

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

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

int PyArray_CastTo(PyArrayObject* out, PyArrayObject* in)

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

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

PyArray_VectorUnaryFunc* PyArray_GetCastFunc(PyArray_Descr* from, int totype)

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

int PyArray_CanCastSafely(int fromtype, int totype)

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

int PyArray_CanCastTo(PyArray_Descr* fromtype, PyArray_Descr* totype)

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

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

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

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

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

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

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

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

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

PyArray_Descr* PyArray_MinScalarType(PyArrayObject* arr)

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

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

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

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

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

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

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

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

Это применяет повышение типа ко всем входным данным, используя правила NumPy для объединения скаляров и массивов, чтобы определить выходной тип набора операндов. Это тот же тип результата, который производят 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 представляет собой объект, который будет преобразован в массив. Возвращаемое значение — это перечисляемое число типа, которое представляет тип данных, который должен иметь op.

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

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

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

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

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

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

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

char* PyArray_Zero(PyArrayObject* arr)

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

char* PyArray_One(PyArrayObject* arr)

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

int PyArray_ValidType(int typenum)

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

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

void PyArray_InitArrFuncs(PyArray_ArrFuncs* f)

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

int PyArray_RegisterDataType(PyArray_Descr* dtype)

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

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

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

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

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

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

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

int PyArray_INCREF(PyArrayObject* op)

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

void PyArray_Item_INCREF(char* ptr, PyArray_Descr* dtype)

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

int PyArray_XDECREF(PyArrayObject* op)

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

void PyArray_Item_XDECREF(char* ptr, PyArray_Descr* dtype)

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

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

В версиях NumPy 1.6 и ранее следующие флаги не имели префикса _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 для 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-вывода, показывающая, как элементы должны быть записаны.

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

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

PyObject* PyArray_Dumps(PyObject* self, int protocol)

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

int PyArray_FillWithScalar(PyArrayObject* arr, PyObject* obj)

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

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

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

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

Изменение формы массива

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

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

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

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

PyObject* PyArray_Squeeze(PyArrayObject* self)

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

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

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

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

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

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). Возвращает 1-мерную копию массива. Если 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-contiguous, форма изменяется, но копия не выполняется.

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

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

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

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

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

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

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

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

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

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

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

NPY_RAISE

выбрасывает ValueError;

NPY_WRAP

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

NPY_CLIP

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

PyObject* PyArray_Sort(PyArrayObject* self, int axis)

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

PyObject* PyArray_ArgSort(PyArrayObject* self, int axis)

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

PyObject* PyArray_LexSort(PyObject* sort_keys, int axis)

Учитывая последовательность массивов (sort_keys) одинаковой формы, возвращает массив индексов (похожий на PyArray_ArgSort (...)), которые бы сортировали массивы лексикографически. Лексикографическая сортировка означает, что когда два ключа оказываются равными, порядок определяется сравнением последующих ключей. Для типов должна быть определена сортировка слиянием (которая оставляет равные записи неподвижными). Сортировка выполняется путём сортировки индексов сначала по первому sort_key, затем по второму sort_key и так далее. Это эквивалентно команде 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 двумерных массивов, определённых переменными axis1 и axis2. Положительный offset выбирает диагонали над главной диагональю. Отрицательный offset выбирает диагонали под главной диагональю.

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

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

PyObject* PyArray_Conjugate(PyArrayObject* self)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Эквивалентно ndarray.any (self, axis). Возвращает массив с элементами True для каждого 1-d подмассива 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 будет заменен эквивалентным корректным, непрерывным в стиле C, ndarray заданного типа данных, указанного в двух последних аргументах. Убедитесь, что взятие ссылки на входной объект таким образом оправдано. ptr – Адрес переменной (ctype* для 1-d, ctype** для 2-d или ctype*** для 3-d), где ctype — эквивалентный C-тип для типа данных. По возвращении ptr будет доступен как 1-d, 2-d или 3-d массив. 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)

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

Примечания

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

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

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

Примечания

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

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

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

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

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

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

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

npy_intp PyArray_MultiplyList(npy_intp* seq, int n)

int PyArray_MultiplyIntList(int* seq, int n)

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

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

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

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

NpyAuxData

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

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

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

void free_element_doubler_aux_data(NpyAuxData *data)
{
    eldoubler_aux_data *d = (eldoubler_aux_data *)data;
    /* Free the memory owned by this 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. Этот итератор можно использовать для написания чего-то подобного тому, что делают ufunc, где цикл по наибольшей оси выполняется отдельной подпрограммой. Если *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 index, dataptr и координаты в расположение в массиве, указанное N-мерным массивом C, destination, который должен иметь размер по меньшей мере iterator ->nd_m1+1.

PyArray_ITER_GOTO1D(PyObject* iterator, npy_intp index)

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

int PyArray_ITER_NOTDONE(PyObject* iterator)

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

Трансляция (многократно-итераторы)

PyObject* PyArray_MultiIterNew(int num, ...)

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

void PyArray_MultiIter_RESET(PyObject* multi)

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

void PyArray_MultiIter_NEXT(PyObject* multi)

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

void *PyArray_MultiIter_DATA(PyObject* multi, int i)

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

void PyArray_MultiIter_NEXTi(PyObject* multi, int i)

Перемещает указатель только i итератора.

void PyArray_MultiIter_GOTO(PyObject* multi, npy_intp* destination)

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

void PyArray_MultiIter_GOTO1D(PyObject* multi, npy_intp index)

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

int PyArray_MultiIter_NOTDONE(PyObject* multi)

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

int PyArray_Broadcast(PyArrayMultiIterObject* mit)

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

int PyArray_RemoveSmallest(PyArrayMultiIterObject* mit)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

int PyArrayNeighborhoodIter_Reset(PyArrayNeighborhoodIterObject* iter)

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

int PyArrayNeighborhoodIter_Next(PyArrayNeighborhoodIterObject* iter)

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

Массив скаляров

PyObject* PyArray_Return(PyArrayObject* arr)

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

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

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

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

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

Возвращает объект скаляра массива типа и itemsize, указанных объектом массива 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, за исключением подсчета ссылок и проверки ошибок. Возвращает новую ссылку на объект type на успешном выполнении или 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. Все ссылающиеся объекты типов данных (в членах подdescr и 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) равно TRUE, то его счётчик ссылок увеличивается, и ссылка помещается в address. Если obj не является массивом, то преобразуется в массив с помощью PyArray_FromAny. Независимо от возвращаемого значения вы должны DECREF объекта, возвращаемого этой функцией в address, когда закончите с ним.

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

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

int PyArray_IntpConverter(PyObject* obj, PyArray_Dims* seq)

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

int PyArray_BufferConverter(PyObject* obj, PyArray_Chunk* buf)

Преобразует любой Python-объект obj с интерфейсом буфера (с одним сегментом) в переменную с полями, которые подробно описывают использование объектом блока памяти. Переменная buf — указатель на структуру с полями base, ptr, len и flags. Структура PyArray_Chunk двоично совместима с Python-объектом буфера (через поле len на 32-битных платформах и поле ptr на 64-битных платформах или в Python 2.5). При возврате поле base устанавливается в obj (или его базу, если 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 определен до #включения этого файла.

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

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

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

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

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

unsigned int PyArray_GetNDArrayCVersion(void)

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

unsigned int PyArray_GetNDArrayCFeatureVersion(void)

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

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

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

int PyArray_SetNumericOps(PyObject* dict)

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

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

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

PyObject* PyArray_GetNumericOps(void)

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

void PyArray_SetStringFunction(PyObject* op, int repr)

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

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

char* PyDataMem_NEW(size_t nbytes)

PyDataMem_FREE(char* ptr)

char* PyDataMem_RENEW(void * ptr, size_t newbytes)

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

npy_intp* PyDimMem_NEW(nd)

PyDimMem_FREE(npy_intp* ptr)

npy_intp* PyDimMem_RENEW(npy_intp* ptr, npy_intp newnd)

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

PyArray_malloc(nbytes)

PyArray_free(ptr)

PyArray_realloc(ptr, nbytes)

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

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

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

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

NPY_ALLOW_C_API_DEF

Размещается в области объявления переменных для подготовки необходимой переменной.

NPY_ALLOW_C_API

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

NPY_DISABLE_C_API

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

Приоритет

NPY_PRIORITY

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

NPY_SUBTYPE_PRIORITY

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

NPY_SCALAR_PRIORITY

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

double PyArray_GetPriority(PyObject* obj, double def)

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

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

NPY_BUFSIZE

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

NPY_MIN_BUFSIZE

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

NPY_MAX_BUFSIZE

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

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

NPY_NUM_FLOATTYPE

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

NPY_MAXDIMS

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

NPY_VERSION

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

NPY_FALSE

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

NPY_TRUE

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

NPY_FAIL

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

NPY_SUCCEED

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

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

PyArray_SAMESHAPE(a1, a2)

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

PyArray_MAX(a, b)

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

PyArray_MIN(a, b)

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

PyArray_CLT(a, b)

PyArray_CGT(a, b)

PyArray_CLE(a, b)

PyArray_CGE(a, b)

PyArray_CEQ(a, b)

PyArray_CNE(a, b)

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

PyArray_REFCOUNT(PyObject* op)

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

PyArray_XDECREF_ERR(PyObject *obj)

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

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