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

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

В NumPy универсальные функции являются экземплярами класса numpy.ufunc. Многие встроенные функции реализованы на языке С, но экземпляры 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.

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

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

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

Простой интерфейс для установки этой переменной доступен с помощью функции

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

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

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

Обработка ошибок контролируется на основе каждого потока и может быть настроена с помощью функций

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

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

Примечание

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

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

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

Примечание

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

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

Рисунок

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

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

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

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

Переопределение поведения 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.

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

signature

Либо тип данных, кортеж типов данных, либо специальная строка подписи, указывающая типы входных и выходных данных ufunc. Этот аргумент позволяет указать определённую подпись для однострочного цикла, который будет использоваться в базовом вычислении. Если такой цикл не существует для 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, **kwargs)	Применить ufunc `op` ко всем парам (a, b) с a в `A` и b в `B`.
`ufunc.at`(a, indices[, b])	Выполняет небуферизованную операцию на месте с операндом 'a' для элементов, указанных 'indices'.

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

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

Доступные ufuncs

В настоящее время в numpy определено более 60 универсальных функций для одного или нескольких типов, охватывающих широкий спектр операций. Некоторые из этих ufuncs вызываются автоматически над массивами при использовании соответствующей инфиксной нотации (например, add(a, b) вызывается внутри при записи a + b и a или b — ndarray). Тем не менее, вы всё ещё можете использовать вызов ufunc, чтобы использовать дополнительный(е) выходной(е) аргумент(ы) для размещения вывода(ов) в объекте(ах) вашего выбора.

Напомним, что каждый ufunc работает поэлементно. Поэтому каждый ufunc будет описан так, как будто он действует на наборе скалярных входных данных, чтобы вернуть набор скалярных выходных данных.

Примечание

Ufunc всё ещё возвращает свой(и) результат(ы), даже если вы используете необязательный аргумент(ы) для результата.

Математические операции

`add`(x1, x2[, out])	Складывает аргументы поэлементно.
`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])	Вычисляет абсолютное значение поэлементно.
`fabs`(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])	Возвращает натуральный логарифм от (1 + x) поэлементно.
`sqrt`(x[, out])	Возвращает положительную квадратную корень из массива поэлементно.
`square`(x[, out])	Возвращает квадрат каждого элемента входного массива поэлементно.
`cbrt`(x[, out])	Возвращает кубический корень из массива поэлементно.
`reciprocal`(x[, out])	Возвращает обратную величину аргумента поэлементно.

Подсказка

Необязательные аргументы результата могут помочь вам сэкономить память для больших вычислений. Если ваши массивы большие, сложные выражения могут занимать больше времени, чем необходимо, из-за создания и (позже) уничтожения временных пространств для вычислений. Например, выражение 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 также позволяет вычислить общий минимум по массиву.

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])	Поэлементный минимум элементов массива.

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

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

`isfinite`(x[, out])	Проверка поэлементно на конечность (не бесконечность и не число Not a Number).
`isinf`(x[, out])	Проверка поэлементно на положительную или отрицательную бесконечность.
`isnan`(x[, out])	Проверка поэлементно на NaN и возврат результата как булева массива.
`fabs`(x[, out])	Вычисление абсолютных значений поэлементно.
`signbit`(x[, out])	Возвращает поэлементно True, где установлен бит знака (меньше нуля).
`copysign`(x1, x2[, out])	Изменение знака x1 на знак x2 поэлементно.
`nextafter`(x1, x2[, out])	Возвращает следующее значение с плавающей точкой после x1 в направлении x2, поэлементно.
`spacing`(x[, out])	Возвращает расстояние между x и ближайшим соседним числом.
`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–2017 NumPy Developers
Licensed under the NumPy License.
https://docs.scipy.org/doc/numpy-1.12.0/reference/ufuncs.html