# User:Strife Onizuka/Float Functions

LSL Portal | Functions | Events | Types | Operators | Constants | Flow Control | Script Library | Categorized Library | Tutorials |

## Float <-Union-> Integer

I'd like to thank Pedro Oval and Omei Qunhua for their help with these functions.

```
integer fui(float a)//Mono Safe, LSO Safe, Doubles Unsupported, LSLEditor Unsafe
{//union float to integer
integer b = 0x80000000 & ~llSubStringIndex(llList2CSV([a]), "-");//the sign
if((a)){//is it nonzero?
if((a = llFabs(a)) < 2.3509887016445750159374730744445e-38)//Denormalized range check & last stride of normalized range
return b | (integer)(a / 1.4012984643248170709237295832899e-45);//the math overlaps; saves cpu time.
if(a > 3.4028234663852885981170418348452e+38)//Round up to infinity
return b | 0x7F800000;//Positive or negative infinity
if(a > 1.4012984643248170709237295832899e-45){//It should at this point, except if it's NaN
integer c = ~-llFloor(llLog(a) * 1.4426950408889634073599246810019);//extremes will error towards extremes. following yuch corrects it
return b | (0x7FFFFF & (integer)(a * (0x1000000 >> c))) | ((126 + (c = ((integer)a - (3 <= (a *= llPow(2, -c))))) + c) * 0x800000);
}//the previous requires a lot of unwinding to understand it.
return b | 0x7FC00000;//NaN time! We have no way to tell NaN's apart so lets just choose one.
}//Mono does not support indeterminates so I'm not going to worry about them.
return b;//for grins, detect the sign on zero. it's not pretty but it works.
}
float iuf(integer a)
{//union integer to float
if(0x7F800000 & ~a)
return llPow(2, (a | !a) + 0xffffff6a) * (((!!(a = (0xff & (a >> 23)))) * 0x800000) | (a & 0x7fffff)) * (1 | (a >> 31));
return (!(a & 0x7FFFFF)) * (float)"inf" * ((a >> 31) | 1);
}
```

### Base64-Float

As a specialized mode of transport, this is faster than Float2Hex and just as lossless.

```
string fuis(float a){//float union to base64ed integer
integer b = 0x80000000 & ~llSubStringIndex(llList2CSV([a]), "-");//the sign
if((a)){//is it greater than or less than zero?
if((a = llFabs(a)) < 2.3509887016445750159374730744445e-38)//Denormalized range check & last stride of normalized range
b = b | (integer)(a / 1.4012984643248170709237295832899e-45);//the math overlaps; saves cpu time.
else if(a > 3.4028234663852885981170418348452e+38)//Round up to infinity
b = b | 0x7F800000;//Positive or negative infinity
else if(a > 1.4012984643248170709237295832899e-45){//It should at this point, except if it's NaN
integer c = ~-llFloor(llLog(a) * 1.4426950408889634073599246810019);//extremes will error towards extremes. following yuch corrects it
b = b | (0x7FFFFF & (integer)(a * (0x1000000 >> c))) | ((126 + (c = ((integer)a - (3 <= (a *= llPow(2, -c))))) + c) * 0x800000);
}//the previous requires a lot of unwinding to understand it.
else
b = b | 0x7FC00000;//NaN time! We have no way to tell NaN's apart so lets just choose one.
}//for grins, detect the sign on zero. it's not pretty but it works. the previous requires a lot of unwinding to understand it.
return llGetSubString(llIntegerToBase64(b),0,5);
}
float siuf(string b)
{//base64ed integer union to float
integer a = llBase64ToInteger(b);
if(0x7F800000 & ~a)
return llPow(2, (a | !a) + 0xffffff6a) * (((!!(a = (0xff & (a >> 23)))) * 0x800000) | (a & 0x7fffff)) * (1 | (a >> 31));
return (!(a & 0x7FFFFF)) * (float)"inf" * ((a >> 31) | 1);
}
```

Of course if you have fui and iuf you can just wrap them and save some code duplication:

```
float siuf(string b) { return llGetSubString(llIntegerToBase64(iuf(b)),0,5); }
string fuis(float b) { return iuf(llBase64ToInteger(b)); }
```

### Half-Precision

Note: This truncates the value to make it half-precision, it does not round. It is currently not handling "nan" values properly.

