Numpy Ufunc Aritmética Simples

O objetivo deste artigo é fornecer algumas orientações sobre como executar operações aritméticas simples utilizando o NumPy.

Aritmética Simples

Na aritmética simples Numpy Ufunc, você pode usar os operadores aritméticos + – * /

Esta seção explica como estender os recursos de matriz do NumPy fornecendo funções que podem receber qualquer objeto semelhante a uma matriz, como listas , tuplas , etc. e executar aritmética condicional nele.

Aritmética Condicionalmente: Em outras palavras, podemos especificar as condições sob as quais um cálculo aritmético deve ser realizado.

Existe um parâmetro where em cada função aritmética que examinamos, que nos permite indicar a condição a ser satisfeita.



Adição

De acordo com a aritmética simples Numpy Ufunc, a função add() soma os dados de duas matrizes e exibe o resultado do cálculo em outra matriz.

Os números na matriz par_arr serão adicionados aos números na matriz ímpar_arr da seguinte forma:

Example: 

1
2
3
4
5
6
7
8
import numpy as npy
even_arr = npy.array([0, 2, 4, 6, 8, 10])
odd_arr = npy.array([1, 3, 5, 7, 9, 11])
mrx_arr = npy.add(even_arr, odd_arr)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Como resultado do exemplo acima, receberemos [1 5 9 13 17 21], que é o total de 0+1, 2+3, 4+5, 6+7, 8+9 e 10+11.

Os números reverse_arr1 são adicionados aos números reverse_arr2 da seguinte maneira:

Example: 

1
2
3
4
5
6
7
8
import numpy as npy
reverse_arr1 = npy.array([10, 9, 8, 7, 6])
reverse_arr2 = npy.array([5, 4, 3, 2, 1])
mrx_arr = npy.add(reverse_arr1, reverse_arr2)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

No exemplo acima, obtemos [15 13 11 9 7] ou, em outras palavras, uma soma de 10+5, 9+4, 8+3, 7+2 e 6+1.


Subtração

Na aritmética simples Numpy Ufunc, a função subtract() remove os elementos de uma matriz dos elementos de outra matriz.

Calcule a diferença entre fatorial_arr e rational_arr subtraindo-os:

Example: 

1
2
3
4
5
6
7
8
import numpy as npy
factorial_arr = npy.array([1, 2, 6, 24, 120])
rational_arr = npy.array([0.4, 4.6, 2.7, 11.5, 94.2])
mrx_arr = npy.subtract(factorial_arr, rational_arr)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Como resultado de 1-0,4, 2-4,6, 6-2,7, 24-11,5 e 120-94,2, o exemplo acima fornece [ 0,6 -2,6 3,3 12,5 25,8].

Subtraia prime_arr de fibonacci_arr para calcular a diferença:

Example: 

1
2
3
4
5
6
7
import numpy as npy
prime_arr = npy.array([2, 3, 5, 7, 11, 13, 17])
fibonacci_arr = npy.array([0, 1, 1, 2, 3, 5, 8])
mrx_arr = npy.subtract(prime_arr, fibonacci_arr)
print(mrx_arr)[be]
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

No exemplo acima, [2 2 4 5 8 8 9] será produzido a partir de 2-0, 3-1, 5-1, 7-2, 11-3, 13-5 e 17-8.


Multiplicação

Quando examinamos a aritmética simples Numpy Ufunc, a função multiple () multiplica os elementos de uma matriz pelos elementos de uma segunda matriz e exibe a saída.

No exemplo a seguir, multiplique o array factorial_arr pelo array revsquare_arr:

Example: 

1
2
3
4
5
6
7
8
import numpy as npy
factorial_arr = npy.array([1, 2, 6, 24, 120])
revsquare_arr = npy.array([25, 16, 9, 4, 1])
mrx_arr = npy.multiply(factorial_arr, revsquare_arr)
print(mrx_arr)[be]
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Utilizando o exemplo acima, você obterá [25 32 54 96 120] que é o produto de 1*25, 2*16, 6*9, 24*4 e 120*1.

Encontre o produto de prime_arr e fibonacci_arr multiplicando-os:

Example: 

