Универсальные функции (ufunc)

Универсальная функция (или ufunc вкратце) — это функция, которая работает с ndarrays поэлементно, поддерживая векторное сложение, преобразование типов и другие стандартные функции. То есть, ufunc — это «векторизованная» оболочка для функции, принимающей фиксированное число определённых входных значений и возвращающей фиксированное число определённых выходных значений.

В NumPy универсальные функции являются экземплярами класса numpy.ufunc. Многие встроенные функции реализованы на скомпилированном C-коде. Базовые ufuncs работают со скалярами, но также существует обобщённый вид, для которого базовые элементы — подмассивы (вектора, матрицы и т. д.), а векторизация выполняется по другим измерениям. Также можно создавать пользовательские экземпляры ufunc с помощью фабричной функции frompyfunc.

Векторное сложение

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

Все входные массивы с ndim меньше, чем у входного массива с наибольшим ndim, имеют добавленные в начале единицы в их форме.
Размер в каждом измерении формы результата — максимальный из размеров всех входных массивов в этом измерении.
Входной массив можно использовать в вычислении, если его размер в определенном измерении либо совпадает с размером результата в этом измерении, либо имеет значение ровно 1.
Если у входного массива размер измерения в форме равен 1, то для всех вычислений по этому измерению используется первое значение в этом измерении. Другими словами, механизм шагов ufunc просто не будет переходить по этому измерению (шаг смещения по этому измерению будет 0).

Векторное сложение используется в NumPy для того, чтобы определить, как обрабатывать массивы с разными формами; например, все арифметические операции (+, -, *, …) между ndarrays векторизуют массивы перед выполнением операции.

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

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

Пример

Если a.shape равна (5,1), b.shape равна (1,6), c.shape равна (6,) и d.shape равна (), так что d — скаляр, то a, b, c и d векторизуемы до размера (5,6); и

a ведет себя как массив (5,6), где a[:,0] векторизуется по другим столбцам,
b ведет себя как массив (5,6), где b[0,:] векторизуется по другим строкам,
c ведет себя как массив (1,6) и, следовательно, как массив (5,6), где c[:] векторизуется по каждой строке, и, наконец,
d ведет себя как массив (5,6), где единственное значение повторяется.

Определение типа результата

Результат ufunc (и его методов) не обязательно является ndarray, если все входные аргументы не являются ndarrays. Действительно, если любой вход определяет метод __array_ufunc__, управление полностью передается этой функции, т.е., ufunc переопределяется.

Если ни один из входов не переопределяет ufunc, все выходные массивы будут переданы методам __array_prepare__ и __array_wrap__ входа (кроме ndarrays и скаляров), который его определяет и имеет наивысший __array_priority__ по сравнению с другими входами универсальной функции. Значение по умолчанию __array_priority__ для ndarray равно 0,0, а значение по умолчанию __array_priority__ для подтипа равно 0,0. Матрицы имеют __array_priority__, равное 10,0.

Все ufuncs также могут принимать выходные аргументы. При необходимости выход будет преобразован к типу(ам) данных указанного(ых) выходного(ых) массива(ов). Если для выхода используется класс с методом __array__, результаты будут записаны в объект, возвращаемый методом __array__. Затем, если класс также имеет метод __array_prepare__, он вызывается, чтобы метаданные могли быть определены на основе контекста ufunc (контекст, состоящий из самого ufunc, аргументов, переданных ufunc, и области ufunc). Объект массива, возвращаемый методом __array_prepare__, передаётся ufunc для вычисления. Наконец, если класс также имеет метод __array_wrap__, возвращаемый результат ndarray будет передан этому методу непосредственно перед возвращением управления вызывающей стороне.

Использование внутренних буферов

Внутри используются буферы для невыровненных данных, данных, которые необходимо поменять местами, и данных, которые необходимо преобразовать из одного типа данных в другой. Размер внутренних буферов настраивается на основе потока. Может быть создано до $2 (n_{\mathrm{inputs}} + n_{\mathrm{outputs}})$ буферов указанного размера для обработки данных со всех входных и выходных данных ufunc. Размер буфера по умолчанию — 10 000 элементов. Всякий раз, когда нужны вычисления на основе буфера, но все входные массивы меньше размера буфера, эти некорректно или неправильно типизированные массивы копируются до начала вычислений. Поэтому изменение размера буфера может изменить скорость завершения вычислений ufunc различных типов.

