Next: Introduction, Previous: (dir), Up: (dir) [Contents][Index]
This is the bit-ops Reference Manual, version 0.1, generated automatically by Declt version 2.4 "Will Decker" on Wed Jun 20 10:49:07 2018 GMT+0.
| • Introduction: | What bit-ops is all about | |
| • Systems: | The systems documentation | |
| • Modules: | The modules documentation | |
| • Files: | The files documentation | |
| • Packages: | The packages documentation | |
| • Definitions: | The symbols documentation | |
| • Indexes: | Concepts, functions, variables and data types |
In the modern Common Lisp implementations, bit-vector operation functions such as bit-and are compiled into word-size iterations where 32 or 64 bits are processed at once. However, it requires a careful handling when multiple operations are combined, e.g. for avoiding the generation of intermediate vectors by destructively modifying the existing vectors. For example,
(bit-and a (bit-and b c))
causes consing since the intermediate value (bit-and b c) is generated on the heap. This library addresses this problem as well as the scarsity of useful bit-vector functions in ANSI CL.
This section provides a review of related libraries, which I believe is important for alleviating choise paralysis.
BIT-SMASHER provides functions for converting bit-vector to/from integers, octets and hex strings. BIT-OPS does not have such conversion functions. BIT-SMASHER also provides functions for arithmetic, such as addition, subtraction, shifting. However, note that those operations are not always optimized and runs bitvec->integer->bitvec conversion each time, with possibly consing.
BITFIELD-SCHEMA provides several functions analogous to DPB and LPB for integers (GET/PUT-INTEGER). It also provides a DSL for writing accessors to bit-vectors (ala union type in C).
Example from the doc:
(defbitfield-schema tree-node (:offset offt)
(disabled-p :width 1)
(values :width 16 :count 10)
(left-child :width 24)
(right-child :width 7))
BINARY-TYPES provides DEFINE-BITFIELD and
DEFINE-BINARY-CLASS whose role is similar to BITFIELD-SCHEMA, but is for
parsing machine integers, not bit-vectors.
TRIVIAL-BIT-STREAMS
provides a buffered stream of bits. NIBBLES
provides optimized access to octet vectors, especially on SBCL by defining
several SSE VOP operations.
Compute bitwise operations using bit vector arithmetic.
BODY accepts a single form.
Within BODY, one can use variables holding bit-vectors as arguments to
bitwise operations, as well as constants 0 and 1, which maps to the bit vector filled with
0 or 1, respectively.
All bit-vectors that are involved in bitwise operations should be of the same length.
Primitive operators corresponds to ANSI CL functions: For example, (not subform) is compiled
into (bit-not subform <temporary storage>) . Following primitive operators are available:
not and andc1 andc2 eqv ior nand nor orc1 orc2 xor
Additionally, (SUBSEQ FORM OFFSET) operator evaluates FORM and
extracts its window starting from OFFSET and of the length equal to the other variables.
FORM is a regular lisp expression, not a bitwise operation, and the result may be different
from the other bit-vectors.
The final computation result is stored in a newly allocated vector, or in RESULT if specified,
in spirit similar to the optional argument of Common Lisp bit-vector functions.
The entire form returns the bit-vector which contains the result.
The compiler does various optimizations:
DEFINE-BITWISE-OPERATION.
(as-bitwise-operations ()
(and a b c))
->
(LET* ((#:LEN835 (LENGTH C)) (#:G833 (MAKE-BIT-VECTOR #:LEN835)))
(LET* ((+ZERO+ (MAKE-ZERO #:LEN835))
(+ONE+ (MAKE-ONE #:LEN835)))
(DECLARE (DYNAMIC-EXTENT +ZERO+ +ONE+))
(DECLARE (IGNORABLE +ZERO+ +ONE+))
(BIT-AND B C #:G833)
(BIT-AND A #:G833 #:G833)
#:G833))
(define-bitwise-operation if (condition then else)
`(ior (and ,condition ,then)
(andc1 ,condition ,else)))
(as-bitwise-operations (:result r)
(if a b c))
->
(LET* ((#:LEN839 (LENGTH C)) (#:G836 R))
(LET* ((+ZERO+ (MAKE-ZERO #:LEN839))
(+ONE+ (MAKE-ONE #:LEN839))
(#:G837 (MAKE-BIT-VECTOR #:LEN839)))
(DECLARE (DYNAMIC-EXTENT +ZERO+ +ONE+ #:G837))
(DECLARE (IGNORABLE +ZERO+ +ONE+))
(BIT-AND A B #:G836)
(BIT-ANDC1 A C #:G837)
(BIT-IOR #:G836 #:G837 #:G836)
#:G836))
This library is at least tested on implementation listed below:
Also, it depends on the following libraries:
Copyright (c) 2017 Masataro Asai (guicho2.71828@gmail.com)
Licensed under the LLGPL License.
Next: Modules, Previous: Introduction, Up: Top [Contents][Index]
The main system appears first, followed by any subsystem dependency.
| • The bit-ops system: |
Masataro Asai
(:git "https://github.com/guicho271828/bit-ops.git")
LLGPL
Optimized bit-vector operations
0.1
bit-ops.asd (file)
src (module)
Modules are listed depth-first from the system components tree.
| • The bit-ops/src module: |
bit-ops (system)
src/
Files are sorted by type and then listed depth-first from the systems components trees.
| • Lisp files: |
| • The bit-ops.asd file: | ||
| • The bit-ops/src/package.lisp file: | ||
| • The bit-ops/src/macros.lisp file: | ||
| • The bit-ops/src/functions.lisp file: |
Next: The bit-ops/src/package<dot>lisp file, Previous: Lisp files, Up: Lisp files [Contents][Index]
bit-ops.asd
bit-ops (system)
Next: The bit-ops/src/macros<dot>lisp file, Previous: The bit-ops<dot>asd file, Up: Lisp files [Contents][Index]
src (module)
src/package.lisp
Next: The bit-ops/src/functions<dot>lisp file, Previous: The bit-ops/src/package<dot>lisp file, Up: Lisp files [Contents][Index]
src (module)
src/macros.lisp
Previous: The bit-ops/src/macros<dot>lisp file, Up: Lisp files [Contents][Index]
src (module)
src/functions.lisp
Next: Definitions, Previous: Files, Up: Top [Contents][Index]
Packages are listed by definition order.
| • The bit-ops-asd package: | ||
| • The bit-ops package: |
Next: The bit-ops package, Previous: Packages, Up: Packages [Contents][Index]
bit-ops.asd
Previous: The bit-ops-asd package, Up: Packages [Contents][Index]
package.lisp (file)
Definitions are sorted by export status, category, package, and then by lexicographic order.
| • Exported definitions: | ||
| • Internal definitions: |
Next: Internal definitions, Previous: Definitions, Up: Definitions [Contents][Index]
| • Exported macros: | ||
| • Exported functions: |
Next: Exported functions, Previous: Exported definitions, Up: Exported definitions [Contents][Index]
Compute bitwise operations using bit vector arithmetic.
BODY accepts a single form. Within BODY, one can use variables holding bit-vectors as arguments to
bitwise operations, as well as constants 0 and 1, which maps to the bit vector filled with
0 or 1, respectively.
All bit-vectors that are involved in bitwise operations should be of the same length.
Primitive operators corresponds to ANSI CL functions: For example, (not subform) is compiled
into (bit-not subform <temporary storage>) . Following primitive operators are available:
not and andc1 andc2 eqv ior nand nor orc1 orc2 xor
Additionally, (SUBSEQ FORM OFFSET) operator evaluates FORM and
extracts its window starting from OFFSET and of the length equal to the other variables.
FORM is a regular lisp expression, not a bitwise operation, and the result may be different
from the other bit-vectors.
The final computation result is stored in a newly allocated vector, or in RESULT if specified,
in spirit similar to the optional argument of Common Lisp bit-vector functions.
The entire form returns the bit-vector which contains the result.
The compiler does various optimizations:
* Nested expressions store the results into dynamic-extent temporary vectors.
* Common subexpressions are eliminated.
* The number of temporary vectors are minimized/shared in spirit similar to register allocation.
* Macros for bitwise operations can be defined with DEFINE-BITWISE-OPERATION.
package.lisp (file)
Defines a bitwise operation that is available within AS-BITWISE-OPERATIONS macro.
Primitive operators corresponds to ANSI CL functions: For example, (not subform) is compiled
into (bit-not subform <temporary storage>) .
not and andc1 andc2 eqv ior nand nor orc1 orc2 xor
package.lisp (file)
package.lisp (file)
package.lisp (file)
Previous: Exported macros, Up: Exported definitions [Contents][Index]
if A_i=1 then B_i else C_i
functions.lisp (file)
a => b :- not a or b
functions.lisp (file)
package.lisp (file)
Previous: Exported definitions, Up: Definitions [Contents][Index]
| • Internal special variables: | ||
| • Internal functions: | ||
| • Internal conditions: | ||
| • Internal structures: | ||
| • Internal types: |
Next: Internal functions, Previous: Internal definitions, Up: Internal definitions [Contents][Index]
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
Next: Internal conditions, Previous: Internal special variables, Up: Internal definitions [Contents][Index]
Wrapper for REPLACE which follows the syntax of bit-* (The last arg is the destination).
package.lisp (file)
Automatically defined boolean function.
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
package.lisp (file)
Automatically defined getter function. When DEFAULT is supplied, the value is set automatically.
package.lisp (file)
(setf symbol-bitwise-operation) (function)
Automatically defined setter function.
package.lisp (file)
symbol-bitwise-operation (function)
Next: Internal structures, Previous: Internal functions, Up: Internal definitions [Contents][Index]
package.lisp (file)
unbound-variable (condition)
Next: Internal types, Previous: Internal conditions, Up: Internal definitions [Contents][Index]
package.lisp (file)
structure-object (structure)
op-name (function)
(setf op-name) (function)
op-inputs (function)
(setf op-inputs) (function)
op-output (function)
(setf op-output) (function)
Previous: Internal structures, Up: Internal definitions [Contents][Index]
package.lisp (file)
Previous: Definitions, Up: Top [Contents][Index]
| • Concept index: | ||
| • Function index: | ||
| • Variable index: | ||
| • Data type index: |
Next: Function index, Previous: Indexes, Up: Indexes [Contents][Index]
| Jump to: | B F L M |
|---|
| Jump to: | B F L M |
|---|
Next: Variable index, Previous: Concept index, Up: Indexes [Contents][Index]
| Jump to: | (
A B C D F M O P R S |
|---|
| Jump to: | (
A B C D F M O P R S |
|---|
Next: Data type index, Previous: Function index, Up: Indexes [Contents][Index]
| Jump to: | *
I N O S |
|---|
| Jump to: | *
I N O S |
|---|
Previous: Variable index, Up: Indexes [Contents][Index]
| Jump to: | B C O P S T U |
|---|
| Jump to: | B C O P S T U |
|---|