float

Hi again how do you explain this?

This debug code is from a simplistic authentification method of mine:

                float rep = (float)llList2String(args, 2) ;
                llOwnerSay("rep: "+(string)rep );
                llOwnerSay("Ref_Auth: "+(string)Ref_Auth );
                llOwnerSay("diff: "+(string)(rep-Ref_Auth)) ;

And I get this:


Oô

I'm checking the two values and it fails to authenticate, even though they look same.

Worked around with :

if ((string)rep == (string)Ref_Auth)

but still this is weird...

My guess would be rounding errors: according to my understanding of the replies to my float question (), at seven significant digits you're pretty much on the limit of the precision available for a 32-bit float.

can't be sure, but I imagine that one of those two is being sent with one more significant digit than it can accurately hold, and it's being truncated. probably at a point where its being converted from a string.

I could isolate down to this:

default
{
    state_entry()
    {
        float a ;
        float b ;
        
        a = 78789.25 * 54.07 + 444.34 * 588.09 + 711.21 * 12566.1212 ;
        b = (float)"13458600.000000" ;
        llOwnerSay((string)a) ;
        llOwnerSay((string)b) ;
        llOwnerSay((string)(a-b)) ;
    }
}

Without Mono:


With Mono:


So it's a Mono issue... I think it is the conversion to string which is innacurate.

Reported:
https://jira.secondlife.com/browse/SVC-5287

Oh wow, could you pleaseeee report it to Ji-- Ah, you already did so.

(Finally I can post to the Scripting Tips forum! Gah, looks like the scripting tips forum HATES Google Chrome...)

78789.25 * 54.07 + 444.34 * 588.09 + 711.21 * 12566.1212
= 13458597.716752

llOwnerSay( (string)(13458597.716752) );
LSO: 13458598.000000
MONO: 13458600.000000

but it gets worse....

llOwnerSay( (string)(12566.1212) );
LSO: 12566.121094 <--can anyone see what's wrong with this, wowee
MONO: Object: 12566.120000

something else is screwy and I can't tell what offhand.

In C#:

            float y = 12566.1212f;
            double z = y;
            string x = System.Convert.ToString(z);
            MessageBox.Show(x)

I get 12566.12109375 so looks like it's correct, it's because of the way floats are coded.
But if I was converting the float directly it would then show 1256.1212.

In other words,12566.1211 and 12566.1212 are coded the same in float 32 bits.

I think Mono is a bit too "generous" when it comes to rounding values.

I did a binary fraction generation, and from what I can see, it comes out the same in both, despite showing a difference... I'm wondering if there isn't an additional rounding effect being done on string conversion in MONO... it'd make sense of those results from mono showing a difference of 2 despite being the same when printed.

ETA:
don't ask me why they'd want to do rounding after the fact on strings...

I've written two functions that should be more reliable than (string)float.

Float2Hex: https://wiki.secondlife.com/wiki/Float2Hex
Scientific Notation: /15/28/28006/1.html

Keep in mind that while these are lossless, they are slower.