bitary 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ac785e04cdffcc47ba24323144ee8a7c28337fe337e5d21e3e915409e261eea9
-  data.tar.gz: 764c93d304bc84137e3e1e2af4db62411503e65a14a397330b04d4eaa3b209d8
+  metadata.gz: 80cd57b662219349dc57edd47612599f95f5aeca086dbec30af067adb10fe587
+  data.tar.gz: dc630c61a13c74a20e3472a90f244dd995f4c7196fb6146ca15973efe02e310d
 SHA512:
-  metadata.gz: de516b045c571f67e33cc9d377c6602837edfc70fd0191c18edd0ff7777e37acafce24fb5e104c54f0ab4ea6f21dd20e40b3693cd560c658089b401f9323b635
-  data.tar.gz: b826149418b68db29efe5a9a87ccfbe287ccfc3e8632da8abd8e834ea622561dddb3250fdf69de5b9519daee02fb67e4f246ce8bca348d8b19fdb6261468ff94
+  metadata.gz: 9adf435f35e798c71a3a81213f408da0c178b2d3137ecae3619c84e3c95d564e060a4985d24a4746b93a0fb8e2d73fc4a209a38908c7dad25d87dfd728e575da
+  data.tar.gz: a6f136e8e5f140ad9455c14b13d94232d40bfc37e09e62b6827857888d03dacbc53fb027a9da1901dfa2d2f966144680a3e2d0a5dd57c4af563d4bd09af99326

data/CHANGELOG.md

@@ -1,5 +1,10 @@
-## [Unreleased]
+## [0.1.1] - 2024-03-26
+
+- Change root namespace to a class, instead of a module
 
 ## [0.1.0] - 2024-03-26
 
 - Initial release
+- Basic implementation to set/unset/get bits from the bit array
+- Ability to traverse each byte of the structure
+- Increase/decrease the number of bits used internally per element

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/handler/append.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Bitary
+  class Handler
+    class Append < Bitary::Handler
+      def execute(**kwargs)
+        raise ArgumentError unless kwargs.all? do |key, _value|
+          %i[offset value].include?(key)
+        end
+
+        offset = kwargs[:offset] or raise KeyError
+        value = kwargs[:value] or raise KeyError
+        raise ArgumentError unless offset.is_a?(Integer)
+        raise ArgumentError unless value.is_a?(Integer)
+
+        (@value << offset) | value
+      end
+    end
+  end
+end

data/lib/bitary/handler/get.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Bitary
+  class Handler
+    class Get < Bitary::Handler
+      def execute(**kwargs)
+        raise ArgumentError unless kwargs.all? do |key, _value|
+          %i[index size].include?(key)
+        end
+
+        index = kwargs[:index] or raise KeyError
+        size = kwargs[:size] or raise KeyError
+        raise ArgumentError unless index.is_a?(Integer)
+        raise ArgumentError unless size.is_a?(Integer)
+
+        raise IndexError if index.negative? || index >= size
+
+        (@value >> (size - index - 1)) & 0x1
+      end
+    end
+  end
+end

data/lib/bitary/handler/set.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Bitary
+  class Handler
+    class Set < Bitary::Handler
+      def execute(**kwargs)
+        raise ArgumentError unless kwargs.all? do |key, _value|
+          %i[index size].include?(key)
+        end
+
+        index = kwargs[:index] or raise KeyError
+        size = kwargs[:size] or raise KeyError
+        raise ArgumentError unless index.is_a?(Integer)
+        raise ArgumentError unless size.is_a?(Integer)
+
+        raise IndexError if index.negative? || index >= size
+
+        @value | (2**(size - index - 1))
+      end
+    end
+  end
+end

data/lib/bitary/handler/unset.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Bitary
+  class Handler
+    class Unset < Bitary::Handler
+      def execute(**kwargs)
+        raise ArgumentError unless kwargs.all? do |key, _value|
+          %i[index size].include?(key)
+        end
+
+        index = kwargs[:index] or raise KeyError
+        size = kwargs[:size] or raise KeyError
+        raise ArgumentError unless index.is_a?(Integer)
+        raise ArgumentError unless size.is_a?(Integer)
+
+        raise IndexError if index.negative? || index >= size
+
+        @value & (((2**size) - 1) - (2**(size - index - 1)))
+      end
+    end
+  end
+end

data/lib/bitary/handler.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'handler/set'
+
+class Bitary
+  class Handler
+    attr_reader :value
+
+    def initialize(value)
+      raise ArgumentError unless value.is_a?(Integer)
+
+      @value = value
+    end
+
+    def execute(**kwargs)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/bitary/size.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Bitary
+  module Size
+    BYTE  = 8
+    SHORT = 16
+    INT   = 32
+    LONG  = 64
+  end
+end

