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

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

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

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

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

Все входные массивы с 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), где единственное значение повторяется.

Определение типа выходных данных

Выход универсальной функции (и её методов) необязательно является ndarray, если все входные аргументы не являются ndarrays. Действительно, если какой-либо входной параметр определяет метод __array_ufunc__, управление будет полностью передано этой функции, то есть универсальная функция переопределяется.

Если ни один из входов не переопределяет универсальную функцию, все выходные массивы будут переданы методам __array_prepare__ и __array_wrap__ ввода (кроме ndarrays и скаляров), который его определяет и имеет наивысший __array_priority__ любого другого ввода в универсальную функцию. Значение по умолчанию для __array_priority__ ndarray — 0.0, а значение по умолчанию для __array_priority__ подтипа — 0.0. Матрицы имеют __array_priority__ равным 10.0.

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

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

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

setbufsize(размер)

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

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

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

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

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

Примечание

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

Рисунок

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

>>> mark = {False: ' -', True: ' Y'}
>>> def print_table(ntypes):
...     print('X ' + ' '.join(ntypes))
...     for row in ntypes:
...         print(row, end='')
...         for col in ntypes:
...             print(mark[np.can_cast(row, col)], end='')
...         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
? Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y - Y
b - Y Y Y Y Y Y - - - - - - Y Y Y Y Y Y Y Y Y Y Y - Y
h - - Y Y Y Y Y - - - - - - - Y Y Y Y Y Y Y Y Y Y - Y
i - - - Y Y Y Y - - - - - - - - Y Y - Y Y Y Y Y Y - Y
l - - - - Y Y Y - - - - - - - - Y Y - Y Y Y Y Y Y - Y
q - - - - Y Y Y - - - - - - - - Y Y - Y Y Y Y Y Y - Y
p - - - - Y Y Y - - - - - - - - Y Y - Y Y Y Y Y Y - Y
B - - Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y Y - Y
H - - - Y Y Y Y - Y Y Y Y Y - Y Y Y Y Y Y Y Y Y Y - Y
I - - - - Y Y Y - - Y Y Y Y - - Y Y - Y Y Y Y Y Y - Y
L - - - - - - - - - - Y Y Y - - Y Y - Y Y Y Y Y Y - -
Q - - - - - - - - - - Y Y Y - - Y Y - Y Y Y Y Y Y - -
P - - - - - - - - - - Y Y Y - - Y Y - Y Y Y Y Y Y - -
e - - - - - - - - - - - - - Y Y Y Y Y Y Y Y Y Y Y - -
f - - - - - - - - - - - - - - Y Y Y Y Y Y Y Y Y Y - -
d - - - - - - - - - - - - - - - Y Y - Y Y Y Y Y Y - -
g - - - - - - - - - - - - - - - - Y - - Y Y Y Y Y - -
F - - - - - - - - - - - - - - - - - Y Y Y Y Y Y Y - -
D - - - - - - - - - - - - - - - - - - Y Y Y Y Y Y - -
G - - - - - - - - - - - - - - - - - - - Y Y Y Y Y - -
S - - - - - - - - - - - - - - - - - - - - Y Y Y Y - -
U - - - - - - - - - - - - - - - - - - - - - Y Y Y - -
V - - - - - - - - - - - - - - - - - - - - - - Y Y - -
O - - - - - - - - - - - - - - - - - - - - - - Y Y - -
M - - - - - - - - - - - - - - - - - - - - - - Y Y Y -
m - - - - - - - - - - - - - - - - - - - - - - Y Y - Y

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

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

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

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

`ufunc`

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

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

out

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

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

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

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

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

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

where

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

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

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

axes

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

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

axis

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

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

keepdims

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

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

extobj

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

Атрибуты

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

__doc__

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

__name__

Имя ufunc.

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

