Interpolieren Sie ganze Arrays komplexer Zahlen

Ich habe eine Anzahl von zweidimensionalen np.arrays (alle gleich Größe) mit komplexen Zahlen. Jeder von ihnen gehört zu einer Position in einem 4-dimensionalen Raum. Diese Positionen sind spärlich und unregelmäßig verteilt (ein lateinischer Hyperwürfel, um genau zu sein). Ich möchte diese Daten auf andere Punkte im gleichen 4-dimensionalen Raum interpolieren.

Ich kann dies erfolgreich für einfache Zahlen, entweder mit sklearn.kriging() , scipy.interpolate.Rbf() (oder andere):

 # arrayof co-ordinates: 2 4D sets X = np.array([[1.0, 0.0, 0.0, 0.0],\ [0.0, 1.0, 0.0, 0.0]]) # two numbers, one for each of the points above Y = np.array([1,\ 0]) # define the type of gaussian process I want kriging = gp.GaussianProcess(theta0=1e-2, thetaL=1e-4, thetaU=4.0,\ corr='linear', normalize=True, nugget=0.00001, optimizer='fmin_cobyla') # train the model on the data kmodel = kriging.fit(X,Y) # interpolate kmodel.predict(np.array([0.5, 0.5, 0.0, 0.0])) # returns: array([ 0.5]) 

Wenn ich versuche, Arrays (oder nur komplexe Zahlen) als Daten zu verwenden, funktioniert das nicht:

 # two arrays of complex numbers, instead of the numbers Y = np.array([[1+1j, -1-1j],\ [0+0j, 0+0j]]) kmodel = kriging.fit(X,Y) # returns: ValueError: The number of features in X (X.shape[1] = 1) should match the sample size used for fit() which is 4. 

Dies ist offensichtlich, da die docstring für kriging.fit() klar, dass es eine Reihe von n Skalaren, eine pro Element in der ersten Dimension von X braucht.

Eine Lösung besteht darin, die Arrays in Y in einzelne Zahlen zu zerlegen, jene in reale und imaginäre Teile, machen eine separate Interpolation von jedem von ihnen und setzen sie dann wieder zusammen. Ich kann das mit der richtigen Kombination von Loops und irgendeiner Kunst machen, aber es wäre schön, wenn es eine Methode gab (zB bei scipy.interpolate ), die einen ganzen np.array anstelle von skalaren Werten behandeln könnte.

Ich bin nicht auf einen bestimmten Algorithmus (noch) fixiert, also würde ich gerne über irgendwelche wissen, die Arrays von komplexen Zahlen als die "Variable" verwenden können, um interpoliert zu werden. Da – wie gesagt – nur wenige und unregelmäßige Punkte im Raum sind (und kein Gitter zum Interpolieren), wird die einfache lineare Interpolation natürlich nicht tun.

  • Extrahieren Sie verschiedene Werte aus der Liste der Tupel
  • Soll ich `random.seed` oder` numpy.random.seed` verwenden, um die Zufallszahlengenerierung in `scikit-learn` zu kontrollieren?
  • So verwenden Sie die Importfunktion von python richtig __import __ ()
  • Gibt es eine Python MTA (Mail Transfer Agent)
  • Wie kann ich die Pinax (0.9a2) Vorlage ändern?
  • Cross Platform, Sprache Agnostic GUI Markup Sprache?
  • Python Form POST mit urllib2 (auch Frage zum Speichern / Verwenden von Cookies)
  • Extrahieren Sie die Liste der Objekte aus einer anderen Python-Liste basierend auf Attribut
  • One Solution collect form web for “Interpolieren Sie ganze Arrays komplexer Zahlen”

    Es gibt zwei Möglichkeiten, komplexe Zahlen zu betrachten:

    1. Kartesische Form (a + bi) und
    2. Polar / Euler Form (A * exp (i * phi))

    Wenn Sie sagen, dass Sie zwischen zwei Polarkoordinaten interpolieren möchten, möchten Sie in Bezug auf die realen / imaginären Komponenten (1) interpolieren, oder in Bezug auf die Anzahl der Größe und Phase (2)?

    Du kannst die Dinge in echte und imaginäre Komponenten verteilen,

     X = 2 * 5j X_real = np.real(X) X_imag = np.imag(X) # Interpolate the X_real and X_imag # Reconstruct X X2 = X_real + 1j * X_imag 

    Allerdings Mit echten Anwendungen, die komplexe Zahlen, wie z. B. digitale Filter-Design, Sie ganz oft wollen mit Zahlen in Polar / exponentielle Form zu arbeiten.

    Daher können Sie anstelle der Interpolation der Komponenten np.real () und np.imag () die Möglichkeit haben, sie in die Größe & Phase mit np.abs () und Angle oder Arctan2 zu brechen und separat zu interpolieren. Sie können dies zum Beispiel tun, wenn Sie versuchen, die Fourier-Transformation eines digitalen Filters zu interpolieren.

     Y = 1+2j mag = np.abs(Y) phase = np.angle(Y) 

    Die interpolierten Werte können mit der Eulers-Formel in komplexe (kartesische) Zahlen umgewandelt werden

     # Complex number y = mag * np.exp( 1j * phase) # Or if you want the real and imaginary complex components separately, realPart, imagPart = mag * np.cos(phase) , mag * np.sin(phase) 

    Je nachdem, was du tust, das gibt dir eine gewisse Flexibilität mit den Interpolationsmethoden, die du benutzt hast.

    Python ist die beste Programmiersprache der Welt.