Numpy Número complexo

Sabemos que números complexos são aqueles representados pelo A+BI convencional, onde "A" é sempre um número real; "B" também é um número real, mas "i" é um componente imaginário. Mais uma coisa que sabemos é "i^2 = -1" porque nenhum dos números reais pode satisfazer essa equação que chamamos de "eu" de uma parte imaginária. Numpy suporta números reais e números imaginários. Em Numpy, os números imaginários são representados por "J". Existem várias maneiras de criar e manipular matrizes com números complexos, como NP.complexo (), NP.range (), NP.Array () e mais.

Sintaxe

A sintaxe para criar uma matriz que contém números complexos é a seguinte:

Método 1:

1J * np.ARANGE (tamanho)

A sintaxe dada acima 1J é a parte imaginária, o que significa que estamos criando uma variedade de números complexos, onde NP.Organ. Tamanho, que indica o tamanho da matriz, é passado para a função.

Método 2:

NP.Array ([re+re*im, re+re*im,…])

Nesta sintaxe, NP.Arrray é a função que nos permite criar uma matriz, mas não podemos passar o alcance para ela. Simplesmente passamos valores para ele "n" tempos. Na função, passamos "RE", o que indica números reais, adicionando -os a "im" um número imaginário em múltiplos de um número real. Podemos passar valores imaginários para n vezes.

Exemplo # 01:

Como sabemos, Numpy também suporta números complexos e fornece várias variedades de métodos para implementar e manipular números complexos. No exemplo abaixo, implementaremos duas maneiras de criar matrizes contendo números complexos. Para implementar funções Numpy, vamos importar a biblioteca Numpy primeiro como NP. Em seguida, inicializaremos uma matriz chamada "Array_a" à qual atribuímos a função NP.arange () que conterá os números complexos. E o alcance da matriz será "8". Na próxima linha, criamos outra matriz chamada "Array_B" para a qual passamos uma variedade de números complexos, passando os valores complexos diretamente para ela. No final, imprimimos a matriz complexa que criamos usando os dois métodos.

importar numpy como np
Array_a = 1j * np.ARANGE (8)
Array_B = np.Array ([2+1j, 3+4j, 5+2j, 1+6j])
print ("matriz complexa usando a função arange ()", array_a)
Imprima ("Matriz complexa usando NP.Função Array () ", Array_B)

Como mostrado no trecho abaixo, é o resultado do código que executamos. Podemos ver que criamos duas matrizes que têm uma variedade de números complexos de 0J a 7J. No outro, passamos a gama aleatória de números complexos de tamanho 4.

Método 3:

NP.complexo (re+re*im)

Na sintaxe dada acima, NP.Complex () é a classe interna fornecida pelo pacote Python Numpy que nos permite armazenar valores complexos.

Exemplo # 02:

Outra maneira de criar uma matriz complexa Numpy é usar a classe Complex () de Numpy (). Classe complex () é usado para armazenar números complexos e retorna o objeto complexo que podemos usar várias vezes no código único. Agora implementando a classe Complex (), primeiro importaremos nosso pacote Numpy. Em seguida, inicializaremos uma matriz para a qual passamos uma classe complexa que usa um asterisco "*" para passar por uma classe de complexo () para a qual passamos "3+1j". Usando a função Arrange (), criamos uma matriz de tamanho 5. Por fim, acabamos de exibir a saída do código em que criamos uma matriz complexa usando a classe Complex ().

importar numpy como np
Array = np.complexo (3+1j) *np.ARANGE (5)
Imprima ("Matriz complexa usando NP.Classe Complex () ", Array)

Como mostrado na figura abaixo, criamos uma variedade de números complexos. Mas mais uma coisa que podemos notar na figura é que o valor constante não está sendo executado consecutivamente porque passamos "3+1j" para uma classe complexa (), o que significa que um número três será adicionado a todos os próximos valores constantes.

Método 4:

NP.uns (forma, dtype = nenhum, ordem = 'c', *, como = nenhum)

Neste método NP.ONES (), especificamos uma matriz de números complexos usando o parâmetro dType na matriz Numpy. NP.ONES () é usado para retornar uma nova matriz que contém 1s. Para a função NP.ONES (), passamos quatro parâmetros "Shape", que é usado para definir a forma da matriz, seja "2", "3" ou então. O "dtype" é o tipo de dados. No nosso caso, usaremos um tipo de dados complexo. A "ordem" define se a matriz é unidimensional, dois ou multidimensional.

Exemplo # 03:

Vamos implementar o método ONES () para ter uma idéia melhor de como ele funciona ao usar números complexos. Para implementar esse método, vamos primeiro importar nossos pacotes de Numpy que são fornecidos pelo Python. Em seguida, criaremos uma matriz para a qual passaremos o NP.ONES () função para a qual passamos dois parâmetros. O primeiro é "4", o que significa que o tamanho da matriz será 4 e o segundo é "dtype", que é complexo. Isso significa que vamos criar uma variedade de números complexos do tipo de dados. Multiplicar a função () com o valor "2" significa que nosso número real será "2". No final, imprimimos a matriz que criamos usando a declaração de impressão.

importar numpy como np
Array = np.um (4, dtype = complexo)*2
Imprima ("Matriz complexa usando NP.ONES () função ", Array)

Como mostrado abaixo, a saída do nosso código é executada com sucesso na qual temos uma matriz unidimensional que contém 4 valores complexos com um número real 2.

Exemplo # 04:

Vamos agora implementar outro exemplo no qual criaremos uma variedade de números complexos e imprimiremos as partes imaginárias e reais dos números complexos. Primeiro imporemos a biblioteca Numpy e depois criaremos uma matriz para a qual passamos valores complexos “6” para uma matriz chamada “Array” que é “56+0j, 27+0j, 68+0j, 49+0j, 120+0j , 4+0j ”. Na próxima linha, simplesmente imprimimos a matriz. Agora, imprimimos valores imaginários e reais da matriz complexa.

Numpy fornece uma função interna para as duas operações que são mostradas abaixo. O primeiro a obter a parte imaginária é “Array_name.image ”onde o valor antes do ponto é a matriz da qual temos que obter a parte imaginária. E o segundo a obter a parte real é “Array_name.real". No nosso caso, o nome de uma matriz é "Array", então passamos a declaração de impressão, o nome da matriz e a palavra -chave para obter os dois elementos.

importar numpy como np
Array = np.Array ([56.+0.J, 27.+0.J, 68.+0.J, 49.+0.J, 120.+0.J, 3 + 4.j])
Print ("Array original: x", Array)
print ("parte real da matriz:")
Imprimir (matriz.real)
print ("parte imaginária da matriz:")
Imprimir (matriz.image)

Conforme mostrado no trecho abaixo, a saída em que o imaginário e a parte real da matriz complexa são executados com sucesso. Onde as partes reais são "56", "27", "68", "120" e "3". E as partes imaginárias são "0".

Conclusão

Neste artigo, discutimos brevemente números complexos e como podemos criar matrizes complexas usando as funções internas de Numpy. Descrevemos várias funções que nos permitem criar matrizes complexas, implementando vários exemplos para entender melhor.