×

Langue

Fermer
Atelier 801
  • Forums
  • Dev Tracker
  • Connexion
    • English Français
      Português do Brasil Español
      Türkçe Polski
      Magyar Română
      العربية Skandinavisk
      Nederlands Deutsch
      Bahasa Indonesia Русский
      中文 Filipino
      Lietuvių kalba 日本語
      Suomi עברית
      Italiano Česky
      Hrvatski Slovensky
      Български Latviešu
      Estonian
  • Langue
  • Forums
  • /
  • Transformice
  • /
  • Modules
  • /
  • [Tutorial] Bit32
[Tutorial] Bit32
Squalleze
« Citoyen »
1464292800000
    • Squalleze#0000
    • Profil
    • Derniers messages
    • Tribu
#1
  3
  • Início
  • And, &
  • Or, |
  • Not, ~
  • Xor, ~
  • Shift, <<, >>
  • Test
  • Extract
  • Replace
  • Rotate

Bit32


bit32
 arshift
 band &
 bnot ~
 bor |
 btest
 bxor ~
 extract
 replace
 lrotate
 lshift <<
 rrotate
 rshift >>

bit32, é uma biblioteca que trabalha com a manipulação de bits, todas suas funções aceitam apenas números inteiros.

E como sei que alguem vai pensar isso, já vou respondendo, não, não faz diferença seu PC ser 64bits, e também não existe a biblioteca bit64... não em Lua...

Ps.: todos os zeros do lado esquerdo dos binários não possuem importância, é apenas para facílitar o entendimento.
Não confunda & com and e | com or

Tópico criado porque meu amigu Bolodefchoco me obrigou a ensinar ele como isso funfa, e eu fiz com muito amor <1/0 -q, e porque parece que tem gente que não sabe que essa biblioteca existe ^-^

AND, &


Lua 5.2: bit32.band(...)
Lua 5.3: x & y

Essa é uma das funções mais simples, pense o seguinte, um número em binário é composto por uns (1, true) e zeros (0, false), e você possui dois ou mais, então ele irá "checar" o binário de ambos, exemplo:

78 = 01001110
54 = 00110110

então...

78 & 54 = 6
= = =
0 and 0 = 0
1 and 0 = 0
0 and 1 = 0
0 and 1 = 0
1 and 0 = 0
1 and 1 = 1
1 and 1 = 1
0 and 0 = 0

Ou seja, ele pega o mesmo bit de cada número e com um and verifica qual vai ser o valor do mesmo bit no novo valor.

OR, |


Lua 5.2: bit32.bor(...)
Lua 5.3: x | y

Muito semelhante ao &, and, porém utiliza um or como condição, exemplo:

78 = 01001110
54 = 00110110

então...

78 | 54 = 126
= = =
0 or 0 = 0
1 or 0 = 1
0 or 1 = 1
0 or 1 = 1
1 or 0 = 1
1 or 1 = 1
1 or 1 = 1
0 or 0 = 0

NOT, ~


Lua 5.2: bit32.bnot(x)
Lua 5.3: ~x

Essa função/operador funciona de uma maneira um pouco inusitada, exemplo:
~1 = -2
~-293 = 292
~17 = -18

Fórmula:
~x = (-1 - x) % 2 ^ 32

Resumindo, ele inverte o operador do número, subitrai 1 e retorna o resto de sua divisão por 2³² (4.294.967.296) que é o valor máximo armazenado em 32bits

XOR, ~


Lua 5.2: bit32.bxor(...)
Lua 5.3: x ~ y

Primeiramente, vou resumir o XOR, Xor significa eXclusive Or ou eXclusive disjunction e é um operador lógico que só retorna true se ambos os valores forem diferentes, em maioria das línguagens de programação, seu operador é o ^ porém como ele já existe em Lua, o operador ~ é utilizado, exemplo:

true ~ false = true
true ~ true = false
false ~ false = false
false ~ true = true
true ~ true ~ false = false, porque, true ~ true = false, então false ~ false = false
true ~ false ~ false = true, porque, true ~ false = true, então true ~ false = true

então...

78 ~ 54 = 120
= = =
0 xor 0 = 0
1 xor 0 = 1
0 xor 1 = 1
0 xor 1 = 1
1 xor 0 = 1
1 xor 1 = 0
1 xor 1 = 0
0 xor 0 = 0

Shift, <<, >>


