Dieser Artikel beschreibt den in Java implementierten Fourier -Variationsalgorithmus. Teilen Sie es für Ihre Referenz wie folgt weiter:
Das Fourier -Variationsergebnis wird verwendet, um Java als Pluralform A+Bi zu implementieren
Ohne weiteres ist der Implementierungscode wie folgt insgesamt zwei Klassen
FFT.Class Fourier Änderung Funktion Implementierungscode
Paket fft.Test;/**************************************************************************** Bare Bones * Implementierung, die in O (n log n) ausgeführt wird. Unser Ziel ist es, die Klarheit des Codes und nicht die Leistung zu optimieren. * * Einschränkungen ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ ******************************************************************************************************************/public class FFT { // compute the FFT of x[], assuming its length is a power of 2 public static Complex[] fft(Complex[] x) { int N = x.length; // Basisfall if (n == 1) neuer Komplex zurückgeben [] {x [0]}; // Radix 2 Cooley-tukey fft if (n % 2! = 0) {neue RunTimeException werfen ("n ist keine Kraft von 2"); } // FFT von Sa -Begriffen komplex [] sogar = neuer Komplex [n / 2]; für (int k = 0; k <n / 2; k ++) {sogar [k] = x [2 * k]; } Komplex [] q = fft (sogar); // fft von ungeraden Begriffen komplex [] ungerade = sogar; // das Array für (int k = 0; k <n / 2; k ++) {ungerade [k] = x [2 * k+1] wiederverwenden; } Komplex [] r = fft (ungerade); // Komplex kombinieren [] y = neuer Komplex [n]; für (int k = 0; k <n / 2; k ++) {double kth = -2 * k * math.pi / n; Komplex WK = neuer Komplex (Math.Cos (KTH), Math.sin (KTH)); y [k] = q [k] .plus (wk.times (r [k])); y [k + n / 2] = q [k] .minus (wk.times (r [k])); } return y; } // Berechnen Sie die inverse FFT von x [] unter der Annahme, dass seine Länge eine Kraft von 2 öffentlichem statischen Komplex [] IFFT (komplex [] x) {int n = x.length ist; Komplex [] y = neuer Komplex [n]; // Konjugat für (int i = 0; i <n; i ++) {y [i] = x [i] .Conjugate (); } // Vorwärts fft y = fft (y) berechnen; // Nehmen Sie noch einmal Konjugat für (int i = 0; i <n; i ++) {y [i] = y [i] .Conjugate (); } // divide durch n für (int i = 0; i <n; i ++) {y [i] = y [i] .scale (1.0 / n); } return y; } // Die kreisförmige Faltung von x und y öffentlichem statischer Komplex [] convolve (komplex [] x, komplex [] y) {// sollte wahrscheinlich mit 0s pad x und y, damit sie die gleiche Länge haben // und die Befugnisse von 2 if (x.Length! } int n = x.length; // FFT jeder Sequenz berechnen, den Komplex [] a = fft (x) bewerten; Komplex [] b = fft (y); // point-wise multiply, Punktwert-Multiplikationskomplex [] c = neuer Komplex [n]; für (int i = 0; i <n; i ++) {c [i] = a [i] .times (b [i]); } // Inverse FFT, Interpolation Return IFFFT (C) berechnen; } // Die lineare Faltung von x und y öffentlichem statischer Komplex [] conpolve (komplex [] x, komplex [] y) {Komplex Null = neuer Komplex (0, 0); Komplex [] a = neuer Komplex [2 * x.Length]; // 2n-mal Grenze, der Koeffizient höherer Ordnung beträgt 0. Für (int i = 0; i <x.Length; i ++) a [i] = x [i]; für (int i = x.Length; i <2 * x.Length; i ++) a [i] = null; Komplex [] B = neuer Komplex [2 * Y.Length]; für (int i = 0; i <y.Length; i ++) b [i] = y [i]; für (int i = y.Length; i <2 * y.Length; i ++) b [i] = null; return convolve (a, b); } // Zeigen Sie ein Array von komplexen Zahlen an, um die Standardausgabe öffentliche statische void Show (Komplex [] x, String -Titel) {System.out.println (Titel); System.out.println ("------------------------------------"); int complexLength = x.Length; für (int i = 0; i <complexLength; i ++) {// Ausgabekomplex // system.out.println (x [i]); // Ausgabeamplitude erfordert * 2 / Längensystem.out.println (x [i] .Abs () * 2 / komplexlänge); } System.out.println (); }/ ** * Array -Daten in eine Leistung von 2 Ausgabe umgeben * * @param data * @return */ public static double [] pow2DouBlearr (double [] data) {// Erstellen Sie ein neues Array double [] newdata = null; int datalength = data.length; int sumnum = 2; while (sumnum <datalength) {sumnum = sumnum * 2; } int addLength = sumnum - datalength; if (addLength! = 0) {newdata = new Double [Sumnum]; System.ArrayCopy (Daten, 0, newdata, 0, dataLength); für (int i = datalength; i <sumnum; i ++) {newdata [i] = 0d; }} else {newdata = data; } return Newdata; } /** * Deoffset * * @param Originalarr * originalarr * originalarr * public static double [] Deskew (double [] originalarr) {// Filter falsche Parameter if (originalarr == null || originalarr.length <= 0) {return null; } // Definieren Sie das Zielarray double [] resarr = new Double [originalarr.length]; // Die Summe des Array -Doppelsumme = 0D ermitteln; für (int i = 0; i <Originalarr.length; i ++) {sum+= originalarr [i]; } // Finden Sie den Durchschnittswert des Array -Double aver = sum / originalarr.length; // Entfernen Sie den Offset -Wert für (int i = 0; i <Originalarr.length; i ++) {Resarr [i] = originalarr [i] - aver; } return resarr; } public static void main (String [] args) {// int n = integer.parseInt (args [0]); Double[] data = { -0.35668879080953375, -0.6118094913035987, 0.8534269560320435, -0.6699697478438837, 0.35425500561437717, 0.8910250650549392, -0.025718699518642918, 0.07649691490732002}; // Offset Data = Deskew (Daten) entfernen; // Leistung der Anzahl von 2 = pow2DouBlearr (Daten); int n = Data.Length; System.out.println (n + "Nummer in Array n ..."); Komplex [] x = neuer Komplex [n]; // Originaldaten für (int i = 0; i <n; i ++) {// x [i] = new complex (-2 * math.random ()+1, 0); x [i] = neuer Komplex (Daten [i], 0); } show (x, "x"); // FFT des Originaldatenkomplexes [] y = fft (x); Show (y, "y = fft (x)"); // Inverse FFT -Komplex [] z = ifft (y); show (z, "z = ifft (y)"); // kreisförmige Faltung von x mit sich selbst komplex [] c = convolve (x, x); show (c, "c = cconvolve (x, x)"); // lineare Faltung von x mit sich selbst komplex [] d = convolve (x, x); show (d, "d = convolve (x, x)"); }}/******************************************************** --------------------------------------------------------------------------------------------------------------------------------------------------------- 0,35425500561437717 0,8910250650549392 * -0.02571869518642918 0.07649691490732002 * * y = fft (x) ------------------------- 2.4696418005143532i 1.1395317305034673 * -0.17611092978237974 -2.4696418005143532i -0.8301420417085572 + -1.2457766630654419 - 0.7113504894129803i * * Z = ifft (y) ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ . 6.887033953004965e-17i -0.02571869518642918 + * 2,691607282636124E-17i 0,07649691490732002-1,439638731616161616161616167096e-17i ----------------------------------------------------------------------------------------------------------------------------------------------------------------- 1.9986455722517509E-16i 1.432390480003344 + 2.636779683484747E-16i * -2.2165857430333684 + 2.2180047699856214E-17i -0.01255525669751989 + * 1.3815636262919812e-17i 1.0230680492494633-2.4422465262488753E-16I * * D = Convolve (x, x) -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0.43645117531775324 - 2.78776395788635E-18i * -0.2345048043334932 - 6.907818131459906E-18i -0.5663280251946803 + * 5.829891518914417E-17i 1.2954076913348198 + 1.518836016779236E-16i * -2.212650940696159 + 1.1090023849928107E-17i -0.018407034687857718 - * 1.1306778366296569E-17i 1.023068049249463 - 9.435675069681485E-17i * -1.205924207390114 - 2.983724378680108E-16i 0.796330738580325 + * 2.4967811657742562E-17i 0.6732024728888314 - 6.907818131459906E-18i * 0.00836681821649593 + 1.4156564203603091E-16i 0.1369827886685242 + * 1.1179436667055108E-16i -0.00393480233720922 + 1.1090023849928107e-17i * 0,00585177799037828 + 2,512241462921638E-17i 1.1102302462515656565E-16-16- * 1.498679019280728072656565E-16-16- * 1.49867901928072807280728072807280726565E-16-16- * 1.498679019280728072656565E-16-16- * 1,4986790192807280728072807280728072807280726565e-16-16 **********************************************************Komplex. Klassenklasse Klasse
Paket fft. * * Der Datentyp ist "unveränderlich". Sobald Sie ein komplexes Objekt erstellt und initialisieren, können Sie es nicht ändern. Das "endgültige" Schlüsselwort * beim Deklarieren von RE und IM erzwingt diese Regel, wodurch es zu einem Kompilierungs-Zeitfehler wird, die Variablen .re oder .im nach * initialisiert zu ändern. * * % Java -Komplex * a = 5,0 + 6,0i * b = -3.0 + 4,0i * re (a) = 5,0 * im (a) = 6,0 * b + a = 2,0 + 10,0i * a - b = 8,0 + 2,0i * a * b = -39,0 + 2,0i * a /b = 0,36 - 1,52i * (a /b) * b) * b) * b) * b) * (a /b) * (a /b) * (a /b) * (a /b) * (a /b) * (a /b) * (a /b) * (a /b) * (a /b) * (a /b) * (a /b) * (a /b) * (a /b) (a /b) (a /b) (a /b) (a /b) (a /b) (a /b) (A /b) | a | = 7.810249675906654 * tan (a) = -6.685231390246571e -6 + 1.0000103108981198i * ********* private endgültige doppelte Re; // Der eigentliche Teil Private Final Double IM; // Der Imaginationsteil // Erstellen Sie ein neues Objekt mit dem gegebenen realen und den Vorstellungs -Teilen öffentlichen Komplex (doppelter reales, doppeltes Bild) {Re = Real; im = vorstellen; } // eine String -Darstellung des aufgerufenen komplexen Objekts public String toString () {if (im == 0) return re + "" zurückgeben; if (re == 0) return im + "i"; if (im <0) return re + " -" + (-im) + "i"; return re + " +" + " + im +" i ";} // return abs/modulus/Größe public double ABS () {return math.hypot (re, iM);} // Return Winkel/Phase/Argument, normalisiert, um zwischen -pi und pi pi public math () {return math.atan2 (iM, iM, re) zu sein}//complex//complex//complex b), der ein neues Value (complex b) (}//////////////////////////////////////////////////////. = // DOUBLE ABSCHNITTE ANGEBOTE b) {Komplex A = doppelte Real = A.Re * B.Im * B.im; conjugate () {return New Complex (re, -im); b) {Komplex A = Return A.Times (B.Reciprocal ()); Komplex (math.sin (re) * math.cosh (im), math.cos (re) * math.sinh (im)); Dieser Komplex () {return sin (). Cos ()); ! Komplex (-3,0, 4.0); System.out.println ("a - b =" + a.minus (b)); a.Divides (b) .Times (b));Für weitere Informationen zu Java -Algorithmen können Leser, die an dieser Website interessiert sind, die Themen "Java -Datenstruktur und Algorithmus -Tutorial", "Zusammenfassung der Java -Operation DOM -Knoten -Tipps", "Zusammenfassung der Java -Datei- und Verzeichnisoperationstipps" und "Zusammenfassung der Java -Cache -Operation Tipps" anzeigen
Ich hoffe, dieser Artikel wird für Java -Programme aller hilfreich sein.