Простой интерфейс для изменения этой переменной доступен с помощью функции

setbufsize(size)

Установить размер буфера, используемого в ufuncs.

Обработка ошибок

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

`seterr`([all, divide, over, under, invalid])	Установить, как обрабатываются ошибки с плавающей точкой.
`seterrcall`(func)	Установить функцию обратного вызова ошибок с плавающей точкой или объект журнала.

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

Примечание

В NumPy 1.6.0 был создан API для повышения типа, чтобы обобщить механизм определения типов результата. Дополнительные сведения см. в функциях result_type, promote_types и min_scalar_type.

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

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

Примечание

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

Согласно вышеизложенному описанию, правила преобразования типов в основном реализуются вопросом, когда тип данных может быть преобразован «безопасно» в другой тип данных. Ответ на этот вопрос можно определить в Python с помощью вызова функции: can_cast(fromtype, totype). На рисунке ниже показаны результаты этого вызова для 24 поддерживаемых внутри типов на 64-разрядной системе автора. Вы можете сгенерировать эту таблицу для вашей системы с помощью кода, приведенного на рисунке.

Рисунок

Код фрагмент, показывающий таблицу «безопасное преобразование» для 64-разрядной системы. В целом вывод зависит от системы; ваша система может привести к другой таблице.

>>> mark = {False: ' -', True: ' Y'}
>>> def print_table(ntypes):
...     print('X ' + ' '.join(ntypes))
...     for row in ntypes:
...         print(row, end='')
...         for col in ntypes:
...             print(mark[np.can_cast(row, col)], end='')
...         print()
...
>>> print_table(np.typecodes['All'])
X ? b h i l q p B H I L Q P e f d g F D G S U V O M m
? Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y - Y
b - Y Y Y Y Y Y - - - - - - Y Y Y Y Y Y Y Y Y Y Y - Y
h - - Y Y Y Y Y - - - - - - - Y Y Y Y Y Y Y Y Y Y - Y
i - - - Y Y Y Y - - - - - - - - Y Y - Y Y Y Y Y Y - Y
l - - - - Y Y Y - - - - - - - - Y Y - Y Y Y Y Y Y - Y
q - - - - Y Y Y - - - - - - - - Y Y - Y Y Y Y Y Y - Y
p - - - - Y Y Y - - - - - - - - Y Y - Y Y Y Y Y Y - Y
B - - Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y - Y
H - - - Y Y Y Y - Y Y Y Y Y - Y Y Y Y Y Y Y Y Y Y - Y
I - - - - Y Y Y - - Y Y Y Y - - Y Y - Y Y Y Y Y Y - Y
L - - - - - - - - - - Y Y Y - - Y Y - Y Y Y Y Y Y - -
Q - - - - - - - - - - Y Y Y - - Y Y - Y Y Y Y Y Y - -
P - - - - - - - - - - Y Y Y - - Y Y - Y Y Y Y Y Y - -
e - - - - - - - - - - - - - Y Y Y Y Y Y Y Y Y Y Y - -
f - - - - - - - - - - - - - - Y Y Y Y Y Y Y Y Y Y - -
d - - - - - - - - - - - - - - - Y Y - Y Y Y Y Y Y - -
g - - - - - - - - - - - - - - - - Y - - Y Y Y Y Y - -
F - - - - - - - - - - - - - - - - - Y Y Y Y Y Y Y - -
D - - - - - - - - - - - - - - - - - - Y Y Y Y Y Y - -
G - - - - - - - - - - - - - - - - - - - Y Y Y Y Y - -
S - - - - - - - - - - - - - - - - - - - - Y Y Y Y - -
U - - - - - - - - - - - - - - - - - - - - - Y Y Y - -
V - - - - - - - - - - - - - - - - - - - - - - Y Y - -
O - - - - - - - - - - - - - - - - - - - - - - Y Y - -
M - - - - - - - - - - - - - - - - - - - - - - Y Y Y -
m - - - - - - - - - - - - - - - - - - - - - - Y Y - Y

