Fehler beim Rechnen mit Floats

[Bazilinho]

Hallo Leute!
Ich muß eine Berechnung für mein Tool machen. Als Datentyp habe ich mich für floats entschieden, aber aus irgendwelchen mir nicht erfindlichen Gründen gibt es irgendwann ziemlich strange Ergebnisse..
Daher hoffe ich, Ihr könnt mir helfen..

Zur Situation. Ich habe "ein" Array of Arrays float[][].
Der erste Index geht bis 26 also float[26][] und der 2. ist Variabel, soweit so gut.

Ich möchte als Ergebnis ein float[26] haben. Und zwar sollen pro Array von 0-26 die Variablen Werte aufsummiert und mit folgender Formel berechnet werden.

float = Sum (b=1 - B) F_b * cos * (PI*i*(b-0,5) / B)

die b's sind meine ganzen Werte pro Array.
Da das erste Array z.B. 1970 Einträge enthält soll es sich so berechnen:

Wert_1 * cos * (PI*1*(1-0,5) / 1970)
Wert_2 * cos * (PI*1*(2-0,5) / 1970)
etc...

fürs. 2. Array (Größe z.B. 2500) so:

Wert_1 * cos * (PI*2*(1-0,5) / 2500)
Wert_2 * cos * (PI*2*(2-0,5) / 2500)
etc...


Ich habe das in Java wie folgt implementiert:

for (int koeff_nr = 1; koeff_nr <26; koeff_nr++) {
			
			int length_count = 0;		
			
			for (int i = 0; i <data_in[(koeff_nr-1)].length; i++) {
				if (data_in[koeff_nr][i] == 0.0) {
					length_count = i-1;
					break;
				}
			}
			
			
			for (int koeffs = 0; koeffs < (length_count); koeffs++) {
				
				if (DCT_Koeffizienten[koeff_nr] == 0.0) {
					DCT_Koeffizienten[koeff_nr] =  (float) (data_in[koeff_nr][koeffs]*Math.cos((Math.PI*koeff_nr*(koeffs-0.5)) / length_count));
				}
				else {
					
					DCT_Koeffizienten[koeff_nr] = DCT_Koeffizienten[koeff_nr] + (float) (data_in[koeff_nr][koeffs]*Math.cos(Math.PI*koeff_nr*(koeffs-0.5) / length_count));
				}
				
			}
		}

Kurz zum Code..
Ich lese mir mein Array of Arrays float[26][] mit der for-schleife aus.
Gucke zunächst, wie viele Einträge ich habe, da ich das Array mit einer zu großen festen Größe initialisiert habe. Ich gebe zu, das ist vermutlich etwas unsauber, aber das soll hier nicht das Problem sein.

Mit der 2. for-schleife lese ich dann das 2. Array aus und berechne und summiere die Werte auf, um Sie nachher im neuen Array of floats[] abzuspeichern.


Jetzt habe ich das Problem, daß ich für meine erstes i also float[1][] insgesamt 1970 Werte habe. Die ersten 985 Werte werden alle korrekt berechnet und aufsummiert.
Aber ab 986 bekomme ich immer relativ hohe negative Werte, so daß die Gesamtsumme negativ werden würde.

Und das obwohl ich meine Werte VORHER als Betrag genommen habe. Habe auch in mein Eingangs- Array of Arrays geguckt, da sieht alles ganz normal aus.

Und interessanterweise fängt er immer an 2er Potenzen an falsch zu rechnen:
Also im ersten Array bei 1970 / 2 = 985
dann bei Array.length / 4
dann bei Array.length / 6
dann bei Array.length / 8
usw.

Ich hoffe, ich konnte mich halbwegs verständlich ausdrücken und hoffe noch viel mehr, daß mir jemand helfen kann..

Ich danke Euch schonmal!!

Gruß, Bazilinho

 

[SlaterB]

