radix-firstbanco 2.2.0

data/lib/radix/integer.rb

@@ -0,0 +1,466 @@
+require 'radix/numeric'
+
+module Radix
+
+  ##
+  # Advanced integer class for Radix conversions and mathematical operations
+  # with other bases. 
+  #
+  # @!attribute [r] value 
+  #   @return [Fixnum] Integer's decimal value.
+  # @!attribute [r] base
+  #   @return [Fixnum] The base level of Integer instance.
+  # @!attribute [r] code 
+  #   @return [Array<String>, nil] Substitution chars or nil if default.
+  class Integer < Numeric
+
+    ##
+    # Stores the numeric value as normal number.
+    #
+    # @return [Fixnum] Integer's decimal value.
+    attr :value
+
+    ##
+    # Base of the number.
+    #
+    # @return [Fixnum] The base level of Integer instance.
+    attr :base
+
+    ##
+    # Base encoding table.
+    #
+    # @return [Array<String>, nil] Substitution chars or nil if default.
+    attr :code
+
+    private
+
+    ##
+    # Starts a new instance of the Radix::Integer class
+    #
+    # @param [Radix::Numeric, Numeric, Array, String] value
+    #   The value of the new integer in context of base.
+    #
+    # @param [Fixnum, Array<String>] base The base context in which value is
+    #   determined. Can be an array of characters to use in place of default.
+    #
+    # @return [void]
+    def initialize(value, base=10)
+      @value = parse_value(value, base)
+      @base, @code = parse_base(base)
+    end
+
+    ##
+    # Takes a Radix::Numeric, String or array and returns the decimal value for
+    # storage in @value.
+    #
+    # @param [Radix::Numeric, Numeric, String, Array<Numeric, String>] value
+    #   The value of the integer in base context.
+    #
+    # @param [Fixnum, Array<String>] base
+    #   The context base of value.
+    #
+    # @return [Fixnum] Decimal value of Integer.
+    def parse_value(value, base)
+      case value
+      when Integer, Float # Radix
+        parse_numeric(value.to_i, base)
+      when ::Array
+        parse_array(value, base)
+      when ::String
+        parse_string(value, base)
+      when ::Numeric
+        parse_numeric(value, base)
+      end
+    end
+
+    ##
+    # Take an Array in the form of [..., d2, d1, d0] and convert it to
+    # base ten, and store in @value.
+    #
+    # @note If a float style array is passed in for +value+, e.g. [9, '.', 5],
+    #       the fractional part will simply be truncated.
+    #
+    # @param [Array<String, Numeric>] value Given value.
+    #
+    # @param [Fixnum, Array<String>] base Desired base.
+    #
+    # @return [Fixnum] Decimal version of array value in base context.
+    def parse_array(value, base)
+      if i = value.index(DOT)
+        value = [0...i]
+      end
+      super(value, base)
+    end
+
+    ## digits << #Radix.convert(d, base, 10).to_i
+
+    public
+
+
+    ##
+    # Makes this Radix::Integer a ruby integer.
+    # 
+    # @return [Fixnum] Base(10) value.
+    def to_i
+      value.to_i #(sign + convert(10).digits.join('')).to_i
+    end
+
+    alias :to_int :to_i
+
+    ##
+    # Makes this Radix::Integer a ruby float.
+    # 
+    # @return [Float] Base(10) value as float.
+    def to_f
+      value.to_f #(sign + convert(10).digits.join('')).to_f
+    end
+
+    ##
+    # Makes this Radix::Integer an array using code if defined. Returns an
+    # array using default chars otherwise.
+    #
+    # @param [Fixnum] base  Desired base.
+    #
+    # @return [Array<Fixnum, String>] Current base encoded array.
+    def to_a(base=nil)
+      if base
+        convert(base).digits_encoded
+      else
+        digits_encoded
+      end
+    end
+
+    ##
+    # Creates an encoded string in desired base, with desired digit divider.
+    #
+    # @note For base 10 or less does not use a divider unless specified.
+    #
+    # @param [Fixnum, Array<String>] base
+    #   Desired base.
+    #
+    # @param [String] divider
+    #   Desired divider character(s).
+    #
+    # @return [String] Encoded string with specified divider.
+    def to_s(base=nil, divider=nil)
+      divider = divider.to_s if divider
+      if base
+        convert(base).to_s(nil, divider)
+      else
+        if code
+          digits_encoded.join(divider)
+        else
+          if @base > 10
+            digits.join(divider || DIVIDER)
+          else
+            digits.join(divider)
+          end
+        end
+      end
+    end
+
+    ##
+    # Creates a string representation of self.
+    #
+    # @return [String] String rep of self.digits and @base.
+    def inspect
+      "#{digits.join(' ')} (#{base})"
+    end
+
+    ##
+    # Returns an array representation of each column's value in decimal chars.
+    #
+    # @return [Array<String, Fixnum>] Values per column of @base as array. 
+    #   Prepended with "-" if negative.
+    def digits
+      i = base_conversion(value, base)
+      i.unshift('-') if negative?
+      i
+    end
+
+    ##
+    # Returns the encoded version of digits. 
+    #
+    # @return [Array<String>] The encoded digits. Or digits if @code exists.
+    def digits_encoded
+      base_encode(digits)
+    end
+
+    ##
+    # Returns true if the number is negative.
+    #
+    # @return [Boolean] True if negative.
+    def negative?
+      value < 0
+    end
+
+    ##
+    # Converts Integer to a new base.
+    # 
+    # @param [Fixnum, Array<String>] base
+    #   The base context in which value is determined. Can be an array
+    #   of characters to use in place of default.
+    #
+    # @return [Radix:Integer] New Integer of same value, different base.
+    def convert(base)
+      self.class.new(value, base)
+      #new_digits = Radix::Base.convert_base(digits, base, new_base)
+      #self.class.new(new_digits, new_base)
+    end
+
+    ##
+    # Addition binary operation.
+    #
+    # @param [#to_i] other
+    #
+    # @example Which operand determines the base?
+    #   > i = Radix::Integer.new(123,16)
+    #   7 11 (16)
+    #   > i2 = Radix::Integer.new(456,10)
+    #   4 5 6 (10)
+    #   > i + i2          # i is base 16 and is first operand
+    #   2 4 3 (16)        # so base of return is 16
+    #   > i2 + i          # i2 is base 10 and is first operand
+    #   5 7 9 (10)        # so base of return is 10
+    #
+    # @return [Radix::Integer] Result of arithmetic operation.
+    def +(other)
+      operation(:+, other)
+    end
+
+    ##
+    # Subtraction binary operation.
+    #
+    # @param [#to_i] other
+    #
+    # @return [Radix::Integer] Result of arithmetic operation.
+    def -(other)
+      operation(:-, other)
+    end
+
+    ##
+    # Multiplication binary operation.
+    #
+    # @param [#to_i] other
+    #
+    # @return [Radix::Integer] Result of arithmetic operation.
+    def *(other)
+      operation(:*, other)
+    end
+
+    ##
+    # Division binary operation.
+    #
+    # @param [#to_i] other
+    #
+    # @return [Radix::Integer] Result of arithmetic operation.
+    def /(other)
+      operation(:/, other)
+    end
+
+    ##
+    # Power, exponentional operation.
+    #
+    # @param [#to_i] other
+    #   The exponent by which to raise Integer.
+    #
+    # @return [Radix::Integer] Result of exponential operation.
+    def **(other)
+      operation(:**, other)
+    end
+
+    ##
+    # Modulo binary operation.
+    #
+    # @param [#to_i] other
+    #
+    # @return [Radix::Integer] Modulo result of division operation.
+    def %(other)
+      operation(:%, other)
+    end
+
+    ##
+    # Leftwise bit shift operator.
+    #
+    # @note Negative numbers will shift rightward. This will truncate bytes
+    #       that get carried past zero. 
+    #
+    # @param [#to_int] integer
+    #   The number of places to shift the bits of self.
+    #
+    # @return [Radix::Integer] The new Radix::Integer with shifted bits.
+    def <<(integer)
+      Radix::Integer.new(to_int << integer.to_int, base)
+    end
+
+    ##
+    # AND bitwise operator
+    #
+    # @param [#to_int] integer
+    #
+    # @return [Radix::Integer] The logical AND.
+    def &(integer)
+      Radix::Integer.new(to_int & integer.to_int, base)
+    end
+
+    ##
+    # Returns the absolute value of self in @base.
+    #
+    # @return [Radix::Integer] Absolute of @value.
+    def abs
+      self.class.new(value.abs, base)
+    end
+
+    ##
+    # Strict equality requires same class as well as value.
+    #
+    # @param [Object] num
+    #   Object to compare.
+    #
+    # @return [Boolean] True if class and value are equal.
+    def eql?(num)
+      self.class.equal?(num.class) && self == num
+    end
+
+    ##
+    # Simple equality requires equal values only.
+    # @todo Handle Float and Radix::Float.
+    #
+    # @param [#value] other
+    #   Any object that responds to value.
+    #
+    # @return [Boolean] True if values are equal.
+    def ==(other)
+      case other
+      when Float, Integer  # Radix
+        value == other.value
+      else
+        value == other
+      end
+    end
+
+    ##
+    # Comparitive binary operation. Very useful for sorting methods.
+    # 
+    # @param [#to_f] other The object to compare value against.
+    #
+    # @example Comparison testing
+    #   > lower = Radix::Integer.new(123,10)
+    #   1 2 3 (10)
+    #   > higher = Radix::Integer.new(456, 16)
+    #   1 12 8 (16)
+    #   > lower <=> higher
+    #   -1
+    #   > lower <=> 123
+    #   0
+    #   > higher <=> lower
+    #   1
+    #
+    # @return [Fixnum] Returns -1 for less than, 0 for equal or 1 for more than.
+    def <=>(other)
+      value <=> other.to_f  # to_num
+    end
+
+    ##
+    # Create a new Radix::Integer from value in Base-10
+    #
+    # @return [Array<Radix::Integer>] An array of the new Integer object and
+    #   self.
+    def coerce(value)
+      [Radix::Integer.new(value), self]  
+    end
+
+    private
+
+    ##
+    # Perform passed arithmetic operation.
+    #
+    # @param [#to_i] other  
+    #
+    # @example Which operand determines the base?
+    #   > i = Radix::Integer.new(123,16)
+    #   7 11 (16)
+    #   > i2 = Radix::Integer.new(456,10)
+    #   4 5 6 (10)
+    #   > i + i2          # i is base 16 and is first operand
+    #   2 4 3 (16)        # so base of return is 16
+    #   > i2 + i          # i2 is base 10 and is first operand
+    #   5 7 9 (10)        # so base of return is 10
+    #
+    # @return [Radix::Integer] Result of binary operation in @base.
+    def operation(op, other)
+      a = self.to_i
+      b = other.to_i
+      x = a.__send__(op, b)
+      self.class.new(x, base)
+    end
+
+    ##
+    # Returns the value as an array of decimal values where each column is a
+    # place of @base.
+    # 
+    # @param (see #Radix::Integer.value)
+    # @param (see #Radix::Integer.base)
+    #
+    # @return [Array<Fixnum>]
+    def base_conversion(value, base)
+      #if value < 0
+      #  @negative, value = true, value.abs
+      #end
+      i = value.abs
+
+      a = []
+      while i > 0
+        i, r = i.divmod(base)
+        a << r
+      end
+
+      # if nothing add zero
+      a << 0 if a.empty?
+
+      a.reverse
+    end
+
+  end
+
+end
+
+### Want to see the hard way to do addition?
+##
+##   def +(other)
+##     other = convert_other(other)
+##
+##     result = []
+##     index  = -1
+##     carry  = 0
+##
+##     x1 = self.digits[index]
+##     x2 = other.digits[index]
+##     while x1 or x2
+##       r = (x1||0) + (x2||0) + carry
+##       if r >= base
+##         result.unshift(r - base)
+##         carry = 1
+##       else
+##         result.unshift(r)
+##         carry = 0
+##       end
+##       index -= 1
+##       x1 = self.digits[index]
+##       x2 = other.digits[index]
+##     end
+##     result << carry if carry != 0
+##     Radix::Integer.new(result, base)
+##   end
+##
+##   def convert_other(other)
+##     case other
+##     when Radix::Integer
+##       other.convert(base)
+##     when Integer
+##       Radix::Integer.new(other, base)
+##     when String, Array
+##       Radix::Integer.new(other, base)
+##     end
+##   end
+##