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

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

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

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

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

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

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

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

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

setbufsize(размер)

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

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

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

`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’ включены в таблицу для полноты, к ним не могут применяться функции ufunc. Также обратите внимание, что на 32-битной системе целочисленные типы могут иметь разные размеры, что приводит к немного изменённой таблице.

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

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

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

`ufunc`

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

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

out

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

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

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

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

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

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

where

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

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

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

axes

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

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

axis

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

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

keepdims

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

Если это установлено в True, оси, по которым производилось сокращение, будут оставаться в результате как размерность с размером один, чтобы результат корректно транслировался с входными данными. Этот параметр может быть использован только для обобщённых функций ufunc, которые работают с входными данными, у которых все имеют одинаковое количество основных размерностей, и с выходами, которые не имеют основных размерностей, то есть с сигнатурами, такими как (i),(i)->() или (m,m)->(). При использовании расположение размерностей в выводе можно контролировать с помощью axes и axis.

casting

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

Может быть ‘no’, ‘equiv’, ‘safe’, ‘same_kind’, или ‘unsafe’. См. can_cast для объяснений значений параметра.

Определяет политику разрешённых преобразований типов. Для совместимости с предыдущими версиями NumPy по умолчанию устанавливается ‘unsafe’ для NumPy < 1.7. В NumPy 1.7 начался переход на ‘same_kind’, где функции ufunc генерируют DeprecationWarning для вызовов, разрешённых по правилам ‘unsafe’, но не по правилам ‘same_kind’. Начиная с NumPy 1.10 и далее, значение по умолчанию — ‘same_kind’.

order

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

Указывает порядок итераций вычисления/размещение памяти выходного массива. По умолчанию — ‘K’. ‘C’ означает, что вывод должен быть C-непрерывным, ‘F’ — F-непрерывным, ‘A’ — F-непрерывным, если входные данные F-непрерывны, и не C-непрерывны, в противном случае C-непрерывным, а ‘K’ означает, что необходимо максимально точно воспроизвести порядок элементов входных данных.

dtype

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

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

subok

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

По умолчанию истинно. Если установлено в ложь, вывод всегда будет строгим массивом, а не подтипом.

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 позволяет изменить тип данных, по которому происходит редукция (и, следовательно, тип выходных данных). Таким образом, вы можете гарантировать, что выходные данные имеют тип с достаточной точностью для обработки вашего результата. Ответственность за изменение типа reduce в основном лежит на вас. Есть одно исключение: если для редукции по операциям «сложение» или «умножение» не задан параметр dtype, а тип входных данных — целочисленный (или булевый) и меньше размера типа int_ , то он будет неявно повышен до типа int_ (или uint). Наконец, ключевое слово out позволяет вам предоставить массив вывода (для функций ufuncs с одним выходом, которые в настоящее время поддерживаются; для будущего расширения, однако, можно передать кортеж с одним аргументом). Если задано out, аргумент dtype игнорируется.

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

`ufunc.reduce`(a[, axis, dtype, out, …])	Уменьшает размерность `a` на единицу, применяя ufunc вдоль одной оси.
`ufunc.accumulate`(array[, axis, dtype, out])	Накапливает результат применения оператора ко всем элементам.
`ufunc.reduceat`(a, indices[, axis, dtype, out])	Выполняет (локальную) редукцию со специфицированными срезами по одной оси.
`ufunc.outer`(A, B, **kwargs)	Применяет функцию ufunc `op` ко всем парам (a, b) с a в `A` и b в `B`.
`ufunc.at`(a, indices[, b])	Выполняет операцию на месте без буферизации на операнде ‘a’ для элементов, указанных в ‘indices’.

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

Операция reduce, подобная операции, выполняемая над массивом с типом данных, диапазон которого «слишком мал» для обработки результата, будет молча обернута. Следует использовать dtype для увеличения размера типа данных, по которому выполняется редукция.

Доступные ufuncs

В настоящее время в numpy определено более 60 универсальных функций на одном или нескольких типах, охватывающих широкий спектр операций. Некоторые из этих функций ufunc вызываются автоматически для массивов, когда используется соответствующая инфиксная запись (например, 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, …])	Возвращает комплексно сопряженное значение поэлементно.
`conjugate`(x, /[, out, where, casting, …])	Возвращает комплексно сопряженное значение поэлементно.
`exp`(x, /[, out, where, casting, order, …])	Вычисление экспоненты всех элементов в входном массиве.
`exp2`(x, /[, out, where, casting, order, …])	Вычисление 2^x для всех элементов в входном массиве.
`log`(x, /[, out, where, casting, order, …])	Натуральный логарифм поэлементно.
`log2`(x, /[, out, where, casting, order, …])	Логарифм по основанию 2 от входных данных.
`log10`(x, /[, out, where, casting, order, …])	Возвращает десятичный логарифм входного массива поэлементно.
`expm1`(x, /[, out, where, casting, order, …])	Вычисление e^x - 1 для всех элементов в массиве.
`log1p`(x, /[, out, where, casting, order, …])	Возвращает натуральный логарифм от одного плюс входной массив, поэлементно.
`sqrt`(x, /[, out, where, casting, order, …])	Возвращает неотрицательный квадратный корень массива поэлементно.
`square`(x, /[, out, where, casting, order, …])	Возвращает поэлементное возведение в квадрат входных данных.
`cbrt`(x, /[, out, where, casting, order, …])	Возвращает кубокорень от массива поэлементно.
`reciprocal`(x, /[, out, where, casting, …])	Возвращает обратную величину аргумента поэлементно.
`gcd`(x1, x2, /[, out, where, casting, order, …])	Возвращает наибольший общий делитель для `\|x1\|` и `\|x2\|`
`lcm`(x1, x2, /[, out, where, casting, order, …])	Возвращает наименьшее общее кратное для `\|x1\|` и `\|x2\|`

Подсказка

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

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

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

`sin`(x, /[, out, where, casting, order, …])	Тригонометрический синус, поэлементное.
`cos`(x, /[, out, where, casting, order, …])	Косинус, поэлементное.
`tan`(x, /[, out, where, casting, order, …])	Вычисление тангенса поэлементно.
`arcsin`(x, /[, out, where, casting, order, …])	Обратный синус, поэлементное.
`arccos`(x, /[, out, where, casting, order, …])	Обратный тригонометрический косинус, поэлементное.
`arctan`(x, /[, out, where, casting, order, …])	Обратный тригонометрический тангенс, поэлементное.
`arctan2`(x1, x2, /[, out, where, casting, …])	Поэлементная арктангенс `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 XOR 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, …])	Проверить элементы на конечность (не бесконечность и не число Not a Number).
`isinf`(x, /[, out, where, casting, order, …])	Проверить элементы на положительную или отрицательную бесконечность.
`isnan`(x, /[, out, where, casting, order, …])	Проверить элементы на NaN (Not a Number) и вернуть результат в виде булевого массива.
`isnat`(x, /[, out, where, casting, order, …])	Проверить элементы на NaT (не время) и вернуть результат в виде булевого массива.
`fabs`(x, /[, out, where, casting, order, …])	Вычислить абсолютные значения элементов.
`signbit`(x, /[, out, where, casting, order, …])	Возвращает True для элементов, где установлен знак (меньше нуля).
`copysign`(x1, x2, /[, out, where, casting, …])	Изменить знак x1 на знак x2 для каждого элемента.
`nextafter`(x1, x2, /[, out, where, casting, …])	Возвращает следующее значение с плавающей точкой после x1 в направлении x2 для каждого элемента.
`spacing`(x, /[, out, where, casting, order, …])	Возвращает расстояние между x и ближайшим соседним числом.
`modf`(x[, out1, out2], / [[, out, where, …])	Возвращает дробную и целую части массива для каждого элемента.
`ldexp`(x1, x2, /[, out, where, casting, …])	Возвращает x1 * 2**x2 для каждого элемента.
`frexp`(x[, out1, out2], / [[, out, where, …])	Разложить элементы x на мантиссу и показатель степени двойки.
`fmod`(x1, x2, /[, out, where, casting, …])	Возвращает остаток от деления для каждого элемента.
`floor`(x, /[, out, where, casting, order, …])	Возвращает наибольшее целое число, меньшее или равное элементу.
`ceil`(x, /[, out, where, casting, order, …])	Возвращает наименьшее целое число, большее или равное элементу.
`trunc`(x, /[, out, where, casting, order, …])	Возвращает усечённое значение элемента.