Ne Lua utiliser des entiers 64 bits?

Ne Lua utiliser des entiers 64 bits? Comment puis-je l'utiliser?

OriginalL'auteur Aaron de Windt | 2010-06-23

  1. 13

    Le compiler vous-même. Lua utilise double-précision des nombres à virgule flottante par défaut. Cependant, cela peut être modifié dans la source (luaconf.h, recherchez LUA_NUMBER).

    Pour clarifier, Lua a qu'un seul nombre de type de données. Par défaut, c'est un double, mais peut être modifié dans les fichiers d'en-tête d'un autre type, comme int64_t.
    Si vous modifiez le type de numéro dans luaconf.h, n'oubliez pas de modifier les macros apparentées en conséquence.
    Il est documenté à droite au-dessus de la macro, donc j'ai pensé qu'il serait assez facile à détecter.
    Notez que cela aura des balayage des effets secondaires, puisque c'est le seul type de numéros. Par exemple, math.sin n'est pas nécessairement sensible à un type intégral pour LUA_NUMBER. Il y a un patch pour le Lua sources, connu sous le nom LNUM patch, ce qui peut atténuer ce en soutenant intégrante de type à côté d'un type à virgule flottante. Voir stackoverflow.com/questions/945731/...
    Il n'existe qu'un seul type numérique, et même avec le LNUM patch RBerteig mentionné qui ne change pas, à partir du programmeur point de vue – vous juste un coup entiers 64 bits côtés avec des doubles et des que j'ai compris il choisir le bon type sera fait automatiquement. Vous n'avez pas à déclarer les types de Lua comme vous le faites en VB ou C# – ces langues utilisent un de complètement différent de frappe de la discipline.

    OriginalL'auteur Joey

  2. 7
    require "bit"
