Bin to Float convertieren funktioniert nicht

[ms_cikar]

Hallo Leute,

Ich bin verzweifelt.

Ich habe eine Bin folge von 32 Bit: 01000011110010111110011010100110
Ich würde gerne diese Bin folge (gespeichert in einem String) zu float wert umwandeln.
Leider klappt das nicht so gut.

String binfolge= "01000011110010111110011010100110";
float test= Float.parseFloat(binfolge);
System.err.println(test);

Was mache ich falsch?

 

[mihe7]

parseFloat erwartet einen String, der eine Fließkommazahl im Dezimalsystem darstellt. Du möchtest vermutlich

float test = Float.intBitsToFloat(Integer.parseInt(binfolge, 2));

 

[KonradN]

Was mache ich falsch?

Du versuchst Methoden zu verwenden, ohne diese zu kennen. Die Dokumentation beschreibt, was die Methoden können:
parseFloat(String):

Returns a new float initialized to the value represented by the specified String, as performed by the valueOf method of class Float.

Daher dann: valueOf(String) beschreibt, was da als Eingabe möglich ist. Findest Du da was taugliches? Kannst Du da etwas umwandeln, dass es tauglich wird? Evtl. willst Du einfach mal die Dokumentation durchschauen - Evtl. findest Du ja eine Methode, die Bits nimmt um diese zu einem float umwandelt?

 

[KonradN]

parseFloat erwartet einen String, der eine Fließkommazahl im Dezimalsystem darstellt. Du möchtest vermutlich

float test = Float.intBitsToFloat(Integer.parseInt(binfolge, 2));

Bah, erst etwas schneller und dann noch Spielverderber

 

[planet_safe]

Hallo, so eine Klasse ist doch leicht selber geschrieben:

public class MyFloat extends Number {
    private int sign;
    private int exponent;
    private int mantisse;

    public MyFloat(String bits) {
        bits = fitLength(bits);
        if (bits.charAt(0) == '0') {
            sign = 1;
        } else {
            sign = -1;
        }
        exponent = 0;
        for (int i = 1; i < 9; i++) {
            exponent |= (bits.charAt(i) - '0') << (8 - i);
        }
        mantisse = 0;
        for (int i = 9; i < 32; i++) {
            mantisse |= (bits.charAt(i) - '0') << (31 - i);
        }
        System.out.println(sign + " " + exponent + " " + mantisse);
    }

    private String fitLength(String s) {
        while (s.length() < 32) {
            s = "0" + s;
        }
        return s;
    }

    @Override
    public int intValue() {
        return (int) floatValue();
    }

    @Override
    public long longValue() {
        return (long) floatValue();
    }

    @Override
    public float floatValue() {
        return sign * Float.parseFloat("1." + mantisse) * (float) Math.pow(2, exponent - 127);
    }

    @Override
    public double doubleValue() {
        return floatValue();
    }

    public static void main(String[] args) {
        String s = Integer.toBinaryString(Float.floatToIntBits(-256));
        System.out.println(s);
        MyFloat mf = new MyFloat(s);
        System.out.println(mf.floatValue());
    }
}

(Achtung: KANN Fehler enthalten...)

 

[mihe7]

Hallo, so eine Klasse ist doch leicht selber geschrieben:

Wozu?!?

(Achtung: KANN Fehler enthalten...)

Verstehe, um dem Fehler eine Chance zu geben.

 

[planet_safe]

Wozu?!?


Verstehe, um dem Fehler eine Chance zu geben.

Hallo @mihe7 , alter Haulunk

um Verständnis aufzubauen...

Float.parseFloat("1." + mantisse)

... hättest du vielleicht eine Idee, wie man das besser schreiben könnte, oder was daran falsch wäre?

 

[httpdigest]

alter Haulunk

Du meinst Halunke?

 

[planet_safe]

Du meinst Halunke?

Jaaa, heute ist nicht mein Tag

 

[mihe7]

... hättest du vielleicht eine Idee, wie man das besser schreiben könnte, oder was daran falsch wäre?

Funktioniert etwas nicht?

 

[planet_safe]

Funktioniert etwas nicht?

    public static void main(String[] args) {
        String s = Integer.toBinaryString(Float.floatToIntBits(57));
        System.out.println(s);
        MyFloat mf = new MyFloat(s);
        System.out.println(mf.floatValue());
    }

Die Ausgabe ist nicht wie erwartet 57.0, sondern 52.97152... Bei anderen Zahlen ist die Abweichung sogar noch krasser...

Danke, falls Du dich damit beschäftigen möchtest... hab leider keinen den ich fragen könnte oder der sich damit auskennt.

 

[KonradN]

