Универсальные функции (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.

END_OF_DOCUMENT_MARKER

В основе каждой 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.16.1/reference/ufuncs.html