bitary 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac785e04cdffcc47ba24323144ee8a7c28337fe337e5d21e3e915409e261eea9
-  data.tar.gz: 764c93d304bc84137e3e1e2af4db62411503e65a14a397330b04d4eaa3b209d8
+  metadata.gz: ee481b52a264fe1e578b65f0228e9a9c6e4eb57a7fa7fb224fb4c1dd31d60f0c
+  data.tar.gz: 2529e365b65266446aace9bce47369f49615869c4c4ab6ffe134b90c61422535
 SHA512:
-  metadata.gz: de516b045c571f67e33cc9d377c6602837edfc70fd0191c18edd0ff7777e37acafce24fb5e104c54f0ab4ea6f21dd20e40b3693cd560c658089b401f9323b635
-  data.tar.gz: b826149418b68db29efe5a9a87ccfbe287ccfc3e8632da8abd8e834ea622561dddb3250fdf69de5b9519daee02fb67e4f246ce8bca348d8b19fdb6261468ff94
+  metadata.gz: 1b549423b7cbe533c07fc54b5a4f938612889508703530336b048206f4681356fbbcb04065b7d04a887ed3f03db6ad6cb94538a4b047a6e2e7eeb4904d0af5f9
+  data.tar.gz: 4e4831d9dcb860c06067ca92e63b41d81ac90e0d3e7aa2f0ddfd48f80f8b8352bf77c6cedbc8b5002285d29f2c6c33b9e96b1456175b1a7ebb41a272a015ce87

data/README.md

@@ -24,10 +24,8 @@ Documentation still needs to be written, but here is a breakdown
 of the main capabilities brought by the current bit array implementation:
 
 ```ruby
-include Bitary
-
-bit_array_sz = BitArray.new(128) # give an explicit size. Defaults to 64 bits used per item
-bit_array_ar = BitArray.new(
+bit_array_sz = Bitary.new(128) # give an explicit size. Defaults to 64 bits used per item
+bit_array_ar = Bitary.new(
   [255, 10, 20],
   bits_per_item: 8
 ) # create based on some integer array
@@ -53,18 +51,18 @@ bit_array_sz.each_byte do |byte|
 end
 
 # convert
-bit_array_ar.to_a # [255, 10, 20]
-bit_array_ar.to_s # "11111111 00001010 00010100"
+bit_array_ar.to_a # [127, 10, 20]
+bit_array_ar.to_s # "01111111 00001010 00010100"
 
 # increase/decrease bits used per item
 bit_array_ar.bits_per_item = 64
-bit_array_ar.to_a # [16_714_260]
-bit_array_ar.to_s # "0000000000000000000000000000000000000000111111110000101000010100"
+bit_array_ar.to_a # [8_325_652]
+bit_array_ar.to_s # "0000000000000000000000000000000000000000011111110000101000010100"
 
 bit_array_sz.bits_per_item # 64
 bit_array_sz.to_a # [1_099_511_627_776, 0]
 bit_array_sz.bits_per_item = 32
-bit_array_sz.to_a # [256, 0, 0, 1]
+bit_array_sz.to_a # [256, 0, 0, 0]
 ```
 
 ## Development

data/lib/bitary/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module Bitary
-  VERSION = '0.1.0'
+class Bitary
+  VERSION = '0.1.1'
 end

data/lib/bitary.rb

@@ -2,170 +2,168 @@
 
 require_relative 'bitary/version'
 
-module Bitary
-  class BitArray
-    attr_reader :size, :bits_per_item
+class Bitary
+  attr_reader :size, :bits_per_item
 
-    def initialize(initial_data, bits_per_item: 64)
-      raise ArgumentError unless [8, 16, 32, 64].include?(bits_per_item)
+  def initialize(initial_data, bits_per_item: 64)
+    raise ArgumentError unless [8, 16, 32, 64].include?(bits_per_item)
 