Lua 5.2: bit32.lshift(x, tamanho)
Lua 5.3: x << tamanho
Lua 5.2: bit32.rshift(x, tamanho)
Lua 5.3: x >> tamanho
Lua 5.2: bit32.arshift(x, tamanho)

Como o próprio nome já diz, essas funções/operadores empurram os bits por um determinado tamanho, diferente do rotate eles não reaparecem no lado oposto, e sim são "eliminados" caso ultrapassem a casa dos 32bits.

Shift Left
9213 << 0 = 9213 = 00000000000000000010001111111101
9213 << 1 = 18426 = 00000000000000000100011111111010
9213 << 2 = 36852 = 00000000000000001000111111110100
9213 << 3 = 73704 = 00000000000000010001111111101000
9213 << 4 = 147408 = 00000000000000100011111111010000
9213 << 5 = 294816 = 00000000000001000111111110100000
9213 << 6 = 589632 = 00000000000010001111111101000000
9213 << 7 = 1179264 = 00000000000100011111111010000000
9213 << 8 = 2358528 = 00000000001000111111110100000000
9213 << 9 = 4717056 = 00000000010001111111101000000000
9213 << 10 = 9434112 = 00000000100011111111010000000000
9213 << 11 = 18868224 = 00000001000111111110100000000000
9213 << 12 = 37736448 = 00000010001111111101000000000000
9213 << 13 = 75472896 = 00000100011111111010000000000000
9213 << 14 = 150945792 = 00001000111111110100000000000000
9213 << 15 = 301891584 = 00010001111111101000000000000000
9213 << 16 = 603783168 = 00100011111111010000000000000000
9213 << 17 = 1207566336 = 01000111111110100000000000000000
9213 << 18 = 2415132672 = 10001111111101000000000000000000
9213 << 19 = 535298048 = 00011111111010000000000000000000
9213 << 20 = 1070596096 = 00111111110100000000000000000000
9213 << 21 = 2141192192 = 01111111101000000000000000000000
9213 << 22 = 4282384384 = 11111111010000000000000000000000
9213 << 23 = 4269801472 = 11111110100000000000000000000000
9213 << 24 = 4244635648 = 11111101000000000000000000000000
9213 << 25 = 4194304000 = 11111010000000000000000000000000
9213 << 26 = 4093640704 = 11110100000000000000000000000000
9213 << 27 = 3892314112 = 11101000000000000000000000000000
9213 << 28 = 3489660928 = 11010000000000000000000000000000
9213 << 29 = 2684354560 = 10100000000000000000000000000000
9213 << 30 = 1073741824 = 01000000000000000000000000000000
9213 << 31 = 2147483648 = 10000000000000000000000000000000
Shift Right
9213 >> 0 = 9213 = 00000000000000000010001111111101
9213 >> 1 = 4606 = 00000000000000000001000111111110
9213 >> 2 = 2303 = 00000000000000000000100011111111
9213 >> 3 = 1151 = 00000000000000000000010001111111
9213 >> 4 = 575 = 00000000000000000000001000111111
9213 >> 5 = 287 = 00000000000000000000000100011111
9213 >> 6 = 143 = 00000000000000000000000010001111
9213 >> 7 = 71 = 00000000000000000000000001000111
9213 >> 8 = 35 = 00000000000000000000000000100011
9213 >> 9 = 17 = 00000000000000000000000000010001
9213 >> 10 = 8 = 00000000000000000000000000001000
9213 >> 11 = 4 = 00000000000000000000000000000100
9213 >> 12 = 2 = 00000000000000000000000000000010
9213 >> 13 = 1 = 00000000000000000000000000000001
9213 >> 14 = 0 = 00000000000000000000000000000000
9213 >> 15 = 0 = 00000000000000000000000000000000
9213 >> 16 = 0 = 00000000000000000000000000000000
9213 >> 17 = 0 = 00000000000000000000000000000000
9213 >> 18 = 0 = 00000000000000000000000000000000
9213 >> 19 = 0 = 00000000000000000000000000000000
9213 >> 20 = 0 = 00000000000000000000000000000000
9213 >> 21 = 0 = 00000000000000000000000000000000
9213 >> 22 = 0 = 00000000000000000000000000000000
9213 >> 23 = 0 = 00000000000000000000000000000000
9213 >> 24 = 0 = 00000000000000000000000000000000
9213 >> 25 = 0 = 00000000000000000000000000000000
9213 >> 26 = 0 = 00000000000000000000000000000000
9213 >> 27 = 0 = 00000000000000000000000000000000
9213 >> 28 = 0 = 00000000000000000000000000000000
9213 >> 29 = 0 = 00000000000000000000000000000000
9213 >> 30 = 0 = 00000000000000000000000000000000
9213 >> 31 = 0 = 00000000000000000000000000000000

