Универсальные функции (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(size) Устанавливает размер буфера, используемого в ufuncs.

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

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

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

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

Примечание

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

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

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

Примечание

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

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

Рисунок

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

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

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

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

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

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

`ufunc`

Дополнительные ключевые аргументы

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

out

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

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

..versionadded:: 1.10

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

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

where

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

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

casting

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

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

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

order

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

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

dtype

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

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

subok

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

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

signature

Либо тип данных, кортеж типов данных, либо специальная строка сигнатуры, указывающая входные и выходные типы ufunc. Этот аргумент позволяет указать определённую сигнатуру для использования 1-мерной петли в базовом вычислении. Если указанная петля не существует для ufunc, возникает ошибка TypeError. Обычно подходящая петля находится автоматически, сравнивая входные типы с доступными и поиск петли с типами данных, к которым все входы могут быть безопасно приведены. Этот ключевой аргумент позволяет вам обойти этот поиск и выбрать конкретную петлю. Список доступных сигнатур предоставляется атрибутом types объекта ufunc. Для обратной совместимости этот аргумент также может быть передан как sig, хотя предпочтительнее использовать полную форму.

extobj

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

Атрибуты

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

__doc__

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

__name__

Имя ufunc.

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

Методы

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

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

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

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

Операция reduce-like над массивом с типом данных, имеющим слишком маленький диапазон для обработки результата, будет молча завернута. Следует использовать dtype для увеличения размера типа данных, над которым выполняется уменьшение.

Доступные ufunc

В настоящее время в numpy определено более 60 универсальных функций для одного или нескольких типов, охватывающих широкий спектр операций. Некоторые из этих ufunc вызываются автоматически для массивов при использовании соответствующего инфиксного обозначения (например, 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])	Элемент-поэлементная обратная тангенс от x1 / x2, выбирающая квадрант корректно.
`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 XOR 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(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])	Поэлементная проверка на конечность (не бесконечность и не Not a Number).
`isinf`(x[, out])	Поэлементная проверка на положительную или отрицательную бесконечность.
`isnan`(x[, out])	Поэлементная проверка на NaN и возврат результата в виде логического массива.
`signbit`(x[, out])	Возвращает поэлементно 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])	Возвращает наибольшее целое число, меньшее или равное входному значению, поэлементно.
`ceil`(x[, out])	Возвращает наименьшее целое число, большее или равное входному значению, поэлементно.
`trunc`(x[, out])	Возвращает усеченное значение входного значения, поэлементно.

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