data/lib/bitary/version.rb

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

data/lib/bitary.rb

@@ -1,171 +1,164 @@
 # frozen_string_literal: true
 
+require_relative 'bitary/size'
 require_relative 'bitary/version'
 
-module Bitary
-  class BitArray
-    attr_reader :size, :bits_per_item
+class Bitary
+  include Size
 
-    def initialize(initial_data, bits_per_item: 64)
-      raise ArgumentError unless [8, 16, 32, 64].include?(bits_per_item)
+  attr_reader :size, :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 initialize(initial_data, bits_per_item: LONG)
+    raise ArgumentError unless [BYTE, SHORT, INT, LONG].include?(bits_per_item)
 
-    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)
+    item = @internal_array[item_index]
 
-    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
+    Handler::Get.new(item).execute(
+      index: index % @bits_per_item,
+      size: item_bit_size
+    )
+  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)
+    item = @internal_array[item_index]
 
-    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
+        Handler::Set.new(item).execute(
+          index: index % @bits_per_item,
+          size: item_bit_size
+        )
+      else
+        Handler::Unset.new(item).execute(
+          index: index % @bits_per_item,
+          size: item_bit_size
+        )
+      end
+  end
 
-    def bits_per_item=(value)
-      raise ArgumentError unless [8, 16, 32, 64].include?(value)
+  def set(index)
+    self[index] = 1
+  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 unset(index)
+    self[index] = 0
+  end
 
-      @bits_per_item = value
-    end
+  def each_byte(&proc)
+    res = decrease_items_size(@internal_array, BYTE, @bits_per_item)
+    proc ? res.each { |byte| proc.call(byte) } : res.each
+  end
 
-    private
+  def to_a
+    @internal_array.clone
+  end
 
-    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 to_s
+    @internal_array.map do |item|
+      format("%0#{@bits_per_item}d", item.to_s(2))
+    end.join(' ')
+  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 bits_per_item=(value)
+    raise ArgumentError unless [BYTE, SHORT, INT, LONG].include?(value)
 
-    def map_to_bit(value)
-      if value
-        if value.is_a?(Integer)
-          value.zero? ? 0 : 1
-        else
-          1
-        end
+    @internal_array =
+      if value > @bits_per_item
+        increase_items_size(@internal_array, value, @bits_per_item)
       else
-        0
+        decrease_items_size(@internal_array, value, @bits_per_item)
       end
-    end
 
-    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
+    @bits_per_item = value
+  end
 
-    def compute_item_index(index)
-      index / @bits_per_item
-    end
+  private
 
-    def compute_relative_offset(index, size)
-      size - (index % @bits_per_item) - 1
+  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 set_bit(value, offset)
-      value | (2**offset)
-    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 unset_bit(value, offset, size)
-      value & (((2**size) - 1) - (2**offset))
+  def map_to_bit(value)
+    if value
+      if value.is_a?(Integer)
+        value.zero? ? 0 : 1
+      else
+        1
+      end
+    else
+      0
     end
+  end
 
-    def get_bit(value, offset)
-      (value >> offset) & 0x1
+  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 append_bits(value, offset, bits)
-      (value << offset) | bits
-    end
+  def compute_item_index(index)
+    index / @bits_per_item
+  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
+  def increase_items_size(array, new_size, bpi)
+    processed_bits = 0
+    array.each_with_object([0]) do |value, acc|
+      offset = bpi
+      if processed_bits >= new_size
+        offset = 0
+        acc << 0
+        processed_bits = 0
       end
-    end
 
-    def decrease_items_size(array, new_size, bpi)
-      array.each_with_object([]) do |item, acc|
-        acc.concat(explode_item(item, new_size, bpi))
-      end
+      acc[-1] = Handler::Append.new(acc[-1]).execute(offset:, value:)
+      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 []
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: bitary
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Maximilien Ballesteros
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-26 00:00:00.000000000 Z
+date: 2024-03-29 00:00:00.000000000 Z
 dependencies: []
 description: Ruby-based implementation of the bit array data structure
 email:
@@ -24,6 +24,12 @@ files:
 - README.md
 - Rakefile
 - lib/bitary.rb
+- lib/bitary/handler.rb
+- lib/bitary/handler/append.rb
+- lib/bitary/handler/get.rb
+- lib/bitary/handler/set.rb
+- lib/bitary/handler/unset.rb
+- lib/bitary/size.rb
 - lib/bitary/version.rb
 - sig/bitary.rbs
 homepage: https://github.com/Patacode/bitary