Creates a newBitArray ofsize bits.

initial optionally sets the starting value,true orfalse, for all bits in the array.

Creates a newBitArray ofsize bits and invokes the given block once for each index ofself, setting the bit at that index totrue if the block is truthy.

BitArray.new(5) { |i| i >= 3 }     # => BitArray[00011]
BitArray.new(6) { |i| i if i < 2 } # => BitArray[110000]

Returns count or less (if there aren't enough) elements starting at the given start index.

Negative indices count backward from the end of the array (-1 is the last element). Additionally, an empty array is returned when the starting index for an element range is at the end of the array.

RaisesIndexError if the starting index is out of range.

require "bit_array"

ba = BitArray.new(5)
ba[0] = true; ba[2] = true; ba[4] = true
ba # => BitArray[10101]

ba[-3, 3] # => BitArray[101]
ba[6, 1]  # raise indexError
ba[1, 2]  # => BitArray[01]
ba[5, 1]  # => BitArray[]

Returns all elements that are within the given range.

Negative indices count backward from the end of the array (-1 is the last element). Additionally, an empty array is returned when the starting index for an element range is at the end of the array.

RaisesIndexError if the starting index is out of range.

require "bit_array"

ba = BitArray.new(5)
ba[0] = true; ba[2] = true; ba[4] = true
ba # => BitArray[10101]

ba[1..3]    # => BitArray[010]
ba[4..7]    # => BitArray[1]
ba[6..10]   # raise IndexError
ba[5..10]   # => BitArray[]
ba[-2...-1] # => BitArray[0]

Sets the givenvalue at the givenindex. Returnsvalue.

Negative indices can be used to start counting from the end of the container. RaisesIndexError if trying to set an element outside the container's range.

ary = [1, 2, 3]
ary[0] = 5
ary # => [5, 2, 3]

ary[3] = 5 # raises IndexError

Returnstrue if all of the elements of the collection are truthy.

[nil, true, 99].all? # => false
[15].all?            # => true

Returnstrue if at least one of the collection's members is truthy.

[nil, true, 99].any? # => true
[nil, false].any?    # => false
([] of Int32).any?   # => false

• #present? does not consider truthiness of elements.
• #any?(&) and#any(pattern) allow custom conditions.

NOTE #any? usually has the same semantics as#present?. They only differ if the element type can be falsey (i.e.T <= Nil || T <= Pointer || T <= Bool). It's typically advised to prefer#present? unless these specific truthiness semantics are required.

Returns the number of times thatitem is present in the bit array.

ba = BitArray.new(12, true)
ba[3] = false
ba[7] = false
ba.count(true)  # => 10
ba.count(false) # => 2

Returns a newBitArray with all of the same elements.

Replacescount or less (if there aren't enough) elements starting at the givenstart index withvalue. Returnsself.

Negative values ofstart count from the end of the container.

RaisesIndexError if thestart index is out of range.

RaisesArgumentError ifcount is negative.

array = [1, 2, 3, 4, 5]
array.fill(9, 2, 2) # => [1, 2, 9, 9, 5]
array               # => [1, 2, 9, 9, 5]

Replaces every element inself with the givenvalue. Returnsself.

array = [1, 2, 3, 4]
array.fill(2) # => [2, 2, 2, 2]
array         # => [2, 2, 2, 2]

SeeObject#hash(hasher)

Returnstrue if the collection containsobj,false otherwise.

ba = BitArray.new(8, true)
ba.includes?(true)  # => true
ba.includes?(false) # => false

Returns the index of the first appearance ofobj inself starting from the givenoffset, ornil if the value is not inself.

ba = BitArray.new(16)
ba[5] = ba[11] = true
ba.index(true)             # => 5
ba.index(true, offset: 8)  # => 11
ba.index(true, offset: 12) # => nil

Creates a string representation ofself.

require "bit_array"

ba = BitArray.new(5)
ba.to_s # => "BitArray[00000]"

Inverts all bits in the array. Falses becometrue and vice versa.

require "bit_array"

ba = BitArray.new(5)
ba[2] = true; ba[3] = true
ba # => BitArray[00110]
ba.invert
ba # => BitArray[11001]

Returnstrue if all of the elements of the collection are falsey.

[nil, false].none?       # => true
[nil, false, true].none? # => false

It's the opposite of#all?.

Returnstrue if only one element in this enumerable is truthy.

[1, false, false].one? # => true
[1, false, 3].one?     # => false
[1].one?               # => true
[false].one?           # => false

Reverses in-place all the elements ofself. Returnsself.

Returns the index of the last appearance ofobj inself, or nil ifobj is not inself.

Ifoffset is given, the search starts from that index towards the first elements inself.

ba = BitArray.new(16)
ba[5] = ba[11] = true
ba.rindex(true)            # => 11
ba.rindex(true, offset: 8) # => 5
ba.rindex(true, offset: 4) # => nil

Shifts all elements ofself to the leftn times. Returnsself.

a1 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a2 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
a3 = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

a1.rotate!
a2.rotate!(1)
a3.rotate!(3)

a1 # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
a2 # => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
a3 # => [3, 4, 5, 6, 7, 8, 9, 0, 1, 2]

The number of bits the BitArray stores

Tallies the collection. Accepts ahash to count occurrences. The value corresponding to each element must be an integer. The number of occurrences is added to each value inhash, andhash is returned.

hash = {} of Char => Int32
words = ["crystal", "ruby"]
words.each { |word| word.chars.tally(hash) }
hash # => {'c' => 1, 'r' => 2, 'y' => 2, 's' => 1, 't' => 1, 'a' => 1, 'l' => 1, 'u' => 1, 'b' => 1}

Tallies the collection. Returns a hash where the keys are the elements and the values are numbers of elements in the collection that correspond to the key.

["a", "b", "c", "b"].tally # => {"a"=>1, "b"=>2, "c"=>1}

Creates a string representation ofself.

require "bit_array"

ba = BitArray.new(5)
ba.to_s # => "BitArray[00000]"

Returns aBytes able to read and write bytes from a buffer. The slice will be long enough to hold all the bits groups in bytes despite theUInt32 internal representation. It's useful for reading and writing a bit array from a byte buffer directly.

WARNING It is undefined behaviour to set any of the unused bits of a bit array to true via a slice.

Togglescount or less (if there aren't enough) bits starting at the given start index. Afalse bit becomes atrue bit, and vice versa.

Negative indices count backward from the end of the array (-1 is the last element).

RaisesIndexError ifindex is out of range. RaisesArgumentError ifcount is a negative number.

require "bit_array"

ba = BitArray.new(5)
ba.to_s # => "BitArray[00000]"
ba.toggle(1, 3)
ba.to_s # => "BitArray[01110]"

Toggles all bits that are within the givenrange. Afalse bit becomes a true bit, and vice versa.

Negative indices count backward from the end of the array (-1 is the last element).

RaisesIndexError if the starting index is out of range.

require "bit_array"

ba = BitArray.new(5)
ba.to_s # => "BitArray[00000]"
ba.toggle(1..-2)
ba.to_s # => "BitArray[01110]"

Toggles the bit at the givenindex. Afalse bit becomes atrue bit, and vice versa.

Negative indices count backward from the end of the array (-1 is the last element).

RaisesIndexError ifindex is out of range.

require "bit_array"

ba = BitArray.new(5)
ba[3] # => false
ba.toggle(3)
ba[3] # => true

Returns the element at the givenindex, without doing any bounds check.

Indexable makes sure to invoke this method withindex in0...size, so converting negative indices to positive ones is not needed here.

Clients never invoke this method directly. Instead, they access elements with#[](index) and#[]?(index).

This method should only be directly invoked if you are absolutely sure the index is in bounds, to avoid a bounds check for a small boost of performance.

Sets the element at the givenindex tovalue, without doing any bounds check.

Indexable::Mutable makes sure to invoke this method withindex in 0...size, so converting negative indices to positive ones is not needed here.

Clients never invoke this method directly. Instead, they modify elements with#[]=(index, value).

This method should only be directly invoked if you are absolutely sure the index is in bounds, to avoid a bounds check for a small boost of performance.