1
2
3
4
5
6
7
8
import numpy as npy
prime_arr = npy.array([2, 3, 5, 7, 11, 13, 17])
fibonacci_arr = npy.array([0, 1, 1, 2, 3, 5, 8])
mrx_arr = npy.multiply(prime_arr, fibonacci_arr)
print(mrx_arr)[be]
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

No exemplo acima, [0 3 5 14 33 65 136] representa o resultado da multiplicação de 2*0, 3*1, 5*1, 7*2, 11*3, 13*5 e 17*8.


Divisão

Com a aritmética simples Numpy Ufunc, a função divide() divide os elementos de uma matriz pelos elementos de uma segunda matriz e armazena o resultado em uma nova matriz.

Pegue os valores de gap_arr1 e gap_arr2 e divida-os:

Example: 

1
2
3
4
5
6
7
import numpy as npy
gap_arr1 = npy.array([5, 25, 45, 65, 85])
gap_arr2 = npy.array([5, 10, 15, 20, 25])
mrx_arr = npy.divide(gap_arr1, gap_arr2)
print(mrx_arr)[be]
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Utilizando o exemplo acima, você obterá [1. 2,5 3. 3,25 3,4] que é a divisão de 5/5, 25/10, 45/15, 65/20 e 85/25.

Você pode dividir os números reverse_list1 e reverse_list2 da seguinte maneira:

Example: 

1
2
3
4
5
6
7
8
import numpy as npy
reverse_list1 = npy.array([10, 9, 8, 7, 6])
reverse_list2 = npy.array([5, 4, 3, 2, 1])
mrx_arr = npy.divide(reverse_list1, reverse_list2)
print(mrx_arr)[be]
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

No exemplo acima, [2. 2,25 2,66666667 3,5 6. ] representa a saída das divisões 10/5, 9/4, 8/3, 7/2 e 6/1.


Poder

Na aritmética simples Numpy Ufunc, power() aumenta os números da matriz inicial para a potência dos números da segunda matriz.

Aumente os números em num_arr à potência dos números em power_arr:

Example: 

1
2
3
4
5
6
7
8
import numpy as npy
num_arr = npy.array([1, 2, 3, 4, 5])
power_arr = npy.array([1, 2, 3, 4, 5])
mrx_arr = npy.power(num_arr, power_arr)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Como resultado do exemplo acima, receberemos [ 1 4 27 256 3125], que é o total de 1*1, 2*2, 3*3*3, 4*4*4*4 e 5*5* 5*5*5.

Implemente o exemplo acima alterando a ordem da matriz de energia:

Example: 

1
2
3
4
5
6
7
8
import numpy as npy
num_arr = npy.array([1, 2, 3, 4, 5])
revpower_arr = npy.array([5, 4, 3, 2, 1])
mrx_arr = npy.power(num_arr, revpower_arr)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

No exemplo acima, obtemos [ 1 16 27 16 5], ou seja, um incremento de 1*1*1*1*1, 2*2*2*2, 3*3*3, 4*4 , e 5*1.


Restante

As funções mod() e rest() calculam o restante dos elementos no primeiro array em relação aos elementos no array secundário.

Os restos abaixo de duas matrizes devem ser exibidos da seguinte forma:

Example: 

1
2
3
4
5
6
7
8
9
import numpy as npy
even_arr = npy.array([0, 2, 4, 6, 8, 10])
odd_arr = npy.array([1, 3, 5, 7, 9, 11])
mrx_arr = npy.mod(even_arr, odd_arr)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Usando o exemplo acima, você obterá [ 0 2 4 6 8 10 ] que representa o resto da divisão de 0 por 1 (0%1), 2 por 3 (2%3), 4 por 5 (4%5), 6 com 7 (6%7), 8 com 9 (8%9) e 10 com 11 (10%11).

Se houver restos no exemplo abaixo, retorne-os da seguinte forma:

Example: 

1
2
3
4
5
6
7
8
9
import numpy as npy
factorial_arr = npy.array([1, 2, 6, 24, 120])
gap_arr = npy.array([3, 6, 9, 12, 15])
mrx_arr = npy.mod(factorial_arr, gap_arr)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

De acordo com o exemplo acima, [1 2 6 0 0] é o resto quando você divide 1 por 3 (1%3), 2 por 6 (2%6), 6 por 9 (6%9), 24 por 12 ( 24%12) e 120 por 15 (120%15).

