how come the decimals in roblox are not perfect for number Values?

when You insert a "number Value" into your roblox game and put the value as .7, it turns out as like: 69999999999999995559 for some reason...

though when I print "what is .8 - .1?" , it simply prints "0.7"

why does this happen?

is there a way to get a perfect decimal number from a number value without getting thousands of digests !?

Roblox uses doubles, which are 64-bit floating point values. Floating point values compromise precision for the space it takes up, meaning that when you have a fractional value, you (usually) won't get the exact value you wanted. This will, however, not affect any integer with an absolute value less than 2^53. However, Lua manages to hide these floating point errors, but I couldn't find any documentation of the process. If you want to find more information on this, look at this Wikipedia article. Hope this helps!

What you're seeing is roundoff error.

.69, with the 9 repeating like that, is really close to .7, but it is not .7.

There is a simple way to get your desired 0.7, and that is to use the Lua rounding formula:

roundedNumber = math.floor(numberToRound + 0.5)

If you use this on .69, you may have to actually multiply the number by 10 then floor it.

Rounding .69 to 0.7:

local num = 0.69
function RoundDecimal(givenNum)
	if tostring(givenNum):find(".") and (tostring(givenNum):find(".") - 1) == "0" then
		local newNum = givenNum * 10
		local flooredNum = math.floor(newNum + 0.5)
		local finalNum = flooredNum / 10
		return finalNum
	end
end
print(RoundDecimal(num))

The output:

0.7

But what's going on with the NumberValue?

Well, the number you insert into a NumberValue is not taken as a literal double or float. This means that the compiler can throw a binary-stored number at you instead of the decimal inside of the NumberValue.

A similar dilemma occurs with the tostring() function. When tostring() converts a number to a string, it suspends the floating point of the number, making the number more vulnerable to being binary-stored instead of being literal (however this usually only occurs with decimals because they have floating points). If you run a loop like this...

for i = 100, 0, -0.1 do
	wait(0.1)
	print(tostring(i))
end

.. nothing appears to be off. Around 91.4, however, you'll start to see this:

91.4
91.3
91.20000000001
91.10000000001
91.00000000001
-- and so on

This is the type of thing that baffles programmers but is simple to work around.