API массивов

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

Эти функции и макросы предоставляют лёгкий доступ к элементам 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_intpi)

void*PyArray_GETPTR2(PyArrayObject*obj, npy_intpi, npy_intpj)

void*PyArray_GETPTR3(PyArrayObject*obj, npy_intpi, npy_intpj, npy_intpk)

void*PyArray_GETPTR4(PyArrayObject*obj, npy_intpi, npy_intpj, npy_intpk, npy_intpl)

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

С нуля

PyObject*PyArray_NewFromDescr(PyTypeObject*subtype, PyArray_Descr*descr, intnd, npy_intpconst*dims, npy_intpconst*strides, void*data, intflags, PyObject*obj)

Эта функция заимствует ссылку на descr. Самый простой способ получить её — с помощью PyArray_DescrFromType.

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

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

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

Если data равно NULL, то будет выделена новая неинициализированная память, и flags может быть отличным от нуля, чтобы указать на массиве, континуированный по стилю Fortran. Используйте PyArray_FILLWBYTE для инициализации памяти.

Если data не NULL, предполагается, что он указывает на память, которая будет использоваться для массива, и аргумент flags используется в качестве новых флагов массива (кроме состояния NPY_ARRAY_OWNDATA, флаг NPY_ARRAY_WRITEBACKIFCOPY нового массива будет сброшен).

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

PyArray_CheckStrides может помочь проверить информацию о шагах, отличную от NULL.

Если data предоставлено, оно должно существовать в течение всего срока жизни массива. Один из способов управления этим — с помощью PyArray_SetBaseObject

PyObject*PyArray_NewLikeArray(PyArrayObject*prototype, NPY_ORDERorder, PyArray_Descr*descr, intsubok)

Добавлена в версии 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, intnd, npy_intpconst*dims, inttype_num, npy_intpconst*strides, void*data, intitemsize, intflags, PyObject*obj)

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

PyObject*PyArray_SimpleNew(intnd, npy_intpconst*dims, inttypenum)

Создает новый неинициализированный массив типа typenum, размер которого в каждом из nd измерений задаётся целочисленным массивом dims. Память для массива не инициализируется (за исключением случая, когда typenum — NPY_OBJECT, в этом случае каждый элемент массива устанавливается в NULL). Аргумент typenum позволяет указать любой встроенный тип данных, например, NPY_FLOAT или NPY_LONG. Память для массива можно обнулить, если нужно, с помощью PyArray_FILLWBYTE (return_object, 0). Эта функция не может использоваться для создания массива с гибким типом (размер элемента не указан).

PyObject*PyArray_SimpleNewFromData(intnd, npy_intpconst*dims, inttypenum, void*data)

Создать обёртку массива вокруг data, на который указывает указанный указатель. Флаги массива будут иметь значения по умолчанию, предполагающие, что область данных хорошо себя ведёт и является непрерывной в стиле C. Форма массива задаётся массивом dims длиной nd. Тип данных массива задаётся typenum. Если данные поступают из другого объекта Python со счётом ссылок, счётчик ссылок на этот объект должен быть увеличен после передачи указателя, а член base возвращаемого ndarray должен указывать на объект Python, который владеет данными. Это гарантирует, что предоставленная память не будет освобождена, пока возвращённый массив существует.

PyObject*PyArray_SimpleNewFromDescr(intnd, npy_intconst*dims, PyArray_Descr*descr)

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

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

voidPyArray_FILLWBYTE(PyObject*obj, intval)

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

PyObject*PyArray_Zeros(intnd, npy_intpconst*dims, PyArray_Descr*dtype, intfortran)

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

PyObject*PyArray_ZEROS(intnd, npy_intpconst*dims, inttype_num, intfortran)

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

PyObject*PyArray_Empty(intnd, npy_intpconst*dims, PyArray_Descr*dtype, intfortran)

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

PyObject*PyArray_EMPTY(intnd, npy_intpconst*dims, inttypenum, intfortran)

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

PyObject*PyArray_Arange(doublestart, doublestop, doublestep, inttypenum)

Создать новый одномерный массив типа данных 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).

intPyArray_SetBaseObject(PyArrayObject*arr, PyObject*obj)

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

Эта функция получает в собственность ссылку на obj и устанавливает ее в качестве базового свойства arr.

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

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

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

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

PyObject*PyArray_FromAny(PyObject*op, PyArray_Descr*dtype, intmin_depth, intmax_depth, intrequirements, PyObject*context)

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

NPY_ARRAY_C_CONTIGUOUS

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

NPY_ARRAY_F_CONTIGUOUS

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

NPY_ARRAY_ALIGNED

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

NPY_ARRAY_WRITEABLE

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

NPY_ARRAY_ENSURECOPY

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

NPY_ARRAY_ENSUREARRAY

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

NPY_ARRAY_FORCECAST

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

NPY_ARRAY_WRITEBACKIFCOPY

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

Комбинации флагов массивов также могут быть добавлены.

PyObject*PyArray_CheckFromAny(PyObject*op, PyArray_Descr*dtype, intmin_depth, intmax_depth, intrequirements, PyObject*context)

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

PyObject*PyArray_FromArray(PyArrayObject*op, PyArray_Descr*newtype, intrequirements)

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

PyObject*PyArray_ContiguousFromAny(PyObject*op, inttypenum, intmin_depth, intmax_depth)

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

