ulamek dziesietny - >ulamek zwykly

Cześć

potrzebuje do wiekszego projektu jakąś metode, ktora bedzie mi zamieniac np. ulamek -0.7125 na jego odpowiednik ulamka zwyklego w najbardziej skroconej postaci czyli licznik -57, mianownik 80.

Jak cos takiego wykonac, bo w ogole nie mam pomyslu jak sie za to zabrac.

z gory dzieki za wskazowki

probowalem cos takiego, ale zle dziala:

  a- to liczba przekazana do funkcji (ten ulamek dziesietny)
double t = a;
        if (t < 0)
        {
            double i = 0, j = 0;
            int flaga = 0;
            t = std::abs(t);
            for (i = 0; i < 200; i++)
            {
                for (j = 0; j < 200; j++)
                {
                    if (i / j == t)
                    {
                        flaga = 1;
                        break;
                    }
                }
            if (flaga == 1)
                break;
            }

            l = -i;
            m = j;
        }
        else
        {
             double i = 0, j = 0;
            int flaga = 0;
            
            for (i = 0; i < 200; i++)
            {
                for (j = 0; j < 200; j++)
                {
                    if (i / j == t)
                    {
                        flaga = 1;
                        break;
                    }
                }
            if (flaga == 1)
                break;
            }

            l = i;
            m = j;
        }

Masz ilosc cyfr po przecinku, wiec masz mianownik (odpowiednia potega 10), a dodatkowo to, co jest po przecinku, to jest licznik.
Innymi slowy: -0.1234 = - (1234/10000)

ok, tylko to nie bedzie jeszcze skrocona forma...

a tak czy siak, skad wziasc, ze mianownik to 1000 a nie np., 10000, jak to fizycznie zrealizowac ?

Liczysz miejsca po przecinku i masz mianownik ( chyba, że chcesz zapisać ułamek okresowy, to algorytm jest troszeczkę inny ), co do skracania szukasz wspólnego dzielnika licznika i mianownika i dzielisz, jaki więc problem? Algorytm wspólnego dzielnika poznajesz w szkole podstawowej tak jak same ułamki.

ok, tylko jak wlasnie policzyc te miejsca po przecinku ?

probowalem tak, ale nie dziala:

 
 double t = std::abs(a);
        int i = 0;
        while (t < 1)
        {
            t *= 10;
            ++i;
        }
        l = t;

        m = 10;

        int j = 1;
        while (j <= i)
        {
            j++;
            m *= 10;
        }

napisalem i nawet dziala :)

 
   int flaga = 0;
        double t;
        if (a < 0)
        {
            t = std::abs(a);
            flaga = 1;
        }
        else
            t = std::abs(a);
        
        int i = 0;
        while (t < 100000000)
        {
            t *= 10;
            ++i;
        }
        l = t;

        m = 1;

        int j = 1;
        while (j <= i)
        {
            j++;
            m *= 10;
        }
        
        double k=NWD(l,m);
        l/=k;
        m/=k;

        if (flaga ==1)
            l=-l;