hyperint 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 16b917b6d6e3980ac82b82a2d1fd63d8a1e80357f8eae7cb91d165b0de2057ff
+  data.tar.gz: 590789dda4742539c3ac640f942b78d54efae3d5df65839a0e7bc151ad642ae3
+SHA512:
+  metadata.gz: 15d10f1f67bb90dde3a75e92670133a8b860e0e5482b36d4596cf84098bd4a150a97d5f62d409a3dcfcb18b73443a054441d725d3b684b7bd828d26817887027
+  data.tar.gz: ee69e14032cc324c50feb77996a129f7d764f825c4c1115a3f8a024d4922369e0c25339fbaa82d06f185ca980d32c4cb90aca09280ac5daf95a8dacd3b00ddfe

data/lib/hyperint/arithmetic.rb

@@ -0,0 +1,255 @@
+class HyperInt
+  def add(other)
+    check_type(other)
+
+    if zero?
+      return other.abs
+    end
+
+    if other.zero?
+      return abs
+    end
+
+    if @sign == other.sign
+      result = add_magnitudes(@digits, other.digits)
+      return build_from_digits(@sign, result)
+    end
+
+    comparison = compare_magnitudes(@digits, other.digits)
+
+    if comparison == 0
+      return HyperInt.zero
+    end
+
+    if comparison > 0
+      result = subtract_magnitudes(@digits, other.digits)
+      build_from_digits(@sign, result)
+    else
+      result = subtract_magnitudes(other.digits, @digits)
+      build_from_digits(other.sign, result)
+    end
+  end
+
+  def sub(other)
+    check_type(other)
+    add(other.negate)
+  end
+
+  def mul(other)
+    check_type(other)
+
+    return HyperInt.zero if zero? || other.zero?
+
+    result = Array.new(@digits.length + other.digits.length, 0)
+
+    @digits.each_with_index do |a, i|
+      carry = 0
+
+      other.digits.each_with_index do |b, j|
+        index = i + j
+        value = result[index] + a * b + carry
+
+        result[index] = value % BASE
+        carry = value / BASE
+      end
+
+      index = i + other.digits.length
+
+      while carry > 0
+        value = result[index] + carry
+        result[index] = value % BASE
+        carry = value / BASE
+        index += 1
+        result << 0 if index == result.length && carry > 0
+      end
+    end
+
+    sign = @sign == other.sign ? 1 : -1
+    build_from_digits(sign, result)
+  end
+
+  def div(other)
+    check_type(other)
+    raise ZeroDivisionError, "divided by 0" if other.zero?
+
+    quotient, = divide_magnitudes(@digits, other.digits)
+
+    if quotient == [0]
+      return HyperInt.zero
+    end
+
+    sign = @sign == other.sign ? 1 : -1
+    build_from_digits(sign, quotient)
+  end
+
+  def mod(other)
+    check_type(other)
+    raise ZeroDivisionError, "divided by 0" if other.zero?
+
+    _, remainder = divide_magnitudes(@digits, other.digits)
+
+    if remainder == [0]
+      return HyperInt.zero
+    end
+
+    build_from_digits(@sign, remainder)
+  end
+
+  def pow(other)
+    check_type(other)
+    raise ArgumentError, "negative exponent" if other.negative?
+
+    result = HyperInt.one
+    base = abs
+    exponent = other.abs
+    two = HyperInt.new(2)
+
+    while !exponent.zero?
+      if exponent.mod(two).equals?(HyperInt.one)
+        result = result.mul(base)
+      end
+
+      exponent = exponent.div(two)
+
+      unless exponent.zero?
+        base = base.mul(base)
+      end
+    end
+
+    if @sign < 0 && other.mod(two).equals?(HyperInt.one)
+      result.negate
+    else
+      result
+    end
+  end
+
+  private
+
+  def add_magnitudes(a, b)
+    result = []
+    carry = 0
+    length = [a.length, b.length].max
+
+    length.times do |i|
+      sum = (a[i] || 0) + (b[i] || 0) + carry
+
+      if sum >= BASE
+        sum -= BASE
+        carry = 1
+      else
+        carry = 0
+      end
+
+      result << sum
+    end
+
+    result << carry if carry > 0
+    result
+  end
+
+  def subtract_magnitudes(a, b)
+    result = []
+    borrow = 0
+
+    a.length.times do |i|
+      difference = a[i] - (b[i] || 0) - borrow
+
+      if difference < 0
+        difference += BASE
+        borrow = 1
+      else
+        borrow = 0
+      end
+
+      result << difference
+    end
+
+    result.pop while result.length > 1 && result[-1] == 0
+    result
+  end
+
+  def compare_magnitudes(a, b)
+    return 1 if a.length > b.length
+    return -1 if a.length < b.length
+
+    (a.length - 1).downto(0) do |i|
+      return 1 if a[i] > b[i]
+      return -1 if a[i] < b[i]
+    end
+
+    0
+  end
+
+  def divide_magnitudes(dividend, divisor)
+    return [[0], dividend.dup] if compare_magnitudes(dividend, divisor) < 0
+
+    quotient = Array.new(dividend.length, 0)
+    remainder = [0]
+
+    (dividend.length - 1).downto(0) do |i|
+      remainder.unshift(dividend[i])
+      normalize_digits(remainder)
+
+      low = 0
+      high = BASE - 1
+
+      while low <= high
+        middle = (low + high) / 2
+        product = multiply_magnitude_by_small(divisor, middle)
+        comparison = compare_magnitudes(product, remainder)
+
+        if comparison <= 0
+          low = middle + 1
+        else
+          high = middle - 1
+        end
+      end
+
+      digit = high
+
+      if digit > 0
+        product = multiply_magnitude_by_small(divisor, digit)
+        remainder = subtract_magnitudes(remainder, product)
+      end
+
+      quotient[i] = digit
+    end
+
+    normalize_digits(quotient)
+    normalize_digits(remainder)
+
+    [quotient, remainder]
+  end
+
+  def multiply_magnitude_by_small(digits, multiplier)
+    return [0] if multiplier == 0
+
+    result = []
+    carry = 0
+
+    digits.each do |digit|
+      value = digit * multiplier + carry
+      result << value % BASE
+      carry = value / BASE
+    end
+
+    result << carry if carry > 0
+    result
+  end
+
+  def normalize_digits(digits)
+    digits.pop while digits.length > 1 && digits[-1] == 0
+
+    digits << 0 if digits.empty?
+
+    digits
+  end
+
+  def build_from_digits(sign, digits)
+    result = HyperInt.new(0)
+    result.instance_variable_set(:@sign, sign)
+    result.instance_variable_set(:@digits, digits)
+    result.send(:normalize)
+    result
+  end
+end