Da fallen doch mehrere Dinge auf - alle beim Umgang mit der Mantisse.
Eine Mantisse mit 1.xxxxx im Dualen System ist nicht so einfach zu einem 1.xxxxx im Dezimalsystem zu machen. Zumal Du ja auch führende 0er nicht beachtest.

Aber ich habe mir den Code auch nicht zu genau angesehen und nur überflogen. Aber das sah so auf den ersten Blick zumindest dubios aus.

 

[mihe7]

Die Mantissenbits müssten noch durch 2^23 geteilt werden. In Deinem Beispiel ist die Mantisse 1 + 0,6553600, tatsächlich müsste sie aber 1 + (6553600 / 2^23), also 1 + 0,78125 sein. Dann ist 1,78125 * 2^5 = 57.

 

[planet_safe]

Die Mantissenbits müssten noch durch 2^23 geteilt werden. In Deinem Beispiel ist die Mantisse 1 + 0,6553600, tatsächlich müsste sie aber 1 + (6553600 / 2^23), also 1 + 0,78125 sein. Dann ist 1,78125 * 2^5 = 57.

Tatsächlich... Danke.

Könntest du nochmal drüber schauen, ob das jetzt i. O. ist?

public class MyFloat extends Number {
    private final int sign;
    private int exponent;
    private int mantisse;

    public MyFloat(String bits) {
        bits = fitLength(bits);
        if (bits.charAt(0) == '0') {
            sign = 1;
        } else {
            sign = -1;
        }
        exponent = 0;
        for (int i = 1; i < 9; i++) {
            exponent |= (bits.charAt(i) - '0') << (8 - i);
        }
        mantisse = 0;
        for (int i = 9; i < 32; i++) {
            mantisse |= (bits.charAt(i) - '0') << (31 - i);
        }
        System.out.println(sign + " " + exponent + " " + mantisse);
    }

    private String fitLength(String s) {
        while (s.length() < 32) {
            s = "0" + s;
        }
        return s;
    }

    private float power2(int exponent) {
        float a = 1;
        while (exponent > 0) {
            a *= 2;
            exponent--;
        }
        return a;
    }

    @Override
    public int intValue() {
        return (int) floatValue();
    }

    @Override
    public long longValue() {
        return (long) floatValue();
    }

    @Override
    public float floatValue() {
        if (mantisse == 0) {
            return sign * (1f + 1f / power2(23)) * power2(exponent - 127);
        }
        return sign * (1f + mantisse / power2(23)) * power2(exponent - 127);
    }

    @Override
    public double doubleValue() {
        return floatValue();
    }

    public static void main(String[] args) {
        String s = Integer.toBinaryString(Float.floatToIntBits(-123));
        System.out.println(s);
        MyFloat mf = new MyFloat(s);
        System.out.println(mf.floatValue());
    }
}

Was mache ich, wenn mantisse == 0 gilt?

    public static void main(String[] args) {
        String s = Integer.toBinaryString(Float.floatToIntBits(256));
        System.out.println(s);
        MyFloat mf = new MyFloat(s);
        System.out.println(mf.floatValue());
    }

Das ergibt leider 256.00003 ...

 

[KonradN]

Das ergibt leider 256.00003 ...

Das dürfte die normale Ungenauigkeit bei Deinen float Rechnungen sein.

Wenn Du z.B. einfach mal Deine power2 Methode prüfst:

        System.out.println(power2(32));
        System.out.println(Math.pow(2, 32));

dann hast Du schon eine Ungenauigkeit:
4.2949673E9
4.294967296E9

Arbeite mit double bei power2 und mach die Rechnung mit double Werten. Erst am Ende dann ein cast zu float.

Was mache ich, wenn mantisse == 0 gilt?

Dann ist das nur (float) (sign * 1. * power2(exponent - 127)); - der Wert wäre ja mit der "1." davor dann 1.0000..... und damit ja schlicht 1.

 

[KonradN]

könntest du bitte noch etwas näher erläutern, wie es zu diesem Wert 2^23 kommt?

Die Mantisse enthält doch die Bits von 1,xxxxxx

Nehmen wir einfach einmal genau 1 Bit. Dann wäre das 1 + 0,x mit x = 0 oder 1.
Binär 0,1 ist Dezimal 0,5. Wenn x also 1 ist, dann muss ich es durch 2 teilen. (oder 2^1)

Wenn man 2 Bits hat, dann hat man einen Wert von 0,xx
0,1 binär ist 0,5 dezimal
0,01 binär ist 0,25 dezimal

Bei zwei bits haben wir Werte von 0 bis 3. Und dies entspricht den Werten 0; 0,25; 0,5; 0,75 ... also x/4 (oder eben 2^2)

Bei n Bits teilt man also durch 2^n.

Nun wertest Du ja für die Mantisse diese Bits aus:

        for (int i = 9; i < 32; i++) {
            mantisse |= (bits.charAt(i) - '0') << (31 - i);
        }

