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

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

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

Векторное сложение массивов

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

Все входные массивы с ndim меньше, чем размерность входного массива с наибольшей ndim, имеют 1 добавленные в начало своих форм.
Размерность каждой размерности результирующей формы равна максимуму всех размеров входных массивов в этой размерности.
Входные данные могут быть использованы в вычислении, если их размер в определённой размерности совпадает с размером выходного массива в этой размерности или равен 1.
Если входной массив имеет размер 1 в своей форме в какой-либо размерности, то первое значение в этой размерности будет использоваться во всех вычислениях по этой размерности. Другими словами, механизм шага ufunc просто не будет перемещаться по этой размерности (шаг stride будет равен 0 для этой размерности).

Векторное сложение используется по всему NumPy для определения того, как обрабатывать массивы с разными формами; например, все арифметические операции (+, -, *, ...) между ndarrays векторизуют массивы перед операцией.

Набор массивов называется «broadcastable» к одной форме, если вышеуказанные правила дают допустимый результат, т.е., одно из следующих утверждений истинно:

Массивы имеют точно такую же форму.
Массивы имеют одинаковое число размерностей, а длина каждой размерности является либо общей длиной, либо 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.

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

Рисунок

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

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

Настройка поведения Ufunc

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

`ufunc`

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

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

out

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

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

..versionadded:: 1.10

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