arshift faz o mesmo que os outros, porém se o número for positivo é para a direita, e negativo para a esquerda...

Test


Lua 5.2: bit32.btest(...)

Essa função irá retornar true se o output de bit32.band(...) for diferente de 0.
bit32.btest(...) = (bit32.band(...) ~= 0)

Extract


Lua 5.2: bit32.extract(x, inicio[, tamanho = 1])

O atributo inicio é um número entre 0 e 31, e tamanho por padrão é 1, porém deve ser um número entre 1 e 32 - inicio.
Funciona semelhante a um string.sub, porém de binário é claro...
Por exemplo, você tem o número 9213, seu binário é 10001111111101, então:

bit32.extract(9213, 0) = 00000000000000000010001111111101 = 1
bit32.extract(9213, 0, 10) = 00000000000000000010001111111101 = 1021
bit32.extract(9213, 0, 3) = 00000000000000000010001111111101 = 5
bit32.extract(9213, 9, 15) = 00000000000000000010001111111101 = 17
bit32.extract(9213, 0, 32) = 00000000000000000010001111111101 = 9213
bit32.extract(9213, 5, 27) = 00000000000000000010001111111101 = 287
bit32.extract(9213, 5, 14) = 00000000000000000010001111111101 = 287

Replace


Lua 5.2: bit32.replace(x, y, inicio[, tamanho])

Esse funciona muito semelhante ao extract, só que ao contrário, pense assim, você tem uma palavra, e você quer colocar dentro dela uma outra palavra, é exatamente isso! Você só precisa determinar onde essa palavra entra e o tamanho que ela vai ocupar, simples! Porém no caso são bits obviamente...

Exemplos:
9213 = 00000000000000000010001111111101
4294967295 = 11111111111111111111111111111111 (escolhi esse para ficar melhor de entender)

█ = área substituida
█ = área "pega" do valor que substituirá a área vermelha
█ = área intacta
█ = área não pega do valor dado


bit32.replace(4294967295, 9213, 0, 8) = 4294967293
11111111111111111111111111111111 + 00000000000000000010001111111101 = 11111111111111111111111111111101

bit32.replace(9213, 100, 6, 26) = 6461
00000000000000000010001111111101 + 00000000000000000000000001100100 = 00000000000000000001100100111101

bit32.replace(100, 9213, 15, 3) = 163940
00000000000000000000000001100100 + 00000000000000000010001111111101 = 00000000000000101000000001100100

bit32.replace(0, 4294967295, 10, 8)= 261120
00000000000000000000000000000000 + 11111111111111111111111111111111 = 00000000000000111111110000000000


Rotate


Lua 5.2: bit32.lrotate(x, tamanho)
Lua 5.2: bit32.rrotate(x, tamanho)

O atributo tamanho será modulado? por 32 (tamanho % 32)
Um pouco complicado de se explicar, porém imagine uma roda, nela estão grifados todos os bits (do lado dela, não dentro), quando você gira essa roda 5 bits sentido horário a ordem se mantem, porém os útimos 5 bits passam a ser os primeiros, e se você girar no sentido contrário, eles voltam a sua posição, é meio que isso...

Se tamanho for negativo funcionará como um rrotate em lrotate e como lrotate em rrotate

No caso o número é 9213 e seu binário é 10001111111101, exemplo:

