struct BitArray
Overview
BitArray is an array data structure that compactly stores bits.
Bits externally represented as Bool
s are stored internally as
UInt32
s. The total number of bits stored is set at creation and is
immutable.
BitArray
includes all the methods in Enumerable
.
Example
require "bit_array"
ba = BitArray.new(12) # => "BitArray[000000000000]"
ba[2] # => false
0.upto(5) { |i| ba[i*2] = true }
ba # => "BitArray[101010101010]"
ba[2] # => true
Included Modules
Defined in:
bit_array.crClass Method Summary
-
.new(size, initial : Bool = false)
Create a new BitArray of
#size
bits.
Instance Method Summary
-
#[]=(index, value : Bool)
Sets the bit at the given index.
-
#inspect(io : IO)
Creates a string representation of self.
-
#invert
Inverts all bits in the array.
-
#size : Int32
The number of bits the BitArray stores
-
#to_s(io : IO)
Creates a string representation of self.
-
#to_slice : Slice(UInt8)
Returns a Slice(UInt8) able to read and write bytes from a buffer.
-
#toggle(index)
Toggles the bit at the given index.
- #unsafe_at(index : Int)
Instance methods inherited from module Indexable({"T", T})
[](index : Int)
[],
[]?(index : Int)
[]?,
at(index : Int)at(index : Int, &block) at, bsearch(&block) bsearch, bsearch_index(&block) bsearch_index, each(&block)
each each, each_index
each_index(&block) each_index, empty? empty?, equals?(other, &block) equals?, first(&block)
first first, first? first?, hash hash, index(object, offset : Int = 0)
index(offset : Int = 0, &block) index, last
last(&block) last, last? last?, reverse_each(&block)
reverse_each reverse_each, rindex(value, offset = size - 1)
rindex(offset = size - 1, &block) rindex, sample(random = Random::DEFAULT) sample, size size, unsafe_at(index : Int) unsafe_at, values_at(*indexes : Int) values_at
Instance methods inherited from module Iterable
cyclecycle(n) cycle, each each, each_cons(count : Int) each_cons, each_slice(count : Int) each_slice, each_with_index(offset = 0) each_with_index, each_with_object(obj) each_with_object
Instance methods inherited from module Enumerable({"T", T})
all?all?(&block) all?, any?
any?(&block) any?, compact_map(&block) compact_map, count(item)
count(&block) count, cycle(&block)
cycle(n, &block) cycle, each(&block : T -> _) each, each_cons(count : Int, &block) each_cons, each_slice(count : Int, &block) each_slice, each_with_index(offset = 0, &block) each_with_index, each_with_object(obj, &block) each_with_object, find(if_none = nil, &block) find, first
first(count : Int) first, first? first?, flat_map(&block : T -> Array(U)) forall U flat_map, grep(pattern) grep, group_by(&block : T -> U) forall U group_by, in_groups_of(size : Int, filled_up_with : U = nil, &block) forall U
in_groups_of(size : Int, filled_up_with : U = nil) forall U in_groups_of, includes?(obj) includes?, index(obj)
index(&block) index, index_by(&block : T -> U) forall U index_by, join(separator = "")
join(separator, io, &block)
join(separator = "", &block)
join(separator, io) join, map(&block : T -> U) forall U map, map_with_index(&block : T, Int32 -> U) map_with_index, max max, max? max?, max_by(&block : T -> U) forall U max_by, max_by?(&block : T -> U) forall U max_by?, max_of(&block : T -> U) forall U max_of, max_of?(&block : T -> U) forall U max_of?, min min, min? min?, min_by(&block : T -> U) forall U min_by, min_by?(&block : T -> U) forall U min_by?, min_of(&block : T -> U) forall U min_of, min_of?(&block : T -> U) forall U min_of?, minmax minmax, minmax? minmax?, minmax_by(&block : T -> U) forall U minmax_by, minmax_by?(&block : T -> U) forall U minmax_by?, minmax_of(&block : T -> U) forall U minmax_of, minmax_of?(&block : T -> U) forall U minmax_of?, none?(&block)
none? none?, one?(&block) one?, partition(&block) partition, product(initial : Number, &block)
product
product(initial : Number)
product(&block) product, reduce(memo, &block)
reduce(&block) reduce, reject(&block : T -> ) reject, select(&block : T -> ) select, size size, skip(count : Int) skip, skip_while(&block) skip_while, sum
sum(initial)
sum(&block)
sum(initial, &block) sum, take_while(&block) take_while, to_a to_a, to_h to_h, to_set to_set
Instance methods inherited from struct Struct
==(other : self) : Bool
==,
hash : Int32
hash,
inspect(io : IO) : Nil
inspect,
to_s(io)
to_s
Instance methods inherited from struct Value
==(other)
==,
dup
dup
Instance methods inherited from class Object
!=(other)
!=,
!~(other)
!~,
==(other)
==,
===(other)===(other : YAML::Any)
===(other : JSON::Any) ===, =~(other) =~, class class, crystal_type_id crystal_type_id, dup dup, hash hash, inspect(io : IO)
inspect inspect, itself itself, not_nil! not_nil!, tap(&block) tap, to_json to_json, to_pretty_json(indent : String = " ")
to_pretty_json(io : IO, indent : String = " ") to_pretty_json, to_s
to_s(io : IO) to_s, to_yaml
to_yaml(io : IO) to_yaml, try(&block) try
Class methods inherited from class Object
==(other : Class)
==,
===(other)
===,
cast(other) : self
cast,
clone
clone,
dup
dup,
from_json(string_or_io) : selffrom_json(string_or_io, root : String) : self from_json, from_yaml(string : String) : self from_yaml, hash hash, inspect(io) inspect, name : String name, nilable? nilable?, to_s(io) to_s, |(other : U.class) forall U |
Class Method Detail
Create a new BitArray of #size
bits.
initial
optionally sets the starting value, true or false, for all bits
in the array.
Instance Method Detail
Sets the bit at the given index.
Negative indices can be used to start counting from the end of the array.
Raises IndexError
if trying to access a bit outside the array's range.
ba = BitArray.new(5)
ba[3] = true
Creates a string representation of self.
ba = BitArray.new(5)
puts ba.to_s #=> "BitArray[00000]"
Inverts all bits in the array. Falses become true and vice versa.
ba = BitArray.new(5)
ba[2] = true; ba[3] = true
ba # => BitArray[00110]
ba.invert
ba # => BitArray[11001]
Creates a string representation of self.
ba = BitArray.new(5)
puts ba.to_s #=> "BitArray[00000]"
Returns a Slice(UInt8) able to read and write bytes from a buffer.
The slice will be long enough to hold all the bits groups in bytes despite the UInt32
internal representation.
It's useful for reading and writing a bit array from a byte buffer directly.
Toggles the bit at the given index. A false bit becomes a true bit, and
vice versa.
Negative indices can be used to start counting from the end of the array.
Raises IndexError
if trying to access a bit outside the array's range.
ba = BitArray.new(5)
ba[3] # => false
ba.toggle(3)
ba[3] # => true