| *lua-bit.txt* Nvim |
| *lua-bit* |
|
|
| LUA BITOP REFERENCE MANUAL |
|
|
|
|
| Adapted from <https://bitop.luajit.org> |
|
|
|
|
| Lua BitOp is a C extension module for Lua 5.1/5.2 which adds bitwise |
| operations on numbers. |
|
|
| Type |gO| to see the table of contents. |
|
|
| ============================================================================== |
| API FUNCTIONS *lua-bit-api* |
|
|
| This list of API functions is not intended to replace a tutorial. If you are |
| not familiar with the terms used, you may want to study the Wikipedia article |
| on bitwise operations (https://en.wikipedia.org/wiki/Bitwise_operation) first. |
|
|
| ------------------------------------------------------------------------------ |
| Loading the BitOp module |
| *lua-bit-module* |
|
|
| The suggested way to use the BitOp module is to add the following to the start |
| of every Lua file that needs one of its functions: >lua |
| local bit = require("bit") |
| < |
| This makes the dependency explicit, limits the scope to the current file and |
| provides faster access to the bit.* functions, too. It's good programming |
| practice not to rely on the global variable bit being set (assuming some other |
| part of your application has already loaded the module). The require function |
| ensures the module is only loaded once, in any case. |
|
|
| ------------------------------------------------------------------------------ |
| Defining Shortcuts |
| *lua-bit-shortcuts* |
|
|
| It's a common (but not a required) practice to cache often used module |
| functions in locals. This serves as a shortcut to save some typing and also |
| speeds up resolving them (only relevant if called hundreds of thousands of |
| times). |
| >lua |
| local bnot = bit.bnot |
| local band, bor, bxor = bit.band, bit.bor, bit.bxor |
| local lshift, rshift, rol = bit.lshift, bit.rshift, bit.rol |
| -- etc... |
|
|
| -- Example use of the shortcuts: |
| local function tr_i(a, b, c, d, x, s) |
| return rol(bxor(c, bor(b, bnot(d))) + a + x, s) + b |
| end |
| < |
|
|
| Remember that `and`, `or` and `not` are reserved keywords in Lua. They cannot |
| be used for variable names or literal field names. That's why the |
| corresponding bitwise functions have been named `band`, `bor`, and `bnot` (and |
| `bxor` for consistency). |
|
|
| While we are at it: a common pitfall is to use bit as the name of a local |
| temporary variable — well, don't! :-) |
|
|
| ------------------------------------------------------------------------------ |
| About the Examples |
|
|
| The examples below show small Lua one-liners. Their expected output is shown |
| after `-->`. This is interpreted as a comment marker by Lua so you can cut & |
| paste the whole line to a Lua prompt and experiment with it. |
|
|
| Note that all bit operations return signed 32 bit numbers (rationale). And |
| these print as signed decimal numbers by default. |
|
|
| For clarity the examples assume the definition of a helper function |
| `printx()`. This prints its argument as an unsigned 32 bit hexadecimal number |
| on all platforms: |
| >lua |
| function printx(x) |
| print("0x"..bit.tohex(x)) |
| end |
| < |
| ------------------------------------------------------------------------------ |
| Bit operations |
| *lua-bitop* |
|
|
| y = bit.tobit(x) *bit.tobit()* |
| Normalizes a number to the numeric range for bit operations and returns |
| it. This function is usually not needed since all bit operations already |
| normalize all of their input arguments. See |lua-bit-semantics|. |
|
|
| Example: >lua |
| print(0xffffffff) --> 4294967295 (see Note) |
| print(bit.tobit(0xffffffff)) --> -1 |
| printx(bit.tobit(0xffffffff)) --> 0xffffffff |
| print(bit.tobit(0xffffffff + 1)) --> 0 |
| print(bit.tobit(2^40 + 1234)) --> 1234 |
| < |
| Note: |lua-bit-hex-literals| explains why the numbers printed in the first |
| two lines differ (if your Lua installation uses a double number type). |
|
|
| y = bit.tohex(x [,n]) *bit.tohex()* |
| Converts its first argument to a hex string. The number of hex digits is |
| given by the absolute value of the optional second argument. Positive |
| numbers between 1 and 8 generate lowercase hex digits. Negative numbers |
| generate uppercase hex digits. Only the least-significant `4*|n|` bits are |
| used. The default is to generate 8 lowercase hex digits. |
|
|
| Example: >lua |
| print(bit.tohex(1)) --> 00000001 |
| print(bit.tohex(-1)) --> ffffffff |
| print(bit.tohex(0xffffffff)) --> ffffffff |
| print(bit.tohex(-1, -8)) --> FFFFFFFF |
| print(bit.tohex(0x21, 4)) --> 0021 |
| print(bit.tohex(0x87654321, 4)) --> 4321 |
| < |
| y = bit.bnot(x) *bit.bnot()* |
| Returns the bitwise `not` of its argument. |
|
|
| Example: >lua |
| print(bit.bnot(0)) --> -1 |
| printx(bit.bnot(0)) --> 0xffffffff |
| print(bit.bnot(-1)) --> 0 |
| print(bit.bnot(0xffffffff)) --> 0 |
| printx(bit.bnot(0x12345678)) --> 0xedcba987 |
| < |
| y = bit.bor(x1 [,x2...]) *bit.bor()* |
| y = bit.band(x1 [,x2...]) *bit.band()* |
| y = bit.bxor(x1 [,x2...]) *bit.bxor()* |
| Returns either the bitwise `or`, bitwise `and`, or bitwise `xor` of all of its |
| arguments. Note that more than two arguments are allowed. |
|
|
| Example: >lua |
| print(bit.bor(1, 2, 4, 8)) --> 15 |
| printx(bit.band(0x12345678, 0xff)) --> 0x00000078 |
| printx(bit.bxor(0xa5a5f0f0, 0xaa55ff00)) --> 0x0ff00ff0 |
| < |
| y = bit.lshift(x, n) *bit.lshift()* |
| y = bit.rshift(x, n) *bit.rshift()* |
| y = bit.arshift(x, n) *bit.arshift()* |
| Returns either the bitwise `logical left-shift`, bitwise `logical` |
| `right-shift`, or bitwise `arithmetic right-shift` of its first argument |
| by the number of bits given by the second argument. |
|
|
| Logical shifts treat the first argument as an unsigned number and shift in |
| 0-bits. Arithmetic right-shift treats the most-significant bit as a sign |
| bit and replicates it. Only the lower 5 bits of the shift count are used |
| (reduces to the range [0..31]). |
|
|
| Example: >lua |
| print(bit.lshift(1, 0)) --> 1 |
| print(bit.lshift(1, 8)) --> 256 |
| print(bit.lshift(1, 40)) --> 256 |
| print(bit.rshift(256, 8)) --> 1 |
| print(bit.rshift(-256, 8)) --> 16777215 |
| print(bit.arshift(256, 8)) --> 1 |
| print(bit.arshift(-256, 8)) --> -1 |
| printx(bit.lshift(0x87654321, 12)) --> 0x54321000 |
| printx(bit.rshift(0x87654321, 12)) --> 0x00087654 |
| printx(bit.arshift(0x87654321, 12)) --> 0xfff87654 |
| < |
| y = bit.rol(x, n) *bit.rol()* |
| y = bit.ror(x, n) *bit.ror()* |
| Returns either the bitwise `left rotation`, or bitwise `right rotation` of its |
| first argument by the number of bits given by the second argument. Bits |
| shifted out on one side are shifted back in on the other side. |
|
|
| Only the lower 5 bits of the rotate count are used (reduces to the range |
| [0..31]). |
|
|
| Example: >lua |
| printx(bit.rol(0x12345678, 12)) --> 0x45678123 |
| printx(bit.ror(0x12345678, 12)) --> 0x67812345 |
| < |
| y = bit.bswap(x) |
| Swaps the bytes of its argument and returns it. This can be used to |
| convert little-endian 32 bit numbers to big-endian 32 bit numbers or vice |
| versa. |
|
|
| Example: >lua |
| printx(bit.bswap(0x12345678)) --> 0x78563412 |
| printx(bit.bswap(0x78563412)) --> 0x12345678 |
| < |
| ------------------------------------------------------------------------------ |
| Example Program |
|
|
| This is an implementation of the (naïve) Sieve of Eratosthenes algorithm. It |
| counts the number of primes up to some maximum number. |
|
|
| A Lua table is used to hold a bit-vector. Every array index has 32 bits of the |
| vector. Bitwise operations are used to access and modify them. Note that the |
| shift counts don't need to be masked since this is already done by the BitOp |
| shift and rotate functions. |
| >lua |
| local bit = require("bit") |
| local band, bxor = bit.band, bit.bxor |
| local rshift, rol = bit.rshift, bit.rol |
|
|
| local m = tonumber(arg and arg[1]) or 100000 |
| if m < 2 then m = 2 end |
| local count = 0 |
| local p = {} |
|
|
| for i=0,(m+31)/32 do p[i] = -1 end |
|
|
| for i=2,m do |
| if band(rshift(p[rshift(i, 5)], i), 1) ~= 0 then |
| count = count + 1 |
| for j=i+i,m,i do |
| local jx = rshift(j, 5) |
| p[jx] = band(p[jx], rol(-2, j)) |
| end |
| end |
| end |
|
|
| io.write(string.format("Found %d primes up to %d\n", count, m)) |
| < |
| Lua BitOp is quite fast. This program runs in less than 90 milliseconds on a 3 |
| GHz CPU with a standard Lua installation, but performs more than a million |
| calls to bitwise functions. If you're looking for even more speed, check out |
| |lua-luajit|. |
|
|
| ------------------------------------------------------------------------------ |
| Caveats *lua-bit-caveats* |
|
|
| Signed Results ~ |
|
|
| Returning signed numbers from bitwise operations may be surprising to |
| programmers coming from other programming languages which have both signed and |
| unsigned types. But as long as you treat the results of bitwise operations |
| uniformly everywhere, this shouldn't cause any problems. |
|
|
| Preferably format results with `bit.tohex` if you want a reliable unsigned |
| string representation. Avoid the `"%x"` or `"%u"` formats for `string.format`. They |
| fail on some architectures for negative numbers and can return more than 8 hex |
| digits on others. |
|
|
| You may also want to avoid the default number to string coercion, since this |
| is a signed conversion. The coercion is used for string concatenation and all |
| standard library functions which accept string arguments (such as `print()` or |
| `io.write()`). |
|
|
| Conditionals ~ |
|
|
| If you're transcribing some code from C/C++, watch out for bit operations in |
| conditionals. In C/C++ any non-zero value is implicitly considered as `true`. |
| E.g. this C code: >c |
| if (x & 3) ... |
| < |
| must not be turned into this Lua code: >lua |
| if band(x, 3) then ... -- wrong! |
| < |
| In Lua all objects except `nil` and `false` are considered `true`. This |
| includes all numbers. An explicit comparison against zero is required in this |
| case: >lua |
| if band(x, 3) ~= 0 then ... -- correct! |
|
|
| Comparing Against Hex Literals ~ |
|
|
| Comparing the results of bitwise operations (signed numbers) against hex |
| literals (unsigned numbers) needs some additional care. The following |
| conditional expression may or may not work right, depending on the platform |
| you run it on: >lua |
| bit.bor(x, 1) == 0xffffffff |
| < |
| E.g. it's never true on a Lua installation with the default number type. Some |
| simple solutions: |
|
|
| Never use hex literals larger than 0x7fffffff in comparisons: >lua |
| bit.bor(x, 1) == -1 |
| < |
| Or convert them with bit.tobit() before comparing: >lua |
| bit.bor(x, 1) == bit.tobit(0xffffffff) |
| < |
| Or use a generic workaround with bit.bxor(): >lua |
| bit.bxor(bit.bor(x, 1), 0xffffffff) == 0 |
| < |
| Or use a case-specific workaround: >lua |
| bit.rshift(x, 1) == 0x7fffffff |
| < |
| ============================================================================== |
| OPERATIONAL SEMANTICS AND RATIONALE *lua-bit-semantics* |
|
|
|
|
| Input and Output Ranges ~ |
| *lua-bit-io-ranges* |
|
|
| Bitwise operations cannot sensibly be applied to FP numbers (or their |
| underlying bit patterns). They must be converted to integers before operating |
| on them and then back to FP numbers. |
|
|
| It's desirable to define semantics that work the same across all platforms. |
| This dictates that all operations are based on the common denominator of 32 |
| bit integers. The `float` type provides only 24 bits of precision. This makes it |
| unsuitable for use in bitwise operations. Lua BitOp refuses to compile against |
| a Lua installation with this number type. |
|
|
| Bit operations only deal with the underlying bit patterns and generally ignore |
| signedness (except for arithmetic right-shift). They are commonly displayed |
| and treated like unsigned numbers, though. |
|
|
| But the Lua number type must be signed and may be limited to 32 bits. Defining |
| the result type as an unsigned number would not be cross-platform safe. All |
| bit operations are thus defined to return results in the range of signed 32 |
| bit numbers (converted to the Lua number type). |
|
|
| *lua-bit-hex-literals* |
| Hexadecimal literals are treated as unsigned numbers by the Lua parser before |
| converting them to the Lua number type. This means they can be out of the |
| range of signed 32 bit integers if the Lua number type has a greater range. |
| E.g. 0xffffffff has a value of 4294967295 in the default installation, but may |
| be -1 on embedded systems. It's highly desirable that hex literals are treated |
| uniformly across systems when used in bitwise operations. All bit operations |
| accept arguments in the signed or the unsigned 32 bit range (and more, see |
| below). Numbers with the same underlying bit pattern are treated the same by |
| all operations. |
|
|
|
|
| Modular Arithmetic ~ |
| *lua-bit-modular-arith* |
|
|
| Arithmetic operations on n-bit integers are usually based on the rules of |
| modular arithmetic modulo 2^n. Numbers wrap around when the mathematical result |
| of operations is outside their defined range. This simplifies hardware |
| implementations and some algorithms actually require this behavior (like many |
| cryptographic functions). |
|
|
| E.g. for 32 bit integers the following holds: `0xffffffff + 1 = 0` |
|
|
| Arithmetic modulo 2^32 is trivially available if the Lua number type is a 32 |
| bit integer. Otherwise normalization steps must be inserted. Modular |
| arithmetic should work the same across all platforms as far as possible: |
|
|
| - For the default number type of double, arguments can be in the range of |
| ±2^51 and still be safely normalized across all platforms by taking their |
| least-significant 32 bits. The limit is derived from the way doubles are |
| converted to integers. |
| - The function bit.tobit can be used to explicitly normalize numbers to |
| implement modular addition or subtraction. E.g. >lua |
| bit.tobit(0xffffffff + 1) |
| returns 0 on all platforms. |
| - The limit on the argument range implies that modular multiplication is |
| usually restricted to multiplying already normalized numbers with small |
| constants. FP numbers are limited to 53 bits of precision, anyway. E.g. |
| (2^30+1)^2 does not return an odd number when computed with doubles. |
|
|
| BTW: The `tr_i` function shown here |lua-bit-shortcuts| is one of the |
| non-linear functions of the (flawed) MD5 cryptographic hash and relies on |
| modular arithmetic for correct operation. The result is fed back to other |
| bitwise operations (not shown) and does not need to be normalized until the |
| last step. |
|
|
|
|
| Restricted and undefined behaviors ~ |
| *lua-bit-restrictions* |
|
|
| The following rules are intended to give a precise and useful definition (for |
| the programmer), yet give the implementation (interpreter and compiler) the |
| maximum flexibility and the freedom to apply advanced optimizations. It's |
| strongly advised not to rely on undefined or implementation-defined behavior. |
|
|
| - All kinds of floating-point numbers are acceptable to the bitwise |
| operations. None of them cause an error, but some may invoke undefined |
| behavior: |
| - -0 is treated the same as +0 on input and is never returned as a result. |
| - Passing ±Inf, NaN or numbers outside the range of ±2^51 as input yields |
| an undefined result. |
| - Non-integral numbers may be rounded or truncated in an |
| implementation-defined way. This means the result could differ between |
| different BitOp versions, different Lua VMs, on different platforms or |
| even between interpreted vs. compiled code (as in LuaJIT). Avoid |
| passing fractional numbers to bitwise functions. Use `math.floor()` or |
| `math.ceil()` to get defined behavior. |
| - Lua provides auto-coercion of string arguments to numbers by default. This |
| behavior is deprecated for bitwise operations. |
|
|
| ============================================================================== |
| COPYRIGHT |
|
|
| Lua BitOp is Copyright (C) 2008-2012 Mike Pall. |
| Lua BitOp is free software, released under the MIT license. |
|
|
| ============================================================================== |
| vim:tw=78:ts=4:sw=4:sts=4:et:ft=help:norl: |
|
|