data/lib/hyperint/comparison.rb

@@ -0,0 +1,36 @@
+class HyperInt
+  def equals?(other)
+    check_type(other)
+    to_i == other.to_i
+  end
+
+  def not_equals?(other)
+    !equals?(other)
+  end
+
+  def greater_than?(other)
+    check_type(other)
+    to_i > other.to_i
+  end
+
+  def greater_than_or_equal?(other)
+    check_type(other)
+    to_i >= other.to_i
+  end
+
+  def less_than?(other)
+    check_type(other)
+    to_i < other.to_i
+  end
+
+  def less_than_or_equal?(other)
+    check_type(other)
+    to_i <= other.to_i
+  end
+
+  private
+
+  def check_type(other)
+    raise TypeError, "argument must be HyperInt" unless other.is_a?(HyperInt)
+  end
+end

data/lib/hyperint/conversion.rb

@@ -0,0 +1,76 @@
+class HyperInt
+  def to_s(base = 10)
+    raise ArgumentError, "base must be between 2 and 36" unless (2..36).include?(base)
+    return "0" if zero?
+
+    value = self
+    result = +""
+
+    while !value.zero?
+      quotient, remainder = value.divide_small(base)
+      result << remainder.to_s(36)
+      value = quotient
+    end
+
+    result.reverse!
+    @sign < 0 ? "-#{result}" : result
+  end
+
+  def abs
+    copy = HyperInt.new(0)
+    copy.instance_variable_set(:@sign, @sign.abs)
+    copy.instance_variable_set(:@digits, @digits.dup)
+    copy
+  end
+
+  def negate
+    copy = HyperInt.new(0)
+    copy.instance_variable_set(:@sign, -@sign)
+    copy.instance_variable_set(:@digits, @digits.dup)
+    copy
+  end
+
+  def zero?
+    @sign == 0
+  end
+
+  def positive?
+    @sign > 0
+  end
+
+  def negative?
+    @sign < 0
+  end
+
+  def self.zero
+    new(0)
+  end
+
+  def self.one
+    new(1)
+  end
+
+  def divide_small(divisor)
+    result = []
+    remainder = 0
+
+    @digits.reverse_each do |digit|
+      current = remainder * BASE + digit
+      quotient = current / divisor
+      remainder = current % divisor
+      result << quotient
+    end
+
+    result.reverse!
+
+    while result.length > 1 && result[-1] == 0
+      result.pop
+    end
+
+    quotient = HyperInt.new(0)
+    quotient.instance_variable_set(:@sign, result == [0] ? 0 : @sign)
+    quotient.instance_variable_set(:@digits, result)
+
+    [quotient, remainder]
+  end
+end

