bitary 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ac785e04cdffcc47ba24323144ee8a7c28337fe337e5d21e3e915409e261eea9
+  data.tar.gz: 764c93d304bc84137e3e1e2af4db62411503e65a14a397330b04d4eaa3b209d8
+SHA512:
+  metadata.gz: de516b045c571f67e33cc9d377c6602837edfc70fd0191c18edd0ff7777e37acafce24fb5e104c54f0ab4ea6f21dd20e40b3693cd560c658089b401f9323b635
+  data.tar.gz: b826149418b68db29efe5a9a87ccfbe287ccfc3e8632da8abd8e834ea622561dddb3250fdf69de5b9519daee02fb67e4f246ce8bca348d8b19fdb6261468ff94

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,23 @@
+AllCops:
+  NewCops: enable
+
+Style/Documentation:
+  Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Metrics/MethodLength:
+  Max: 15
+
+Style/CaseEquality:
+  Exclude:
+    - 'spec/**/*.rb'
+
+Layout/LineLength:
+  Max: 80
+
+Style/MixinUsage:
+  Exclude:
+    - 'spec/**/*.rb'

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-03-26
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Maximilien Ballesteros
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,82 @@
+# Bitary
+
+Ruby-based implementation of the bit array data structure.
+
+It's still under development, but as of now, it implements simple and well-optimized logic allowing you to set, unset and retrieve bits.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+```bash
+$ bundle add bitary
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+$ gem install bitary
+```
+
+## Usage
+
+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(
+  [255, 10, 20],
+  bits_per_item: 8
+) # create based on some integer array
+
+bit_array_sz.bits_per_item # 64
+bit_array_ar.bits_per_item # 8
+
+bit_array_ar.size # 128
+bit_array_ar.size # 24
+
+# set/unset/get
+bit_array_sz[23] = 1 # set bit at position 23 (0-indexed)
+bit_array_sz[23] # 1
+bit_array_sz[32] # 0
+
+bit_array_ar[0] # 1
+bit_array_ar[0] = 0 # unset bit at position 0 (0-indexed)
+bit_array_ar[0] # 0
+
+# traverse
+bit_array_sz.each_byte do |byte|
+  # do something with each byte
+end
+
+# convert
+bit_array_ar.to_a # [255, 10, 20]
+bit_array_ar.to_s # "11111111 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_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]
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests and `rake rubocop` to lint your code. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/Patacode/bitary.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/lib/bitary/version.rb

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

data/lib/bitary.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require_relative 'bitary/version'
+
+module Bitary
+  class BitArray
+    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)
+
+      @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
+
+      item_index = compute_item_index(index)
+      item_bit_size = compute_item_bit_size(item_index)
+      offset = compute_relative_offset(index, item_bit_size)
+
+      get_bit(@internal_array[item_index], offset)
+    end
+
+    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
+
+    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 to_a
+      @internal_array.clone
+    end
+
+    def to_s
+      @internal_array.map do |item|
+        format("%0#{@bits_per_item}d", item.to_s(2))
+      end.join(' ')
+    end
+
+    def bits_per_item=(value)
+      raise ArgumentError unless [8, 16, 32, 64].include?(value)
+
+      @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
+
+      @bits_per_item = value
+    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 map_to_bit(value)
+      if value
+        if value.is_a?(Integer)
+          value.zero? ? 0 : 1
+        else
+          1
+        end
+      else
+        0
+      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
+
+    def compute_item_index(index)
+      index / @bits_per_item
+    end
+
+    def compute_relative_offset(index, size)
+      size - (index % @bits_per_item) - 1
+    end
+
+    def set_bit(value, offset)
+      value | (2**offset)
+    end
+
+    def unset_bit(value, offset, size)
+      value & (((2**size) - 1) - (2**offset))
+    end
+
+    def get_bit(value, offset)
+      (value >> offset) & 0x1
+    end
+
+    def append_bits(value, offset, bits)
+      (value << offset) | bits
+    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 decrease_items_size(array, new_size, bpi)
+      array.each_with_object([]) do |item, acc|
+        acc.concat(explode_item(item, new_size, bpi))
+      end
+    end
+
+    def explode_item(item, new_size, bpi)
+      res = []
+      offset = bpi
+      mask = (2**new_size) - 1
+
+      while offset.positive?
+        offset -= new_size
+        res << ((item >> offset) & mask)
+      end
+
+      res
+    end
+
+    alias at []
+    alias set []=
+  end
+end

data/sig/bitary.rbs

@@ -0,0 +1,4 @@
+module Bitary
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification
+name: bitary
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Maximilien Ballesteros
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-03-26 00:00:00.000000000 Z
+dependencies: []
+description: Ruby-based implementation of the bit array data structure
+email:
+- maxou.info@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/bitary.rb
+- lib/bitary/version.rb
+- sig/bitary.rbs
+homepage: https://github.com/Patacode/bitary
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/Patacode/bitary
+  source_code_uri: https://github.com/Patacode/bitary
+  changelog_uri: https://github.com/Patacode/bitary/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
+summary: Bit array data structure
+test_files: []