Ao utilizar a função restante(), você receberá o resultado idêntico ao de quando utiliza a função mod():

Utilize a função restante() para gerar restos:

Example: 

1
2
3
4
5
6
7
8
9
import numpy as npy
even_arr = npy.array([0, 2, 4, 6, 8, 10])
odd_arr = npy.array([1, 3, 5, 7, 9, 11])
mrx_arr = npy.remainder(even_arr, odd_arr)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Mostre o restante de fatorial_arr e gap_arr:

Example: 

1
2
3
4
5
6
7
8
9
import numpy as npy
factorial_arr = npy.array([1, 2, 6, 24, 120])
gap_arr = npy.array([3, 6, 9, 12, 15])
mrx_arr = npy.mod(factorial_arr, gap_arr)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Quociente e Mod

É importante observar que a função divmod() fornece o quociente e o mod. O valor de saída é composto por duas matrizes, a primeira matriz contendo o quociente e a segunda matriz contendo o mod do quociente.

Calcule o quociente e mod de duas matrizes aleatórias da seguinte forma:

Example: 

1
2
3
4
5
6
7
8
import numpy as npy
random_arr1 = npy.array([15, 19, 28, 62, 47])
random_arr2 = npy.array([5, 9, 4, 12, 23])
mrx_arr = npy.divmod(random_arr1, random_arr2)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Como resultado do exemplo acima:
(array([15, 19, 28, 62, 47]),
array([5, 9, 4, 12, 23]))
No primeiro array, você tem os quocientes, que ou seja, quando você divide 15 por 5, 19 por 9, 28 por 4 etc., a saída é um número inteiro.
Na segunda matriz, são exibidos os restos das divisões anteriores.

Exiba o quoteint e o mod com os arrays even_arr e cube_arr:

Example: 

1
2
3
4
5
6
7
8
import numpy as npy
even_arr = npy.array([22, 38, 44, 98, 196])
cube_arr = npy.array([1, 8, 27, 64, 125])
mrx_arr = npy.divmod(even_arr, cube_arr)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

O exemplo acima fornece os seguintes resultados:

Aritmética simples em Numpy Ufunc

A primeira matriz mostra os quocientes, que é equivalente ao valor inteiro do resultado quando você divide 22 por 1, 38 por 8, 44 por 27, etc.

Na segunda matriz é apresentado o restante das divisões semelhantes.


Valores absolutos

Não há diferença entre as funções abs() e absolute() no sentido de que ambas se comportam da mesma forma absoluta em termos de elementos, mas devemos utilizar absolute() para reduzir o conflito com a função math.abs( ) incorporada do Python .

Converta todos os valores negativos de num_arr em positivos com a função absolute():

Example: 

1
2
3
4
5
6
7
import numpy as npy
num_arr = npy.array([-1, -2, -3, -4, -5])
mrx_arr = npy.absolute(num_arr)
print(mrx_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Em primeiro lugar, converta o valor negativo das duas matrizes em positivo e, em seguida, utilize a função add ():

Example: 

1
2
3
4
5
6
7
8
9
10
import numpy as npy
num_arr1 = npy.array([-1, 2, -3, -4, 5])
num_arr2 = npy.array([-6, 7, 8, -9, -10])
mrx_arr = npy.absolute(num_arr1)
ample_arr = npy.absolute(num_arr2)
sum_arr = npy.add(mrx_arr, ample_arr)
print(sum_arr)
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Exemplo de Explicação

Primeiro, a função absolute() é aplicada a num_arr1 e num_arr2 para obter os valores absolutos de cada elemento nas matrizes.

Isso significa que quaisquer valores negativos são convertidos em valores positivos.

Em seguida, a função add() é usada para adicionar os arrays resultantes mrx_arr e ample_arr elemento a elemento.

Isso resulta em uma nova matriz sum_arr contendo a soma dos valores absolutos correspondentes em num_arr1 e num_arr2.

Nós valorizamos o seu feedback.
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0
+1
0

Assine a nossa newsletter
Digite seu e-mail para receber um resumo semanal de nossos melhores posts. Saber mais!
ícone