Left Rotate
bit32.lrotate(9213, 0) = 9213 = 00000000000000000010001111111101
bit32.lrotate(9213, 1) = 18426 = 00000000000000000100011111111010
bit32.lrotate(9213, 2) = 36852 = 00000000000000001000111111110100
bit32.lrotate(9213, 3) = 73704 = 00000000000000010001111111101000
bit32.lrotate(9213, 4) = 147408 = 00000000000000100011111111010000
bit32.lrotate(9213, 5) = 294816 = 00000000000001000111111110100000
bit32.lrotate(9213, 6) = 589632 = 00000000000010001111111101000000
bit32.lrotate(9213, 7) = 1179264 = 00000000000100011111111010000000
bit32.lrotate(9213, 8) = 2358528 = 00000000001000111111110100000000
bit32.lrotate(9213, 9) = 4717056 = 00000000010001111111101000000000
bit32.lrotate(9213, 10) = 9434112 = 00000000100011111111010000000000
bit32.lrotate(9213, 11) = 18868224 = 00000001000111111110100000000000
bit32.lrotate(9213, 12) = 37736448 = 00000010001111111101000000000000
bit32.lrotate(9213, 13) = 75472896 = 00000100011111111010000000000000
bit32.lrotate(9213, 14) = 150945792 = 00001000111111110100000000000000
bit32.lrotate(9213, 15) = 301891584 = 00010001111111101000000000000000
bit32.lrotate(9213, 16) = 603783168 = 00100011111111010000000000000000
bit32.lrotate(9213, 17) = 1207566336 = 01000111111110100000000000000000
bit32.lrotate(9213, 18) = 2415132672 = 10001111111101000000000000000000
bit32.lrotate(9213, 19) = 535298049 = 00011111111010000000000000000001
bit32.lrotate(9213, 20) = 1070596098 = 00111111110100000000000000000010
bit32.lrotate(9213, 21) = 2141192196 = 01111111101000000000000000000100
bit32.lrotate(9213, 22) = 4282384392 = 11111111010000000000000000001000
bit32.lrotate(9213, 23) = 4269801489 = 11111110100000000000000000010001
bit32.lrotate(9213, 24) = 4244635683 = 11111101000000000000000000100011
bit32.lrotate(9213, 25) = 4194304071 = 11111010000000000000000001000111
bit32.lrotate(9213, 29) = 4093640847 = 11110100000000000000000010001111
bit32.lrotate(9213, 27) = 3892314399 = 11101000000000000000000100011111
bit32.lrotate(9213, 28) = 3489661503 = 11010000000000000000001000111111
bit32.lrotate(9213, 29) = 2684355711 = 10100000000000000000010001111111
bit32.lrotate(9213, 30) = 1073744127 = 01000000000000000000100011111111
bit32.lrotate(9213, 31) = 2147488254 = 10000000000000000001000111111110
Right Rotate
bit32.rrotate(9213, 0) = 9213 = 00000000000000000010001111111101
bit32.rrotate(9213, 1) = 2147488254 = 10000000000000000001000111111110
bit32.rrotate(9213, 2) = 1073744127 = 01000000000000000000100011111111
bit32.rrotate(9213, 3) = 2684355711 = 10100000000000000000010001111111
bit32.rrotate(9213, 4) = 3489661503 = 11010000000000000000001000111111
bit32.rrotate(9213, 5) = 3892314399 = 11101000000000000000000100011111
bit32.rrotate(9213, 6) = 4093640847 = 11110100000000000000000010001111
bit32.rrotate(9213, 7) = 4194304071 = 11111010000000000000000001000111
bit32.rrotate(9213, 8) = 4244635683 = 11111101000000000000000000100011
bit32.rrotate(9213, 9) = 4269801489 = 11111110100000000000000000010001
bit32.rrotate(9213, 10) = 4282384392 = 11111111010000000000000000001000
bit32.rrotate(9213, 11) = 2141192196 = 01111111101000000000000000000100
bit32.rrotate(9213, 12) = 1070596098 = 00111111110100000000000000000010
bit32.rrotate(9213, 13) = 535298049 = 00011111111010000000000000000001
bit32.rrotate(9213, 14) = 2415132672 = 10001111111101000000000000000000
bit32.rrotate(9213, 15) = 1207566336 = 01000111111110100000000000000000
bit32.rrotate(9213, 16) = 603783168 = 00100011111111010000000000000000
bit32.rrotate(9213, 17) = 301891584 = 00010001111111101000000000000000
bit32.rrotate(9213, 18) = 150945792 = 00001000111111110100000000000000
bit32.rrotate(9213, 19) = 75472896 = 00000100011111111010000000000000
bit32.rrotate(9213, 20) = 37736448 = 00000010001111111101000000000000
bit32.rrotate(9213, 21) = 18868224 = 00000001000111111110100000000000
bit32.rrotate(9213, 22) = 9434112 = 00000000100011111111010000000000
bit32.rrotate(9213, 23) = 4717056 = 00000000010001111111101000000000
bit32.rrotate(9213, 24) = 2358528 = 00000000001000111111110100000000
bit32.rrotate(9213, 25) = 1179264 = 00000000000100011111111010000000
bit32.rrotate(9213, 26) = 589632 = 00000000000010001111111101000000
bit32.rrotate(9213, 27) = 294816 = 00000000000001000111111110100000
bit32.rrotate(9213, 28) = 147408 = 00000000000000100011111111010000
bit32.rrotate(9213, 29) = 73704 = 00000000000000010001111111101000
bit32.rrotate(9213, 3) = 36852 = 00000000000000001000111111110100
bit32.rrotate(9213, 31) = 18426 = 00000000000000000100011111111010