schau dir doch einfach den cos-Faktor mit System.out.println() an, ab der Hälfte geht er ins negative, wie das bei PI/2 so üblich ist,
bei hoeherer koeff_nr geht es schneller, denn die geht als Faktor mit ein,
wie sich das positive oder negative cos am Ende in der Summe auswirkt hängt davon ab, in welchen Bereichen die data_in-Werte größer sind

 

[Bazilinho]

Hi Slater!
Vielen Dank erstmal für Deine Antwort!!
Aber irgendwie weiß ich nicht woran es liegt....

count 983 982.5 1165.0742
cos-werte 1.1098074 1.5684042511703358
count 984 983.5 1165.0756
cos-werte 0.7266244 1.5699989682533764
count 985 984.5 1165.0782
cos-werte 0.79915375 1.5715936853364167
count 986 985.5 1165.0789
cos-werte 0.49863356 1.5731884024194573
count 987 986.5 1165.0782
cos-werte 0.63147384 1.574783119502498

Das ist jetzt mal ein System.out der entsprechenden Problemzone..
Die count-Zeilen, zählen halt die Values und hintendran ist der Gesamt-Wert.
Immer mit 1 Versatz, Du siehst daß der Gesamtwert am Ende abnimmt.

und in der cos-Zeile habe ich als 2. Wert die Cos-Werte. Bzw. muß der cos noch auf die Werte gerechnet werden und dann in dem letzten Fall mal 0,799 genommen werden.

Ich versteh da leider immer noch net, warum es an der Stelle negativ wird..

 

[SlaterB]

ich habe ebenso oder jedenfalls keine Ahnung, was du mir mitteilen willst oder was deine Ausgaben bedeuten,

ich rede von
[c]Math.cos((Math.PI*koeff_nr*(koeffs-0.5)) / length_count)[/c]
koeff_nr ist erstmal egal, schon am Anfang mit koeff_nr == 1 besteht das Problem,
-> [c]Math.cos((Math.PI*(koeffs-0.5)) / length_count)[/c]
-0.5 ist bei Werten in den Tausendern relativ egal, selbst im kleineren Bereich,
vielleicht hast du irgendwas entscheidendes damit vor, in der derzeitigen Konstellation kann man es weglassen
->[c]Math.cos( Math.PI * [koeffs / length_count])[/c]
koeffs läuft in der Schleife von 0 bis length_count, der rechte Teil ist also ein Faktor von 0 bis 1,
cos(0) ist 1, cos(PI) ist -1, dawischen verläuft das ganze

was du loggst ist mir nicht ersichtlich, ich poste 'dagegen' folgendes Testprogramm:

public class Test {
	public static void main(String[] args) {
		int[] data_in = {1,2,3,4,5,6,7,8,9,10,11,12,13,0};

		int length_count = 0;
		double DCT_Koeffizienten = 0;

		for (int i = 0; i < data_in.length; i++) {
			if (data_in[i] == 0.0) {
				length_count = i - 1;
				break;
			}
		}
		System.out.println(length_count);
		for (int koeffs = 0; koeffs < (length_count); koeffs++) {

			if (DCT_Koeffizienten == 0.0) {
				DCT_Koeffizienten = (float) (data_in[koeffs] * Math
						.cos((Math.PI * (koeffs - 0.5)) / length_count));
				System.out.println("a: "+DCT_Koeffizienten);
			} else {
				System.out.println("f: "+(Math.cos(Math.PI
						* (koeffs - 0.5) / length_count)));
				DCT_Koeffizienten = DCT_Koeffizienten
						+ (float) (data_in[koeffs] * Math.cos(Math.PI
								* (koeffs - 0.5) / length_count));
			}

		}
		System.out.println(DCT_Koeffizienten);
	}
}

Ausgabe:

12
a: 0.9914448857307434
f: 0.9914448613738104
f: 0.9238795325112867
f: 0.7933533402912352
f: 0.6087614290087207
f: 0.38268343236508984
f: 0.1305261922200517
f: -0.1305261922200516
f: -0.3826834323650895
f: -0.6087614290087207
f: -0.793353340291235
f: -0.9238795325112867
-15.216438174247742