- Offizieller Beitrag
Eigentlich wollte ich nur Dezimalzahlen als Hex ausgeben um Handle zu vergleichen. Aber, wie üblich, war mir die einseitige Nutzung der Funktion zu wenig und ich habe es auf alle Basen von 2 bis 16 angewendet zum Konvertieren von/zu allen Bereichen.
Nur Dezimal wird als Zahl ein-/ausgegeben, für alle anderen Basen kommen Strings zur Anwendung. Auf Base2 und Base16 kann zusätzlich mit einem Parameter für Länge konvertiert werden. Bei Bedarf werden dann Vornullen eingefügt. Ist die Längenangabe kürzer als das Ergebnis, wird automatisch angepasst. Falsche Längenangaben [<1, >32(2bin), >16(2hex)] werden korrigiert.
Es gibt eine Universalfunktion (base2base), die alle Typen untereinander konvertiert und vordefinierte Funktionen für die gängigeren Typen (2, 8, 10, 12, 16) untereinander (dec2bin, bin2hex, ...), es entfallen hier die Parameter für Quell- und Zieltyp.
conversion.lua
-- TIME_STAMP 2021-10-22 10:47:23 v 0.2
do
conversion = {}
--[[
Note:
With the exception of base10 values, all other values are used as strings.
Conversion to base2 and to base16 can commit an optional length parameter to insert leading zeros.
The length is limited for 32bit numbers (base2: 32, base16: 16).
Base2 values also recognised, if they committed as number (without leading zeros) with max length of 19 characters.
Syntax:
load module: module = require "ModuleName" i.e. conv = require "conversion"
function call: module:FunctionName(param..) i.e. result = conv:dec2bin(NUM)
or
module.FunctionName(module, param..) i.e. result = conv.dec2bin(conv, NUM)
or
require "conversion" (without variable assignment)
uses the name: "conversion" instead above the own variable "conv"
universal function for all bases from 2 to 16:
conversion.base2base(ValueToConvert, BaseForThisValue, BaseForTheResult[default:10] [,opt. length])
default length: for base2 = the result length itself
for base16 = 6
increases automatically, if the result is longer as the given length
predefined functions for usual base types (2, 8, 10, 12, 16):
conversion.FUNCNAME(ValueToConvert [,opt. length])
--]]
------------------------------------------------------------------------------------------------
-- universal base to base conversion (2...16)
-- default target is base10
------------------------------------------------------------------------------------------------
conversion.base2base = function(self, _v, _basesource, _basetarget, _len)
_basetarget = _basetarget or 10
if _basesource == _basetarget then return _v end
if (_basesource < 2 or _basesource > 16) or
(_basetarget < 2 or _basetarget > 16) then return nil end
local decsource = self:_base2dec(_v, _basesource)
if _basetarget == 2 then
return self:dec2bin(decsource, _len)
elseif _basetarget == 16 then
return self:dec2hex(decsource, _len)
else
return self:_dec2base(decsource, _basetarget)
end
end
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
-- predefined functions for usual base types (2, 8, 10, 12, 16)
------------------------------------------------------------------------------------------------
-- binary
------------------------------------------------------------------------------------------------
conversion.bin2oct = function(self, _b)
return self:dec2oct(self:bin2dec(_b))
end
conversion.bin2dec = function(self, _b)
return self:_base2dec(_b, 2)
end
conversion.bin2duodec = function(self, _b)
return self:dec2duodec(self:bin2dec(_b))
end
conversion.bin2hex = function(self, _b, _len)
return self:dec2hex(self:bin2dec(_b), _len)
end
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
-- octal
------------------------------------------------------------------------------------------------
conversion.oct2bin = function(self, _o, _len)
return self:dec2bin(self:oct2dec(_o), _len)
end
conversion.oct2dec = function(self, _o)
return self:_base2dec(_o, 8)
end
conversion.oct2duodec = function(self, _o)
return self:dec2duodec(self:oct2dec(_o))
end
conversion.oct2hex = function(self, _o, _len)
return self:dec2hex(self:oct2dec(_o), _len)
end
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
--decimal
------------------------------------------------------------------------------------------------
conversion.dec2bin = function(self, _d, _len)
local _len = _len or 1
if _len < 1 then _len = 1 end
if _len > 32 then _len = 32 end
local sRet = self:_dec2base(_d, 2)
local retlen = #sRet
if _len < retlen then _len = retlen end
return ('0'):rep(_len-retlen)..sRet
end
conversion.dec2oct = function(self, _d)
return self:_dec2base(_d, 8)
end
conversion.dec2duodec = function(self, _d)
return self:_dec2base(_d, 12)
end
conversion.dec2hex = function(self, _d, _len)
_len = _len or 6
if _len < 1 then _len = 1 end
if _len > 16 then _len = 16 end
local sRet = self:_dec2base(_d, 16)
local retlen = #sRet
if retlen > _len then _len = retlen end
return '0x'..('0'):rep(_len-retlen)..sRet
end
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
-- duodecimal
------------------------------------------------------------------------------------------------
conversion.duodec2bin = function(self, _dd, _len)
return self:dec2bin(self:duodec2dec(_dd), _len)
end
conversion.duodec2oct = function(self, _dd)
return self:dec2oct(self:duodec2dec(_dd))
end
conversion.duodec2dec = function(self, _dd)
return self:_base2dec(_dd, 12)
end
conversion.duodec2hex = function(self, _dd, _len)
return self:dec2hex(self:duodec2dec(_dd), _len)
end
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
-- hexadecimal
------------------------------------------------------------------------------------------------
conversion.hex2bin = function(self, _h, _len)
return self:dec2bin(self:hex2dec(_h), _len)
end
conversion.hex2oct = function(self, _h)
return self:dec2oct(self:hex2dec(_h))
end
conversion.hex2dec = function(self, _h)
return self:_base2dec(_h, 16)
end
conversion.hex2duodec = function(self, _h)
return self:dec2duodec(self:hex2dec(_h))
end
------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------
-- helper functions
------------------------------------------------------------------------------------------------
conversion._dec2base = function(self, _d, _baseto)
local tNumstr = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}
local sRet, rest = '', 0
repeat
rest = (_d % _baseto) +1
sRet = tNumstr[rest]..sRet
_d = math.floor(_d/_baseto)
until _d == 0
return sRet
end
conversion._base2dec = function(self, _v, _basefrom)
if _basefrom == 16 then return tonumber(_v) end
local iRet = 0
local tNum = {['0']=0,['1']=1,['2']=2,['3']=3,['4']=4,['5']=5,['6']=6,['7']=7,['8']=8,['9']=9,['A']=10,['B']=11,['C']=12,['D']=13,['E']=14}
if type(_v) ~= 'string' then _v = tostring(_v) end
for i = #_v, 1, -1 do
iRet = iRet + tNum[_v:sub(i,i)] * (_basefrom^(#_v -i))
end
return iRet
end
------------------------------------------------------------------------------------------------
return conversion
end
Alles anzeigen
Bsp.
-- load library in local space
local conv = require 'conversion'
-- conversion with predefined functions
b10 = 2147483647
print("@@_Debug_line "..debug.getinfo(1).currentline.." b10:", b10)
b10_b2 = conv:dec2bin(b10)
print("@@_Debug_line "..debug.getinfo(1).currentline.." b10_b2:", b10_b2)
b2_b8 = conv:bin2oct(b10_b2)
print("@@_Debug_line "..debug.getinfo(1).currentline.." b2_b8:", b2_b8)
b8_b12 = conv:oct2duodec(b2_b8)
print("@@_Debug_line "..debug.getinfo(1).currentline.." b8_b12:", b8_b12)
b12_b16 = conv:duodec2hex(b8_b12)
print("@@_Debug_line "..debug.getinfo(1).currentline.." b12_b16:", b12_b16)
b16_b10 = conv:hex2dec(b12_b16)
print("@@_Debug_line "..debug.getinfo(1).currentline.." b16_b10:", b16_b10)
-- conversion with universal function
b10 = 129
print("\n@@_Debug_line "..debug.getinfo(1).currentline.." b10:", b10)
b10_b5 = conv:base2base(b10, 10, 5)
print("@@_Debug_line "..debug.getinfo(1).currentline.." b10_b5:", b10_b5)
b5_b13 = conv:base2base(b10_b5, 5, 13)
print("@@_Debug_line "..debug.getinfo(1).currentline.." b5_b13:", b5_b13)
b13_b16 = conv:base2base(b5_b13, 13, 16, 8) -- length 8
print("@@_Debug_line "..debug.getinfo(1).currentline.." b13_b16:", b13_b16)
b16_b2 = conv:base2base(b13_b16, 16, 2, 16) -- length 16
print("@@_Debug_line "..debug.getinfo(1).currentline.." b16_b2:", b16_b2)
b2_b10 = conv:base2base(b16_b2, 2)
print("@@_Debug_line "..debug.getinfo(1).currentline.." b2_b10:", b2_b10)
@@_Debug_line 407 b10: 2147483647
@@_Debug_line 410 b10_b2: 1111111111111111111111111111111
@@_Debug_line 413 b2_b8: 17777777777
@@_Debug_line 416 b8_b12: 4BB2308A7
@@_Debug_line 419 b12_b16: 0x7FFFFFFF
@@_Debug_line 422 b16_b10: 2147483647
@@_Debug_line 427 b10: 129
@@_Debug_line 430 b10_b5: 1004
@@_Debug_line 433 b5_b13: 9C
@@_Debug_line 436 b13_b16: 0x00000081
@@_Debug_line 439 b16_b2: 0000000010000001
@@_Debug_line 442 b2_b10: 129
Alles anzeigen