PyObject*PyArray_ContiguousFromObject(PyObject*op, inttypenum, intmin_depth, intmax_depth)

Эта функция возвращает хорошо себя ведущий непрерывный массив в стиле C из любого вложенного последовательности или объекта, экспортирующего интерфейс массива. Минимальное количество измерений, которое может иметь массив, задано значением min_depth, а максимальное - max_depth. Это эквивалентно вызову PyArray_FromAny с требованиями NPY_ARRAY_DEFAULT и NPY_ARRAY_ENSUREARRAY.

PyObject*PyArray_FromObject(PyObject*op, inttypenum, intmin_depth, intmax_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, NULL).

PyObject*PyArray_FromString(char*string, npy_intpslen, PyArray_Descr*dtype, npy_intpnum, char*sep)

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

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

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

PyObject*PyArray_FromBuffer(PyObject*buf, PyArray_Descr*dtype, npy_intpcount, npy_intpoffset)

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

intPyArray_CopyInto(PyArrayObject*dest, PyArrayObject*src)

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

intPyArray_CopyObject(PyArrayObject*dest, PyObject*src)

Присваивает объект src массиву NumPy dest в соответствии с правилами преобразования массивов. Это в основном идентично PyArray_FromAny, но присваивает непосредственно целевому массиву. Возвращает 0 при успехе и -1 при ошибках.

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, intrequirements)

Аналогично 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_WRITEBACKIFCOPY, NPY_ARRAY_FORCECAST и NPY_ARRAY_ENSUREARRAY. Можно также использовать стандартные комбинации флагов:

PyObject*PyArray_FROM_OT(PyObject*obj, inttypenum)

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

PyObject*PyArray_FROM_OTF(PyObject*obj, inttypenum, intrequirements)

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

PyObject*PyArray_FROMANY(PyObject*obj, inttypenum, intmin, intmax, intrequirements)

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

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

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

Общие проверки типа Python

intPyArray_Check(PyObject*op)

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

intPyArray_CheckExact(PyObject*op)

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

intPyArray_HasArrayInterface(PyObject*op, PyObject*out)

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

intPyArray_HasArrayInterfaceType(PyObject*op, PyArray_Descr*dtype, PyObject*context, PyObject*out)

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

intPyArray_IsZeroDim(PyObject*op)

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

PyArray_IsScalar(op, cls)

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

intPyArray_CheckScalar(PyObject*op)

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

intPyArray_IsPythonNumber(PyObject*op)

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

intPyArray_IsPythonScalar(PyObject*op)

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

intPyArray_IsAnyScalar(PyObject*op)

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

intPyArray_CheckAnyScalar(PyObject*op)

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

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

Некоторые атрибуты дескриптора могут быть не определены и не должны или не могут быть обработаны напрямую.

npy_intpPyDataType_ELSIZE(PyArray_Descr*descr)

Размер элемента типа данных (itemsize в Python).

Примечание

Если descr прикреплен к массиву PyArray_ITEMSIZE(arr), можно использовать и доступно во всех версиях NumPy.

voidPyDataType_SET_ELSIZE(PyArray_Descr*descr, npy_intpsize)

Позволяет установить размер элемента, это только актуально для типов данных string/bytes, поскольку это текущий шаблон для определения нового размера.

npy_intpPyDataType_ALIGNENT(PyArray_Descr*descr)

Выравнивание типа данных.

PyObject*PyDataType_METADATA(PyArray_Descr*descr)

Метаданные, прикрепленные к типу данных, либо NULL, либо словарь.

PyObject*PyDataType_NAMES(PyArray_Descr*descr)

NULL или кортеж имён структурированных полей, прикреплённых к типу данных.

PyObject*PyDataType_FIELDS(PyArray_Descr*descr)

NULL, None или словарь структурированных полей типа данных. Этот словарь не должен изменяться, NumPy может изменить способ хранения полей в будущем.

Это тот же словарь, что и возвращается np.dtype.fields.

NpyAuxData*PyDataType_C_METADATA(PyArray_Descr*descr)

Объект C-метаданных, прикреплённый к дескриптору. Обычно этот метод доступа не нужен. Поле C-метаданных предоставляет доступ к информации о единице времени datetime/timedelta.

PyArray_ArrayDescr*PyDataType_SUBARRAY(PyArray_Descr*descr)

Информация о подмассиве типа данных, эквивалентная Python np.dtype.base и np.dtype.shape.

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

typePyArray_ArrayDescr

typedef struct {
    PyArray_Descr *base;
    PyObject *shape;
} PyArray_ArrayDescr;

PyArray_Descr*base

Дескриптор типа данных базового типа.

PyObject*shape

Форма (всегда непрерывная в стиле C) подмассива в виде кортежа Python.

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

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

intPyTypeNum_ISUNSIGNED(intnum)

intPyDataType_ISUNSIGNED(PyArray_Descr*descr)

intPyArray_ISUNSIGNED(PyArrayObject*obj)

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

intPyTypeNum_ISSIGNED(intnum)

intPyDataType_ISSIGNED(PyArray_Descr*descr)

intPyArray_ISSIGNED(PyArrayObject*obj)

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

intPyTypeNum_ISINTEGER(intnum)

intPyDataType_ISINTEGER(PyArray_Descr*descr)

