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

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

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

Векторное умножение

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

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

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

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

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

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

Примечание

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

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

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

Примечание

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

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

Рисунок

Фрагмент кода, демонстрирующий таблицу «возможность безопасного преобразования» для 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, а в будущей версии — ошибку.

where

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

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

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.

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

subok

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

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

signature

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

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

Операция уменьшения над массивом с типом данных, диапазон которого «слишком мал», чтобы обработать результат, будет молча обернута. Следует использовать 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, …])	Логарифм суммы экспонент входных данных в двоичной системе.
`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, …])	Двоичный логарифм входного массива, по элементам.
`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, …])	Возвращает обратную величину аргумента, по элементам.

Подсказка

Дополнительные аргументы вывода могут помочь сэкономить память для больших вычислений. Если ваши массивы велики, сложные выражения могут занимать больше времени, чем необходимо, из-за создания и (позже) уничтожения временных областей для вычислений. Например, выражение 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, …])	Вычислить побитовую AND двух массивов поэлементно.
`bitwise_or`(x1, x2, /[, out, where, casting, …])	Вычислить побитовую OR двух массивов поэлементно.
`bitwise_xor`(x1, x2, /[, out, where, …])	Вычислить побитовую XOR двух массивов поэлементно.
`invert`(x, /[, out, where, casting, order, …])	Вычислить побитовое инвертирование, или побитовое NOT, поэлементно.
`left_shift`(x1, x2, /[, out, where, casting, …])	Сдвинуть биты целого числа влево.
`right_shift`(x1, x2, /[, out, where, …])	Сдвинуть биты целого числа вправо.

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

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

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

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

`logical_and`(x1, x2, /[, out, where, …])	Вычислить логическое И x1 AND x2 поэлементно.
`logical_or`(x1, x2, /[, out, where, casting, …])	Вычислить логическое ИЛИ x1 OR x2 поэлементно.
`logical_xor`(x1, x2, /[, out, where, …])	Вычислить логическое ИСКЛЮЧАЮЩЕЕ ИЛИ x1 XOR x2 поэлементно.
`logical_not`(x, /[, out, where, casting, …])	Вычислить логическое НЕ NOT 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 (not a time) и возврат результата в виде булевого массива.
`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.14.5/reference/ufuncs.html