Обратите внимание, что, хотя в таблице они включены для полноты, типы «S», «U» и «V» не могут быть обработаны ufunc. Также обратите внимание, что на 32-разрядной системе целые типы могут иметь разные размеры, что приводит к слегка изменённой таблице.

Смешанные операции скаляр-массив используют другой набор правил преобразования, гарантирующий, что скаляр не может «растянуть» массив, если скаляр не является принципиально иного типа данных (например, под другой иерархией в иерархии типов данных) по сравнению с массивом. Это правило позволяет использовать скалярные константы в вашем коде (которые, как типы Python, интерпретируются соответствующим образом в ufuncs), не беспокоясь о том, вызовет ли точность скалярной константы расширение на вашем большом массиве (с малой точностью).

Переопределение поведения Ufunc

Классы (включая подклассы ndarray) могут переопределить, как ufuncs действуют на них, определив определённые специальные методы. Для получения подробной информации см. Стандартные подклассы массивов.

ufunc

numpy.ufunc

Функции, которые работают по элементу над целыми массивами.

Необязательные ключевые аргументы

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

out

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

Первый вывод может быть предоставлен в качестве позиционного или ключевого параметра. Ключевые аргументы «out» несовместимы с позиционными.

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

Ожидается, что ключевой аргумент «out» будет кортежем с одной записью на каждый вывод (который может быть None для массивов, которые должны быть выделены ufunc). Для ufuncs с одним выводом также допустимо передать один массив (вместо кортежа, содержащего один массив).

Передача одного массива в ключевом аргументе «out» ufunc с несколькими выходами устарела и будет выводить предупреждение в numpy 1.10 и ошибку в будущей версии.

Если «out» равно None (значение по умолчанию), создаётся неинициализированный массив возврата. Затем выходной массив заполняется результатами ufunc в тех местах, где широковещательная передача «where» равна True. Если «where» является скалярным значением True (значение по умолчанию), то это соответствует заполнению всего выходного массива. Обратите внимание, что выходы, которые явно не заполнены, остаются со своими значениями по умолчанию.

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

Операции, в которых входные и выходные операнды ufunc имеют перекрытие памяти, определяются так же, как и для эквивалентных операций, где нет перекрытия памяти. Затронутые операции создают временные копии по мере необходимости для устранения зависимости данных. Поскольку обнаружение этих случаев вычислительно дорого, используется эвристика, которая в редких случаях может привести к ненужным временным копиям. Для операций, где зависимость данных достаточно проста для анализа эвристикой, временные копии не будут создаваться даже если массивы перекрываются, если можно вывести, что копии не нужны. Например, np.add(a, b, out=a) не будет включать копии.

where

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

Принимает булевый массив, который передаётся вместе с операндами. Значения True указывают на вычисление ufunc в этом положении, значения False указывают на оставление значения в выходе без изменений. Этот аргумент не может быть использован для обобщённых ufuncs, поскольку они принимают нескалярные входные данные.

Обратите внимание, что если создаётся неинициализированный массив возврата, значения False оставят эти значения неинициализированными.

axes

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

Список кортежей с индексами осей, над которыми должна работать обобщённая ufunc. Например, для сигнатуры (i,j),(j,k)->(i,k) , подходящей для умножения матриц, базовые элементы являются двумерными матрицами, и они предполагаются хранящимися в двух последних осях каждого аргумента. Соответствующий ключевой аргумент осей был бы [(-2, -1), (-2, -1), (-2, -1)]. Для простоты, для обобщённых ufuncs, которые работают над одномерными массивами (векторами), принимается одно целое число вместо кортежа с одним элементом, а для обобщённых ufuncs, для которых все выходы являются скалярами, выходные кортежи могут быть опушены.

axis

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