intPyArray_ISINTEGER(PyArrayObject*obj)

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

intPyTypeNum_ISFLOAT(intnum)

intPyDataType_ISFLOAT(PyArray_Descr*descr)

intPyArray_ISFLOAT(PyArrayObject*obj)

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

intPyTypeNum_ISCOMPLEX(intnum)

intPyDataType_ISCOMPLEX(PyArray_Descr*descr)

intPyArray_ISCOMPLEX(PyArrayObject*obj)

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

intPyTypeNum_ISNUMBER(intnum)

intPyDataType_ISNUMBER(PyArray_Descr*descr)

intPyArray_ISNUMBER(PyArrayObject*obj)

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

intPyTypeNum_ISSTRING(intnum)

intPyDataType_ISSTRING(PyArray_Descr*descr)

intPyArray_ISSTRING(PyArrayObject*obj)

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

intPyTypeNum_ISFLEXIBLE(intnum)

intPyDataType_ISFLEXIBLE(PyArray_Descr*descr)

intPyArray_ISFLEXIBLE(PyArrayObject*obj)

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

intPyDataType_ISUNSIZED(PyArray_Descr*descr)

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

Изменено в версии 1.18.

Для структурированных типов данных без полей эта функция теперь возвращает False.

intPyTypeNum_ISUSERDEF(intnum)

intPyDataType_ISUSERDEF(PyArray_Descr*descr)

intPyArray_ISUSERDEF(PyArrayObject*obj)

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

intPyTypeNum_ISEXTENDED(intnum)

intPyDataType_ISEXTENDED(PyArray_Descr*descr)

intPyArray_ISEXTENDED(PyArrayObject*obj)

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

intPyTypeNum_ISOBJECT(intnum)

intPyDataType_ISOBJECT(PyArray_Descr*descr)

intPyArray_ISOBJECT(PyArrayObject*obj)

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

intPyTypeNum_ISBOOL(intnum)

intPyDataType_ISBOOL(PyArray_Descr*descr)

intPyArray_ISBOOL(PyArrayObject*obj)

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

intPyDataType_HASFIELDS(PyArray_Descr*descr)

intPyArray_HASFIELDS(PyArrayObject*obj)

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

intPyArray_ISNOTSWAPPED(PyArrayObject*m)

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

intPyArray_ISBYTESWAPPED(PyArrayObject*m)

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

npy_boolPyArray_EquivTypes(PyArray_Descr*type1, PyArray_Descr*type2)

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

npy_boolPyArray_EquivArrTypes(PyArrayObject*a1, PyArrayObject*a2)

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

npy_boolPyArray_EquivTypenums(inttypenum1, inttypenum2)

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

intPyArray_EquivByteorders(intb1, intb2)

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

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

PyObject*PyArray_Cast(PyArrayObject*arr, inttypenum)

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

PyObject*PyArray_CastToType(PyArrayObject*arr, PyArray_Descr*type, intfortran)

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

intPyArray_CastTo(PyArrayObject*out, PyArrayObject*in)

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

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

intPyArray_CanCastSafely(intfromtype, inttotype)

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

intPyArray_CanCastTo(PyArray_Descr*fromtype, PyArray_Descr*totype)

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

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

intPyArray_CanCastTypeTo(PyArray_Descr*fromtype, PyArray_Descr*totype, NPY_CASTINGcasting)

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

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

intPyArray_CanCastArrayTo(PyArrayObject*arr, PyArray_Descr*totype, NPY_CASTINGcasting)

Добавлена в версии 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 могут быть безопасно преобразованы. Эта функция симметрична и ассоциативна. Результат типа string или unicode будет иметь правильный размер для хранения максимального значения входных типов, преобразованных в строку или unicode.

PyArray_Descr*PyArray_ResultType(npy_intpnarrs, PyArrayObject**arrs, npy_intpndtypes, PyArray_Descr**dtypes)

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

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

См. документацию по numpy.result_type для получения более подробной информации об алгоритме продвижения типов.

intPyArray_ObjectType(PyObject*op, intmintype)

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

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

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

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

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

Изменено в версии 1.18.0: Смесь скаляров и нульмерных массивов теперь приводит к типу, способному хранить скалярное значение. Раньше приоритет отдавали типу данных массивов.

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), когда он больше не нужен.

intPyArray_ValidType(inttypenum)

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

Пользовательские типы данных

voidPyArray_InitArrFuncs(PyArray_ArrFuncs*f)

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

intPyArray_RegisterDataType(PyArray_DescrProto*dtype)

Примечание

Начиная с NumPy 2.0 этот API считается устаревшим, новый API DType более мощный и предоставляет дополнительную гибкость. API может быть в конечном итоге устаревшим, но поддержка продолжается на текущий момент.

Компиляция для NumPy 1.x и 2.x

NumPy 2.x требует передачи структурированного типа PyArray_DescrProto вместо PyArray_Descr. Это необходимо для внесения изменений. Для того чтобы код работал и компилировался как в 1.x, так и в 2.x, необходимо изменить тип вашей структуры на PyArray_DescrProto и добавить:

/* Allow compiling on NumPy 1.x */
#if NPY_ABI_VERSION < 0x02000000
#define PyArray_DescrProto PyArray_Descr
#endif

