Formatting a float to a string

It seems like this should be available, but I can't seem to find it.

I need to convert a floating point number to a string. I want to set the number of decimal places, and trim the zeroes off of both sides. I would think this would have been written hundreds of times.

Does anyone have it? or am I gonna have to write it?

(string) 1.258975648842135484310135454

Another common trick is to pass the float thru an integer. So, if you want two decimal places you do something like

float x = 3.1415926
integer i = 100 * x; // i will be 314
x = 0.01 * i;

or

x = 0.01 * (integer)(100 * x);

You can truncate the string if you like, too.

Thanks for your responses,

I guess I wasn't very clear about my request. What I was hoping for would be something like Visual Basic's Format function. Maybe not as elaborate, but somewhat similar.

Maybe I will start coding it; and hope that Mono shows up soon.

Mono should be up next month, but it wont help you as we will not have any access to it other than via LSL and it has been stated several times that there will be no language changes so as to ensure 100% compatability between scripts Compiled to MONO and scripts compiled to LSLRuntime. So go a head, create the function and post it in the Library, I am sure many others will make use of your work.

I didn't test this inworld, so it might need some changes (and, as usual, I'm sure that there's a more elegant solution)...

[Edit] Nice try - but it doesn't work... :( I'll elaborate a little more on this an repost the script later.

The easiest, least intensive solution is what Lee posted. There are no trim right/trim left functions.

I tried to make a function which formats a number with thousand-separators and free configurable decimal separator.

Would result in something like 4'123'456,735 (instead of 4123456.735)

Tried to do it with some typecasting instead of multiplication and found out that typecasting from a float to a string fails miserably.

Try this:

float test = 8.123456;
llOwnerSay("TEST: " + (string)test);

Will result in 8.123456

float test = 18.123456;
llOwnerSay("TEST: " + (string)test);

Will result in 18.123455

float test = 118.123456;
llOwnerSay("TEST: " + (string)test);

Will result in 118.123459

LSL sucks...

This is a common way of truncating the numbers, but it doesn't finish the job.

When I use this procedure, my resulting string = 3.1400000 when I want it to be 3.14

And when the number is 3.0000000, I want it to output 3.0 (I do not want to truncate that final 0.)

So I will work on it (and pass the resulting code here when I have it.)

Thanks

string formatFloat( float num, integer places )
{
float f = llPow( 10.0, places );
integer i = llRound(num * f);
return (string)((integer)(i / f)) + "." + llGetSubString((string)i , -places, -1);
}

you could set a string to the return value and check for trailing 0s if you don't like the fixed format.

Edit: Forgot to mention. This way fails for values between -0.099999 and 0.0999999, for my use this wasn't an issue. it's an easy patch if you need the full range:

string formatFloat( float num, integer places )
{
float f = llPow( 10.0, places );
integer i = llRound(num * f);
string s = "00000" + (string)i; // number of 0s is max places value - 1
return (string)((integer)(i / f)) + "." + llGetSubString( s, -places, -1);
}

aha...
One of the conditions in LSL are 32bit floats, 8 for the exponent and 24 for the mantissa. One bit is for the sign so 23 bits are left for digits: 11111111111111111111111binary equals 8388607decimal. That is 7 decimal digits! More decimal digits can arise from the binary to decimal conversion but give no sense.

But the mantissa is assumed to be preceded by a 1 in all cases except when the exponent field is -127. (Note, that's a binary exponent, 2^n, not a decimal exponent). So for the vast majority of applications, the mant is effectively 24 bits.

But as you yourself pointed out in another thread, extremely large negative exponent values are possible (specifically, binary -126), so the smallest decimal value expressible by a 32-bit float is approx ±1.4e-45, which would take many more than 6 decimal places to represent.

An automatically truncating float to string function, looking backwards from the last digit:

string float2string(float f)
{
   string s = (string)f;
   string digit = "";
   do {
      if (digit == "0") s = llGetSubString(s, 0, -2);
      digit = llGetSubString(s, -1, -1);
   } while (digit == "0");
   if (digit == ".") s = s + "0";
   return s;
}

I was just working on this problem. Thanks for the update.

Now, the final problem: negative numbers don't work. -0.033699 comes out as 0.-34 (with places=3)



Update:

I have modified your code to allow for negatives:

string formatFloat( float num, integer places )
{
string negSign = "";
if (num < 0.0) negSign = "-";

float f = llPow( 10.0, places );
integer i = llRound(llFabs(num) * f);
string s = "00000" + (string)i; // number of 0s is max places value - 1
return negSign + (string)((integer)(i / f)) + "." + llGetSubString( s, -places, -1);
}