Одна ось, над которой должна работать обобщённая ufunc. Это сокращение для ufuncs, которые работают над одной общей основной размерностью, эквивалентно передаче axes с записями (axis,) для каждого аргумента с одной основной размерностью и () для всех остальных. Например, для сигнатуры (i),(i)->(), это эквивалентно передаче axes=[(axis,), (axis,), ()].

keepdims

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

Если это установлено на True, оси, по которым происходит сведение, останутся в результате как размерность с размером один, так что результат будет корректно передаваться входным данным. Этот параметр может быть использован только для обобщённых ufuncs, которые работают над входными данными, все имеющие одинаковое количество основных измерений, и с выходами, которые не имеют основных измерений, т.е. с сигнатурами, подобными (i),(i)->() или (m,m)->() . Если используется, расположение измерений в выходе может быть контролировано с помощью axes и axis.

casting

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

Может быть ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, или ‘unsafe’. См. can_cast для объяснений значений параметров.

Обеспечивает политику того, какой тип преобразования разрешён. Для совместимости с предыдущими версиями NumPy это по умолчанию устанавливается в ‘unsafe’ для numpy < 1.7. В numpy 1.7 началось переход на ‘same_kind’, где ufuncs генерируют DeprecationWarning для вызовов, которые разрешены по правилам ‘unsafe’, но не по правилам ‘same_kind’. Начиная с numpy 1.10 и далее, значение по умолчанию — ‘same_kind’.

order

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

Указывает порядок итерации вычислений/макет памяти выходного массива. По умолчанию установлено значение ‘K’. ‘C’ означает, что выход должен быть C-непрерывным, ‘F’ означает F-непрерывным, ‘A’ означает F-непрерывным, если входные данные являются F-непрерывными и не являются также C-непрерывными, в противном случае C-непрерывным, и ‘K’ означает соответствие порядку элементов входных данных как можно более точно.

dtype

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

Переопределяет тип данных вычислений и выходных массивов. Похоже на signature.

subok

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

По умолчанию значение true. Если установлено в false, выход всегда будет строго массивом, а не подтипом.

signature

Тип данных, кортеж типов данных или специальная строка сигнатуры, указывающая входные и выходные типы ufunc. Этот аргумент позволяет указать определённую сигнатуру для 1-мерного цикла, используемого в базовых вычислениях. Если указанный цикл не существует для ufunc, то возникает ошибка TypeError. Обычно подходящий цикл находится автоматически путём сравнения типов входных данных с имеющимися и поиска цикла с типами данных, в которые все входные данные могут быть преобразованы безопасно. Этот ключевой аргумент позволяет обойти этот поиск и выбрать определённый цикл. Список доступных сигнатур предоставляется атрибутом types объекта ufunc. Для обратной совместимости этот аргумент также может быть предоставлен как sig, хотя предпочтительнее использовать полную форму. Обратите внимание, что это не следует путать с обобщённой ufunc сигнатурой, которая хранится в атрибуте signature объекта ufunc.

extobj

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

Атрибуты

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

__doc__

Строка документации для каждой ufunc. Первая часть строки документации динамически генерируется на основе количества выходов, имени и количества входных данных. Вторая часть строки документации предоставляется во время создания и сохраняется с ufunc.

__name__

Имя ufunc.

`ufunc.nin`	Количество входных данных.
`ufunc.nout`	Количество выходов.
`ufunc.nargs`	Количество аргументов.
`ufunc.ntypes`	Количество типов.
`ufunc.types`	Возвращает список с типами, сгруппированными по вход->выход.
`ufunc.identity`	Идентификационное значение.
`ufunc.signature`	Описание основных элементов, с которыми работает обобщённая ufunc.

Методы