```
integer fui16t(float a)//Mono Safe, LSO Safe, Doubles Unsupported, LSLEditor Unsafe
{//union half-precision float to short integer - truncates
integer b = 0x8000 & ~llSubStringIndex(llList2CSV([a]), "-");//the sign
if((a)){//is it greater than or less than zero?
if((a = llFabs(a)) < 0.0001220703125)//Denormalized range check & last stride of normalized range
return b | (integer)(a * 16777216.0);//the math overlaps; saves cpu time.
if(a >= 65536.0)//Round up to infinity
return b | 0x7C00;//Positive or negative infinity
integer c = llFloor((llLog(a) / 0.69314718055994530941723212145818)) + 14;//extremes will error towards extremes. following yuch corrects it.
return (0x3FF & (integer)(a * (0x800 >> b))) | ((c + (b = ((integer)a - (3 <= (a *= (0.0000152587890625 * (0x40000000 >> c)))))) << 10 ) | b);
}//the previous requires a lot of unwinding to understand it.
if(a == 0)//Just because it's not greater than or less than zero doesn't mean it's non-zero.
return b;//for grins, detect the sign on zero. it's not pretty but it works.
//Mono does not support indeterminates so I'm not going to worry about it.
return b| 0x7FFF;//NaN time! We have no way to tell NaN's apart so lets just choose one.
}
integer fui16(float a, integer rounding_mode)//Mono Safe, LSO Safe, Doubles Unsupported, LSLEditor Unsafe
{//union half-precision float to short integer - with optional rounding
if((a)){//is it greater than or less than zero?
integer b = (integer)(a < 0) << 29;//the sign, but later this variable is reused to store the shift
if((a = llFabs(a)) < 0.0001220703125)//Denormalized range check & last stride of normalized range
b = b | (integer)(a * 16777216.0);//the math overlaps; saves cpu time.
else if(a >= 65536.0)//Round up to infinity
b = b | 0x1F000000;//Positive or negative infinity
else {
integer c = llFloor((llLog(a) / 0.69314718055994530941723212145818)) + 14;//extremes will error towards extremes. following yuch corrects it.
b = (0xFFFFFF & (integer)(a * (0x2000000 >> b))) | ((c + (b = ((integer)a - (3 <= (a *= (0.0000152587890625 * (0x40000000 >> c)))))) << 24 ) | b);
}
if(rounding_mode == 0)//truncate
return b >> 14;
if(rounding_mode == 1)//round to nearest, away from zero on tie.
return (b >> 14) + ((b >> 13) & 1);
if(rounding_mode == 2)//round to nearest, rounds to even on tie. This was a pain to work out how to code. Wikipedia says this is the default.
return ((b >> 14) + ((b >> (13 + ((b & 0x3FFF) == 0x2000))) & 1);
if(rounding_mode == 3)//round to +infinity
return (b >> 14) + (((b << 2) >> 31) | 1) * !!(b & 0x3FFF);
if(rounding_mode == 4)//round to -infinity
return (b >> 14) - (((b << 2) >> 31) | 1) * !!(b & 0x3FFF);
}//the previous requires a lot of unwinding to understand it.
if(a == 0)//Just because it's not greater than or less than zero doesn't mean it's zero.
return ((string)a == (string)(-0.0)) << 15;//for grins, detect the sign on zero. it's not pretty but it works.
//Mono does not support indeterminates so I'm not going to worry about it.
return 0x7FFF;//NaN time! We have no way to tell NaN's apart so lets just choose one.
}
float i16uf(integer a)
{//union short integer to half-precision float
if(0x7C00 & ~a)
return 0.000000059604644775390625 * (1 << (a - !!a)) * ((!!(a = (0x1f & (a >> 10))) << 10) | ((a & 0x3ff))) * (1 | ((a << 16) >> 31));
return (!(a & 0x3FF)) * (float)"inf" * (((a << 16) >> 31)) | 1);
}
```

## Float Distance

FloatDistance and FloatCompare are debugging functions. They allow you to test if float corruption is within acceptable bounds. Due to their contrived nature, they are rarely useful.

These functions work by assigning an integer value to each float value. These integer values are sequential, for every float value there is a unique integer value. FloatDistance looks at the difference of the two integer values and compares that with the max distance specified.

