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

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

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

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

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

Все входные массивы с ndim меньше, чем входной массив с наибольшим ndim, имеют 1 добавленные в начале к своим формам.
Размер в каждом измерении выходной формы — это максимальное значение всех размеров входных данных в этом измерении.
Входные данные могут быть использованы в вычислении, если их размер в конкретном измерении либо соответствует размеру выходных данных в этом измерении, либо равен точно 1.
Если размер входного массива в каком-то измерении равен 1, то первое значение в этом измерении будет использоваться для всех вычислений вдоль этого измерения. Другими словами, механизм шага ufunc просто не будет делать шаги вдоль этого измерения (шаг stride для этого измерения будет 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__ подтипа равен 1,0. Матрицы имеют приоритет __array_priority__, равный 10,0.

Все ufunc также могут принимать выходные аргументы. При необходимости выходные данные будут преобразованы к типу(ам) данных предоставленного выходного массива(ов). Если для выхода используется класс с методом __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) Установить размер буфера, используемого в ufunc.

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

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

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

Рисунок

Код, отображающий таблицу «можно безопасно преобразовать» для 32-разрядной системы.

>>> def print_table(ntypes):
...     print 'X',
...     for char in ntypes: print char,
...     print
...     for row in ntypes:
...         print row,
...         for col in ntypes:
...             print int(np.can_cast(row, col)),
...         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
? 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
b 0 1 1 1 1 1 1 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0
h 0 0 1 1 1 1 1 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0
i 0 0 0 1 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
l 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
q 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
p 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
B 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0
H 0 0 0 1 1 1 1 0 1 1 1 1 1 0 1 1 1 1 1 1 1 1 1 1 0 0
I 0 0 0 0 1 1 1 0 0 1 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
L 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
Q 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
P 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 1 1 0 1 1 1 1 1 1 0 0
e 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0
f 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 0 0
d 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 1 0 0
g 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 1 1 1 0 0
F 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0
D 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 0 0
G 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 0 0
S 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0
U 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0
V 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
O 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0
M 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
m 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1

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

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

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

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

`ufunc`

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

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

out

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

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

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

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

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

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

where

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

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

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

axes

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

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

axis

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

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

keepdims

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

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

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

subok

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

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

signature

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

extobj

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

Атрибуты

У универсальных функций есть некоторые справочные атрибуты. Ни один из атрибутов не может быть изменён.

__doc__

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

__name__

Имя ufunc.

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

Методы

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

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

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

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

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

Доступные ufuncs

В настоящее время в numpy определено более 60 универсальных функций на одном или нескольких типах, охватывающих широкий спектр операций. Некоторые из этих ufuncs вызываются автоматически для массивов при использовании соответствующей инфиксной нотации (например, 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, …])	Умножение аргументов поэлементно.
`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, …])	Возведение элементов первого массива в степени из элементов второго массива, поэлементно.
`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, …])	Возвращает комплексно сопряжённое значение поэлементно.
`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, …])	Вычисление (e^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, …])	Поэлементный арктангенс, корректно определяющий квадрант.
`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, …])	Обратный гиперболический тангенс, поэлементное вычисление.
`deg2rad`(x, /[, out, where, casting, order, …])	Перевод углов из градусов в радианы.
`rad2deg`(x, /[, out, where, casting, order, …])	Перевод углов из радиан в градусы.

Битовые функции

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

`bitwise_and`(x1, x2, /[, out, where, …])	Вычисление побитовой И двух массивов поэлементно.
`bitwise_or`(x1, x2, /[, out, where, casting, …])	Вычисление побитовой ИЛИ двух массивов поэлементно.
`bitwise_xor`(x1, x2, /[, out, where, …])	Вычисление побитовой ИСКЛЮЧАЮЩЕЙ ИЛИ двух массивов поэлементно.
`invert`(x, /[, out, where, casting, order, …])	Вычисление побитового инвертирования, или побитовой НЕ, поэлементно.
`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 также позволяет вычислить общий минимум по массиву.

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, …])	Возвращает усечённое значение входного значения, поэлементно.

© 2005–2019 NumPy Developers
Licensed under the 3-clause BSD License.
https://docs.scipy.org/doc/numpy-1.15.4/reference/ufuncs.html