для совместимости с 1.x. Кроме того, структура не будет являться фактическим дескриптором, только её номер типа будет обновлён. После успешной регистрации фактический тип данных необходимо получить с помощью:

int type_num = PyArray_RegisterDataType(&my_descr_proto);
if (type_num < 0) {
    /* error */
}
PyArray_Descr *my_descr = PyArray_DescrFromType(type_num);

С этими двумя изменениями код должен компилироваться и работать как в 1.x, так и в 2.x или более поздних версиях.

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

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

intPyArray_RegisterCastFunc(PyArray_Descr*descr, inttotype, PyArray_VectorUnaryFunc*castfunc)

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

typePyArray_VectorUnaryFunc

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

intPyArray_RegisterCanCast(PyArray_Descr*descr, inttotype, NPY_SCALARKINDscalar)

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

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

intPyArray_INCREF(PyArrayObject*op)

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

voidPyArray_Item_INCREF(char*ptr, PyArray_Descr*dtype)

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

intPyArray_XDECREF(PyArrayObject*op)

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

voidPyArray_Item_XDECREF(char*ptr, PyArray_Descr*dtype)

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

intPyArray_SetWritebackIfCopyBase(PyArrayObject*arr, PyArrayObject*base)

Предварительное условие: arr является копией base (хотя, возможно, с различными шагами, порядком и т.д.). Устанавливает флаг NPY_ARRAY_WRITEBACKIFCOPY и arr->base, и устанавливает base в READONLY. Вызовите PyArray_ResolveWritebackIfCopy перед вызовом Py_DECREF для копирования любых изменений обратно в base и сброса флага READONLY.

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

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

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

NPY_ARRAY_C_CONTIGUOUS

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

NPY_ARRAY_F_CONTIGUOUS

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

NPY_ARRAY_OWNDATA

Область данных принадлежит этому массиву. Не следует устанавливать вручную, вместо этого создайте PyObject, обертывающий данные, и установите базовый атрибут массива на этот объект. Пример см. в тесте в test_mem_policy.

NPY_ARRAY_ALIGNED

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

NPY_ARRAY_WRITEABLE

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

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

NPY_ARRAY_WRITEBACKIFCOPY

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

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

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_IN_ARRAY

NPY_ARRAY_C_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_IN_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_ALIGNED

NPY_ARRAY_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_WRITEBACKIFCOPY

NPY_ARRAY_INOUT_FARRAY

NPY_ARRAY_F_CONTIGUOUS | NPY_ARRAY_WRITEABLE | NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEBACKIFCOPY

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, а не подклассом.

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

NPY_ARRAY_NOTSWAPPED

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

NPY_ARRAY_BEHAVED_NS

NPY_ARRAY_ALIGNED | NPY_ARRAY_WRITEABLE | NPY_ARRAY_NOTSWAPPED

NPY_ARRAY_ELEMENTSTRIDES

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

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

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

intPyArray_CHKFLAGS(PyObject*arr, intflags)

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

intPyArray_IS_C_CONTIGUOUS(PyObject*arr)

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

intPyArray_IS_F_CONTIGUOUS(PyObject*arr)

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

intPyArray_ISFORTRAN(PyObject*arr)

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

intPyArray_ISWRITEABLE(PyObject*arr)

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

intPyArray_ISALIGNED(PyObject*arr)

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

intPyArray_ISBEHAVED(PyObject*arr)

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

intPyArray_ISBEHAVED_RO(PyObject*arr)

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

intPyArray_ISCARRAY(PyObject*arr)

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

intPyArray_ISFARRAY(PyObject*arr)

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

intPyArray_ISCARRAY_RO(PyObject*arr)

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

intPyArray_ISFARRAY_RO(PyObject*arr)

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

intPyArray_ISONESEGMENT(PyObject*arr)

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

voidPyArray_UpdateFlags(PyArrayObject*arr, intflagmask)

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

intPyArray_FailUnlessWriteable(PyArrayObject*obj, constchar*name)

Эта функция ничего не делает и возвращает 0, если obj разрешает запись. Она вызывает исключение и возвращает -1, если obj не разрешает запись. Она также может выполнять другие задачи, например, выдавать предупреждения о массивах, которые переходят в режим представлений. Всегда вызывайте эту функцию до записи в массив.

name — имя массива, используемое для более информативных сообщений об ошибках. Это может быть что-то вроде «назначение назначения», «массив вывода» или просто «массив».

Слот и Типовые определения

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

NPY_METH_resolve_descriptors

typedefNPY_CASTING(PyArrayMethod_ResolveDescriptors)(structPyArrayMethodObject_tag*method,PyArray_DTypeMeta*const*dtypes,PyArray_Descr*const*given_descrs,PyArray_Descr**loop_descrs,npy_intp*view_offset)

Функция, используемая для установки описателей для операции на основе описателей операндов. Например, операция ufunc с двумя входными операндами и одним выходным операндом, которая вызывается без установки out в Python API, resolve_descriptors будет передавать описатели двух операндов и определять правильный описатель для выхода на основе выходного DType, установленного для ArrayMethod. Если out установлено, то описатель вывода также будет передан и не должен быть изменен.