-      @size = init_size(initial_data, bits_per_item)
-      @internal_array = init_internal_array(initial_data, @size, bits_per_item)
-      @bits_per_item = bits_per_item
-    end
-
-    def [](index)
-      raise IndexError if index.negative? || index >= @size
+    @size = init_size(initial_data, bits_per_item)
+    @internal_array = init_internal_array(initial_data, @size, bits_per_item)
+    @bits_per_item = bits_per_item
+  end
 
-      item_index = compute_item_index(index)
-      item_bit_size = compute_item_bit_size(item_index)
-      offset = compute_relative_offset(index, item_bit_size)
+  def [](index)
+    raise IndexError if index.negative? || index >= @size
 
-      get_bit(@internal_array[item_index], offset)
-    end
+    item_index = compute_item_index(index)
+    item_bit_size = compute_item_bit_size(item_index)
+    offset = compute_relative_offset(index, item_bit_size)
 
-    def []=(index, value)
-      raise IndexError if index.negative? || index >= @size
-
-      bit = map_to_bit(value)
-      item_index = compute_item_index(index)
-      item_bit_size = compute_item_bit_size(item_index)
-      offset = compute_relative_offset(index, item_bit_size)
-
-      @internal_array[item_index] =
-        if bit == 1
-          set_bit(@internal_array[item_index], offset)
-        else
-          unset_bit(
-            @internal_array[item_index],
-            offset,
-            item_bit_size
-          )
-        end
-    end
+    get_bit(@internal_array[item_index], offset)
+  end
 
-    def each_byte(&proc)
-      res = decrease_items_size(@internal_array, 8, @bits_per_item)
-      proc ? res.each { |byte| proc.call(byte) } : res.each
-    end
+  def []=(index, value)
+    raise IndexError if index.negative? || index >= @size
 
-    def to_a
-      @internal_array.clone
-    end
+    bit = map_to_bit(value)
+    item_index = compute_item_index(index)
+    item_bit_size = compute_item_bit_size(item_index)
+    offset = compute_relative_offset(index, item_bit_size)
 
-    def to_s
-      @internal_array.map do |item|
-        format("%0#{@bits_per_item}d", item.to_s(2))
-      end.join(' ')
-    end
+    @internal_array[item_index] =
+      if bit == 1
+        set_bit(@internal_array[item_index], offset)
+      else
+        unset_bit(
+          @internal_array[item_index],
+          offset,
+          item_bit_size
+        )
+      end
+  end
 
-    def bits_per_item=(value)
-      raise ArgumentError unless [8, 16, 32, 64].include?(value)
+  def each_byte(&proc)
+    res = decrease_items_size(@internal_array, 8, @bits_per_item)
+    proc ? res.each { |byte| proc.call(byte) } : res.each
+  end
 
-      @internal_array =
-        if value > @bits_per_item
-          increase_items_size(@internal_array, value, @bits_per_item)
-        else
-          decrease_items_size(@internal_array, value, @bits_per_item)
-        end
+  def to_a
+    @internal_array.clone
+  end
 
-      @bits_per_item = value
-    end
+  def to_s
+    @internal_array.map do |item|
+      format("%0#{@bits_per_item}d", item.to_s(2))
+    end.join(' ')
+  end
 
-    private
+  def bits_per_item=(value)
+    raise ArgumentError unless [8, 16, 32, 64].include?(value)
 
-    def init_size(initial_data, bits_per_item)
-      if initial_data.is_a?(Array)
-        bits_per_item * initial_data.length
+    @internal_array =
+      if value > @bits_per_item
+        increase_items_size(@internal_array, value, @bits_per_item)
       else
-        initial_data
+        decrease_items_size(@internal_array, value, @bits_per_item)
       end
-    end
 
-    def init_internal_array(initial_data, size, bits_per_item)
-      res = [0] * (size / bits_per_item.to_f).ceil
-      initial_data.is_a?(Array) ? initial_data.clone : res
-    end
+    @bits_per_item = value
+  end
 
