Vergleichen von double-Werten

rustyoldguy

Mitglied
Hallo Leute!

Oft kommt es vor, das man Fließkomma-Variablen miteinander vergleichen muss, um dann mit if und else
Verzweigungen im Proggi herzustellen. So was sollte man mit Vorsicht genießen und sich fragen, bis zu
welcher Nachkommastelle diese Auswertung sinnvoll ist.

Hier bietet sich an zunächst mit log10(double_Wert) + 1;
die Anzahl der Vorkommastellen der beiden Werte zu ermitteln.

Mit
nachkomma_double_Wert = std::modf(double_Wert, &vorkomma_double_Wert);

wird dann der Vorkomma-Anteil vom Nachkomma-Anteil getrennt.

Durch anschließende Multiplizierung wird dann der Nachkommaanteil so weit umgewandelt,
um mit den daraus entstandenen Vorkommaanteilen die Werte vergleichen zu können.
C++:
#include <iostream>
#include <iomanip>
#include <cmath>
#include <limits>
 
int compdouble(double da, double db, int stellen)
{
 int rewer = -1, nachint_a = 0, nachint_b = 0, i, faktor = 1, vka, vkb;
 int vorkommastellena = -1, vorkommastellenb = -1;
 double nachkomma_a, vorkomma_a;
 double nachkomma_b, vorkomma_b;
 
 vorkommastellena = (int)log10(da) + 1;
 vorkommastellenb  = (int)log10(db) + 1;
 
 if (stellen >= 1)
  {
   // Vorkomma- und Nachkommastellen separieren
   nachkomma_a = std::modf(da, &vorkomma_a);
   nachkomma_b = std::modf(db, &vorkomma_b);
 
   // Gleitkomma in int umwandlen
   vka = vorkomma_a;     
   vkb = vorkomma_b;     
 
   std::cout << "Vorkommastellen da: " << vorkommastellena << std::endl;
   std::cout << "vorhkommastellen bb: " << vorkommastellenb << std::endl;
   std::cout << "Nachkomma_a: " << nachkomma_a << std::endl;
   std::cout << "Nachkomma_b: " << nachkomma_b << std::endl;
 
   if(vka == vkb)
   for (i = 0; i <= stellen; i++)
    {
     faktor *= 10;
     nachint_a = nachkomma_a * faktor;
     nachint_b = nachkomma_b * faktor;
     std::cout <<"nachint_a: " << std::setw(8) << nachint_a<< "   nachint_b: " << std::setw(8) <<  nachint_b << "   i:" << i << std::endl;
     if(nachint_a != nachint_b)
      {
       rewer = i;  // Gibt an, bis zu welcher Nachkommastelle die Zahlen gleich sind
       break;
      }
    }
       else
     {
      for (i = vorkommastellena - 1; i >= 0; i--)   
       {
        faktor = pow(10, i);
        vka = vorkomma_a / faktor;
        vkb = vorkomma_b / faktor;
        // Format der Auswertungsstellen:  -3-2-1.12345
        rewer =  i * -1;  // Gibt an, bis zu welcher Nachkommastelle die Zahlen gleich sind; Vorkommastelle -1 = Einer, -2=Zehner usw
        std::cout <<"vka: " << std::setw(8) << vka << "   vka: " << std::setw(8) <<  vkb << "   rewer: " << rewer << "   faktor: " << faktor << std::endl; 
        return rewer;
       }
     }
  }
 else rewer = -111; // Wenn Stellen kleiner 1
 
 return rewer;   
}

int main()
{
    int erge = 0;
    double da, db;
    
    std::cout << "Bitte double-Wert eingeben.....: " ;
    std::cin >> da;
    std::cout << "Bitte 2ten double-Wert eingeben: " ;
    std::cin >> db;
 
    erge = compdouble(da, db, 4);   
    std::cout << "Gleich bis Nachkomma-Stelle....: " << erge << std::endl;
    
 return 0;
}

Würde man im oberer source nun 123.456789 und 123.4568797 eingeben, wäre die Antwort, das diese
Variablen bis zur 3ten Nachkommastelle gleich sind.
Bei der Eingabe von -123.456789 und 123.456789 wäre die Ausgabe -1.

Somit kann man sich einiges an Arbeit beim coden ersparen.
 
Zurück
Oben Unten