Difference between revisions of "Category:LSL Float"

<lsl>float min = 1.175494351E-38; float max = 3.402823466E+38; float sci = 2.6E-5; float sci_a = 2.6E+3; float sci_b = 2.6E3; float sci_c = 26000.E-1; float f = 2600;//implicitly typecast to a float float E = 85.34859; float cast = (float)"42";//explicit typecast to a float float Infintity = (float)"inf"; //-- may be negative, will cause a math error if evaluated in LSO, see 'caveats' below float NotANumber = (float)"nan"; //-- may be negative, will cause a math error if evaluated in LSO, see 'caveats' bleow </lsl>

If you need to validate an arbitrary float without limitations then the following function is ideal: <lsl>integer isValidFloat(string s) { return (string)((float)s) != (string)((float)("-" + llStringTrim(s, STRING_TRIM_HEAD))); }</lsl>

However, the following is more efficient, but comes with the noted caveats. If these are not an issue to you then it is the recommended option, particularly under Mono: <lsl>integer isValidFloat(string s) { return (float)(s + "1") != 0.0; }</lsl>

The above snippets are of limited use, as they stop validating at the first character that is not valid in a float string. The following code rigorously validates the whole of a string to ensure it represents a float. <lsl> // Validate a string containing a float value // handles scientific notation and "nan" / "inf" // Does not handle hex floats (!)

integer ValidateFloatString(string ss) {

   ss = llToLower(ss);
   if (ss == "")                                         return FALSE; 
   if (ss == "inf" || ss == "-inf" || ss == "nan")       return TRUE;

   integer flagDP;
   integer flagEXP;
   integer num = llStringLength(ss);
   integer x;
   string char;

   for ( ; x < num; ++x)           // Examine the string byte by byte left to right
   {
       char = llGetSubString(ss, x, x);
       if (char == "-" || char == "+")
       {
           if (x)  return FALSE;
       }
       else if (char == ".")
       {
           if (flagEXP)           return FALSE;      // '.' cannot come after 'E' / 'e'
           if (flagDP++)          return FALSE;      // cannot have more than 1 '.'
       }
       else if (char == "e")
       {
           if (!flagDP)           return FALSE;        // E/e must have been preceeded by a '.'
           if (flagEXP++)         return FALSE;        // ... and no other 'E'
           char = llGetSubString(ss, x+1, x+1);        // Examine the following character
           if (char == "+" || char == "-")        ++x;       
           if ( (num - x) > 3 || (num - x) < 2)   return FALSE;     // 'e' should be followed by 1 or 2 digits after optional sign
       }
       else if ( (string) ( (integer) char) != char)       return FALSE;         // effectively  checking for 0 thru 9
   }
   return TRUE;

} </lsl> Caveats:

• Under LSO-LSL scientific notation with an exponent greater than 38 will fail (throw a Math Error). Mono is unaffected as it supports infinity
• Under both Mono and LSO-LSL you may find strange results if dealing with strings containing more than 9 decimal places. Remember that string casting in LSL only gives up to 6 so is safe, and human input is rarely going to be that accurate, plus values that small are not usually all that useful.
• Due to the limited precision with which floats are stored, not all integer values can be accurately held in a float. Integers above 16,777,216 are rounded down to the nearest even number; above 33,554,432 to the lower multiple of 4 etc.
• "nan" (not-a-number), "inf" (infinity) and their negatives are special text values that can be cast from a string (with any leading spaces or trailing characters). those values will cause a math error when the variable is evaluated in LSO. If you are parsing user data, by casting a string to a float, use the following code (replacing vStrDta with your string variable name) see SVC-6847
  • <lsl>(float)llList2String( llParseStringKeepNulls( llToLower( llStringTrim( vStrDta, STRING_TRIM ) ), ["inf", "nan"], [] ), 0 )</lsl>

There are several ways to convert a float to a string. The first of which is to typecast it to a string (string)(1.0). This however has the disadvantage of rounding and being limited to six decimal places. Several functions have been written to provide more options. They fall into two categories, lossless and lossy.

• Infinity is only accessible in Mono.