JavaScript Wie wird eine Dezimalzahl mit zwei Nachkommastellen in einen Bruch umgewandelt?

[kali-hi]

Irgendwie habe ich gerade eine Denkblockade...

Wie wird eine Dezimalzahl mit genau zwei Nachkommastellen in einen Bruch umgewandelt?

Also, reelle Zahl -> rationale Zahl.

Zum Beispiel: 2,52

 

[Benna]

Ich habe für dich mal gegoogelt: https://www.google.com/search?q=Jav...onale+Zahl+umwandeln&sourceid=chrome&ie=UTF-8

Gern geschehen!

 

[madmax2010]

WIllst du die funktion selber implementieren, oder eine Library nutzen?
Was stellst du dir unter umwandeln vor? Die zahl bleibt doch gleich.


Hint: ggT

Also, reelle Zahl -> rationale Zahl.

Eine Dezimalzah lwie hier beschrieben ist bereits rational

Ergänzung (20. Dezember 2025)

@Benna deine suche tut was anderes, aber mit IEEE754 sollte man sich auch eh mal irgendwann beschäftigt haben..

 

[kali-hi]

WIllst du die funktion selber implementieren, oder eine Library nutzen?

Selber implementieren, moment ich poste ein Beispiel.

Eine Dezimalzahl mit genau zwei Nachkommastellen ist bereits rational

Ja, bitte verzeihe meine Ausdrucksweise.

 

[madmax2010]

0.53 sind 53 hundertstel. c'mon...

 

[kali-hi]

Es geht um die Funktion convertToFractionalMatrix in Zeile 67. Ich weiß nicht, was ich da schreiben soll:

class GaussJordan {
    constructor(matrix) {
        this.message = "";
        this.matrix = matrix;
        this.rows = matrix.length;
        this.cols = matrix[0].length;

        for (let i = 0; i < this.rows; i++) {
            if (this.matrix[i].length !== this.rows + 1) {
                this.appendMessage("Invalid matrix dimensions");
                throw "Invalid matrix dimensions";
            }
        }
    }

    appendMessage(message) {
        this.message += message + "\n";
    }

    getMessage() {
        return this.message;
    }

    print() {
        for (let i = 0; i < this.rows; i++) {
            let s = "";
            for (let j = 0; j < this.cols; j++) {
                s += Number(this.matrix[i][j]).toFixed(2) + "  ";
            }
            this.appendMessage(s);
        }
        this.appendMessage("");
    }

    reduceRow(r1, r2, pos) {
        if (r1.length != r2.length) {
            return false;
        }

        let factor = r2[pos] / r1[pos];
        for (let i = pos; i < r1.length; i++) {
            r2[i] -= factor * r1[i];
        }
        return true;
    }

    normalizeMatrixVariablesToOne() {
        let result = true;
        for (let i = 0; i < this.rows; i++) {
            for (let j = 0; j < this.cols - 1; j++) {
                if (i == j) {
                    if (this.matrix[i][j] == 0) {
                        throw "Division by zero";
                    }
                    continue;
                }
                if (this.matrix[i][j] != 0) {
                    result = false;
                }
            }
            this.matrix[i][this.cols - 1] = this.matrix[i][this.cols - 1] / this.matrix[i][i];
            this.matrix[i][i] = 1.0;
        }
        return result;
    }

    convertToFractionalMatrix() {
        for (let i = 0; i < this.rows; i++) {
            // this.matrix[i][this.cols - 1] = math.fraction(this.matrix[i][this.cols - 1]);

        }
    }

    solve() {
        let k; // pivot
        let swapTemp;

        for (let i = 0; i < this.rows; i++) {
            k = i;

            for (let j = i + 1; j < this.rows; j++) {
                if (this.matrix[j][i] > this.matrix[k][i]) {
                    k = j;
                }
            }

            if (this.matrix[k][i] == 0) {
                this.appendMessage("System of equations contains free variables");
                return;
            }

            // Swap the rows i and k
            swapTemp = this.matrix[i];
            this.matrix[i] = this.matrix[k];
            this.matrix[k] = swapTemp;

            // Iterate over all subsequent rows
            for (let j = 0; j < this.rows; j++) {
                // Reduce row by row
                if (
                    i != j &&
                    !this.reduceRow(this.matrix[i], this.matrix[j], i)
                ) {
                    this.appendMessage("System of equations cannot be solved");
                    return;
                }
            }

            this.print();
        }

        if (!this.normalizeMatrixVariablesToOne()) {
            this.appendMessage("System of equations cannot be fully normalized");
        }
        this.print();

        this.convertToFractionalMatrix();
        this.print();
    }
}

0.53 sind 53 hundertstel

Ja, wahr... Aber wie kommt man dann auf 63/25 ?

 

[madmax2010]

wie viel 100stel (schreibt man das so im deutschen?) ist 1?
wie viel 25stel ist 1?

 

[SaschaHa]

Allgemein:

• a = Anfangszahl
• b = Anzahl der Nachkommastellen
• c = 10^b
• d = a*c
• e = ggT(d, c)
• f = d/e -> Zähler
• g = c/e -> Nenner

 

