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

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

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

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

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

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

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

Внутренне для невыровненных данных, данных с переставленным порядком байтов и данных, которые необходимо преобразовать из одного типа данных в другой, используются буферы. Размер внутренних буферов настраивается на уровне потока. Для обработки данных всех входных и выходных данных ufunc может быть создано до $2 (n_{\mathrm{inputs}} + n_{\mathrm{outputs}})$ буферов заданного размера. Размер буфера по умолчанию составляет 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, принимающих два входных аргумента и возвращающих один выходной аргумент. Попытка вызвать эти методы для других 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, …])	Уменьшает размерность `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, …])	Возвращает комплексно сопряжённое значение поэлементно.
`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, …])	Возвращает десятичный логарифм входного массива поэлементно.
`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, …])	Обратный гиперболический тангенс поэлементно.
`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.17.0/reference/ufuncs.html