Все ufunc имеют четыре метода. Однако эти методы имеют смысл только для скалярных ufunc, принимающих два входных аргумента и возвращающих один выходной аргумент. Попытка вызвать эти методы для других ufunc приведёт к ошибке ValueError. Методы, подобные методам reduce, все принимают ключевое слово axis, ключевое слово dtype и ключевое слово out, и все массивы должны иметь размерность >= 1. Ключевое слово axis указывает ось массива, по которой будет происходить уменьшение (отрицательные значения считаются в обратном порядке). Обычно это целое число, хотя для ufunc.reduce оно также может быть кортежем из int для уменьшения по нескольким осям сразу или None для уменьшения по всем осям. Ключевое слово dtype позволяет управлять очень распространённой проблемой, возникающей при небрежном использовании ufunc.reduce. Иногда у вас есть массив определённого типа данных, и вы хотите сложить все его элементы, но результат не помещается в тип данных массива. Это часто происходит, если у вас есть массив целых чисел с одним байтом. Ключевое слово dtype позволяет изменить тип данных, по которому происходит уменьшение (и, следовательно, тип результата). Таким образом, вы можете гарантировать, что результат имеет тип данных с достаточной точностью для обработки вашего вывода. Ответственность за изменение типа reduce лежит в основном на вас. Существует одно исключение: если для операции уменьшения с операциями «сложения» или «умножения» не указан параметр dtype, то если входной тип является целым (или булевым) типом данных и меньше размера типа данных int_, он будет внутренне преобразован к типу данных int_ (или uint). Наконец, ключевое слово out позволяет предоставить массив вывода (для ufunc с одним выходом, которые в настоящее время поддерживаются; для будущего расширения можно передать кортеж с одним аргументом). Если out задан, то аргумент dtype игнорируется.

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

`ufunc.reduce`(массив[, ось, тип_данных, вывод, …])	Уменьшает размерность массива на один, применяя ufunc по одной оси.
`ufunc.accumulate`(массив[, ось, тип_данных, вывод])	Накапливает результат применения оператора ко всем элементам.
`ufunc.reduceat`(массив, индексы[, ось, …])	Выполняет (локальное) уменьшение с указанными срезами по одной оси.
`ufunc.outer`(A, B, /, **kwargs)	Применяет ufunc `op` ко всем парам (a, b), где a в `A` и b в `B`.
`ufunc.at`(a, индексы[, b])	Выполняет небуферизованную операцию на месте над операндом ‘a’ для элементов, указанных в ‘индексы’.

Предупреждение

Операция reduce-подобная на массиве с типом данных, диапазон которого «слишком мал», чтобы обработать результат, будет молча перекручена. Необходимо использовать dtype для увеличения размера типа данных, по которому происходит уменьшение.

Доступные ufuncs

В настоящее время в numpy определено более 60 универсальных функций для одного или нескольких типов, охватывающих широкий спектр операций. Некоторые из этих ufunc вызываются автоматически над массивами при использовании соответствующей инфиксной нотации (например, add(a, b) вызывается внутренне при написании a + b и a или b является ndarray). Тем не менее, вы всё ещё можете использовать вызов ufunc, чтобы использовать необязательные аргументы вывода для размещения вывода(ов) в объекте(ах) по вашему выбору.

Обратите внимание, что каждая ufunc работает поэлементно. Поэтому каждая скалярная ufunc будет описана так, как если бы она действовала на наборе скалярных входных данных для получения набора скалярных выходных данных.

Примечание

Ufunc всё равно возвращает свой(свои) вывод(ы), даже если вы используете необязательный(ые) аргумент(ы) вывода.

Математические операции

