array elemente quadrieren - vorwärts != rückwarts



  • guten abend miteinander,

    das ist mein erster post hier *winkt in die runde*
    ich bin auf ein seltsames problem gestoßen und befuerchte, dass ich nur den wald vor lauter bäumen nicht sehe.

    ich habe ein float-array mit 100.000 elementen zwischen -25 und 24. deren quadrate summiere ich vorwärts und rückwärts auf. nur sind die ergebnisse abweichend voneinander. aendere ich den datentyp von float auf int, laeuft alles wunderbar. leider sind die abweichungen auch nicht im nachkommabereich, wo ich mit rundungsfehlern argumentieren koennte... vllt. hat ja jemand eine idee. hier erstmal der code:

    srand((unsigned int) time(NULL) );
      float tmp[100000];
    
      for (int i=0; i<100000; ++i) {
        tmp[i] = (float)(rand()%50-25);
      }
    
      float variance = 0;
      for (float* ptr=tmp; ptr < tmp + 100000; ++ptr) {
        float tmp = *ptr;
        variance += (tmp*tmp);
      }
      cout << variance << endl;
      variance = 0;
      for (float* ptr=tmp+100000-1; ptr >= tmp; --ptr) {
        float tmp = *ptr;
        variance += (tmp*tmp);
      }
      cout << variance << endl;
    

    output:
    2.08346e+007
    2.08344e+007

    cheers,
    foobar



  • Hallo

    Dein Output sieht stark nach Initialisierungswerte aus. Für weitere Hilfe bin ich aber zu Faul :-O.

    Mfg.
    way



  • warum sieht das nach initialisierungswerten aus? sind es nicht.
    ich habe die quadrierungsergebnisse auch in zwei dateien geschrieben und diese inhalte verglichen. exakt identisch.
    wenn ich die multiplikation variance += (tmp*tmp) durch variance += tmp ersetze, erhalte ich auch identische ergebnisse...
    habe ich deine antwort falsch verstanden?



  • Der relative Fehler ist aber ziemlich klein! Damit könntest du argumentieren. Der Grund für diesen Fehler ist dir hoffentlich klar?



  • das mag sein - aber trotzdem ist es ein sehr seltsames verhalten... und so klein ist der gar nicht.. immerhin 200.

    und die rechenoperationen lassen doch eigentlich gar keine fehler in diesem bereich zu - ich bin weit entfernt von dem float-maximum, addiere und quadriere nur natuerliche zahlen. da sollte das doch nicht passieren...



  • Die Quantisierungsschritte sind aber nicht-konstant. Wenn du früher in große Bereiche gerätst (weil sie sich hinten oder vorne betragsmäßig große Zahlen ballen), wird der Fehler größer. Und die Fehler summieren sich halt bei 100000 berechnungen in der Kette auch ziemlich auf.



  • hm, danke. das war mir in dem maße nicht bewusst. ueber die quantisierung habe ich nicht nachgedacht.

    danke schoen,
    foobar



  • wie siehts denn aus, wenn tmp(die hilfvariable) und variance vom typ double sind?



  • mit den beiden als double-typ sind die ergebnisse identisch. es stehen ja auch mehr mantissen-bits zur verfügung, bzw. der wertebereich ist deutlich größer, so dass das das ergebnis relativ gesehen in einem viel kleineren bereich liegt und die abweichung nicht in der 6-ten mantissen-nachkommastelle liegt.

    cheers,
    foobar


Log in to reply