Número complejo numpy

Sabemos que los números complejos son aquellos representados por el A+Bi convencional, donde "A" es siempre un número real; "B" también es un número real, pero "I" es un componente imaginario. Una cosa más que sabemos es "i^2 = -1" porque ninguno de los números reales puede satisfacer esta ecuación que llamamos "i" una parte imaginaria. Numpy admite números reales, así como números imaginarios. En Numpy, los números imaginarios están representados por "J". Hay varias formas de crear y manipular matrices que tienen números complejos como NP.complejo (), np.Range (), NP.array () y más.

Sintaxis

La sintaxis para crear una matriz que contiene números complejos es la siguiente:

Método 1:

1J * NP.Arange (tamaño)

La sintaxis dada anteriormente 1J es la parte imaginaria, lo que significa que estamos creando una matriz de números complejos, donde NP.Arrange es la función proporcionada por Numpy para crear una matriz a un rango especificado. El tamaño, que indica el tamaño de la matriz, se pasa a la función.

Método 2:

notario público.Array ([re+re*im, re+re*im,…])

En esta sintaxis, NP.Arrray es la función que nos permite crear una matriz, pero no podemos pasar el rango. Simplemente pasamos valores a él "n" veces. En la función, pasamos "RE" que indica números reales que los agregan a "im" un número imaginario en múltiplo de un número real. Podemos pasar valores imaginarios a n veces.

Ejemplo # 01:

Como sabemos, Numpy también admite números complejos y proporciona múltiples variedades de métodos para implementar y manipular números complejos. En el ejemplo a continuación, implementaremos dos formas de crear matrices que contengan números complejos. Para implementar funciones numpy, importemos la biblioteca Numpy primero como NP. Luego, inicializaremos una matriz llamada "Array_a" a la que asignamos la función NP.arange () que contendrá los números complejos. Y el rango de la matriz será "8". En la siguiente línea, creamos otra matriz llamada "Array_B" a la que pasamos una matriz de números complejos pasando los valores complejos directamente a él. Al final, imprimimos la matriz compleja que creamos utilizando ambos métodos.

importar numpy como np
array_a = 1j * np.Arange (8)
array_b = np.Array ([2+1J, 3+4J, 5+2J, 1+6J])
imprimir ("matriz compleja usando la función arange ()", array_a)
imprimir ("matriz compleja con NP.Array () función ", array_b)

Como se muestra en el fragmento a continuación, es el resultado del código que hemos ejecutado. Podemos ver que hemos creado dos matrices que tienen un rango de números complejos de 0J a 7J. En el otro, hemos pasado el rango aleatorio de números complejos de tamaño 4.

Método 3:

notario público.complejo (re+re*im)

En la sintaxis dada anteriormente, NP.Complex () es la clase incorporada que proporciona el paquete Python Numpy que nos permite almacenar valores complejos.

Ejemplo # 02:

Otra forma de crear una matriz de complejo Numpy es usar la clase de complejo () de Numpy (). La clase compleja () se usa para almacenar números complejos y devuelve el objeto complejo que podemos usar varias veces dentro del código único. Ahora implementando la clase complejo (), primero importaremos nuestro paquete Numpy. Luego, inicializaremos una matriz a la que pasamos una clase compleja que usa un asterisco "*" para pasar un objeto de clase compleja () a la que pasamos "3+1J". Usando la función Arrane (), creamos una matriz de tamaño 5. Por fin, acabamos de mostrar la salida del código en el que creamos una matriz compleja usando la clase compleja ().

importar numpy como np
matriz = np.complejo (3+1J) *NP.Arange (5)
imprimir ("matriz compleja con NP.complejo () clase ", matriz)

Como se muestra en la figura a continuación, hemos creado una matriz de números complejos. Pero una cosa más que podemos notar en la figura es que el valor constante no se ejecuta consecutivamente porque hemos pasado "3+1j" a una clase compleja (), lo que significa que se agregará un número tres a cada siguiente valores constantes.

Método 4:

notario público.Ones (forma, dtype = none, orden = 'c', *, como = ninguno)

En este método NP.un (), especificamos una matriz de números complejos utilizando el parámetro dtype en la matriz numpy. Notario público.un () se usa para devolver una nueva matriz que contiene 1s. A la función np.un (), pasamos cuatro parámetros "forma", que se usa para definir la forma de la matriz, ya sea "2", "3" o de lo contrario. El "dtype" es el tipo de datos. En nuestro caso, utilizaremos un tipo de datos complejo. El "orden" define si la matriz es unidimensional, dos o multidimensional.

Ejemplo # 03:

Implementemos el método ONS () para tener una mejor idea de cómo funciona mientras usa números complejos. Para implementar este método, primero importemos nuestros paquetes de Numpy que proporcionan Python. A continuación, crearemos una matriz a la que pasaremos el NP.una función () a la que pasamos dos parámetros. El primero es "4", lo que significa que el tamaño de la matriz será 4 y el segundo es "dtype", que es complejo. Esto significa que vamos a crear una variedad de números complejos de tipo de datos. Multiplicar la función de los que () con el valor "2" significa que nuestro número real será "2". Al final, imprimimos la matriz que creamos usando la declaración de impresión.

importar numpy como np
matriz = np.un (4, dtype = complejo)*2
imprimir ("matriz compleja con NP.una función () ", Array)

Como se muestra a continuación, la salida de nuestro código se ejecuta correctamente en la que tenemos una matriz unidimensional que contiene 4 valores complejos con un número 2 real.

Ejemplo # 04:

Implementemos ahora otro ejemplo en el que crearemos una serie de números complejos e imprimiremos las partes imaginarias y reales de los números complejos. Primero importaremos la biblioteca Numpy, luego crearemos una matriz a la que pasamos los valores complejos "6" a una matriz llamada "matriz" que es "56+0j, 27+0j, 68+0j, 49+0j, 120+0j , 4+0j ". En la siguiente línea, simplemente imprimimos la matriz. Ahora, imprimemos valores imaginarios y reales de la matriz compleja.

Numpy proporciona una función incorporada para las dos operaciones que se muestran a continuación. El primero en obtener la parte imaginaria es "array_name.imagen ”donde el valor antes del punto es la matriz desde la que tenemos que obtener la parte imaginaria. Y el segundo para obtener la parte real es "array_name.real". En nuestro caso, el nombre de una matriz es "matriz", por lo que aprobamos la declaración de impresión, el nombre de la matriz y la palabra clave para obtener ambos elementos.

importar numpy como np
matriz = np.matriz ([56.+0.J, 27.+0.J, 68.+0.J, 49.+0.J, 120.+0.J, 3 + 4.j])
Imprimir ("Array original: x", matriz)
Imprimir ("Parte real de la matriz:")
imprimir (matriz.real)
Imprimir ("Parte imaginaria de la matriz:")
imprimir (matriz.imagen)

Como se muestra en el fragmento a continuación, la salida en la que la parte imaginaria y la parte real de la matriz compleja se ejecuta con éxito. Donde las partes reales son "56", "27", "68", "120" y "3". Y las partes imaginarias son "0's".

Conclusión

En este artículo, hemos discutido brevemente números complejos y cómo podemos crear matrices complejas utilizando las funciones integradas de Numpy. Describimos múltiples funciones que nos permiten crear matrices complejas mediante la implementación de múltiples ejemplos para comprender mejor.