-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathconversion.lua
More file actions
177 lines (165 loc) · 8.39 KB
/
conversion.lua
File metadata and controls
177 lines (165 loc) · 8.39 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
-- TIME_STAMP 2022-02-17 10:39:15 v 0.2
-- coding:utf-8
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