[kali-hi]

@madmax2010 Also rechne ich einfach (immer) 100 / 52, das wären 50 / 26 und 25 / 13. Dann noch den Vorkommateil hinzu: 2+25/13 ... aber das passt nicht.

Ergänzung (20. Dezember 2025)

Oh, 13 und 25 vertauscht.

Ergänzung (20. Dezember 2025)

wie viel 100stel (schreibt man das so im deutschen?)

Man schreibt Hundertstel oder 100-stel.

Ergänzung (20. Dezember 2025)

Oder Zenti-

Ergänzung (20. Dezember 2025)

... schau vorsichtshalber selber nach: https://flexikon.doccheck.com/de/Präfix_für_Maßeinheiten

Ergänzung (20. Dezember 2025)

oder 100-stel

Nein, auch falsch...

https://www.duden.de/sprachwissen/s...ch#:~:text=Ob 80-prozentig, 12-,, 68er, 20%ig.

 

[SaschaHa]

Beispiel:

• a = 2,52
• b = 2
• c = 10^2 = 100
• d = 2,52*100 = 252
• e = ggT(252, 100) = 4
• f = 252/4 = 63
• g = 100/4 = 25

Das Ergebnis wäre folglich 63/25. Die Unklarheit scheint bei dir beim ggT zu liegen. Diesen benötigst du zum Kürzen des Bruchs. Wie du diesen ermittelst, wirst du schon selbst herausfinden, das Stichwort hast du ja jetzt. Viel Spaß!

 

[kali-hi]

@SaschaHa Der ggT ist nicht so das Problem, irgendwie kam ich vorher gar nicht bis zur Variablen e. Danke für die Hilfe.

 

[madmax2010]

Ggt war auch nur ein ganz grober Hinweis in die Richtung den Bruch zu kürzen wie @SaschaHa vorgerechnet hat.

Ob du jetzt als Bruch 500/1000 oder 1/2 hast ist die gleiche Zahl. Oder 0.5 oder 5/10 oder 50/100.
Zur Not nimm die Länge der Zahl als nenner. Zähler drauf und kürzen soweit du Lust hast

 

[tollertyp]

Ich habe mal ne doofe Frage: Es geht da nur um die Anzeige?
Also wäre es nicht besser, die ganzen Rechnungen direkt mit Rationalen Zahlen zu machen, mit entsprechenden Typen, die also Zähler und Nenner kennen, anstatt am Ende zu hoffen, dass der Wert mit 2 Dezimalstellen in einen Bruch umgewandelt werden kann, der nahe an dem Wert ist, den die Zahl (die ja vermutlich gerundet sein dürfte?) repräsentieren soll?

 

[kali-hi]

@tollertyp Der Benutzer soll hinterher beide Geschmacksrichtungen sehen können, also einmal die Variante x.xx und einmal xx/xx, je nach dem, was bevorzugt ist. Und auf sehr hohe Genauigkeiten kommt es hierbei auch nicht an.

 

[DHC]

