radix-firstbanco 2.2.0

data/lib/radix/numeric.rb

@@ -0,0 +1,217 @@
+require 'radix/base'
+
+module Radix
+
+  # Radix separator used in string and array representations.
+  DOT = '.'
+
+  # Division character for rational numbers
+  DIV = '/'
+
+  # Default seperator character.
+  DIVIDER = " "
+
+  ##
+  # Radix::Numeric class inherits from Ruby's Numeric class. It is then
+  # subclassed by Radix::Integer and Radix::Float.
+  #
+  # @todo Make immutable, but best way to do it?
+  # @example First suggestion
+  #   class << self
+  #     alias_method :_new, :new
+  #     private :_new
+  #   end
+  # @example Second suggestion
+  #   def self.new(value, base=10)
+  #     @cache ||= {}
+  #     @cache[[value, base]] ||= _new(value, base)
+  #   end
+  class Numeric < ::Numeric
+
+    ##
+    # Addition, binary operation.
+    #
+    # @param [Radix::Numeric] other
+    #
+    # @return [Radix::Numeric] Result of arithmetic operation.
+    def +(other)
+      operation(:+, other)
+    end
+
+    ##
+    # Subtraction, binary operation.
+    #
+    # @param [Radix::Numeric] other
+    #
+    # @return [Radix::Numeric] Result of arithmetic operation.
+    def -(other)
+      operation(:-, other)
+    end
+
+    ##
+    # Multiplication, binary operation.
+    #
+    # @param [Radix::Numeric] other
+    #
+    # @return [Radix::Numeric] Result of arithmetic operation.
+    def *(other)
+      operation(:*, other)
+    end
+
+    ##
+    # Division, binary operation.
+    #
+    # @param [Radix::Numeric] other
+    #
+    # @return [Radix::Numeric] Result of arithmetic operation.
+    def /(other)
+      operation(:/, other)
+    end
+
+    private
+
+    ##
+    # Parses the value of the base and character set to use.
+    #
+    # @param [Fixnum, Array<String>] base
+    #   The value of the base, or a set of characters to use as
+    #   representation of the base.
+    #
+    # @note If an array of String characters is passed, its length is the
+    #   value of the base level.
+    #
+    # @return [Array<(Fixnum, [Array<String>, nil])>] Two part array:
+    #   0 - Fixnum value of the base.
+    #   1 - Nil, or Array of characters representing the base values.
+    def parse_base(base)
+      case base
+       when Array
+        code = base
+        base = base.size
+      else
+        code = nil
+        base = base
+      end
+      return base, code
+    end
+
+    ##
+    # Simply returns the passed value. Used for simplifying creation of 
+    # Radix::Numeric instances.
+    # 
+    # @param [Radix::Float, Radix::Integer] value Given value.
+    # @param [Fixnum, Array<String>] base Desired base.
+    #
+    # @return [Radix::Float, Radix::Integer] The passed value.
+    def parse_numeric(value, base)
+      value
+    end
+
+    ##
+    # If a float style string is passed in for +value+, e.g. "9.5", the
+    # decimal will simply be truncated. So "9.x" would become "9".
+    # 
+    # @param [String] value
+    #   Given value.
+    #
+    # @param [Fixnum, Array<String>] base
+    #   Desired base.
+    #
+    # @return [Radix::Float, Radix::Integer] The passed value.
+    def parse_string(value, base)
+      digits = value.split(//)
+      parse_array(digits, base)
+    end
+
+    ##
+    # Take an Array in the form of [d1, d2, ..., DOT, d-1, d-2, ...]
+    # and convert it to base ten, and store in @value.
+    #
+    # @param [Array<String, Numeric>] value Given value.
+    # @param [Fixnum, Array<String>] base Desired base.
+    #
+    # @return [Fixnum] Decimal version of passed array in base context.
+    def parse_array(value, base)
+      value = value.dup
+
+      if value.first == '-'
+        neg = true
+        value.shift
+      else
+        neg = false
+      end
+
+      value = base_decode(value)
+
+      ## raise an error if any digit is not less than base
+      raise ArgumentError if value.any?{ |e| ::Numeric === e && base < e }
+
+      v = decimal(value, base)
+
+      neg ? -v : v # Returns negated v if value array.first == "-"
+    end
+
+    ##
+    # Convert array of values of a different base to decimal. This handles
+    # integer values. The method for Radix::Float is slighly different.
+    #
+    # @param [Array<Numeric, String>] digits
+    #   Representation of base values.
+    #
+    # @param [Fixnum, Array<String>] base
+    #   The base to convert from.
+    #
+    # @return [Integer] The digits of base converted to decimal.
+    def decimal(digits, base)
+      e = digits.size - 1
+      v = 0
+      digits.each do |n|
+        v += n.to_i * base**e
+        e -= 1
+      end
+      v
+    end
+
+    ##
+    # Map array of values to base encoding. If no encoding is defined
+    # this simply returns the +digits+ unchanged.
+    # 
+    # @param [Array<String, Numeric>] digits
+    #
+    # @return [Array<String, Fixnum>] Encoded digits, or digits if @code is nil
+    def base_encode(digits)
+      return digits unless @code
+      digits.map do |i|
+        case i
+        when '-', DOT, DIV
+          i
+        else
+          code[i]
+        end
+      end
+    end
+
+    ##
+    # Decode an encoded array. Defaults to BASE::B62 if self.code is not set.
+    # 
+    # @param [Array<String, Numeric>] digits The encoded characters. 
+    #
+    # @return [Array<String, Numeric>] Decoded array. 
+    def base_decode(digits)
+      #return digits unless code
+      code = self.code || BASE::B62
+      digits.map do |c|
+        case c
+        when '-', DOT, DIV
+          c
+        when ::Numeric
+          c
+        else
+          code.index(c)  # TODO: Could speed up with an reverse index.
+        end
+      end
+    end
+
+  end
+
+end

data/lib/radix/rational.rb

@@ -0,0 +1,311 @@
+require 'rational'
+require 'radix/numeric'
+
+module Radix
+
+  ##
+  # Represents rational numbers.
+  #
+  # @!attribute [r] value
+  #   @return [Rational] Ruby Rational representation of self in Base-10.
+  # @!attribute [r] base
+  #   @return [Fixnum] The base level of Rational instance.
+  # @!attribute [r] code 
+  #   @return [Array<String>, nil] Substitution chars or nil if default.
+  class Rational < Numeric
+
+    ##
+    # Alternative to #new.
+    #
+    # @return [Radix::Rational]
+    def self.[](n,d=nil,b=10)
+      new(n,d,b)
+    end
+
+    ##
+    # Stores the Rational value in Base-10.
+    #
+    # @return [Rational] 
+    attr :value
+
+    ##
+    # Base of the number.
+    #
+    # @return [Fixnum] The base level of Rational instance.
+    attr :base
+
+    ##
+    # Base encoding table.
+    #
+    # @return [Array<String>, nil] Substitution chars or nil if default.
+    attr :code
+
+    private
+
+    ##
+    # Create a new Radix::Rational instance.
+    # @example
+    #   Rational.new(<Integer>, <Integer>, <Integer>)
+    #   Rational.new(<Rational>, <Integer>)
+    # @param [Radix::Rational, ::Rational, Fixnum] numerator A rational number
+    #   or a fixnum for the numerator of a new Rational.
+    # @param [Fixnum] denominator Denominator for new Rational.
+    # @param [Fixnum] base Base level for new Rational.
+    # @return [void]
+    def initialize(numerator, denominator=nil, base=10)
+      case numerator
+      when ::Rational, Rational
+        ratn = numerator
+        base = denominator
+        @value = Rational(ratn.numerator, ratn.denominator)
+      else
+        n = parse_value(numerator, base)
+        d = parse_value(denominator, base)
+        @value = Rational(n, d)
+      end
+      @base, @code = parse_base(base)
+    end
+
+    ##
+    # Parses String, Array, Radix::Float, Radix::Integer or Ruby numerics and
+    # returns the decimal value from base context for storage in @value.
+    # 
+    # @param [Fixnum] base 
+    def parse_value(value, base)
+      case value
+      when Float, Integer # Radix
+        parse_numeric(value.to_i, base)
+      when ::Array
+        parse_array(value, base)
+      when ::String
+        parse_string(value, base)
+      when ::Numeric
+        parse_numeric(value.to_i, base)
+      end
+    end
+
+    public
+
+    ##
+    # The numerator.
+    #
+    # @return [Fixnum] The numerator of Radix::Rational
+    def numerator
+      @value.numerator
+    end
+
+    ##
+    # The denominator.
+    #
+    # @return [Fixnum] The denominator of Radix::Rational
+    def denominator
+      @value.denominator
+    end
+
+    ##
+    # Is the value negative?
+    #
+    # @return [Boolean] Returns true if value < 0.
+    def negative?
+      value < 0
+    end
+
+    ##
+    # Convert rational to new base.
+    #
+    # @param [Fixnum] base Desired base.
+    # @return [Radix::Rational] Returns new Radix::Rational in passed base.
+    def convert(base)
+      self.class.new(numerator, denominator, base)
+    end
+
+    ##
+    # Convert to rational.
+    #
+    # @return [Rational] Returns the value.
+    def to_r
+      value
+    end
+
+    ##
+    # Convert to Float by dividing the numerator by the denominator.
+    #
+    # Returns the converted value. [Float]
+    def to_f
+      numerator.to_f / denominator.to_f
+    end
+
+    ##
+    # Convert to Integer by converting to Float first then
+    # appling #to_i to the float.
+    #
+    # Returns the converted value. [Integer]
+    def to_i
+      to_f.to_i
+    end
+
+    ##
+    # Translate value into an array of places. Uses current base unless
+    # specified.
+    # 
+    # @param [Fixnum] base Desired base.
+    # @return [Array<Fixnum, String>] Array of place values.
+    def to_a(base=nil)
+      if base
+        convert(base).digits_encoded
+      else
+        digits_encoded
+      end     
+    end
+
+    ##
+    # Convert the value into a string representation of the given base.
+    #
+    # @param [Fixnum] base The base to convert.
+    # @param [String] divider The string char(s) to divided with.
+    # @return [String] Translated value.
+    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
+
+    ##
+    # Simple equality requires equal values only.
+    #
+    # @todo This may need improvement to be more percise.
+    # @param [#to_f] other The value to compare to.
+    # @return [Boolean] True if equal values.
+    def ==(other)
+      a, b = self.to_f, other.to_f
+      a == b
+    end
+
+    ##
+    # Returns an irreducible version of self in current base.
+    # 
+    # @todo Is this method neccesary since @value is a Ruby Rational and
+    #   therefore already irreducible?
+    # @return [Radix::Rational]
+    def reduce
+      self.class.new(Rational(numerator, denominator), base)
+    end
+
+    ##
+    # Returns an array representation of the numerator and denominator with
+    # each column's value.
+    #
+    # @return [Array<String, Fixnum>] Values per column of @base as array. 
+    #   Prepended with "-" if negative. 
+    def digits
+      n = base_conversion(numerator, base)
+      d = base_conversion(denominator, base)
+      i = n + ['/'] + d
+      i.unshift('-') if negative? 
+      i
+    end
+
+    ##
+    # Returns digits, or coded version of digits if @code.
+    #
+    # @return [Array<String, Fixnum>] Values per column of @base as array. 
+    #   Prepended with "-" if negative. Or encoded version if @code is
+    #   defined.
+    def digits_encoded
+      base_encode(digits)
+    end
+
+    ##
+    # Creates a string representation of self.
+    #
+    # @return [String] String rep of self.digits and @base.
+    def inspect
+      "#{digits.join(' ')} (#{base})"
+    end
+
+    ##
+    # Returns new Radix::Rational of passed value in base-10 and self as an
+    # Array.
+    # 
+    # @return [Array<(Radix::Rational, Radix::Rational)>]
+    def coerce(value)
+      [Radix::Rational.new(value), self]  
+    end
+
+    private
+
+    ##
+    # Perform passed arithmetic operation.
+    #
+    # @param [#to_r] other  
+    # @return [Radix::Rational] Returns the result of the operation in @base.
+    def operation(op, other)
+      x = value.__send__(op, other.to_r)
+      self.class.new(x, base)
+    end
+
+    ##
+    # Perform base conversion.
+    #
+    # @return [Array<Fixnum, String>] Array of places.
+    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
+
+      a << 0 if a.empty?
+
+      a.reverse
+    end
+
+  end
+
+end
+
+class ::Array
+  ##
+  # Adds convenience method for creating a Radix::Rational.
+  #
+  # @todo Keep #br? Or find another way?
+  # @return [Radix::Rational]
+  def br(base=nil)
+    args = dup
+    args << base if base
+    Radix::Rational.new(*args)
+  end
+end
+
+if RUBY_VERSION < '1.9'
+  class ::Float
+
+    ##
+    # Adds a #to_r method to pre-1.9 ruby Rationals.
+    # 
+    # @return [Rational] 
+    def to_r
+      n, f = to_s.split('.')
+      d = (10 ** f.size).to_i
+      n = (n.to_i * d) + f.to_i
+      Rational(n, d) 
+    end
+  end
+end
+