method — указатель на базовый цикл преобразования или ufunc. В будущем мы можем сделать эту структуру общедоступной, но пока это невидимый указатель, и метод нельзя проверить. dtypes — массив длины nargs из указателей PyArray_DTypeMeta, given_descrs — массив длины nargs экземпляров входных описателей (описатели вывода могут быть NULL, если пользователь не предоставил вывод), а loop_descrs — массив длины nargs описателей, которые должны быть заполнены реализацией разрешения описателей. view_offset в настоящее время интересен только для преобразований и обычно может быть проигнорирован. Когда преобразование не требует какой-либо операции, это можно сигнализировать, установив view_offset в 0. В случае ошибки необходимо вернуть (NPY_CASTING)-1 с установленным ошибкой.

NPY_METH_strided_loop

NPY_METH_contiguous_loop

NPY_METH_unaligned_strided_loop

NPY_METH_unaligned_contiguous_loop

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

Для работы с потенциально невыровненными данными NumPy необходимо уметь копировать невыровненные данные в выровненные. При реализации нового DType необходимо реализовать «преобразование» или копирование для него NPY_METH_unaligned_strided_loop. В отличие от обычных версий, этот цикл не должен предполагать, что к данным можно получить доступ в выровненном формате. Эти циклы должны копировать каждое значение перед доступом или сохранением:

