python - numeros - que es numpy

Numpy: ¿Crea una matriz compleja a partir de 2 reales?

Question

Juro que esto debería ser tan fácil ... ¿Por qué no? :(

De hecho, quiero combinar 2 partes de la misma matriz para hacer una matriz compleja:

Data[:,:,:,0] , Data[:,:,:,1]

Estos no funcionan:

x = np.complex(Data[:,:,:,0], Data[:,:,:,1])
x = complex(Data[:,:,:,0], Data[:,:,:,1])

¿Me estoy perdiendo de algo? ¿A Numpy no le gusta realizar funciones de matriz en números complejos? Aquí está el error:

TypeError: only length-1 arrays can be converted to Python scalars

Answer 1

Eso funcionó para mí:

entrada:

from scipy import *

array([[1,2],[3,2]]).astype(complex)

salida:

array([[ 1.+0.j, 2.+0.j], 
       [ 3.+0.j, 2.+0.j]])

Answer 2

Esto es lo que estás buscando:

from numpy import array

a=array([1,2,3])
b=array([4,5,6])

a + 1j*b

->array([ 1.+4.j,  2.+5.j,  3.+6.j])

Answer 3

Esto parece hacer lo que quieras:

numpy.apply_along_axis(lambda args: [complex(*args)], 3, Data)

Aquí hay otra solución:

# The ellipsis is equivalent here to ":,:,:"...
numpy.vectorize(complex)(Data[...,0], Data[...,1])

Y aún otra solución más simple:

Data[...,0] + 1j * Data[...,1]

PD : si desea guardar memoria (sin matriz intermedia):

result = 1j*Data[...,1]; result += Data[...,0]

La solución de devS a continuación también es rápida.

Answer 4

Por supuesto, es bastante obvio:

Data[...,0] + 1j * Data[...,1]

Answer 5

Si sus partes real e imaginaria son las divisiones a lo largo de la última dimensión y su matriz es contigua a lo largo de la última dimensión, puede hacer

A.view(dtype=np.complex128)

Si usa flotadores de precisión simple, esto sería

A.view(dtype=np.complex64)

Aquí hay un ejemplo más completo

import numpy as np
from numpy.random import rand
# Randomly choose real and imaginary parts.
# Treat last axis as the real and imaginary parts.
A = rand(100, 2)
# Cast the array as a complex array
# Note that this will now be a 100x1 array
A_comp = A.view(dtype=np.complex128)
# To get the original array A back from the complex version
A = A.view(dtype=np.float64)

Si quieres deshacerte de la dimensión extra que queda alrededor del molde, podrías hacer algo como

A_comp = A.view(dtype=np.complex128)[...,0]

Esto funciona porque, en la memoria, un número complejo es realmente solo dos números de coma flotante. El primero representa la parte real, y el segundo representa la parte imaginaria. El método de vista de la matriz cambia el tipo de la matriz para reflejar que desea tratar dos valores de punto flotante adyacentes como un único número complejo y actualiza la dimensión en consecuencia.

Este método no copia ningún valor en la matriz ni realiza ningún cálculo nuevo; todo lo que hace es crear un nuevo objeto de matriz que visualice el mismo bloque de memoria de forma diferente. Eso hace que esta operación se pueda realizar mucho más rápido que cualquier cosa que implique la copia de valores. También significa que cualquier cambio realizado en la matriz de valores complejos se reflejará en la matriz con las partes real e imaginaria.

También puede ser un poco más complicado recuperar la matriz original si elimina el eje adicional que está allí inmediatamente después de la conversión del tipo. Cosas como A_comp[...,np.newaxis].view(np.float64) no funcionan actualmente porque, al momento de escribir este documento, NumPy no detecta que la matriz sigue siendo C-contigua cuando se agrega el nuevo eje. Mira este problema . A_comp.view(np.float64).reshape(A.shape) parece funcionar en la mayoría de los casos.

Answer 6

Soy principiante de Python, así que puede que este no sea el método más eficiente, pero si entiendo correctamente la intención de la pregunta, los pasos que figuran a continuación me funcionaron.

>>> import numpy as np
>>> Data = np.random.random((100, 100, 1000, 2))
>>> result = np.empty(Data.shape[:-1], dtype=complex)
>>> result.real = Data[...,0]; result.imag = Data[...,1]
>>> print Data[0,0,0,0], Data[0,0,0,1], result[0,0,0]
0.0782889873474 0.156087854837 (0.0782889873474+0.156087854837j)

Answer 7

import numpy as np

n = 51 #number of data points
# Suppose the real and imaginary parts are created independently
real_part = np.random.normal(size=n)
imag_part = np.random.normal(size=n)

# Create a complex array - the imaginary part will be equal to zero
z = np.array(real_part, dtype=complex)
# Now define the imaginary part:
z.imag = imag_part
print(z)