Du hast also die Bits von 9 bis 31 - das sind also genau 23 Bits.

 

[KonradN]

Das ergibt allerdings Sinn.... Danke dann ist nun alles klaro

Die zweite Frage hatte ich aber noch übersehen. Dazu müssen wir uns einmal die IEEE 754 anschauen.

IEEE 754 – Wikipedia

de.wikipedia.org

Wenn e == 0, dann ist das Problem, dass die Zahl im denormalisierten Format vorliegt. Das bedeutet, dass beim Exponent nicht 2^(E-B) genommen wird sondern 2^(1-B). Es unterscheidet sich um den Faktor 2. Daher wird m mit 2 multipliziert (bzw << 1 was eine Multiplikation mit 2 bedeutet) Und in dem Fall haben wir nicht die 1.xxxxx als Mantisse sondern nur die Bits der Mantisse.

Wenn e != 0 ist, dann sind die Bits der Mantisse um eine 1 zu ergänzen. Das ist halt dieses 1,xxxxxx was zu dem Mantissen Wert wird. Dieses | 0x800000 addiert sozusagen die 1.

Das Ergebnis ist, dass dann jetzt Werte vorliegen, die immer gerechnet werden:
-1^s * m / 2^23 * 2 ^ (e-127)

Der Unterschied zu Deinem Code ist halt: Du rechnest da noch "1 + " Mantisse, weil Du dieses Bit nicht noch dazu gefügt hast.

 

[mihe7]

Jetzt hat Konrad ja alles schon super erklärt. Vielleicht noch kurz ein Beispiel zu den 2^23: das ist nichts anderes als wir im Dezimalsystem auch machen, wenn wir beispielsweise Centbeträge (ganzzahlig) statt Eurobeträge (mit Nachkommastellen) speichern. Um den ganzzahligen Centbetrag zu erhalten, multiplizieren wir den Eurobetrag mit 10^2 und um den Eurobetrag zu erhalten dividieren wir den Centbetrag durch 10^2.

Tankstellen müssten dagegen mit 10^3 rechnen, um mit Zenticent zu arbeiten (auch wenn es da wohl eher um zentnerweise Cent geht). Nichts anderes ist das hier auch: 23 binäre Nachkommastellen umrechnen in eine Ganzzahl und zurück.

 

[ms_cikar]

Hallo Leute,

vielen dank für die Hilfe.
Leider komme ich da nicht weiter.

Wir vorgeschlagen habe ich den Code geändert:

public class m {

    public static void main(String[] args) {
     String binfolge= "11111111110100110000000000000000";
     float test= Float.intBitsToFloat(Integer.parseInt(binfolge, 2));   
     System.out.println("V1 konvertiert: " + test);

    }

Leider kriege ich eine Fehlermeldung beim Ausführen.
Was mache ich Falsch?

Exception in thread "main" java.lang.NumberFormatException: For input string: "11111111110100110000000000000000" under radix 2
at java.base/java.lang.NumberFormatException.forInputString(NumberFormatException.java:68)
at java.base/java.lang.Integer.parseInt(Integer.java:658)
at test_lö.m.main(m.java:8)

 

[Blender3D]

Leider kriege ich eine Fehlermeldung beim Ausführen.
Was mache ich Falsch?

Das liegt daran, dass dein String 32 Zeichen lang ist. Ein integer kann in Java aber nur Werte von -2^31 bis 2^31 -1 beinhalten.
parsInt wertet aber nur positive Zahlen aus also darf ein String nur 31 Zeichen( 0 oder 1 ) beinhalten. Für Negative Werte sollte der String ein Minuszeichen beinhalten.
Also statt "11111111101010110000000000000000" --> "-1111111110100110000000000000000"
Andernfalls bekommst Du den oben erwähnte Fehler.

 

[mihe7]

@blender hat das Zweierkomplement übersehen: 10....01 (also 2^32 + 1) ist nicht das selbe wie -000...1. Die Rechnung wäre

  11111111101010110000000000000000
==================================
-(00000000010101001111111111111111  Negation der Zahl
  +                              1) Addition von 1
-----------------------------------
 -00000000010101010000000000000000  Ergebnis

Integer.parseInt("-00000000010101010000000000000000", 2) liefert dann das korrekte Ergebnis -5570560. Das geht auch leichter, indem man Integer.parseUnsignedInt() verwendet:

Integer.parseUnsignedInt("11111111101010110000000000000000") == -5570560

 

[ms_cikar]

Integer.parseUnsignedInt("11111111101010110000000000000000") == -5570560

Das hat jetzt geklappt. Ich habe als ergebnis --5570560 bekommen. Wie kann ich diesen Wert als Float formatieren.

package test_lö;

public class m {