type_in in_value;
type_out out_value
memcpy(&value, in_data, sizeof(type_in));
out_value = in_value;
memcpy(out_data, &out_value, sizeof(type_out)

в то время как обычный цикл может просто использовать:

*(type_out *)out_data = *(type_in)in_data;

Невыровненные циклы в настоящее время используются только в преобразованиях и никогда не выбираются в ufunc (ufunc создает временную копию, чтобы гарантировать выровненные входные данные). Эти идентификаторы слотов игнорируются, когда NPY_METH_get_loop определен, где вместо этого используется цикл, возвращаемый функцией get_loop.

NPY_METH_contiguous_indexed_loop

Специализированный внутренний цикл для ускорения общих вычислений ufunc.at.

typedefint(PyArrayMethod_StridedLoop)(PyArrayMethod_Context*context,char*const*data,constnpy_intp*dimensions,constnpy_intp*strides,NpyAuxData*auxdata)

Реализация цикла ArrayMethod. Все идентификаторы слотов циклов, перечисленные выше, должны предоставлять реализацию PyArrayMethod_StridedLoop. context — структура, содержащая контекст для операции цикла, в частности входные описатели. data — массив указателей на начало буферов массива входных и выходных данных. dimensions — размеры цикла для операции. strides — массив длины nargs шагов для каждого входа. auxdata — необязательный набор вспомогательных данных, которые можно передать в цикл, полезно для включения и отключения необязательного поведения или уменьшения рутинных действий, позволяя похожим ufunc использовать общие реализации циклов или выделять память, сохраняющуюся при многократных вызовах циклов с шагами.

NPY_METH_get_loop

Позволяет более тонкую настройку выбора цикла. Принимает реализацию PyArrayMethod_GetLoop, которая в свою очередь возвращает реализацию цикла с шагами. Если NPY_METH_get_loop определено, другие идентификаторы слотов циклов игнорируются, если они указаны.

typedefint(PyArrayMethod_GetLoop)(PyArrayMethod_Context*context,intaligned,intmove_references,constnpy_intp*strides,PyArrayMethod_StridedLoop**out_loop,NpyAuxData**out_transferdata,NPY_ARRAYMETHOD_FLAGS*flags);

Устанавливает используемый цикл для операции во время выполнения. context — контекст выполнения операции. aligned указывает, выровнен ли доступ к данным для цикла (1) или невыровнен (0). move_references указывает, должны ли быть скопированы встроенные ссылки в данных. strides — шаги для входного массива, out_loop — указатель, который должен быть заполнен указателем на реализацию цикла. out_transferdata можно дополнительно заполнить, чтобы позволить передачу дополнительных пользовательских контекстов в операцию. flags необходимо заполнить соответствующими флагами ArrayMethod для операции. Например, это необходимо, чтобы указать, требует ли внутренний цикл удержания Python GIL.

NPY_METH_get_reduction_initial

typedefint(PyArrayMethod_GetReductionInitial)(PyArrayMethod_Context*context,npy_boolreduction_is_empty,char*initial)

Запрос у ArrayMethod начального значения для использования в операции сокращения. context — контекст ArrayMethod, в основном для доступа к описателям входных данных. reduction_is_empty указывает, является ли сокращение пустым. Когда оно пустое, возвращаемое значение может отличаться. В этом случае это «значение по умолчанию», которое может отличаться от значения «тождества», обычно используемого. Например:

• 0.0 — значение по умолчанию для sum([]). Но -0.0 — правильное тождество в противном случае, так как сохраняет знак для sum([-0.0]).
• Для объектов мы не используем тождество, а возвращаем значение по умолчанию 0 и 1 для пустого sum([], dtype=object) и prod([], dtype=object). Это позволяет работать np.sum(np.array(["a", "b"], dtype=object)).
• -inf или INT_MIN для max — это тождество, но, по крайней мере, INT_MIN не хорошее значение по умолчанию, когда элементов нет.

initial — указатель на данные для начального значения, которое должно быть заполнено. Возвращает -1, 0 или 1, обозначающие ошибку, отсутствие начального значения и успешное заполнение начального значения соответственно. Ошибки не должны выдаваться, когда правильное начальное значение отсутствует, так как NumPy может вызывать эту функцию даже тогда, когда это строго не обязательно.

Флаги

enumNPY_ARRAYMETHOD_FLAGS

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

enumeratorNPY_METH_REQUIRES_PYAPI

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

enumeratorNPY_METH_NO_FLOATINGPOINT_ERRORS

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

enumeratorNPY_METH_SUPPORTS_UNALIGNED

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

enumeratorNPY_METH_IS_REORDERABLE

Указывает, что результат применения цикла многократно (например, в операции сокращения) не зависит от порядка применения.

enumeratorNPY_METH_RUNTIME_FLAGS

Флаги, которые могут быть изменены во время выполнения.

Определения типов

Ниже описаны определения типов функций, которые могут реализовывать пользователи API ArrayMethod.

typedefint(PyArrayMethod_TraverseLoop)(void*traverse_context,constPyArray_Descr*descr,char*data,npy_intpsize,npy_intpstride,NpyAuxData*auxdata)

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

В настоящее время он используется для очистки массивов через привязку к API DType NPY_DT_get_clear_loop и заполнения нулями через привязку к API DType NPY_DT_get_fill_zero_loop. Они наиболее полезны для обработки массивов, хранящих вложенные ссылки на объекты Python или данные, выделенные в куче.

descr — описатель массива, data — указатель на буфер массива, size — размер буфера массива в 1D, stride — шаг, а auxdata — дополнительные данные для цикла (необязательно).

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

typedefint(PyArrayMethod_GetTraverseLoop)(void*traverse_context,constPyArray_Descr*descr,intaligned,npy_intpfixed_stride,PyArrayMethod_TraverseLoop**out_loop,NpyAuxData**out_auxdata,NPY_ARRAYMETHOD_FLAGS*flags)

Упрощенная функция get_loop, специфичная для обхода типов данных.

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

Функции и определения типов API

Эти функции являются частью основного API массивов NumPy и были добавлены вместе с остальной частью API ArrayMethod.

intPyUFunc_AddLoopFromSpec(PyObject*ufunc, PyArrayMethod_Spec*spec)

Добавление цикла непосредственно в ufunc из заданного спецификации ArrayMethod. Основная функция регистрации ufunc. Это добавляет новое реализацию/цикл в ufunc. Заменяет PyUFunc_RegisterLoopForType.

intPyUFunc_AddPromoter(PyObject*ufunc, PyObject*DType_tuple, PyObject*promoter)

Обратите внимание, что в настоящее время выходные типы всегда NULL, если они также не являются частью подписи. Это деталь реализации и может измениться в будущем. Однако, как правило, промоутерам не требуется выходных типов. Регистрация нового промоутера для ufunc. Первый аргумент — ufunc, с которым необходимо зарегистрировать промоутер. Второй аргумент — кортеж Python, содержащий DType или None, соответствующий числу входных и выходных значений для ufunc. Последний аргумент — промоутер — функция, хранящаяся в PyCapsule. Ей передаются операция и запрошенные подписи DType, и она может изменить их, чтобы попытаться найти соответствующий цикл/промоутер.

typedefint(PyArrayMethod_PromoterFunction)(PyObject*ufunc,PyArray_DTypeMeta*constop_dtypes[],PyArray_DTypeMeta*constsignature[],PyArray_DTypeMeta*new_op_dtypes[])

Тип функции промоутера, который должен быть обернут в PyCapsule с именем "numpy._ufunc_promoter". Ей передаются операция и запрошенные подписи DType, и она может изменить подписи, чтобы попытаться найти новый цикл или промоутер, которые могут выполнить операцию путем преобразования входных значений в «продвинутые» DType.

intPyUFunc_GiveFloatingpointErrors(constchar*name, intfpe_errors)

Проверка на ошибку с плавающей точкой после выполнения операции с плавающей точкой таким образом, который учитывает обработку ошибок, настроенную с помощью numpy.errstate. Принимает имя операции для использования в сообщении об ошибке и целочисленный флаг, который является одним из NPY_FPE_DIVIDEBYZERO, NPY_FPE_OVERFLOW, NPY_FPE_UNDERFLOW, NPY_FPE_INVALID, чтобы указать, какую ошибку проверить.

Возвращает -1 при ошибке (было выброшено исключение) и 0 при успехе.

intPyUFunc_AddWrappingLoop(PyObject*ufunc_obj, PyArray_DTypeMeta*new_dtypes[], PyArray_DTypeMeta*wrapped_dtypes[], PyArrayMethod_TranslateGivenDescriptors*translate_given_descrs, PyArrayMethod_TranslateLoopDescriptors*translate_loop_descrs)

Позволяет создавать относительно лёгкий обёртку вокруг существующего цикла ufunc. Основная идея — для модулей, так как в настоящее время это немного ограничено тем, что не позволяет использовать цикл из другого ufunc.

typedefint(PyArrayMethod_TranslateGivenDescriptors)(intnin,intnout,PyArray_DTypeMeta*wrapped_dtypes[],PyArray_Descr*given_descrs[],PyArray_Descr*new_descrs[]);

Функция для преобразования заданных описателей (переданных в resolve_descriptors) и их перевода для обернутого цикла. Новые описатели ДОЛЖНЫ быть отображаемыми со старыми, NULL должны поддерживаться (для выходных аргументов) и обычно должны передаваться.

Результат работы этой функции будет использован для построения представлений аргументов так, как если бы они были переведёнными типами, и не использует преобразование. Это означает, что этот механизм в основном полезен для DType, которые «оборачивают» другую реализацию DType. Например, тип «единица» может использовать это, чтобы обернуть существующий тип с плавающей точкой, без необходимости повторной реализации логики ufunc низкого уровня. В примере с типом «единица», resolve_descriptors будет обрабатывать вычисление выходной «единицы» из входной «единицы».

typedefint(PyArrayMethod_TranslateLoopDescriptors)(intnin,intnout,PyArray_DTypeMeta*new_dtypes[],PyArray_Descr*given_descrs[],PyArray_Descr*original_descrs[],PyArray_Descr*loop_descrs[]);

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

PyArray_DTypeMeta *orig_dtypes[3] = {
    &WrappedDoubleDType, &WrappedDoubleDType, &WrappedDoubleDType};
PyArray_DTypeMeta *wrapped_dtypes[3] = {
     &PyArray_Float64DType, &PyArray_Float64DType, &PyArray_Float64DType}

PyObject *mod = PyImport_ImportModule("numpy");
if (mod == NULL) {
    return -1;
}
PyObject *multiply = PyObject_GetAttrString(mod, "multiply");
Py_DECREF(mod);

if (multiply == NULL) {
    return -1;
}

int res = PyUFunc_AddWrappingLoop(
    multiply, orig_dtypes, wrapped_dtypes, &translate_given_descrs
    &translate_loop_descrs);

Py_DECREF(multiply);

static int
translate_given_descrs(int nin, int nout,
                       PyArray_DTypeMeta *NPY_UNUSED(wrapped_dtypes[]),
                       PyArray_Descr *given_descrs[],
                       PyArray_Descr *new_descrs[])
{
    for (int i = 0; i < nin + nout; i++) {
        if (given_descrs[i] == NULL) {
            new_descrs[i] = NULL;
        }
        else {
            new_descrs[i] = PyArray_DescrFromType(NPY_DOUBLE);
        }
    }
    return 0;
}

static int
translate_loop_descrs(int nin, int NPY_UNUSED(nout),
                      PyArray_DTypeMeta *NPY_UNUSED(new_dtypes[]),
                      PyArray_Descr *given_descrs[],
                      PyArray_Descr *original_descrs[],
                      PyArray_Descr *loop_descrs[])
{
    // more complicated parametric DTypes may need to
    // to do additional checking, but we know the wrapped
    // DTypes *have* to be float64 for this example.
    loop_descrs[0] = PyArray_DescrFromType(NPY_FLOAT64);
    Py_INCREF(loop_descrs[0]);
    loop_descrs[1] = PyArray_DescrFromType(NPY_FLOAT64);
    Py_INCREF(loop_descrs[1]);
    loop_descrs[2] = PyArray_DescrFromType(NPY_FLOAT64);
    Py_INCREF(loop_descrs[2]);
}

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

PyObject*PyArray_GetField(PyArrayObject*self, PyArray_Descr*dtype, intoffset)

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

intPyArray_SetField(PyArrayObject*self, PyArray_Descr*dtype, intoffset, 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, npy_boolinplace)

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

PyObject*PyArray_NewCopy(PyArrayObject*old, NPY_ORDERorder)

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

PyObject*PyArray_ToList(PyArrayObject*self)

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

PyObject*PyArray_ToString(PyArrayObject*self, NPY_ORDERorder)

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

intPyArray_Dump(PyObject*self, PyObject*file, intprotocol)

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

PyObject*PyArray_Dumps(PyObject*self, intprotocol)

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

intPyArray_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 должен быть односегментным, и общее количество байтов должно быть одинаковым. В последнем случае размерности возвращаемого массива будут изменены в последнем (или первом для массивов, упорядоченных по Фортрану) измерении. Область данных возвращаемого массива и self точно такая же.

Обработка формы

PyObject*PyArray_Newshape(PyArrayObject*self, PyArray_Dims*newshape, NPY_ORDERorder)

Результат — новый массив (указывает на то же место в памяти, что и 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, inta1, inta2)

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

PyObject*PyArray_Resize(PyArrayObject*self, PyArray_Dims*newshape, intrefcheck, NPY_ORDERfortran)

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

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

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

PyObject*PyArray_Flatten(PyArrayObject*self, NPY_ORDERorder)

Эквивалентно 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_ORDERorder)

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

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

