Method: Radix::Integer#code

Defined in:: lib/radix/integer.rb,
lib/radix/integer.rb
#code ⇒ `Array<String>`^? (readonly)

Base encoding table.
Returns:
(Array<String>, nil) —

Substitution chars or nil if default.
# File 'lib/radix/integer.rb', line 15

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)
    @base, @code = parse_base(base)
    @value = parse_value(value, @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
Method: Radix::Integer#code

#code ⇒ Array<String>? (readonly)

#code ⇒ `Array<String>`^? (readonly)