Передача одного массива в ключевом аргументе ‘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’, где 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.

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

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`	Значение тождества.

Методы

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

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

`ufunc.reduce`(a[, axis, dtype, out, keepdims])	Уменьшает размерность `a` на единицу, применяя ufunc по одной оси.
`ufunc.accumulate`(array[, axis, dtype, out])	Накапливает результат применения оператора ко всем элементам.
`ufunc.reduceat`(a, indices[, axis, dtype, out])	Выполняет (локальное) уменьшение с заданными срезами по одной оси.
`ufunc.outer`(A, B)	Применяет 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])	Складывает аргументы поэлементно.
`subtract`(x1, x2[, out])	Вычитает аргументы поэлементно.
`multiply`(x1, x2[, out])	Умножает аргументы поэлементно.
`divide`(x1, x2[, out])	Делит аргументы поэлементно.
`logaddexp`(x1, x2[, out])	Логарифм суммы экспонент входных данных.
`logaddexp2`(x1, x2[, out])	Логарифм суммы экспонент входных данных по основанию 2.
`true_divide`(x1, x2[, out])	Возвращает истинное деление входных данных поэлементно.
`floor_divide`(x1, x2[, out])	Возвращает наибольшее целое число, меньшее или равное частному входных данных.
`negative`(x[, out])	Числовое отрицание, поэлементно.
`power`(x1, x2[, out])	Элементы первого массива возводятся в степень элементов второго массива поэлементно.
`remainder`(x1, x2[, out])	Возвращает остаток от деления поэлементно.
`mod`(x1, x2[, out])	Возвращает остаток от деления поэлементно.
`fmod`(x1, x2[, out])	Возвращает остаток от деления поэлементно.
`absolute`(x[, out])	Вычисляет абсолютное значение поэлементно.
`rint`(x[, out])	Округляет элементы массива до ближайшего целого числа.
`sign`(x[, out])	Возвращает указатель знака числа поэлементно.
`conj`(x[, out])	Возвращает комплексно сопряжённое значение поэлементно.
`exp`(x[, out])	Вычисляет экспоненту всех элементов входного массива.
`exp2`(x[, out])	Вычисляет 2^x для всех x в входном массиве.
`log`(x[, out])	Натуральный логарифм поэлементно.
`log2`(x[, out])	Логарифм по основанию 2 от x.
`log10`(x[, out])	Возвращает десятичный логарифм входного массива поэлементно.
`expm1`(x[, out])	Вычисляет e^x-1 для всех элементов массива.
`log1p`(x[, out])	Возвращает натуральный логарифм от одного плюс входной массив поэлементно.
`sqrt`(x[, out])	Возвращает положительный квадратный корень из массива поэлементно.
`square`(x[, out])	Возвращает квадрат элементов входного массива поэлементно.
`reciprocal`(x[, out])	Возвращает обратную величину аргумента поэлементно.
`ones_like`(a[, dtype, order, subok])	Возвращает массив из единиц с той же формой и типом, что и заданный массив.

Подсказка

Необязательные аргументы вывода могут быть полезны для экономии памяти при больших вычислениях. Если ваши массивы большие, сложные выражения могут занимать больше времени, чем необходимо, из-за создания и (позже) уничтожения временных областей вычислений. Например, выражение 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])	Тригонометрический синус, поэлементно.
`cos`(x[, out])	Косинус, поэлементно.
`tan`(x[, out])	Вычисление тангенса поэлементно.
`arcsin`(x[, out])	Обратный синус, поэлементно.
`arccos`(x[, out])	Обратный косинус, поэлементно.
`arctan`(x[, out])	Обратный тангенс, поэлементно.
`arctan2`(x1, x2[, out])	Поэлементный арктангенс, правильно определяющий квадрант.
`hypot`(x1, x2[, out])	Зная катеты прямоугольного треугольника, найти гипотенузу.
`sinh`(x[, out])	Гиперболический синус, поэлементно.
`cosh`(x[, out])	Гиперболический косинус, поэлементно.
`tanh`(x[, out])	Вычисление гиперболического тангенса поэлементно.
`arcsinh`(x[, out])	Обратный гиперболический синус, поэлементно.
`arccosh`(x[, out])	Обратный гиперболический косинус, поэлементно.
`arctanh`(x[, out])	Обратный гиперболический тангенс, поэлементно.
`deg2rad`(x[, out])	Преобразование углов из градусов в радианы.
`rad2deg`(x[, out])	Преобразование углов из радиан в градусы.

Битовые функции

Эти функции принимают целые числа в качестве аргументов и работают с их битовыми представлениями.

`bitwise_and`(x1, x2[, out])	Вычислить побитовое И двух массивов поэлементно.
`bitwise_or`(x1, x2[, out])	Вычислить побитовое ИЛИ двух массивов поэлементно.
`bitwise_xor`(x1, x2[, out])	Вычислить побитовое ИСКЛЮЧАЮЩЕЕ ИЛИ двух массивов поэлементно.
`invert`(x[, out])	Вычислить побитовое инвертирование (или побитовое НЕ) поэлементно.
`left_shift`(x1, x2[, out])	Сдвинуть биты целого числа влево.
`right_shift`(x1, x2[, out])	Сдвинуть биты целого числа вправо.

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

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

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

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

`logical_and`(x1, x2[, out])	Вычислить логическое И x1 и x2 поэлементно.
`logical_or`(x1, x2[, out])	Вычислить логическое ИЛИ x1 и x2 поэлементно.
`logical_xor`(x1, x2[, out])	Вычислить логическое ИСКЛЮЧАЮЩЕЕ ИЛИ x1 и x2 поэлементно.
`logical_not`(x[, out])	Вычислить логическое НЕ x поэлементно.

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

Побитовые операторы & и | — это правильный способ выполнения поэлементного сравнения массивов. Убедитесь, что вы понимаете приоритет операторов: (a > 2) & (a < 5) — правильный синтаксис, потому что a > 2 & a < 5 приведет к ошибке, так как 2 & a вычисляется в первую очередь.

maximum(x1, x2[, out]) Элемент-но-максимальное значение элементов массива.

Подсказка

Функция Python max() найдет максимальное значение по одномерному массиву, но сделает это с помощью более медленного интерфейса последовательности. Метод reduce функции ufunc maximum намного быстрее. Также, метод max() не даст ожидаемых результатов для массивов с размерностью больше единицы. Метод reduce функции minimum также позволяет вычислить общее минимальное значение по массиву.

minimum(x1, x2[, out]) Элемент-но-минимальное значение элементов массива.

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

Поведение 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])	Элемент-но-максимальное значение элементов массива.
`fmin`(x1, x2[, out])	Элемент-но-минимальное значение элементов массива.

Функции с плавающей запятой

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

`isreal`(x)	Возвращает массив bool, где True, если элемент входного массива вещественный.
`iscomplex`(x)	Возвращает массив bool, где True, если элемент входного массива комплексный.
`isfinite`(x[, out])	Элемент-но проверяет конечность (не бесконечность и не NaN).
`isinf`(x[, out])	Элемент-но проверяет положительную или отрицательную бесконечность.
`isnan`(x[, out])	Элемент-но проверяет NaN и возвращает результат в виде булевого массива.
`signbit`(x[, out])	Возвращает массив bool, где True, если бит знака установлен (меньше нуля).
`copysign`(x1, x2[, out])	Изменить знак x1 на знак x2 поэлементно.
`nextafter`(x1, x2[, out])	Возвращает следующее значение с плавающей точкой после x1 в направлении x2, поэлементно.
`modf`(x[, out1, out2])	Возвращает дробную и целую части массива, поэлементно.
`ldexp`(x1, x2[, out])	Возвращает x1 * 2**x2, поэлементно.
`frexp`(x[, out1, out2])	Разложить элементы x на мантиссу и показатель степени двойки.
`fmod`(x1, x2[, out])	Возвращает остаток от деления поэлементно.
`floor`(x[, out])	Возвращает целую часть (floor) входного значения, поэлементно.
`ceil`(x[, out])	Возвращает верхнюю целую часть (ceiling) входного значения, поэлементно.
`trunc`(x[, out])	Возвращает усеченное значение входного значения, поэлементно.

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