Dernière modification le 1464993240000
Hydroper
« Citoyen »
1471014720000
    • Hydroper#0528
    • Profil
    • Derniers messages
    • Tribu
#2
  0
Eu tinha precisado desse tópico ontem e-e
Bolodefchoco
« Sénateur »
1515095100000
    • Bolodefchoco#0095
    • Profil
    • Derniers messages
    • Tribu
#3
  0
this thread shall not die

Nunca encontrei funcionalidade pra isso no transformice :_:
Nunca vi um tópico com tanto 0, 1 e beleza ao mesmo tempo
Squalleze
« Citoyen »
1515454800000
    • Squalleze#0000
    • Profil
    • Derniers messages
    • Tribu
#4
  0
eu q fiz o tópico e ele tá super confuso, além de quem na época eu n sabia direito o bnot então provavelmente irei arrumar
Mescouleur
« Citoyen »
1517027220000
    • Mescouleur#0000
    • Profil
    • Derniers messages
#5
  0
mas meu pc é 64bits, vai funcionar msm assim?
Cherry_sweet
« Citoyen »
1517030940000
    • Cherry_sweet#0000
    • Profil
    • Derniers messages
    • Tribu
#6
  0
Mescouleur a dit :
mas meu pc é 64bits, vai funcionar msm assim?

eu ia fazer essa piada aff

legal seu topico <3
Bortverde
« Consul »
1517055180000
    • Bortverde#0015
    • Profil
    • Derniers messages
    • Tribu
#7
  0
Que doideira
E qual a utilidade disso? Quem diria que teria esse tipo de coisa no TFM, já que ele usa Lua
Laagaadoo
« Citoyen »
1517067420000
    • Laagaadoo#0000
    • Profil
    • Derniers messages
    • Tribu
#8
  0
Bortverde a dit :
Que doideira
E qual a utilidade disso? Quem diria que teria esse tipo de coisa no TFM, já que ele usa Lua

Você pode por exemplo fazer um sistema de permissões:
Code Lua

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
local kick = 0x1
local message = 0x2
local password = 0x4
local ban = 0x8

local players = {
Laagaadoo = {
-- tem permissão de fazer 2 coisas
permissions = bit32.bor(ban, password) --> 12
},
Lagad0 = {
-- tem permissão de fazer 3 coisas
permissions = bit32.bor(kick, password, message) --> 7
}
}

if bit32.band(players.Laagaadoo.permissions, ban) == ban then
print("Laagaadoo tem permissão de banir")
else
print("Laagaadoo não tem permissão de banir")
end

if bit32.band(players.Lagad0.permissions, ban) == ban then
print("Lagad0 tem permissão de banir")
else
print("Lagad0 não tem permissão de banir")
end

--> Laagaadoo tem permissão de banir
--> Lagad0 não tem permissão de banir
Bolodefchoco
« Sénateur »
1534011540000
    • Bolodefchoco#0095
    • Profil
    • Derniers messages
    • Tribu
#9
  2
Algumas fórmulas legais de saber:

lshift(x, y) = x * (2 ^ y)
rshift(x, y) = x / (2 ^ y)


Soma pode ser bor(x, y), ou x+y se ambos forem potencias de 10
Subtração é band(x, bnot(y)), ou x & ~y

Lindo do laag pr0

Dernière modification le 1534012860000
Feiticeirobr
« Censeur »
1534014900000
    • Feiticeirobr#0000
    • Profil
    • Derniers messages
    • Tribu
#10
  0
Pensei que era alguma coisa do pc skdfjhjksdfh
Bloom
« Héliaste »
1544147340000
    • Bloom#6766
    • Profil
    • Derniers messages
#11
  0
Belo tópico!
  • Forums
  • /
  • Transformice
  • /
  • Modules
  • /
  • [Tutorial] Bit32
© Atelier801 2018

Equipe Conditions Générales d'Utilisation Politique de Confidentialité Contact

Version 1.27