-    def map_to_bit(value)
-      if value
-        if value.is_a?(Integer)
-          value.zero? ? 0 : 1
-        else
-          1
-        end
-      else
-        0
-      end
+  private
+
+  def init_size(initial_data, bits_per_item)
+    if initial_data.is_a?(Array)
+      bits_per_item * initial_data.length
+    else
+      initial_data
     end
+  end
+
+  def init_internal_array(initial_data, size, bits_per_item)
+    res = [0] * (size / bits_per_item.to_f).ceil
+    initial_data.is_a?(Array) ? initial_data.clone : res
+  end
 
-    def compute_item_bit_size(index)
-      if index == @internal_array.length - 1
-        size - ((@internal_array.length - 1) * @bits_per_item)
+  def map_to_bit(value)
+    if value
+      if value.is_a?(Integer)
+        value.zero? ? 0 : 1
       else
-        @bits_per_item
+        1
       end
+    else
+      0
     end
+  end
 
-    def compute_item_index(index)
-      index / @bits_per_item
+  def compute_item_bit_size(index)
+    if index == @internal_array.length - 1
+      size - ((@internal_array.length - 1) * @bits_per_item)
+    else
+      @bits_per_item
     end
+  end
 
-    def compute_relative_offset(index, size)
-      size - (index % @bits_per_item) - 1
-    end
+  def compute_item_index(index)
+    index / @bits_per_item
+  end
 
-    def set_bit(value, offset)
-      value | (2**offset)
-    end
+  def compute_relative_offset(index, size)
+    size - (index % @bits_per_item) - 1
+  end
 
-    def unset_bit(value, offset, size)
-      value & (((2**size) - 1) - (2**offset))
-    end
+  def set_bit(value, offset)
+    value | (2**offset)
+  end
 
-    def get_bit(value, offset)
-      (value >> offset) & 0x1
-    end
+  def unset_bit(value, offset, size)
+    value & (((2**size) - 1) - (2**offset))
+  end
 
-    def append_bits(value, offset, bits)
-      (value << offset) | bits
-    end
+  def get_bit(value, offset)
+    (value >> offset) & 0x1
+  end
 
-    def increase_items_size(array, new_size, bpi)
-      processed_bits = 0
-      array.each_with_object([0]) do |item, acc|
-        offset = bpi
-        if processed_bits >= new_size
-          offset = 0
-          acc << 0
-          processed_bits = 0
-        end
-
-        acc[-1] = append_bits(acc[-1], offset, item)
-        processed_bits += bpi
-      end
-    end
+  def append_bits(value, offset, bits)
+    (value << offset) | bits
+  end
 
-    def decrease_items_size(array, new_size, bpi)
-      array.each_with_object([]) do |item, acc|
-        acc.concat(explode_item(item, new_size, bpi))
+  def increase_items_size(array, new_size, bpi)
+    processed_bits = 0
+    array.each_with_object([0]) do |item, acc|
+      offset = bpi
+      if processed_bits >= new_size
+        offset = 0
+        acc << 0
+        processed_bits = 0
       end
+
+      acc[-1] = append_bits(acc[-1], offset, item)
+      processed_bits += bpi
     end
+  end
 
-    def explode_item(item, new_size, bpi)
-      res = []
-      offset = bpi
-      mask = (2**new_size) - 1
+  def decrease_items_size(array, new_size, bpi)
+    array.each_with_object([]) do |item, acc|
+      acc.concat(explode_item(item, new_size, bpi))
+    end
+  end
 
-      while offset.positive?
-        offset -= new_size
-        res << ((item >> offset) & mask)
-      end
+  def explode_item(item, new_size, bpi)
+    res = []
+    offset = bpi
+    mask = (2**new_size) - 1
 
-      res
+    while offset.positive?
+      offset -= new_size
+      res << ((item >> offset) & mask)
     end
 
-    alias at []
-    alias set []=
+    res
   end
+
+  alias at []
+  alias set []=
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bitary
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Maximilien Ballesteros