Nur zur Info.
Das Kürzen wird oft bei Servo-Regler angewandt. Zumindest mache ich es.
Gerade, wenn man mehrere Getriebestufen hat, kann es zu Drifts kommen, wenn man nur die gerundeten Getriebeübersetzungsangaben (i = x.yyy) verwendet.
Man verrechnet alle Zähne der Zahnräder (Antrieb/Abtrieb // Zähler/Nenner).
Dann kürzt man das Ergebnis mit ggT meist auf einen sehr viel kleineren Z/N-Wert.
Die Servo-Regler arbeiten intern mit Ganzahlen/Integer (32/64 bit).
Da sind große Werte für Z/N nicht optimal.

 

[kali-hi]

Hab's gelöst. Gegeben sei das LGS:

2 9 5
2 4.5 3

Die Lösung ist:

2.00  9.00  5.00 
0.00  -4.50  -2.00 

2.00  0.00  1.00 
0.00  -4.50  -2.00 

1.00  0.00  0.50 
0.00  1.00  0.44 

1.00  0.00  1/2 
0.00  1.00  11/25

(Ja ok, ein vielleicht zu einfaches Beispiel gewählt...)

class GaussJordan {
    constructor(matrix) {
        this.message = "";
        this.matrix = matrix;
        this.rows = matrix.length;
        this.cols = matrix[0].length;

        for (let i = 0; i < this.rows; i++) {
            if (this.matrix[i].length != this.rows + 1) {
                this.appendMessage("Invalid matrix dimensions");
                throw "Invalid matrix dimensions";
            }
        }
    }

    appendMessage(message) {
        this.message += message + "\n";
    }

    getMessage() {
        return this.message;
    }

    ggT(a, b) {
        if (b == 0) {
            return a;
        }
        return this.ggT(b, a % b);
    }

    print(fractional = false) {
        for (let i = 0; i < this.rows; i++) {
            let s = "";
            for (let j = 0; j < this.cols; j++) {
                if (fractional) {
                    let v = this.matrix[i][j];
                    if (v != 0 && v != 1) {
                        let a = Math.round(Number(v).toFixed(2) * 100.0);
                        let b = 100;
                        let ggt = this.ggT(a, b);
                        s += (a / ggt) + "/" + (b / ggt) + "  ";
                    } else {
                        s += Number(v).toFixed(2) + "  ";
                    }
                } else {
                    s += Number(this.matrix[i][j]).toFixed(2) + "  ";
                }
            }
            this.appendMessage(s);
        }
        this.appendMessage("");
    }

    reduceRow(r1, r2, pos) {
        if (r1.length != r2.length) {
            return false;
        }

        let factor = r2[pos] / r1[pos];
        for (let i = pos; i < r1.length; i++) {
            r2[i] -= factor * r1[i];
        }
        return true;
    }

    normalizeMatrixVariablesToOne() {
        let result = true;
        for (let i = 0; i < this.rows; i++) {
            for (let j = 0; j < this.cols - 1; j++) {
                if (i == j) {
                    if (this.matrix[i][j] == 0) {
                        return false;
                    }
                    continue;
                }
                if (this.matrix[i][j] != 0) {
                    result = false;
                }
            }
            this.matrix[i][this.cols - 1] = this.matrix[i][this.cols - 1] / this.matrix[i][i];
            this.matrix[i][i] = 1.0;
        }
        return result;
    }

    solve() {
        let k; // pivot
        let swapTemp;

        for (let i = 0; i < this.rows; i++) {
            k = i;

            for (let j = i + 1; j < this.rows; j++) {
                if (this.matrix[j][i] > this.matrix[k][i]) {
                    k = j;
                }
            }

            if (this.matrix[k][i] == 0) {
                this.appendMessage("System of equations contains free variables");
                return;
            }

            // Swap the rows i and k
            swapTemp = this.matrix[i];
            this.matrix[i] = this.matrix[k];
            this.matrix[k] = swapTemp;

            // Iterate over all subsequent rows
            for (let j = 0; j < this.rows; j++) {
                // Reduce row by row
                if (
                    i != j &&
                    !this.reduceRow(this.matrix[i], this.matrix[j], i)
                ) {
                    this.appendMessage("System of equations cannot be solved");
                    return;
                }
            }

            this.print();
        }

        if (!this.normalizeMatrixVariablesToOne()) {
            this.appendMessage("System of equations cannot be fully normalized");
        }
        this.print();
        this.print(true);
    }
}

Ich musste also nur die print-Funktion in Zeile 31 anpassen.

 

[BeBur]

Sinnvollerweise würde man die Darstellung der Zahl entkoppeln, z.B. so (pseudo-code(*)):

NumberFormatter::SetPrintFormat(PrintFormat::Fraction);
NumberFormatter::SetWidth(6); // Two digits for numerator/denominator + fraction symbol + sign
for(auto row: matrix) {
    for(auto element: row) {
        NumberFormatter::PrintNumber(element);
    }
    PrintRowDelimiter();
}

(*) Ok, technisch gesehen ist es C++, nicht Puseudo-Code, aber modernes C++ ist oft genau so leicht zu lesen.

 

[kali-hi]

die Darstellung der Zahl entkoppeln

Das hab ich doch getan

Ergänzung (21. Dezember 2025)

Es lässt sich auch weiter vereinfachen:

        ggT(a, b) {
            if (b == 0) {
                return a;
            }
            return this.ggT(b, a % b);
        }

        print(fractional = false) {
            for (let i = 0; i < this.rows; i++) {
                let s = "";
                for (let j = 0; j < this.cols; j++) {
                    let v = this.matrix[i][j];
                    if (fractional && v != 0 && v != 1) {
                        let a = parseInt(v * 100.0);
                        let b = 100;
                        let ggt = this.ggT(a, b);
                        s += (a / ggt) + "/" + (b / ggt) + "  ";
                    } else {
                        s += Number(v).toFixed(2) + "  ";
                    }
                }
                this.appendMessage(s);
            }
            this.appendMessage("");
        }

Es gibt aber ein Problem, zum Beispiel bei 2/3:

3.00  2.00 

1.00  0.67 

1.00  33/50

Eigentlich sollten es hier 2/3 sein, nicht 33/50 ... Hat jemand dazu eine Idee? Ich runde ja bereits immer ab.

Vielleicht muss ich mir doch die Mühe machen, und bei allen Berechnungen mit reinen rationalen Zahlen rechnen...

 

[simpsonsfan]

Nun, 2/3 ist nunmal keine

Dezimalzahl mit genau zwei Nachkommastellen

Und 67/100 ist weder 33/50 noch 2/3.

Falls du tatsächlich exakte rationale Ergebnisse haben möchtest, wäre das Rechnen mit Brüchen vermutlich das Einfachste.

 

[SaschaHa]

2/3 ist eine periodische Dezimalzahl, als reelle Zahl wäre sie also unendlich lang und kommt folglich nicht ohne Rundung aus. Bei solchen Zahlen macht eine Umwandlung daher keinen Sinn.