CODEWITHSUNDEEP
lua
Vyacheslav
Vyacheslav

Reputation: 27211

What is Lua number type length in bytes?

What is the number format length in bytes? This is a "multi type" data format. Is it 4 bytes? 8 bytes? How much? How can I get it programmatically? Does the length depend on the OS/processor type?

Here https://www.lua.org/pil/2.3.html the documentation says this is a double precision type. That is, it has 64 bits. Am I right?

Upvotes: 3

Views: 11179

Answers (6)

notpeter
notpeter

Reputation: 1130

Lua supports specification of the byte length of floating point (4 == single precision, 8 == double precision) and length of integers (4 == 32bit, 8 == 64bit) at compile time.

To inspect/assert this at runtime you can use the following:

function float_bytes()
    return #string.pack("J", 0)
end

function int_bytes()
    return math.maxinteger == 2147483647 and 4 or math.maxinteger == 9223372036854775807 and 8 or nil
end

Upvotes: 0

Spherical Triangle
Spherical Triangle

Reputation: 119

We can use string.pack as follows:

s = string.pack("J",0)
number_of_bytes = #s

Upvotes: 0

mkluwe
mkluwe

Reputation: 4061

Lua as a language does not define what you ask for. The data type used for representing numbers may differ from version to version (note that the link to the free online version of "Programming in Lua" is about Lua 5.0), but primarily this is defined by the way Lua is compiled, as others already said.

Look at luaconf.h for all the details.

Regarding your actual problem (converting hex-string to numbers), you could look at the result of tonumber() on various input strings, compared to known results:

function hexConvertibeBytes()
    local i, s = 0, ''
    repeat
        i, s = i + 1, s .. 'FF'
        local n = tonumber( s, 16 )
    until n ~= 256^i - 1
    return i - 1
end

Upvotes: 0

catwell
catwell

Reputation: 7020

Like @Roddy said, it's slightly complicated with the integer type. Moreover, it depends on how your Lua is compiled.

Basically, in Lua 5.3, there are two types, the integer type lua_Integer and the number type lua_Number. You can get their lengths programatically from within Lua by parsing a chunk header:

local chunk = string.dump(function() end)
print("lua_Integer", chunk:byte(16))
print("lua_Number", chunk:byte(17))

Typically both lengths will be 8 bytes. However on some embedded platforms you can find Luas where the lua_Number type is a float (4 bytes), a 32 bit integer or even weirder things.

Upvotes: 6

Roddy
Roddy

Reputation: 68033

It depends on the version of Lua, and of course, how it's compiled.

5.3 has true integers, typically 64 bits. https://www.lua.org/manual/5.3/manual.html

The type number uses two internal representations, or two subtypes, one called integer and the other called float.

...

Standard Lua uses 64-bit integers and double-precision (64-bit) floats, but you can also compile Lua so that it uses 32-bit integers and/or single-precision (32-bit) floats.

Earlier versions always use 64-bit double-precision floating point, which effectively accurately represents up to 52-bit integers. Your link... https://www.lua.org/pil/2.3.html

Upvotes: 3

Uri Brecher
Uri Brecher

Reputation: 437

according to the Lua reference (for integers)

In case of overflows in integer arithmetic, all operations wrap around, according to the usual rules of two-complement arithmetic. (In other words, they return the unique representable integer that is equal modulo 2^64 to the mathematical result.)

and for floating point

With the exception of exponentiation and float division, the arithmetic operators work as follows: If both operands are integers, the operation is performed over integers and the result is an integer. Otherwise, if both operands are numbers or strings that can be converted to numbers (see §3.4.3), then they are converted to floats, the operation is performed following the usual rules for floating-point arithmetic (usually the IEEE 754 standard), and the result is a float.

Upvotes: 3

Related Questions