    public static void main(String[] args) {
     String binfolge= "11111111101010110000000000000000";
     System.out.println("Variable ist: " +binfolge);
    
     int Binfolge_convertiert_als_long =  Integer.parseUnsignedInt(binfolge, 2);
     System.out.println("Binfolge_convertiert_als_long:  "+ Binfolge_convertiert_als_long);
    
     float test= Float.intBitsToFloat(Binfolge_convertiert_als_long);   
     System.out.println("V1 konvertiert: " + test);
    }

}

Wenn ich es ausführe bekomme ich für test variable NaN

Variable ist: 11111111101010110000000000000000
Binfolge_convertiert_als_long:  -5570560
V1 konvertiert: NaN

 

[mihe7]

Wenn ich es ausführe bekomme ich für test variable NaN

Ja, das ist auch richtig.

 

[KonradN]

@mihe7 hat ja schon geschrieben, dass dies richtig ist. Aber das kann man ja auch einfach einmal prüfen:

1) sign / exponent / mantisse ermitteln.
Sign: 1 (-)
Exponent: 11111111 (255)
Mantisse: 01010110000000000000000 (2.818.048)

2) Den Link zu https://de.wikipedia.org/wiki/IEEE_754#Interpretation_des_Zahlenformats hatte ich schon gebracht. Sollte man sich ansehen.
Die Tabelle zeigt es ja recht schön, also gehen wir die Zeilen durch:

• E ist nicht 0
• E ist nicht < als (2^r)-1 (r ist ja 8, 2^8 ist 256 ... und E ist nicht < 255
• Also bleiben in der Tabelle die zwei Zeilen mit E=(2^r)-1 - muss man nur schauen: Ist die Mantisse 0 oder nicht?

==> M > 0 ist NaN.

 

[KonradN]

Ich denke, dass die Klasse MyFloat, die hier erstellt wurde, prinzipiell ja durchaus interessant sein kann, um das, was man manuell machen kann, in so einer Klasse machen zu lassen.

Ich habe daher jetzt einfach mal die Methode floatValue angepasst, damit diese dem IEEE 754 Standard entspricht.

package de.kneitzel;

public class MyFloat extends Number {
    private final int sign;
    private int exponent;
    private int mantisse;

    public MyFloat(String bits) {
        bits = fitLength(bits);
        if (bits.charAt(0) == '0') {
            sign = 1;
        } else {
            sign = -1;
        }
        exponent = 0;
        for (int i = 1; i < 9; i++) {
            exponent |= (bits.charAt(i) - '0') << (8 - i);
        }
        mantisse = 0;
        for (int i = 9; i < 32; i++) {
            mantisse |= (bits.charAt(i) - '0') << (31 - i);
        }
        System.out.println(sign + " " + exponent + " " + mantisse);
    }

    private String fitLength(String s) {
        while (s.length() < 32) {
            s = "0" + s;
        }
        return s;
    }

    private double power2(int exponent) {
        double a = 1.;
        while (exponent > 0) {
            a *= 2;
            exponent--;
        }
        return a;
    }

    @Override
    public int intValue() {
        return (int) floatValue();
    }

    @Override
    public long longValue() {
        return (long) floatValue();
    }

    @Override
    public float floatValue() {
        if (exponent == 255) {
            if (mantisse != 0) return Float.NaN;
            if (sign < 0) return Float.NEGATIVE_INFINITY;
            return Float.POSITIVE_INFINITY;
        }

        if (exponent == 0) {
            return (float) (sign * mantisse / power2(23) * power2(1-127));
        }

        return (float) (sign * (1. + mantisse/power2(23)) * power2(exponent - 127));
    }

    @Override
    public double doubleValue() {
        return floatValue();
    }

}

Und noch ein kleiner, erster Test (denormalisierte Zahlen sind noch nicht getestet):

package de.kneitzel;

import org.junit.jupiter.api.Test;

import static org.junit.jupiter.api.Assertions.*;
import static org.junit.jupiter.api.Assertions.assertEquals;

class MyFloatTest {
    @Test
    public void testMyFloatClass() {
        assertAll(
                () -> assertEquals(Float.NaN, new MyFloat("11111111101010110000000000000000").floatValue()),
                () -> assertEquals(Float.NEGATIVE_INFINITY, new MyFloat("11111111100000000000000000000000").floatValue()),
                () -> assertEquals(Float.POSITIVE_INFINITY, new MyFloat("01111111100000000000000000000000").floatValue()),
                () -> assertEquals(-123.456f, new MyFloat(Integer.toBinaryString(Float.floatToIntBits(-123.456f))).floatValue())
        );
    }
}

Vielleicht hilft da ja ein kleines bisschen bei dem Verständnis. Die Ausgabe am Ende des Parsens habe ich daher auch noch drin gelassen.