data/lib/hyperint.rb

@@ -0,0 +1,102 @@
+require_relative "hyperint/arithmetic"
+require_relative "hyperint/comparison"
+require_relative "hyperint/conversion"
+
+class HyperInt
+  BASE = 1_000_000_000
+  BASE_DIGITS = 9
+
+  attr_reader :sign, :digits
+
+  def initialize(value, base = 10)
+    raise TypeError, "value must be an Integer or String" unless value.is_a?(Integer) || value.is_a?(String)
+    raise ArgumentError, "base must be between 2 and 36" unless (2..36).include?(base)
+
+    if value.is_a?(Integer)
+      initialize_from_integer(value)
+    else
+      initialize_from_string(value, base)
+    end
+  end
+
+  def self.from_integer(value)
+    new(value)
+  end
+
+  def to_i
+    value = 0
+
+    @digits.reverse_each do |digit|
+      value = value * BASE + digit
+    end
+
+    @sign < 0 ? -value : value
+  end
+
+  private
+  def initialize_from_integer(value)
+    @sign = value <=> 0
+
+    if value == 0
+      @digits = [0]
+      return
+    end
+
+    value = value.abs
+    @digits = []
+
+    while value > 0
+      @digits << value % BASE
+      value /= BASE
+    end
+  end
+
+  def initialize_from_string(value, base)
+    value = value.strip
+
+    negative = value.start_with?("-")
+    value = value.delete_prefix("-").delete_prefix("+")
+
+    raise ArgumentError, "invalid integer" unless value.match?(/\A[0-9a-zA-Z]+\z/)
+
+    @sign = negative ? -1 : 1
+    @digits = convert_string_to_digits(value, base)
+    normalize
+  end
+
+  def convert_string_to_digits(value, base)
+    result = [0]
+
+    value.each_char do |char|
+      digit = char.to_i(base)
+
+      raise ArgumentError, "invalid digit" if digit >= base
+
+      carry = digit
+
+      result.each_index do |i|
+        current = result[i] * base + carry
+        result[i] = current % BASE
+        carry = current / BASE
+      end
+
+      result << carry if carry > 0
+    end
+
+    result
+  end
+
+  def normalize
+    @digits.pop while @digits.length > 1 && @digits[-1] == 0
+
+    if @digits.length == 1 && @digits[0] == 0
+      @sign = 0
+    end
+  end
+
+  def check_type(other)
+    raise TypeError, "argument must be HyperInt" unless other.is_a?(HyperInt)
+  end
+
+  private :check_type
+end

metadata

@@ -0,0 +1,44 @@
+--- !ruby/object:Gem::Specification
+name: hyperint
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Araki-Tomoya
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: A large integer library implemented independently from Ruby Integer.
+email:
+- ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/hyperint.rb
+- lib/hyperint/arithmetic.rb
+- lib/hyperint/comparison.rb
+- lib/hyperint/conversion.rb
+homepage: https://github.com/rimsky-yamatov/hyperint
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.16
+specification_version: 4
+summary: Arbitrary-precision integer library for Ruby
+test_files: []