[java] -0.0f != 0.0f

[Alarmnummer]

Ik ben tegen het volgende probleem aangelopen:
-0.0f != 0.0f
Ik snap dat je de 0 dus schijnbaar op 2 manieren kan schrijven, maar ik weet niet hoe ik deze expressie om kan zetten naar een (efficiente) expressie die wel doet wat ik wil.

[dlmh]

Het is op zich niet zo raar dat -0.0 anders in Floating point wordt weergegeven dan +0.0f omdat daar een bit voor gereserveerd is binnen dat getal. Als je nou Math.abs(Float f) gebruikt?

[Verwijderd]

(int) Math.round(Float f) ben je mss ook iets mee...

[whoami]

Mja, floating point is nooit helemaal precies, dus eigenlijk zou met een bepaalde marge moeten rekening houden als je een vergelijking doet; zoiets bv:

code:

if( (-0.0f) - (+0.0f) <= Math.Abs(0.00001f) )
{
     // gelijk
}
else
{
    // niet gelijk
}

[ Voor 3% gewijzigd door whoami op 29-08-2004 09:46 ]

[mbravenboer]

Wil je in je onderbewustzijn misschien liever met decimale getalen werken?

[Alarmnummer]

Ik ben er intussen al uit. Ik heb het geluk dat ik een overkoepelend object heb waar die float in terecht komt, en daar kan ik het wat aansturen. Afgezien van de equals, ging de hashcode namelijk ook fout. De hashcode van 0.0f is anders dan -0.0f.

Java:

public final class FloatConstant extends Constant{

    private static final long serialVersionUID = 0L;

    public final float _value;
    private final int _hashcode;
    
    public FloatConstant(float value){
        super(FLOAT_CONSTANT);
        _value = value==-0.0f?0.0f:value;
        _hashcode = Float.floatToIntBits(_value);
    }

    public FloatConstant(float value, SourceLoc loc){
        super(FLOAT_CONSTANT,loc);
        _value = value==-0.0f?0.0f:value;
        _hashcode = Float.floatToIntBits(_value);       
    }

    public float getValue(){
        return _value;
    }

    public void accepts(TermVisitor v) {
        v.visit(this);
    }

    public boolean isMatchable(Term t){
        assert t!=null;

        if(t._type==VAR_TERM)
            return true;

        if(t._type!=FLOAT_CONSTANT)
            return false;

        return ((FloatConstant)t)._value==_value;
    }

    public String toString(){
        return Float.toString(_value);
    }

    public boolean equals(Object item){
        if(item == null)
            return false;
        if(item == this)
            return true;
        if(item.hashCode()!=hashCode())
            return false;
        if(!(item instanceof FloatConstant))
            return false;
        FloatConstant otherConstant = (FloatConstant)item;
        return otherConstant._value==_value;
    }

    public int hashCode(){
        return _hashcode; 
    }
}

[ Voor 21% gewijzigd door Alarmnummer op 29-08-2004 11:52 ]

[mbravenboer]

Dat is natuurlijk een aardige workaround, maar zouden decimale getallen misschien geen betere, volledige oplossing zijn? Ik weet natuurlijk niet wat de precieze toepassing is.

[Alarmnummer]

mbravenboer schreef op 29 augustus 2004 @ 11:48:
Dat is natuurlijk een aardige workaround, maar zouden decimale getallen misschien geen betere, volledige oplossing zijn? Ik weet natuurlijk niet wat de precieze toepassing is.

De FloatConstant heb ik nodig als onderdeel van een Prolog term (expressie) om Prolog met floating point getallen te laten werken. Ik ben hoe dan ook die FloatConstant nodig. En verder geld in prolog dat 0.0=-0.0 dus ik moet me hier ook aan houden (als ik ISO compliant wil zijn)

[ Voor 6% gewijzigd door Alarmnummer op 29-08-2004 11:52 ]

[MSalters]

Vreemd, was Java niet IEEE-754 compliant? Ik weet dat de meest recente Java-versies dat optioneel maken, maar zonder "relaxed math" oid zou IEEE-754 moeten gelden en dan is -0.0==+0.0

[mbravenboer]

MSalters: Vreemd, was Java niet IEEE-754 compliant?

Inderdaad, maar alleen als je de strictfp modifier gebruikt. Ik wist niet dat in IEEE-754 geldt dat -0.0==+0.0, maar die modifier moet dan dus het probleem fraaier oplossen.

[jvo]

MSalters schreef op 30 augustus 2004 @ 09:03:
Vreemd, was Java niet IEEE-754 compliant? Ik weet dat de meest recente Java-versies dat optioneel maken, maar zonder "relaxed math" oid zou IEEE-754 moeten gelden en dan is -0.0==+0.0

Bij mij lijken ze ook gewoon gelijk te zijn.
System.out.println(0.0 == -0.0); geeft true. Je gebruikt wel float of double en niet Float of Double toch? De door mij gebruikte sdk is overigens 1.4.0 beta 3.