PyObject*PyArray_TakeFrom(PyArrayObject*self, PyObject*indices, intaxis, PyArrayObject*ret, NPY_CLIPMODEclipmode)

Эквивалентно 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_CLIPMODEclipmode)

Эквивалентно 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, intaxis)

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

PyObject*PyArray_Choose(PyArrayObject*self, PyObject*op, PyArrayObject*ret, NPY_CLIPMODEclipmode)

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

NPY_RAISE

возвращает ошибку ValueError;

NPY_WRAP

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

NPY_CLIP

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

PyObject*PyArray_Sort(PyArrayObject*self, intaxis, NPY_SORTKINDkind)

Эквивалентно ndarray.sort (self, axis, kind). Возвращает массив с элементами self, отсортированными вдоль axis. Массив сортируется с использованием алгоритма, обозначенного kind, это целое число/перечисление, указывающее тип используемого алгоритма сортировки.

PyObject*PyArray_ArgSort(PyArrayObject*self, intaxis)

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

PyObject*PyArray_LexSort(PyObject*sort_keys, intaxis)

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

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

PyObject*PyArray_SearchSorted(PyArrayObject*self, PyObject*values, NPY_SEARCHSIDEside, PyObject*perm)

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

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

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

intPyArray_Partition(PyArrayObject*self, PyArrayObject*ktharray, intaxis, NPY_SELECTKINDwhich)

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

