Sintaxis
La sintaxis para crear una matriz que contenga números complejos es la siguiente:
Método 1:
1j * np. naranja ( Talla )La sintaxis dada arriba 1j es la parte imaginaria, lo que significa que estamos creando una matriz de números complejos, donde np.arrang es la función proporcionada por NumPy para crear una matriz en un rango específico. El tamaño, que indica el tamaño de la matriz, se pasa a la función.
Método 2:
p.ej. formación ( [ Re+Re*Im , Re+Re*Im , … ] )En esta sintaxis, np.arrray es la función que nos permite crear una matriz pero no podemos pasarle el rango. Simplemente le pasamos valores “n” veces. En la función, pasamos 'Re' que indica números reales sumándolos 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 siguiente ejemplo, implementaremos dos formas de crear matrices que contengan números complejos. Para implementar funciones NumPy, primero importemos la biblioteca NumPy como np. Luego, inicializaremos una matriz llamada “array_a” a la que le 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 'matriz_b' a la que le pasamos una matriz de números complejos pasándole los valores complejos directamente. Al final, imprimimos la matriz compleja que creamos usando ambos métodos.
importar entumecido como p.ej.
array_a = 1j * np. naranja ( 8 )
matriz_b = p.ej. formación ( [ 2 +1d , 3 +4j , 5 +2j , 1 +6j ] )
impresión ( 'matriz compleja usando la función arange()' , array_a )
impresión ( 'matriz compleja usando la función np.array()' , matriz_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:
p.ej. complejo ( Re+Re*Im )En la sintaxis anterior, np.complex() es la clase integrada proporcionada por el paquete NumPy de Python que nos permite almacenar valores complejos.
Ejemplo # 02:
Otra forma de crear una matriz compleja de NumPy es usar la clase complex() 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 complex(), primero importaremos nuestro paquete Numpy. Luego, inicializaremos una matriz a la que le pasamos una clase compleja que usa un asterisco “*” para pasar un objeto de clase compleja() al que le pasamos “3+1j”. Usando la función de arreglo (), creamos una matriz de tamaño 5. Por último, solo mostramos la salida del código en el que creamos una matriz compleja usando la clase complex ().
importar entumecido como p.ej.formación = p.ej. complejo ( 3 +1d ) *p.ej. naranja ( 5 )
impresión ( 'matriz compleja usando la clase np.complex ()' , formación )
Como se muestra en la siguiente figura, 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 valor constante.
Método 4:
p.ej. unos ( forma , tipo de d = Ninguna , ordenar = 'C' , * , me gusta = Ninguna )En este método np.ones(), especificamos una matriz de números complejos usando el parámetro dtype en la matriz NumPy. Np.ones() se usa para devolver una nueva matriz que contiene 1s. A la función np.ones(), le pasamos cuatro parámetros “forma”, que se usa para definir la forma de la matriz, ya sea “2”, “3” u otra. El 'dtype' es el tipo de datos. En nuestro caso, utilizaremos un tipo de datos complejo. El 'orden' define si la matriz es unidimensional, bidimensional o multidimensional.
Ejemplo # 03:
Implementemos el método ones() para tener una mejor idea de cómo funciona al usar números complejos. Para implementar este método, primero importemos nuestros paquetes de NumPy proporcionados por Python. A continuación, crearemos una matriz a la que le pasaremos la función np.ones() a la que le 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 matriz de números complejos de tipo de datos. Multiplicar la función ones() 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 entumecido como p.ej.formación = p.ej. unos ( 4 , tipo de d = complejo ) * 2
impresión ( 'matriz compleja usando la función np.ones ()' , formación )
Como se muestra a continuación, la salida de nuestro código se ejecuta con éxito en la que tenemos una matriz unidimensional que contiene 4 valores complejos con un número real 2.
Ejemplo # 04:
Ahora implementemos otro ejemplo en el que crearemos una matriz de números complejos e imprimiremos las partes imaginaria y real de los números complejos. Primero importaremos la biblioteca NumPy, luego crearemos una matriz a la que le pasamos '6' valores complejos 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, imprimimos valores imaginarios y reales de la matriz compleja.
Numpy proporciona una función integrada para las dos operaciones que se muestran a continuación. El primero en obtener la parte imaginaria es “array_name.imag” donde el valor antes del punto es la matriz de 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 pasamos la declaración de impresión, el nombre de la matriz y la palabra clave para obtener ambos elementos.
importar entumecido como p.ej.formación = p.ej. formación ( [ 56 .+ 0 . j , 27 .+ 0 . j , 68 .+ 0 . j , 49 .+ 0 . j , 120 .+ 0 . j , 3 + 4 . j ] )
impresión ( 'Array original:x' , formación )
impresión ( 'Parte real de la matriz:' )
impresión ( formación . real )
impresión ( 'Parte imaginaria de la matriz:' )
impresión ( formación . imagen )
Como se muestra en el fragmento a continuación, la salida en la que la parte imaginaria y 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 los 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 implementando múltiples ejemplos para comprender mejor.