`add`(x1, x2, /[, out, where, casting, order, …])	Элемент-поэлементное сложение аргументов.
`subtract`(x1, x2, /[, out, where, casting, …])	Вычитание аргументов, элемент-по-элементу.
`multiply`(x1, x2, /[, out, where, casting, …])	Умножение аргументов, элемент-по-элементу.
`matmul`(x1, x2, /[, out, casting, order, …])	Матричное произведение двух массивов.
`divide`(x1, x2, /[, out, where, casting, …])	Возвращает истинное деление входных данных, элемент-по-элементу.
`logaddexp`(x1, x2, /[, out, where, casting, …])	Логарифм суммы экспоненциалов входных данных.
`logaddexp2`(x1, x2, /[, out, where, casting, …])	Логарифм суммы экспоненциалов входных данных в основании 2.
`true_divide`(x1, x2, /[, out, where, …])	Возвращает истинное деление входных данных, элемент-по-элементу.
`floor_divide`(x1, x2, /[, out, where, …])	Возвращает наибольшее целое число, меньшее или равное частному от деления входных данных.
`negative`(x, /[, out, where, casting, order, …])	Числовое отрицание, элемент-по-элементу.
`positive`(x, /[, out, where, casting, order, …])	Числовое положительное значение, элемент-по-элементу.
`power`(x1, x2, /[, out, where, casting, …])	Элементы первого массива возводятся в степени из второго массива, элемент-по-элементу.
`float_power`(x1, x2, /[, out, where, …])	Элементы первого массива возводятся в степени из второго массива, элемент-по-элементу.
`remainder`(x1, x2, /[, out, where, casting, …])	Возвращает остаток от деления, элемент-по-элементу.
`mod`(x1, x2, /[, out, where, casting, order, …])	Возвращает остаток от деления, элемент-по-элементу.
`fmod`(x1, x2, /[, out, where, casting, …])	Возвращает остаток от деления, элемент-по-элементу.
`divmod`(x1, x2[, out1, out2], / [[, out, …])	Возвращает целую часть от деления и остаток одновременно, элемент-по-элементу.
`absolute`(x, /[, out, where, casting, order, …])	Вычисляет абсолютное значение, элемент-по-элементу.
`fabs`(x, /[, out, where, casting, order, …])	Вычисляет абсолютные значения, элемент-по-элементу.
`rint`(x, /[, out, where, casting, order, …])	Округляет элементы массива до ближайшего целого.
`sign`(x, /[, out, where, casting, order, …])	Возвращает указание на знак числа, элемент-по-элементу.
`heaviside`(x1, x2, /[, out, where, casting, …])	Вычисляет функцию Хевисайда.
`conj`(x, /[, out, where, casting, order, …])	Возвращает комплексно сопряжённое значение, элемент-по-элементу.
`conjugate`(x, /[, out, where, casting, …])	Возвращает комплексно сопряжённое значение, элемент-по-элементу.
`exp`(x, /[, out, where, casting, order, …])	Вычисляет экспоненту всех элементов в входном массиве.
`exp2`(x, /[, out, where, casting, order, …])	Вычисляет 2^x для всех элементов в входном массиве.
`log`(x, /[, out, where, casting, order, …])	Натуральный логарифм, элемент-по-элементу.
`log2`(x, /[, out, where, casting, order, …])	Логарифм по основанию 2 от входных данных.
`log10`(x, /[, out, where, casting, order, …])	Возвращает логарифм по основанию 10 входного массива, элемент-по-элементу.
`expm1`(x, /[, out, where, casting, order, …])	Вычисляет exp(x) - 1 для всех элементов в массиве.
`log1p`(x, /[, out, where, casting, order, …])	Возвращает натуральный логарифм от единицы плюс входной массив, элемент-по-элементу.
`sqrt`(x, /[, out, where, casting, order, …])	Возвращает неотрицательный квадратный корень из массива, элемент-по-элементу.
`square`(x, /[, out, where, casting, order, …])	Возвращает квадрат каждого элемента входных данных.
`cbrt`(x, /[, out, where, casting, order, …])	Возвращает кубический корень из массива, элемент-по-элементу.
`reciprocal`(x, /[, out, where, casting, …])	Возвращает обратную величину аргумента, элемент-по-элементу.
`gcd`(x1, x2, /[, out, where, casting, order, …])	Возвращает наибольший общий делитель чисел `\|x1\|` и `\|x2\|`.
`lcm`(x1, x2, /[, out, where, casting, order, …])	Возвращает наименьшее общее кратное чисел `\|x1\|` и `\|x2\|`.

Подсказка

Дополнительные выходные аргументы могут помочь вам сэкономить память для больших вычислений. Если ваши массивы большие, сложные выражения могут занимать больше времени, чем необходимо, из-за создания и (позднее) уничтожения временных областей вычислений. Например, выражение G = a * b + c эквивалентно t1 = A * B; G = T1 + C; del t1. Оно будет выполняться быстрее как G = A * B; add(G, C, G), что равно G = A * B; G += C.

Тригонометрические функции

Все тригонометрические функции используют радианы, когда требуется угол. Соотношение градусов к радианам равно $180^{\circ}/\pi.$

`sin`(x, /[, out, where, casting, order, …])	Тригонометрический синус, поэлементно.
`cos`(x, /[, out, where, casting, order, …])	Косинус, поэлементно.
`tan`(x, /[, out, where, casting, order, …])	Вычисление тангенса поэлементно.
`arcsin`(x, /[, out, where, casting, order, …])	Обратный синус, поэлементно.
`arccos`(x, /[, out, where, casting, order, …])	Обратный тригонометрический косинус, поэлементно.
`arctan`(x, /[, out, where, casting, order, …])	Обратный тригонометрический тангенс, поэлементно.
`arctan2`(x1, x2, /[, out, where, casting, …])	Поэлементная арктангенс от `x1/x2`, правильно выбирая квадрант.
`hypot`(x1, x2, /[, out, where, casting, …])	При заданных «катетах» прямоугольного треугольника, возвращает его гипотенузу.
`sinh`(x, /[, out, where, casting, order, …])	Гиперболический синус, поэлементно.
`cosh`(x, /[, out, where, casting, order, …])	Гиперболический косинус, поэлементно.
`tanh`(x, /[, out, where, casting, order, …])	Вычисление гиперболического тангенса поэлементно.
`arcsinh`(x, /[, out, where, casting, order, …])	Обратный гиперболический синус поэлементно.
`arccosh`(x, /[, out, where, casting, order, …])	Обратный гиперболический косинус, поэлементно.
`arctanh`(x, /[, out, where, casting, order, …])	Обратный гиперболический тангенс поэлементно.
`degrees`(x, /[, out, where, casting, order, …])	Преобразование углов из радиан в градусы.
`radians`(x, /[, out, where, casting, order, …])	Преобразование углов из градусов в радианы.
`deg2rad`(x, /[, out, where, casting, order, …])	Преобразование углов из градусов в радианы.
`rad2deg`(x, /[, out, where, casting, order, …])	Преобразование углов из радиан в градусы.

Функции для работы с битами

Все эти функции требуют целочисленных аргументов и манипулируют битовым представлением этих аргументов.

`bitwise_and`(x1, x2, /[, out, where, …])	Вычисляет поэлементную поразрядную AND двух массивов.
`bitwise_or`(x1, x2, /[, out, where, casting, …])	Вычисляет поэлементную поразрядную OR двух массивов.
`bitwise_xor`(x1, x2, /[, out, where, …])	Вычисляет поэлементную поразрядную XOR двух массивов.
`invert`(x, /[, out, where, casting, order, …])	Вычисляет поразрядное инвертирование (или поразрядное NOT) поэлементно.
`left_shift`(x1, x2, /[, out, where, casting, …])	Сдвигает биты целого числа влево.
`right_shift`(x1, x2, /[, out, where, …])	Сдвигает биты целого числа вправо.

Функции сравнения

`greater`(x1, x2, /[, out, where, casting, …])	Возвращает логическое значение (x1 > x2) поэлементно.
`greater_equal`(x1, x2, /[, out, where, …])	Возвращает логическое значение (x1 >= x2) поэлементно.
`less`(x1, x2, /[, out, where, casting, …])	Возвращает логическое значение (x1 < x2) поэлементно.
`less_equal`(x1, x2, /[, out, where, casting, …])	Возвращает логическое значение (x1 <= x2) поэлементно.
`not_equal`(x1, x2, /[, out, where, casting, …])	Возвращает (x1 != x2) поэлементно.
`equal`(x1, x2, /[, out, where, casting, …])	Возвращает (x1 == x2) поэлементно.

Предупреждение

Не используйте ключевые слова Python and и or для объединения логических выражений массивов. Эти ключевые слова проверяют истинность всего массива (а не поэлементно, как вы могли ожидать). Используйте поразрядные операторы & и | вместо этого.

`logical_and`(x1, x2, /[, out, where, …])	Вычисляет логическое значение x1 И x2 поэлементно.
`logical_or`(x1, x2, /[, out, where, casting, …])	Вычисляет логическое значение x1 ИЛИ x2 поэлементно.
`logical_xor`(x1, x2, /[, out, where, …])	Вычисляет логическое значение x1 ИСКЛЮЧАЮЩЕЕ ИЛИ x2 поэлементно.
`logical_not`(x, /[, out, where, casting, …])	Вычисляет логическое значение НЕ x поэлементно.

Предупреждение

Поразрядные операторы & и | — это правильный способ выполнения поэлементных сравнений массивов. Убедитесь, что вы понимаете приоритет операторов: (a > 2) & (a < 5) — правильный синтаксис, потому что a > 2 & a < 5 приведет к ошибке из-за того, что 2 & a вычисляется в первую очередь.

maximum(x1, x2, /[, out, where, casting, …])

Максимальное значение по элементам массива.

Подсказка

Функция Python max() найдет максимальное значение по одномерному массиву, но сделает это с использованием более медленного последовательного интерфейса. Метод reduce функции ufunc maximum намного быстрее. Также, метод max() не даст ожидаемых результатов для массивов с размерностью больше единицы. Метод reduce для минимального значения также позволяет вычислять общее минимальное значение по массиву.

minimum(x1, x2, /[, out, where, casting, …])

Минимальное значение по элементам массива.

Предупреждение

Поведение maximum(a, b) отличается от max(a, b). Как функция ufunc, maximum(a, b) выполняет поэлементное сравнение a и b и выбирает каждый элемент результата в зависимости от того, какой элемент в двух массивах больше. В отличие от этого, max(a, b) рассматривает объекты a и b как единое целое, смотрит на (общее) логическое значение a > b и использует его для возврата либо a, либо b (как единое целое). Аналогичное различие существует между minimum(a, b) и min(a, b).

`fmax`(x1, x2, /[, out, where, casting, …])	Максимальное значение элементов массива.
`fmin`(x1, x2, /[, out, where, casting, …])	Минимальное значение элементов массива.

Функции с плавающей запятой

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

`isfinite`(x, /[, out, where, casting, order, …])	Проверка поэлементно на конечность (не бесконечность и не число Not a Number).
`isinf`(x, /[, out, where, casting, order, …])	Проверка поэлементно на положительную или отрицательную бесконечность.
`isnan`(x, /[, out, where, casting, order, …])	Проверка поэлементно на NaN (Not a Number) и возвращение результата в виде булевого массива.
`isnat`(x, /[, out, where, casting, order, …])	Проверка поэлементно на NaT (не время) и возвращение результата в виде булевого массива.
`fabs`(x, /[, out, where, casting, order, …])	Вычисление абсолютных значений поэлементно.
`signbit`(x, /[, out, where, casting, order, …])	Возвращает поэлементно True, где установлен бит знака (меньше нуля).
`copysign`(x1, x2, /[, out, where, casting, …])	Изменение знака x1 на знак x2 поэлементно.
`nextafter`(x1, x2, /[, out, where, casting, …])	Возвращение следующего значения с плавающей запятой после x1 в направлении x2 поэлементно.
`spacing`(x, /[, out, where, casting, order, …])	Возвращение расстояния между x и ближайшим соседним числом.
`modf`(x[, out1, out2], / [[, out, where, …])	Возвращение дробной и целой частей массива поэлементно.
`ldexp`(x1, x2, /[, out, where, casting, …])	Возвращает x1 * 2**x2 поэлементно.
`frexp`(x[, out1, out2], / [[, out, where, …])	Разложение элементов x на мантиссу и показатель степени двойки.
`fmod`(x1, x2, /[, out, where, casting, …])	Возвращение остатка от деления поэлементно.
`floor`(x, /[, out, where, casting, order, …])	Возвращение наименьшего целого числа, не превосходящего входное значение, поэлементно.
`ceil`(x, /[, out, where, casting, order, …])	Возвращение наименьшего целого числа, не меньшего входного значения, поэлементно.
`trunc`(x, /[, out, where, casting, order, …])	Возвращение усеченного значения входного значения поэлементно.