PyObject*PyArray_ArgPartition(PyArrayObject*op, PyArrayObject*ktharray, intaxis, NPY_SELECTKINDwhich)

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

PyObject*PyArray_Diagonal(PyArrayObject*self, intoffset, intaxis1, intaxis2)

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

npy_intpPyArray_CountNonzero(PyArrayObject*self)

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

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

PyObject*PyArray_Nonzero(PyArrayObject*self)

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

PyObject*PyArray_Compress(PyArrayObject*self, PyObject*condition, intaxis, PyArrayObject*out)

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

Вычисление

PyObject*PyArray_ArgMax(PyArrayObject*self, intaxis, PyArrayObject*out)

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

PyObject*PyArray_ArgMin(PyArrayObject*self, intaxis, PyArrayObject*out)

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

PyObject*PyArray_Max(PyArrayObject*self, intaxis, PyArrayObject*out)

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

PyObject*PyArray_Min(PyArrayObject*self, intaxis, PyArrayObject*out)

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

PyObject*PyArray_Ptp(PyArrayObject*self, intaxis, PyArrayObject*out)

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

PyObject*PyArray_Mean(PyArrayObject*self, intaxis, intrtype, PyArrayObject*out)

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

PyObject*PyArray_Trace(PyArrayObject*self, intoffset, intaxis1, intaxis2, intrtype, PyArrayObject*out)

Эквивалентно ndarray.trace (self, offset, axis1, axis2, rtype). Возвращает сумму (используя rtype как тип данных для суммирования) по элементам диагонали с offset для 2-мерных массивов, определяемых переменными 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, PyArrayObject*out)

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

Параметры:

• self – Входной массив.
• out – Выходной массив. Если указан, результат помещается в этот массив.

Возвращает:

Комплексно сопряженное значение self.

PyObject*PyArray_Round(PyArrayObject*self, intdecimals, PyArrayObject*out)

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

PyObject*PyArray_Std(PyArrayObject*self, intaxis, intrtype, PyArrayObject*out)

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

PyObject*PyArray_Sum(PyArrayObject*self, intaxis, intrtype, PyArrayObject*out)

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

PyObject*PyArray_CumSum(PyArrayObject*self, intaxis, intrtype, PyArrayObject*out)

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

PyObject*PyArray_Prod(PyArrayObject*self, intaxis, intrtype, PyArrayObject*out)

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

PyObject*PyArray_CumProd(PyArrayObject*self, intaxis, intrtype, PyArrayObject*out)

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

PyObject*PyArray_All(PyArrayObject*self, intaxis, PyArrayObject*out)

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

PyObject*PyArray_Any(PyArrayObject*self, intaxis, PyArrayObject*out)

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

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

intPyArray_AsCArray(PyObject**op, void*ptr, npy_intp*dims, intnd, PyArray_Descr*typedescr)

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

Параметры:

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

intPyArray_Free(PyObject*op, void*ptr)

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

PyObject*PyArray_Concatenate(PyObject*obj, intaxis)

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

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

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

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

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

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

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

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

PyArrayObject*PyArray_EinsteinSum(char*subscripts, npy_intpnop, PyArrayObject**op_in, PyArray_Descr*dtype, NPY_ORDERorder, NPY_CASTINGcasting, PyArrayObject*out)

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

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

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

PyObject*PyArray_Correlate(PyObject*op1, PyObject*op2, intmode)

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

Примечания

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

PyObject*PyArray_Correlate2(PyObject*op1, PyObject*op2, intmode)

Обновлённая версия PyArray_Correlate, которая использует обычное определение корреляции для 1d массивов. Корреляция вычисляется в каждой точке выходного массива путем умножения op1 на сдвинутую версию op2 и суммирования результата. В результате сдвига, необходимые значения за пределами определенного диапазона op1 и op2 интерпретируются как ноль. Параметр mode определяет, сколько сдвигов вернуть: 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.

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

npy_boolPyArray_CheckStrides(intelsize, intnd, npy_intpnumbytes, npy_intpconst*dims, npy_intpconst*newstrides)

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

npy_intpPyArray_MultiplyList(npy_intpconst*seq, intn)

intPyArray_MultiplyIntList(intconst*seq, intn)

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

intPyArray_CompareLists(npy_intpconst*l1, npy_intpconst*l2, intn)

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

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

typeNpyAuxData

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

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

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

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

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

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

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

    return (NpyAuxData *)ret;
}

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

    return (NpyAuxData *)ret;
}

typeNpyAuxData_FreeFunc

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

typeNpyAuxData_CloneFunc

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

voidNPY_AUXDATA_FREE(NpyAuxData*auxdata)

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

NpyAuxData*NPY_AUXDATA_CLONE(NpyAuxData*auxdata)

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