Tut Lua nutzen von 64-bit-Ganzzahlen?

Tut Lua nutzen von 64-bit-Ganzzahlen? Wie kann ich es verwenden?

InformationsquelleAutor Aaron de Windt | 2010-06-23

13

Selbst kompilieren. Lua verwendet double-precision-floating-point-zahlen standardmäßig. Dies kann jedoch geändert werden in der Quelle (luaconf.h, suchen LUA_NUMBER).
- Um zu klären, Lua hat einen einzigen numerischen Datentyp haben. Standardmäßig ist dies ein double, kann aber geändert werden in den header-Dateien zu einem anderen Typ, wie int64_t.
- Wenn Sie die Nummer geben luaconf.h, vergessen Sie nicht, ändern Sie den zugehörigen Makros entsprechend.
- Es ist dokumentiert, die direkt über den makro -, aber, so dachte ich, es wäre ziemlich schwer zu finden.
- Beachten Sie, dass diese haben einige kehren Nebenwirkungen, da dies ist die einzige Art zahlen müssen. Zum Beispiel math.sin ist nicht unbedingt sinnvoll, mit einem integral-Typ für LUA_NUMBER. Es gibt einen patch, um die Lua-Quellen, bekannt als die LNUM patch, die können dies vermeiden, indem Sie die Unterstützung einer integralen Typ neben einem floating-point-Typ. Siehe stackoverflow.com/questions/945731/...
- Ich mache ein apps zu verwenden, in der pge lua-game-engine auf der psp. Ich dachte, definieren Sie den Typ der Variablen, wie in VB.NET oder C#.
- Es gibt nur einen einzigen numerischen Typ und auch mit der LNUM patch RBerteig erwähnt, dass ändert sich nicht aus der programmer ' s Sicht – Sie nur plötzlich in der 64-bit-Ganzzahlen, neben Doppel-und soweit ich es verstanden habe bei der Wahl des richtigen Typs erfolgt automatisch. Sie deklarieren Sie nicht den Typen in Lua wie man das in VB oder C# – diese Sprachen verwenden eine komplett unterschiedliche Typisierung Disziplin.
InformationsquelleAutor Joey

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

Warum nicht, definieren Sie eine Klasse mit metatable Felder zur Unterstützung arithmeric Betreiber ? Und warum keine Funktion für die Konvertierung dieser zahlen-zu-dezimal-strings (Sie können auch binden Sie diese Funktion, um die "__string' metatable) ? Hinweis: wenn Lua kompiliert wird, um Unterstützung für zahlen mit IEEE 64-bit verdoppelt, es speichert genau alle zahlen mit absoluten Wert <= (2^53).

InformationsquelleAutor Chessforeva Dev

3

Lua 5.3 führt integer Subtyp, der mit 64-bit-Ganzzahl, standardmäßig.

Vom Lua 5.3 Referenz-Handbuch

Die Typ-Nummer verwendet zwei interne Repräsentationen, sogenannte integer und die andere namens float. Lua hat explizite Regeln, wenn jede Darstellung verwendet wird, aber es wandelt auch zwischen Ihnen automatisch wie erforderlich (siehe §3.4.3). Also, der Programmierer kann wählen, meistens ignorieren Sie den Unterschied zwischen Ganzzahlen und Fließkommazahlen oder übernehmen die vollständige Kontrolle über die Darstellung jeder Zahl. Standard-Lua verwendet 64-bit-Ganzzahlen und double-precision (64-bit) schwebt, aber Sie können auch kompilieren Lua, so dass es verwendet 32-bit-Ganzzahlen und/oder single-precision (32-bit) schwimmt. Die option mit 32 bits für die beiden Ganzzahlen und Fließkommazahlen ist besonders attraktiv für kleine Maschinen und embedded-Systeme. (Siehe makro LUA_32BITS im Datei -luaconf.h.)
- Ja, das ist viel schneller als bei Emulationen unter Verwendung von arrays von 32-bit-integers oder strings für die Speicherung der exakten Werte. Aber Lua kann auch einfach portiert, laufen in anderen host-Sprachen als C oder C++ (z.B. in PHP, Java oder Javascript), mit anderen native numerische Datentypen, oder zahlen mit einer höheren Genauigkeit (z.B. 80-bit-long double in x86-Architekturen). Mit emulation können Sie auch unterstützen, komplexe zahlen oder Matrizen, in Lua.
InformationsquelleAutor Yu Hao

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.