Category talk:LSL Float - Revision history

Sei Lisa: /* Validation of float strings */

2016-01-28T00:14:36Z

Validation of float strings

← Older revision		Revision as of 17:14, 27 January 2016
Line 196:		Line 196:
	</source>		</source>
	::[[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST)		::[[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST)

			This function <code>integer isValidFloat(string s) { return (string)((float)s) != (string)((float)("-" + llStringTrim(s, STRING_TRIM_HEAD))); }</code> rejects this string under Mono as not a float: "-0.0000001". I've written a validation function that doesn't have that problem and rejects trailing characters, and posted it here: [http://www.sluniverse.com/php/vb/script-library/113452-validating-float.html] --[[User:Sei Lisa\|Sei Lisa]] ([[User talk:Sei Lisa\|talk]]) 16:14, 27 January 2016 (PST)

	== Float2Sci ==		== Float2Sci ==

Sei Lisa: tags

2016-01-28T00:09:33Z

Strife Onizuka: /* Float2Sci */

2014-01-23T23:49:14Z

Float2Sci

← Older revision		Revision as of 16:49, 23 January 2014
Line 201:		Line 201:

	: First lossless in this care means that every bit of information that is held in the float is preserved and the can be used to reconstruct the input. Floats do not have a large quantity of precision, which translates roughly to the number of accurate digits. Unfortunately PI is irrational and irrational numbers cannot be losslessly stored in a float because they require an infinite number of digits to express them accurately. So, PI gets truncated. When you do math operations, errors creep. You would think that 10 * 0.1 would equal 1.0, it does not. The reason for this is that 0.1 can't be accurately represented as a float. The point of the lossless functions are to keep more errors from creeping in as a result of converting the number back into a float. Also for debugging purposes, you may want to know the exact value, if you can't find out the exact value, you may have numbers that look like they should work but then don't and you won't know why. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:21, 23 January 2014 (PST)		: First lossless in this care means that every bit of information that is held in the float is preserved and the can be used to reconstruct the input. Floats do not have a large quantity of precision, which translates roughly to the number of accurate digits. Unfortunately PI is irrational and irrational numbers cannot be losslessly stored in a float because they require an infinite number of digits to express them accurately. So, PI gets truncated. When you do math operations, errors creep. You would think that 10 * 0.1 would equal 1.0, it does not. The reason for this is that 0.1 can't be accurately represented as a float. The point of the lossless functions are to keep more errors from creeping in as a result of converting the number back into a float. Also for debugging purposes, you may want to know the exact value, if you can't find out the exact value, you may have numbers that look like they should work but then don't and you won't know why. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:21, 23 January 2014 (PST)
	: TL;DR: The functions are lossless, LSL is not.		: '''TL;DR''': The functions are lossless, LSL is not.

	::Yep, I woke up in the night thinking that must be the explanation LOL [[User:Omei Qunhua\|Omei Qunhua]] 15:31, 23 January 2014 (PST)		::Yep, I woke up in the night thinking that must be the explanation LOL [[User:Omei Qunhua\|Omei Qunhua]] 15:31, 23 January 2014 (PST)

			:::I find the math really interesting, I'd recommend looking over {{wikipedia\|Floating_point}} for more details if you are interested in the math. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:49, 23 January 2014 (PST)

Omei Qunhua: /* Float2Sci */

2014-01-23T23:31:06Z

Float2Sci

← Older revision		Revision as of 16:31, 23 January 2014
Line 202:		Line 202:
	: First lossless in this care means that every bit of information that is held in the float is preserved and the can be used to reconstruct the input. Floats do not have a large quantity of precision, which translates roughly to the number of accurate digits. Unfortunately PI is irrational and irrational numbers cannot be losslessly stored in a float because they require an infinite number of digits to express them accurately. So, PI gets truncated. When you do math operations, errors creep. You would think that 10 * 0.1 would equal 1.0, it does not. The reason for this is that 0.1 can't be accurately represented as a float. The point of the lossless functions are to keep more errors from creeping in as a result of converting the number back into a float. Also for debugging purposes, you may want to know the exact value, if you can't find out the exact value, you may have numbers that look like they should work but then don't and you won't know why. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:21, 23 January 2014 (PST)		: First lossless in this care means that every bit of information that is held in the float is preserved and the can be used to reconstruct the input. Floats do not have a large quantity of precision, which translates roughly to the number of accurate digits. Unfortunately PI is irrational and irrational numbers cannot be losslessly stored in a float because they require an infinite number of digits to express them accurately. So, PI gets truncated. When you do math operations, errors creep. You would think that 10 * 0.1 would equal 1.0, it does not. The reason for this is that 0.1 can't be accurately represented as a float. The point of the lossless functions are to keep more errors from creeping in as a result of converting the number back into a float. Also for debugging purposes, you may want to know the exact value, if you can't find out the exact value, you may have numbers that look like they should work but then don't and you won't know why. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:21, 23 January 2014 (PST)
	: TL;DR: The functions are lossless, LSL is not.		: TL;DR: The functions are lossless, LSL is not.

			::Yep, I woke up in the night thinking that must be the explanation LOL [[User:Omei Qunhua\|Omei Qunhua]] 15:31, 23 January 2014 (PST)

Strife Onizuka: /* Float2Sci */

2014-01-23T23:23:50Z

Float2Sci

← Older revision		Revision as of 16:23, 23 January 2014
Line 201:		Line 201:

	: First lossless in this care means that every bit of information that is held in the float is preserved and the can be used to reconstruct the input. Floats do not have a large quantity of precision, which translates roughly to the number of accurate digits. Unfortunately PI is irrational and irrational numbers cannot be losslessly stored in a float because they require an infinite number of digits to express them accurately. So, PI gets truncated. When you do math operations, errors creep. You would think that 10 * 0.1 would equal 1.0, it does not. The reason for this is that 0.1 can't be accurately represented as a float. The point of the lossless functions are to keep more errors from creeping in as a result of converting the number back into a float. Also for debugging purposes, you may want to know the exact value, if you can't find out the exact value, you may have numbers that look like they should work but then don't and you won't know why. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:21, 23 January 2014 (PST)		: First lossless in this care means that every bit of information that is held in the float is preserved and the can be used to reconstruct the input. Floats do not have a large quantity of precision, which translates roughly to the number of accurate digits. Unfortunately PI is irrational and irrational numbers cannot be losslessly stored in a float because they require an infinite number of digits to express them accurately. So, PI gets truncated. When you do math operations, errors creep. You would think that 10 * 0.1 would equal 1.0, it does not. The reason for this is that 0.1 can't be accurately represented as a float. The point of the lossless functions are to keep more errors from creeping in as a result of converting the number back into a float. Also for debugging purposes, you may want to know the exact value, if you can't find out the exact value, you may have numbers that look like they should work but then don't and you won't know why. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:21, 23 January 2014 (PST)
			: TL;DR: The functions are lossless, LSL is not.

Strife Onizuka: /* Float2Sci */

2014-01-23T23:21:28Z

Float2Sci

← Older revision		Revision as of 16:21, 23 January 2014
Line 199:		Line 199:
	== Float2Sci ==		== Float2Sci ==
	Float2Sci is listed under "lossless functions", yet next to that function PI is shown as 3.1415925, whereas (off the top of my head, LOL) PI is 3.141592653589793... so at least the 7th DP is wrong, so how can it be a lossless function? [[User:Omei Qunhua\|Omei Qunhua]] 15:31, 22 January 2014 (PST)		Float2Sci is listed under "lossless functions", yet next to that function PI is shown as 3.1415925, whereas (off the top of my head, LOL) PI is 3.141592653589793... so at least the 7th DP is wrong, so how can it be a lossless function? [[User:Omei Qunhua\|Omei Qunhua]] 15:31, 22 January 2014 (PST)

			: First lossless in this care means that every bit of information that is held in the float is preserved and the can be used to reconstruct the input. Floats do not have a large quantity of precision, which translates roughly to the number of accurate digits. Unfortunately PI is irrational and irrational numbers cannot be losslessly stored in a float because they require an infinite number of digits to express them accurately. So, PI gets truncated. When you do math operations, errors creep. You would think that 10 * 0.1 would equal 1.0, it does not. The reason for this is that 0.1 can't be accurately represented as a float. The point of the lossless functions are to keep more errors from creeping in as a result of converting the number back into a float. Also for debugging purposes, you may want to know the exact value, if you can't find out the exact value, you may have numbers that look like they should work but then don't and you won't know why. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:21, 23 January 2014 (PST)

Omei Qunhua: Is Float2Sci lossless?

2014-01-22T23:31:16Z

Is Float2Sci lossless?

← Older revision		Revision as of 16:31, 22 January 2014
Line 196:		Line 196:
	</lsl>		</lsl>
	::[[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST)		::[[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST)

			== Float2Sci ==
			Float2Sci is listed under "lossless functions", yet next to that function PI is shown as 3.1415925, whereas (off the top of my head, LOL) PI is 3.141592653589793... so at least the 7th DP is wrong, so how can it be a lossless function? [[User:Omei Qunhua\|Omei Qunhua]] 15:31, 22 January 2014 (PST)

Omei Qunhua: /* Validation of float strings */

2013-12-21T23:48:16Z

Validation of float strings

← Older revision		Revision as of 16:48, 21 December 2013
Line 166:		Line 166:
	::Omei coughs gently, passes Strife his spectacles and a cut-and-paste tool, and another tool [http://sourceforge.net/projects/lsleditor/ lslEditor] [[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST)		::Omei coughs gently, passes Strife his spectacles and a cut-and-paste tool, and another tool [http://sourceforge.net/projects/lsleditor/ lslEditor] [[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST)

	::::I really don't like writing in LSLEditor, it's too darn slow. It's like pulling teeth. That said, I do like to test code with it (but there are somethings it just does not do right and you have to know which ones those are). I'll start testing the darn thing and figure out where the bugs are (day off). -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 12:00, 21 December 2013 (PST)		::::I really don't like writing in LSLEditor, it's too darn slow. It's like pulling teeth. That said, I do like to test code with it (but there are somethings it just does not do right and you have to know which ones those are). I'll start testing the darn thing and figure out where the bugs are (day off). -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]][[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 12:00, 21 December 2013 (PST)

	::~~:Results differ from mine~~ on ~~6 of my tests, tho' I may be misunderstanding on some of what's acceptable/not:-~~		::There were two typos on that one line. Then after your line } else { //decimal the next line shouldn't include the llDeleteSubString... After that, I tested it via lslEditor, and it validates pure integers OK, but decimals and scientific all fail. I've not tried putting hex through it. Have fun debugging! [[User:Omei Qunhua\|Omei Qunhua]] 15:48, 21 December 2013 (PST)

	~~<pre>~~
	12.~~345E+05 0~~ ~~should be OK~~
	~~-12~~.~~345 0 should be OK~~
	12.~~E+05 0 should be OK~~
	~~n22 1 should fail~~
	~~123~~.~~E-22~~ ~~0 should be~~ OK ~~(no~~ decimals ~~after DP~~. I ~~found such an example on the float wiki page)~~
	~~+123.456 0 should be OK ?? maybe~~ not ~~(leading +)~~
	~~</pre>~~
	~~[[User:Omei Qunhua\|Omei Qunhua]] 14:37, 20 December 2013 (PST)~~

	~~::Oh I was looking at a wrong page. I see that 123E1 / 123E+1 are valid~~. [[User:Omei Qunhua\|Omei Qunhua]] 15:50, 20 December 2013 (PST)

	[[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST) Float string validation will very rarely need to accommodate scientific notation		[[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST) Float string validation will very rarely need to accommodate scientific notation

Strife Onizuka: /* Validation of float strings */

2013-12-21T20:00:32Z

Validation of float strings

← Older revision		Revision as of 13:00, 21 December 2013
Line 165:		Line 165:

	::Omei coughs gently, passes Strife his spectacles and a cut-and-paste tool, and another tool [http://sourceforge.net/projects/lsleditor/ lslEditor] [[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST)		::Omei coughs gently, passes Strife his spectacles and a cut-and-paste tool, and another tool [http://sourceforge.net/projects/lsleditor/ lslEditor] [[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST)

			::::I really don't like writing in LSLEditor, it's too darn slow. It's like pulling teeth. That said, I do like to test code with it (but there are somethings it just does not do right and you have to know which ones those are). I'll start testing the darn thing and figure out where the bugs are (day off). -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 12:00, 21 December 2013 (PST)

	:::Results differ from mine on 6 of my tests, tho' I may be misunderstanding on some of what's acceptable/not:-		:::Results differ from mine on 6 of my tests, tho' I may be misunderstanding on some of what's acceptable/not:-

Omei Qunhua: /* Validation of float strings */

2013-12-21T13:31:10Z

Validation of float strings

@@ Line 47: / Line 47: @@
 ::Writing a complete validator for LSL would be difficult but not impossible, especially now. You could use JSON to do the number parsing for decimal floats, but you would still need to write a parser for hexfloats. That is the advantage of the current validator, it's format agnostic and fast. Having to test all characters is not fast, it's going to be quite slow.
 :That said I've had a few ideas on how to do it faster (but still not fast). -- '''[[User:Strife_Onizuka|Strife]]''' <sup><small>([[User talk:Strife_Onizuka|talk]]|[[Special:Contributions/Strife_Onizuka|contribs]])</small></sup> 11:04, 19 December 2013 (PST)
 ::::Sure, sensible validation of a float string is tricky, but I just think the current offering is pointless. People's eyes will light up when they see a proposed solution on the Wiki, and then be lifted to the heavens as they realise it does next to nothing :) [[User:Omei Qunhua|Omei Qunhua]] 14:03, 19 December 2013 (PST)
@@ Line 161: / Line 163: @@
 :::One line doesn't compile:-    	string lower = llStringTrim(llToLowerCase(in), STRING_TRIM_BOTH);       should  be      	string lower = llStringTrim(llToLower(in), STRING_TRIM);
 :::Results differ from mine on 6 of my tests, tho' I may be misunderstanding on some of what's acceptable/not:-
@@ Line 170: / Line 174: @@
   n22         1     should fail
 .E-22    0     should be OK (no decimals after DP. I found such an example on the float wiki page)
-  +123.456    0     should be OK (leading +)
+  +123.456    0     should be OK ?? maybe not (leading +)
 </pre>
 [[User:Omei Qunhua|Omei Qunhua]] 14:37, 20 December 2013 (PST)
 ::Oh I was looking at a wrong page. I see that 123E1 / 123E+1 are valid. [[User:Omei Qunhua|Omei Qunhua]] 15:50, 20 December 2013 (PST)

← Older revision		Revision as of 17:09, 27 January 2016
Line 2:		Line 2:

	Simple Script		Simple Script
	<~~lsl~~>		<source lang="lsl2">
	default		default
	{		{
Line 10:		Line 10:
	}		}
	}		}
	</~~lsl~~>		</source>
	In Mono It Says: 340282300000000000000000000000000000000.000000		In Mono It Says: 340282300000000000000000000000000000000.000000

Line 59:		Line 59:
	I've removed the code that was computing the value of the various sub components.		I've removed the code that was computing the value of the various sub components.

	<~~lsl~~>		<source lang="lsl2">
	// Validate a string containing a float value		// Validate a string containing a float value
	// Does not handle hex floats (!)		// Does not handle hex floats (!)
Line 100:		Line 100:
	return TRUE;		return TRUE;
	}		}
	</~~lsl~~>		</source>
	[[User:Omei Qunhua\|Omei Qunhua]] 03:57, 20 December 2013 (PST)		[[User:Omei Qunhua\|Omei Qunhua]] 03:57, 20 December 2013 (PST)

Line 109:		Line 109:
	:::Fixed above points bar hex floats and extensions to inf and nan [[User:Omei Qunhua\|Omei Qunhua]] 14:43, 20 December 2013 (PST)		:::Fixed above points bar hex floats and extensions to inf and nan [[User:Omei Qunhua\|Omei Qunhua]] 14:43, 20 December 2013 (PST)

	<~~lsl~~>		<source lang="lsl2">
	integer allFloat(string in) {		integer allFloat(string in) {
	string lower = llStringTrim(llToLower(in), STRING_TRIM_BOTH);		string lower = llStringTrim(llToLower(in), STRING_TRIM_BOTH);
Line 154:		Line 154:
	}		}
	return FALSE;		return FALSE;
	}</~~lsl~~>		}</source>

	My solution (not compiled or debugged) --'''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 21:50, 19 December 2013 (PST)		My solution (not compiled or debugged) --'''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 21:50, 19 December 2013 (PST)
Line 171:		Line 171:

	[[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST) Float string validation will very rarely need to accommodate scientific notation		[[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST) Float string validation will very rarely need to accommodate scientific notation
	<~~lsl~~>		<source lang="lsl2">
	// Version 2: validates input such as [-]aaaa.bbbb		// Version 2: validates input such as [-]aaaa.bbbb
	// Compiled and tested. Omei Qunhua. Dec 2013		// Compiled and tested. Omei Qunhua. Dec 2013
Line 194:		Line 194:
	return TRUE;		return TRUE;
	}		}
	</~~lsl~~>		</source>
	::[[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST)		::[[User:Omei Qunhua\|Omei Qunhua]] 05:31, 21 December 2013 (PST)

← Older revision		Revision as of 16:49, 23 January 2014
Line 201:		Line 201:

	: First lossless in this care means that every bit of information that is held in the float is preserved and the can be used to reconstruct the input. Floats do not have a large quantity of precision, which translates roughly to the number of accurate digits. Unfortunately PI is irrational and irrational numbers cannot be losslessly stored in a float because they require an infinite number of digits to express them accurately. So, PI gets truncated. When you do math operations, errors creep. You would think that 10 * 0.1 would equal 1.0, it does not. The reason for this is that 0.1 can't be accurately represented as a float. The point of the lossless functions are to keep more errors from creeping in as a result of converting the number back into a float. Also for debugging purposes, you may want to know the exact value, if you can't find out the exact value, you may have numbers that look like they should work but then don't and you won't know why. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:21, 23 January 2014 (PST)		: First lossless in this care means that every bit of information that is held in the float is preserved and the can be used to reconstruct the input. Floats do not have a large quantity of precision, which translates roughly to the number of accurate digits. Unfortunately PI is irrational and irrational numbers cannot be losslessly stored in a float because they require an infinite number of digits to express them accurately. So, PI gets truncated. When you do math operations, errors creep. You would think that 10 * 0.1 would equal 1.0, it does not. The reason for this is that 0.1 can't be accurately represented as a float. The point of the lossless functions are to keep more errors from creeping in as a result of converting the number back into a float. Also for debugging purposes, you may want to know the exact value, if you can't find out the exact value, you may have numbers that look like they should work but then don't and you won't know why. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:21, 23 January 2014 (PST)
	: TL;DR: The functions are lossless, LSL is not.		: '''TL;DR''': The functions are lossless, LSL is not.

	::Yep, I woke up in the night thinking that must be the explanation LOL [[User:Omei Qunhua\|Omei Qunhua]] 15:31, 23 January 2014 (PST)		::Yep, I woke up in the night thinking that must be the explanation LOL [[User:Omei Qunhua\|Omei Qunhua]] 15:31, 23 January 2014 (PST)

			:::I find the math really interesting, I'd recommend looking over {{wikipedia\|Floating_point}} for more details if you are interested in the math. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:49, 23 January 2014 (PST)

← Older revision		Revision as of 16:31, 23 January 2014
Line 202:		Line 202:
	: First lossless in this care means that every bit of information that is held in the float is preserved and the can be used to reconstruct the input. Floats do not have a large quantity of precision, which translates roughly to the number of accurate digits. Unfortunately PI is irrational and irrational numbers cannot be losslessly stored in a float because they require an infinite number of digits to express them accurately. So, PI gets truncated. When you do math operations, errors creep. You would think that 10 * 0.1 would equal 1.0, it does not. The reason for this is that 0.1 can't be accurately represented as a float. The point of the lossless functions are to keep more errors from creeping in as a result of converting the number back into a float. Also for debugging purposes, you may want to know the exact value, if you can't find out the exact value, you may have numbers that look like they should work but then don't and you won't know why. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:21, 23 January 2014 (PST)		: First lossless in this care means that every bit of information that is held in the float is preserved and the can be used to reconstruct the input. Floats do not have a large quantity of precision, which translates roughly to the number of accurate digits. Unfortunately PI is irrational and irrational numbers cannot be losslessly stored in a float because they require an infinite number of digits to express them accurately. So, PI gets truncated. When you do math operations, errors creep. You would think that 10 * 0.1 would equal 1.0, it does not. The reason for this is that 0.1 can't be accurately represented as a float. The point of the lossless functions are to keep more errors from creeping in as a result of converting the number back into a float. Also for debugging purposes, you may want to know the exact value, if you can't find out the exact value, you may have numbers that look like they should work but then don't and you won't know why. -- '''[[User:Strife_Onizuka\|Strife]]''' <sup><small>([[User talk:Strife_Onizuka\|talk]]\|[[Special:Contributions/Strife_Onizuka\|contribs]])</small></sup> 15:21, 23 January 2014 (PST)
	: TL;DR: The functions are lossless, LSL is not.		: TL;DR: The functions are lossless, LSL is not.

			::Yep, I woke up in the night thinking that must be the explanation LOL [[User:Omei Qunhua\|Omei Qunhua]] 15:31, 23 January 2014 (PST)