ビットベクタライブラリ (Gauche ユーザリファレンス)

11.36 `srfi-178` - ビットベクタライブラリ

Module: srfi-178

Gauche supports bitvectors as a native type, but the core library only offers a handful of primitives. This module complements the comprehensive operations on bitvectors.

The following procedures are built-in. See ビットベクタ, for the description.

bit->integer      bit->boolean
bitvector         make-bitvector     list->bitvector
bitvector?        bitvector-length
string->bitvector bitvector->string
bitvector-ref/int bitvector-ref/bool
bitvector-set!    bitvector-copy     bitvector-copy!

Constructors

Function: bitvector-unfold f length seed …

Function: bitvector-unfold-right f length seed …

[SRFI-178] {srfi-178} Creates a bitvector of length length, and fill its contents by repeatedly applying f. The procedure f must take one more than the number of seeds, and must return the same number of values. First, f is applied to the index and seed …, then its first return value (which must be a bit, i.e. 0, 1 or a boolean value) is used to initialize the first element of the bitvector, and the rest of the return value is used as the next argument to f. It is repeated length times.

While bitvector-unfold fills the bits from left to right, bitvector-unfold-right does from right to left.

(use math.prime)
(bitvector-unfold (^[index n]
                    (values (small-prime? n) (+ n 1)))
                  20 0)
  ⇒ #*00110101000101000101
(bitvector-unfold-right (^[index n]
                          (values (small-prime? n) (+ n 1)))
                        20 0)
  ⇒ #*10100010100010101100

Note: This procedure follows the protocol of vector-unfold (see R7RSベクタ), and has a different protocol from other unfold procedures (see R7RSリスト).

Function: bitvector-reverse-copy bv :optional start end

[SRFI-178] {srfi-178} Copies a bitvector bv in reverse order. Optional start and end arguments limits the range of the input.

(bitvector-reverse-copy #*10110011100011110000 4 16)
  ⇒ #*111100011100

Function: bitvector-append bv …: [SRFI-178] {srfi-178} All arguments must be bytevectors. Returns a fresh bytevector which is concatenation of all arguments.

Function: bitvector-concatenate bvs: [SRFI-178] The argument must be a list of bytevectors. Returns a fresh bytevector which is concatenation of all arguments. {srfi-178}

Function: bitvector-append-subbitvectors bv start end …: [SRFI-178] {srfi-178} The number of arguments must be a multiple of 3. Each triplet of the arguments is a bytevector followed by start and end index, specifying the input bytevector range. Returns a fresh bytevector which is concatenation of all the subvectors.

Predicates

Function: bitvector-emtpy? bv: [SRFI-178] {srfi-178} Returns #t iff bv is an empty bytevector.

Function: bitvector=? bv …: [SRFI-178] {srfi-178} Returns #t iff all the bytevectors have the same content. If there’s zero or one argument, it returns #t.

Iteration

Function: bitvector-take bv n

Function: bitvector-take-right bv n

[SRFI-178] {srfi-178} Returns a new bitvector with the first/last n bits of a bitvector bv. An error is thrown if length of bv is less than n.

In Gauche, you can also use generic (subseq bv 0 n) to take the first n bits. See シーケンスフレームワーク.

Function: bitvector-drop bv n

Function: bitvector-drop-right bv n

[SRFI-178] {srfi-178} Returns a new bitvector with bits except first/last n bits of a bitvector bv. An error is thrown if length of bv is less than n.

In Gauche, you can also use generic (subseq bv n) to drop the first n bits. See シーケンスフレームワーク.

Function: bitvector-segment bv n: [SRFI-178] {srfi-178} Slices a bitvector bv with n-bits each, and returns a list of bitvectors. If the length of bv isn’t a multiple of n, the last bitvector may be shorter.

Function: bitvector-fold/int kons knil bv1 bv2 …

Function: bitvector-fold/bool kons knil bv1 bv2 …

Function: bitvector-fold-right/int kons knil bv1 bv2 …

Function: bitvector-fold-right/bool kons knil bv1 bv2 …

[SRFI-178] {srfi-178} Fold kons over the elements of bitvectors with knil as the initial state value.

The kons procedure is always called as (kons state e1 e2 …), where e1 e2 … are elements from each bitvectors, as integer 0/1 (for /int procdures) or boolean #f/#t (for /bool procedures). This is the same order as vector-fold in scheme.vector module (see R7RSベクタ). (Note that list fold procedure calls the knil procedure with different order; see リストをたどる手続き).