Методы 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, …])	Сокращает размерность массива на один, применяя 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, …])	Умножает аргументы, поэлементно.
`matmul`(x1, x2, /[, out, casting, order, …])	Матричное произведение двух массивов.
`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, …])	Элементы первого массива возводятся в степени из второго массива, поэлементно.
`float_power`(x1, x2, /[, out, where, …])	Элементы первого массива возводятся в степени из второго массива, поэлементно.
`remainder`(x1, x2, /[, out, where, casting, …])	Возвращает остаток от деления, поэлементно.
`mod`(x1, x2, /[, out, where, casting, order, …])	Возвращает остаток от деления, поэлементно.
`fmod`(x1, x2, /[, out, where, casting, …])	Возвращает остаток от деления, поэлементно.
`divmod`(x1, x2[, out1, out2], / [[, out, …])	Возвращает частное и остаток от деления, поэлементно.
`absolute`(x, /[, out, where, casting, order, …])	Вычисляет абсолютное значение, поэлементно.
`fabs`(x, /[, out, where, casting, order, …])	Вычисляет абсолютные значения, поэлементно.
`rint`(x, /[, out, where, casting, order, …])	Округляет элементы массива до ближайшего целого числа.
`sign`(x, /[, out, where, casting, order, …])	Возвращает поэлементное указание знака числа.
`heaviside`(x1, x2, /[, out, where, casting, …])	Вычисляет функцию Хевисайда.
`conj`(x, /[, out, where, casting, order, …])	Возвращает комплексно сопряжённое значение, поэлементно.
`conjugate`(x, /[, out, where, casting, …])	Возвращает комплексно сопряжённое значение, поэлементно.
`exp`(x, /[, out, where, casting, order, …])	Вычисляет экспоненту от всех элементов входного массива.
`exp2`(x, /[, out, where, casting, order, …])	Вычисляет `2**p` для всех `p` в входном массиве.
`log`(x, /[, out, where, casting, order, …])	Натуральный логарифм, поэлементно.
`log2`(x, /[, out, where, casting, order, …])	Логарифм по основанию 2 от `x`.
`log10`(x, /[, out, where, casting, order, …])	Возвращает логарифм по основанию 10 входного массива, поэлементно.
`expm1`(x, /[, out, where, casting, order, …])	Вычисляет `exp(x) - 1` для всех элементов в массиве.
`log1p`(x, /[, out, where, casting, order, …])	Возвращает натуральный логарифм от единицы плюс входной массив, поэлементно.
`sqrt`(x, /[, out, where, casting, order, …])	Возвращает неотрицательный квадратный корень из массива, поэлементно.
`square`(x, /[, out, where, casting, order, …])	Возвращает поэлементное возведение в квадрат входного массива.
`cbrt`(x, /[, out, where, casting, order, …])	Возвращает кубический корень из массива, поэлементно.
`reciprocal`(x, /[, out, where, casting, …])	Возвращает обратную величину аргумента, поэлементно.
`gcd`(x1, x2, /[, out, where, casting, order, …])	Возвращает наибольший общий делитель `\|x1\|` и `\|x2\|`
`lcm`(x1, x2, /[, out, where, casting, order, …])	Возвращает наименьшее общее кратное `\|x1\|` и `\|x2\|`

Подсказка

Дополнительные выходные аргументы могут помочь вам сохранить память для больших вычислений. Если ваши массивы велики, сложные выражения могут занимать больше времени, чем абсолютно необходимо, из-за создания и (позже) уничтожения временных областей вычислений. Например, выражение G = a * b + c эквивалентно t1 = A * B; G = T1 + C; del t1. Оно будет выполняться быстрее как G = A * B; add(G, C, G), что то же самое, что G = A * B; G += C.

Тригонометрические функции

Все тригонометрические функции используют радиан для измерения углов. Соотношение градусов к радианам составляет $180^{\circ}/\pi.$

`sin`(x, /[, out, where, casting, order, …])	Тригонометрический синус, поэлементно.
`cos`(x, /[, out, where, casting, order, …])	Косинус поэлементно.
`tan`(x, /[, out, where, casting, order, …])	Вычисление тангенса поэлементно.
`arcsin`(x, /[, out, where, casting, order, …])	Обратный синус, поэлементно.
`arccos`(x, /[, out, where, casting, order, …])	Обратный тригонометрический косинус, поэлементно.
`arctan`(x, /[, out, where, casting, order, …])	Обратный тригонометрический тангенс, поэлементно.
`arctan2`(x1, x2, /[, out, where, casting, …])	Поэлементная арктангенс `x1/x2`, корректно выбирающая квадрант.
`hypot`(x1, x2, /[, out, where, casting, …])	Даны «катеты» прямоугольного треугольника, возвращает его гипотенузу.
`sinh`(x, /[, out, where, casting, order, …])	Гиперболический синус, поэлементно.
`cosh`(x, /[, out, where, casting, order, …])	Гиперболический косинус, поэлементно.
`tanh`(x, /[, out, where, casting, order, …])	Вычисление гиперболического тангенса поэлементно.
`arcsinh`(x, /[, out, where, casting, order, …])	Обратный гиперболический синус поэлементно.
`arccosh`(x, /[, out, where, casting, order, …])	Обратный гиперболический косинус, поэлементно.
`arctanh`(x, /[, out, where, casting, order, …])	Обратный гиперболический тангенс поэлементно.
`degrees`(x, /[, out, where, casting, order, …])	Перевод углов из радиан в градусы.
`radians`(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 и возвращение результата в виде булевого массива.
`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, …])	Возвращает целую часть числа, меньшую или равную x, поэлементно.
`ceil`(x, /[, out, where, casting, order, …])	Возвращает наименьшее целое число, большее или равное x, поэлементно.
`trunc`(x, /[, out, where, casting, order, …])	Возвращает целую часть числа, поэлементно.