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

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

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

Векторная обработка

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

Все входные массивы с ndim меньше, чем у входного массива с наибольшим ndim, имеют префикс 1 в своих формах.
Размер в каждом измерении формы результата является максимальным из всех размеров входных массивов в этом измерении.
Входной массив может быть использован в вычислениях, если его размер в определённом измерении совпадает с размером результата в этом измерении или имеет значение, равное 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_prepare__ и __array_wrap__ входного (кроме ndarrays и скаляров) объекта, который его определяет и имеет наивысший __array_priority__ по сравнению с другими входными данными универсальной функции. Значение по умолчанию __array_priority__ для ndarray равно 0.0, а значение по умолчанию __array_priority__ для подтипа равно 1.0. Матрицы имеют __array_priority__ равное 10.0.

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

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

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

setbufsize(size) Установить размер буфера, используемого в ufunc.

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

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

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

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

Примечание

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

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

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

Примечание

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

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

Рисунок

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

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

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

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

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

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

`ufunc`

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

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

out

Введено в версии 1.6.

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

Введено в версии 1.10.

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

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

where

Введено в версии 1.7.

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

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-мерного цикла для использования в базовых вычислениях. Если цикл, указанный для ufunc, не существует, то возникает TypeError. Обычно подходящий цикл находится автоматически путем сравнения типов входных данных с доступными и поиска цикла с типами данных, к которым все входные данные могут быть приведены безопасно. Этот ключевой аргумент позволяет обойти этот поиск и выбрать конкретный цикл. Список доступных подписей предоставляется атрибутом types объекта ufunc. Для обратной совместимости этот аргумент также можно предоставить как sig, хотя предпочтительнее использовать полную форму.

extobj

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

Атрибуты

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

__doc__

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

__name__

Имя ufunc.

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

Методы

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

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

`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**p` для всех `p` в входном массиве.
`log`(x, /[, out, where, casting, order, ...])	Натуральный логарифм, по элементам.
`log2`(x, /[, out, where, casting, order, ...])	Логарифм по основанию 2 от `x`.
`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, ...])	Поэлементное вычисление битовой И двух массивов.
`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(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, ...])	Поэлементная проверка на конечность (не бесконечность и не число NaN).
`isinf`(x, /[, out, where, casting, order, ...])	Поэлементная проверка на положительную или отрицательную бесконечность.
`isnan`(x, /[, out, where, casting, order, ...])	Поэлементная проверка на NaN и возвращение результата в виде булевого массива.
`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, ...])	Возвращает ближайшее целое число, большее или равное x, поэлементно.
`trunc`(x, /[, out, where, casting, order, ...])	Возвращает целую часть числа, поэлементно.

© 2008–2017 NumPy Developers
Licensed under the NumPy License.
https://docs.scipy.org/doc/numpy-1.13.0/reference/ufuncs.html