```
integer FloatDistance(float a, float b, integer distance)
{
integer A = fui(a);
integer B = fui(b);
if((A ^ B) & 0x80000000)
A = (A & 0x7fFfFfFf)-~(B & 0x7fFfFfFf);//If you want to treat -0 and 0 as the same number replace "-~" with "+"
else
A = llAbs(B - A);
//distance is treated as if it were unsigned. If you do not want this, remove both " - 0x80000000"
return (A - 0x80000000) <= (distance - 0x80000000);
}
```

### Float Compare

This function builds on the ideas set down in FloatDistance but changes how the distance is measured. I wrote this function before FloatDistance and didn't write any more documentation about it than what you see as comments. I'm not really keen on writing any for it now.

The idea is that if the values are within "c" range of each other than they are considered equal and zero is returned. Otherwise it returns the sign of `(a - b)`

.

```
integer FloatCompare(float a, float b, integer c)
{//compare floats and allow for a margin of error, requires fui().
if(a != b)//(c) Strife Onizuka 2006
{//they are not equal
//First we convert the floats to integer form, as they would be in memory;
integer a_i = fui(a);
integer b_i = fui(b);
integer a_e = (a_i >> 23) & 0xff;
integer b_e = (b_i >> 23) & 0xff;
if(!(a_e || b_e) || //to disable the +/- roll under support put a // just before the !
((a_i & 0x80000000) == (b_i & 0x80000000)))//sign match check
{//start by getting and testing the difference, this is what limits c
integer diff = a_e - b_e;//ugly is fast, basically, it gets the mantissa, sets the sign on the mantissa,
if(diff >= -1 || diff <= 1)//shifts it depending on exponent, finally executes the test.
if(llAbs(((((a_i & 0x7FFFFF) | (!!a_e << 23)) * ((a_i >> 31) | 1)) >> !~-diff) -
((((b_i & 0x7FFFFF) | (!!b_e << 23)) * ((b_i >> 31) | 1)) >> !~diff)) <= c)
jump out;
}
return (a > b) - (a < b);
}
@out;
return 0;
}
```

## FUI2HexFloat

```
//This implementation isn't meant to create the most compact hexfloat and makes no effort to.
//It was designed to easily produce an accurate hexfloat given an fui access.
string FUI2HexFloat(integer b)
{//Dump FUI float-integer to a hex-float string
string c = "";
integer e = 0xff & (b >> 23);
if(e ^ 127)
{
c = "p" + (string)((e | !e) - 127);
integer f = 0xfffffe & (b << 1);
if(f)
{
integer d = 0;
integer g;
while(!((f >> d) & 0xf))
d+=4;
for( ;d < 24; d += 4)
c = llGetSubString(hexc, g = 0xf & (f >> d), g) + c;
}
c = "0x"+(string)(!!e) + "." + c;
}
else if(b & 0x7fffff)
c = "NaN";
else
c = "Infinity";
if(b & 0x80000000)
c = "-" + c;
return c;
}
string Float2Hex(float a)
{//Another way to do Float2Hex, i wrote this for the heck of it; not because it's a good idea.
return FUI2HexFloat(fui(a));
}
```

## Float2Equation

I wrote this so I could quickly get numbers out of LSLEditor without having to write a specialized serializer. Just drop the resulting string into your favorite high precision calculator to get the decimal version. I'll write a version later that doesn't depend upon fui to do the heavy lifting.

```
string Float2Equation(float b){
integer a = fui(b);
if(!(0x7F800000 & ~a)){
if(a & 0x7FFFFF)
return llGetSubString("-nan", 1, ~a >> 31);
return llGetSubString("-infinity", 1, ~a >> 31);
}
integer exp = 0xff & (a >> 23);
integer power = (exp | !exp ) - 150;
integer number = (((!!exp) * 0x800000) | (a & 0x7fffff)) * (1 | (a >> 31));
if(power){
string c = (string)(number * llPow(2, power));
if(b == (float)c)
return c;
if(power > 0)
return number + " * " + llGetSubString((string)llPow(2, power),0,-8);
if(power > -128)
return number + " / " + llGetSubString((string)llPow(2, -power),0,-8);
return number + " / "+llGetSubString((string)llPow(2, 127),0,-8) +" / "+llGetSubString((string)llPow(2, 127-power),0,-8);
}
return (string)number;
}
```