-- Lua unsigned 64bit emulated bitwises
-- Slow. But it works.
function i64(v)
local o = {}; o.l = v; o.h = 0; return o;
end -- constructor +assign 32-bit value
function i64_ax(h,l)
local o = {}; o.l = l; o.h = h; return o;
end -- +assign 64-bit v.as 2 regs
function i64u(x)
return ( ( (bit.rshift(x,1) * 2) + bit.band(x,1) ) % (0xFFFFFFFF+1));
end -- keeps [1+0..0xFFFFFFFFF]
function i64_clone(x)
local o = {}; o.l = x.l; o.h = x.h; return o;
end -- +assign regs
-- Type conversions
function i64_toInt(a)
return (a.l + (a.h * (0xFFFFFFFF+1)));
end -- value=2^53 or even less, so better use a.l value
function i64_toString(a)
local s1=string.format("%x",a.l);
local s2=string.format("%x",a.h);
local s3="0000000000000000";
s3=string.sub(s3,1,16-string.len(s1))..s1;
s3=string.sub(s3,1,8-string.len(s2))..s2..string.sub(s3,9);
return "0x"..string.upper(s3);
end
-- Bitwise operators (the main functionality)
function i64_and(a,b)
local o = {}; o.l = i64u( bit.band(a.l, b.l) ); o.h = i64u( bit.band(a.h, b.h) ); return o;
end
function i64_or(a,b)
local o = {}; o.l = i64u( bit.bor(a.l, b.l) ); o.h = i64u( bit.bor(a.h, b.h) ); return o;
end
function i64_xor(a,b)
local o = {}; o.l = i64u( bit.bxor(a.l, b.l) ); o.h = i64u( bit.bxor(a.h, b.h) ); return o;
end
function i64_not(a)
local o = {}; o.l = i64u( bit.bnot(a.l) ); o.h = i64u( bit.bnot(a.h) ); return o;
end
function i64_neg(a)
return i64_add( i64_not(a), i64(1) );
end  -- negative is inverted and incremented by +1
-- Simple Math-functions
-- just to add, not rounded for overflows
function i64_add(a,b)
local o = {};
o.l = a.l + b.l;
local r = o.l - 0xFFFFFFFF;
o.h = a.h + b.h;
if( r>0 ) then
o.h = o.h + 1;
o.l = r-1;
end
return o;
end
-- verify a>=b before usage
function i64_sub(a,b)
local o = {}
o.l = a.l - b.l;
o.h = a.h - b.h;
if( o.l<0 ) then
o.h = o.h - 1;
o.l = o.l + 0xFFFFFFFF+1;
end
return o;
end
-- x n-times
function i64_by(a,n)
local o = {};
o.l = a.l;
o.h = a.h;
for i=2, n, 1 do
o = i64_add(o,a);
end
return o;
end
-- no divisions   
-- Bit-shifting
function i64_lshift(a,n)
local o = {};
if(n==0) then
o.l=a.l; o.h=a.h;
else
if(n<32) then
o.l= i64u( bit.lshift( a.l, n) ); o.h=i64u( bit.lshift( a.h, n) )+ bit.rshift(a.l, (32-n));
else
o.l=0; o.h=i64u( bit.lshift( a.l, (n-32)));
end
end
return o;
end
function i64_rshift(a,n)
local o = {};
if(n==0) then
o.l=a.l; o.h=a.h;
else
if(n<32) then
o.l= bit.rshift(a.l, n)+i64u( bit.lshift(a.h, (32-n))); o.h=bit.rshift(a.h, n);
else
o.l=bit.rshift(a.h, (n-32)); o.h=0;
end
end
return o;
end
-- Comparisons
function i64_eq(a,b)
return ((a.h == b.h) and (a.l == b.l));
end
function i64_ne(a,b)
return ((a.h ~= b.h) or (a.l ~= b.l));
end
function i64_gt(a,b)
return ((a.h > b.h) or ((a.h == b.h) and (a.l >  b.l)));
end
function i64_ge(a,b)
return ((a.h > b.h) or ((a.h == b.h) and (a.l >= b.l)));
end
function i64_lt(a,b)
return ((a.h < b.h) or ((a.h == b.h) and (a.l <  b.l)));
end
function i64_le(a,b)
return ((a.h < b.h) or ((a.h == b.h) and (a.l <= b.l)));
end
-- samples
a = i64(1);               -- 1
b = i64_ax(0x1,0);        -- 4294967296 = 2^32
a = i64_lshift(a,32);     -- now i64_eq(a,b)==true
print( i64_toInt(b)+1 );  -- 4294967297
X = i64_ax(0x00FFF0FF, 0xFFF0FFFF);
Y = i64_ax(0x00000FF0, 0xFF0000FF);
-- swap algorithm
X = i64_xor(X,Y);
Y = i64_xor(X,Y);
X = i64_xor(X,Y);
print( "X="..i64_toString(X) ); -- 0x00000FF0FF0000FF
print( "Y="..i64_toString(Y) ); -- 0x00FFF0FFFFF0FFFF
    Pourquoi ne pas définir une classe avec métatable champs à l'appui de la arithmeric opérateurs ? Et pourquoi pas de fonction pour convertir ces nombres à virgule cordes (vous pouvez également lier cette fonction pour le '__string' métatable) ? Remarque: si la fonction Lua est compilé avec le support de nombres avec la norme IEEE 64 bits double, il stocke exactement tous les numéros à valeur absolue <= (2^53).

    OriginalL'auteur Chessforeva Dev

  3. 3

    Lua 5.3 introduit le sous-type integer, qui utilise entier de 64 bits par défaut.

    De Lua 5.3 manuel de référence

    Le numéro du type utilise deux représentations internes, l'une appelée entier et l'autre appelé à flotteur. Lua a des règles explicites sur lors de chaque représentation est utilisé, mais il convertit également entre automatiquement en tant que de besoin (voir §3.4.3). Par conséquent, le programmeur peut choisir pour la plupart ignorer la différence entre les nombres entiers et décimaux ou d'assumer le contrôle complet sur la représentation de chaque numéro. Standard Lua utilise les entiers 64 bits et de double précision (64 bits) flotte, mais vous pouvez aussi compiler Lua afin qu'il utilise des nombres entiers de 32 bits et/ou de simple précision (32 bits) flotte. L'option avec 32 bits pour les nombres entiers et décimaux est particulièrement intéressante pour les petites machines et les systèmes embarqués. (Voir macro LUA_32BITS dans le fichier luaconf.h.)

    Oui, c'est beaucoup plus rapide que les émulations à l'aide de tableaux de nombres entiers de 32 bits ou des chaînes de caractères pour stocker des valeurs exactes. Cependant Lua peut également être facilement porté à exécuter dans d'autres langues que le C ou C++ (par exemple en PHP, Java ou Javascript), proposant d'autres natif de types de données numériques, ou des nombres avec une précision plus élevée (par exemple 80 bits de long double dans les architectures x86). Avec l'émulation, vous pouvez vous aussi soutenir les nombres complexes ou de matrices en Lua.

    OriginalL'auteur Yu Hao