radix 1.1.0 → 2.0.0

data/lib/radix/meta/package

@@ -1,6 +1,6 @@
 name    : radix
-version : 1.1.0
-date    : 2010-09-03
+version : 2.0.0
+date    : 2010-10-31
 
 requires:
   - syckle (build)

data/lib/radix/meta/profile

@@ -3,7 +3,7 @@ title  : Radix
 suite  : rubyworks
 summary: Convert to and from any base.
 contact: trans <transfire@gmail.com>
-license: LGPL
+license: Apache 2.0
 authors: Thomas Sawyer
 created: 2009-07-01
 
@@ -11,10 +11,10 @@ description:
   Convert to and from any base.
 
 resources:
-  hompage    : http://rubyworks.github.com/radix
-  development: http://github.com/rubyworks/radix
-  mailinglist: http://groups.google.com/group/rubyworks-mailinglist
-  repository : git://github.com/rubyworks/radix.git
+  home: http://rubyworks.github.com/radix
+  code: http://github.com/rubyworks/radix
+  mail: http://groups.google.com/group/rubyworks-mailinglist
+  repo: git://github.com/rubyworks/radix.git
 
 copyright: 
   Copyright (c) 2009 Thomas Sawyer

data/lib/radix/numeric.rb

@@ -0,0 +1,144 @@
+require 'radix/base'
+
+module Radix
+
+  # Redix separator used in string and array representations.
+  DOT = '.'
+
+  #
+  DIV = '/'
+
+  #
+  DIVIDER = " "
+
+  # Radix Numeric base class is subclassed by Radix::Integer and Radix::Float,
+  # and is a subclass of Ruby's built-in Numeric class.
+  class Numeric < ::Numeric
+
+    # TODO: Make immutable, but best way to do it?
+
+    #class << self
+    #  alias_method :_new, :new
+    #  private :_new
+    #end
+    #
+    #def self.new(value, base=10)
+    #  @cache ||= {}
+    #  @cache[[value, base]] ||= _new(value, base)
+    #end
+
+    # Addition
+    def +(other)
+      operation(:+, other)
+    end
+
+    # Subtraction
+    def -(other)
+      operation(:-, other)
+    end
+
+    # Multiplication
+    def *(other)
+      operation(:*, other)
+    end
+
+    # Division
+    def /(other)
+      operation(:/, other)
+    end
+
+    private
+
+    #
+    def parse_base(base)
+      case base
+      when Array
+        code = base
+        base = base.size
+      else
+        code = nil
+        base = base
+      end
+      return base, code
+    end
+
+    #
+    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".
+    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.
+    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
+    end
+
+    # Convert array of values of a different base to decimal.
+    # This handles integer values. The method for Radix::Float
+    # is slighly different.
+    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.
+    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.
+    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/operator.rb

@@ -1,30 +0,0 @@
-require 'radix/number'
-
-class ::Numeric
-
-  #
-  def b(base)
-    Radix::Number.new(self, base)
-  end
-
-end
-
-
-class ::String
-
-  #
-  def b(base)
-    Radix::Number.new(self, base)
-  end
-
-end
-
-
-class ::Array
-
-  #
-  def b(base)
-    Radix::Number.new(self, base)
-  end
-
-end

data/lib/radix/rational.rb

@@ -0,0 +1,203 @@
+require 'rational'
+require 'radix/numeric'
+
+module Radix
+
+  #
+  class Rational < Numeric
+
+    # Alternative to #new.
+    def self.[](n,d=nil,b=10)
+      new(n,d,b)
+    end
+
+    # Stores the Rational value.
+    attr :value
+
+    # Base of the number.
+    attr :base
+
+    # Base encoding table.
+    attr :code
+
+    private
+
+    # Create a new Radix::Rational instance.
+    #
+    #   Rational.new(<Integer>, <Integer>, <Integer>)
+    #   Rational.new(<Rational>, <Integer>)
+    #
+    def initialize(numerator, denominator=nil, base=10)
+      case numerator
+      when ::Rational, Rational
+        ratn = numerator
+        base = denominator
+        @value = ::Rational.new!(ratn.numerator, ratn.denominator)
+      else
+        n = parse_value(numerator, base)
+        d = parse_value(denominator, base)
+        @value = ::Rational.new!(n, d)
+      end
+      @base, @code = parse_base(base)
+    end
+
+    #
+    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
+
+    #
+    def numerator
+      @value.numerator
+    end
+
+    #
+    def denominator
+      @value.denominator
+    end
+
+    #
+    def negative?
+      value < 0
+    end
+
+    #
+    def convert(base)
+      self.class.new(numerator, denominator, base)
+    end
+
+    #
+    def to_r
+      value
+    end
+
+    #
+    def to_f
+      numerator.to_f / denominator.to_f
+    end
+
+    #
+    def to_i
+      to_f.to_i
+    end
+
+    #
+    def to_a(base=nil)
+      if base
+        convert(base).digits_encoded
+      else
+        digits_encoded
+      end     
+    end
+
+    #
+    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
+
+    #
+    def ==(other)
+      a, b = self.to_f, other.to_f
+      a == b
+    end
+
+    #
+    def reduce
+      self.class.new(Rational(numerator, denominator), base)
+    end
+
+    #
+    def digits
+      n = base_conversion(numerator, base)
+      d = base_conversion(denominator, base)
+      i = n + ['/'] + d
+      i.unshift('-') if negative? 
+      i
+    end
+
+    #
+    def digits_encoded
+      base_encode(digits)
+    end
+
+    #
+    def inspect
+      "#{digits.join(' ')} (#{base})"
+    end
+
+    #
+    def coerce(value)
+      [Radix::Rational.new(value), self]  
+    end
+
+    private
+
+    #
+    def operation(op, other)
+      x = value.__send__(op, other.to_r)
+      self.class.new(x, base)
+    end
+
+    #
+    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.reverse
+    end
+
+  end
+
+end
+
+class ::Array
+  # Convenience method for creating a Radix::Rational.
+  # TODO: Keep #br? Or find another way?
+  def br(base=nil)
+    args = dup
+    args << base if base
+    Radix::Rational.new(*args)
+  end
+end
+
+class ::Float
+  #
+  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

data/meta/package

@@ -1,6 +1,6 @@
 name    : radix
-version : 1.1.0
-date    : 2010-09-03
+version : 2.0.0
+date    : 2010-10-31
 
 requires:
   - syckle (build)

data/meta/profile

@@ -3,7 +3,7 @@ title  : Radix
 suite  : rubyworks
 summary: Convert to and from any base.
 contact: trans <transfire@gmail.com>
-license: LGPL
+license: Apache 2.0
 authors: Thomas Sawyer
 created: 2009-07-01
 
@@ -11,10 +11,10 @@ description:
   Convert to and from any base.
 
 resources:
-  hompage    : http://rubyworks.github.com/radix
-  development: http://github.com/rubyworks/radix
-  mailinglist: http://groups.google.com/group/rubyworks-mailinglist
-  repository : git://github.com/rubyworks/radix.git
+  home: http://rubyworks.github.com/radix
+  code: http://github.com/rubyworks/radix
+  mail: http://groups.google.com/group/rubyworks-mailinglist
+  repo: git://github.com/rubyworks/radix.git
 
 copyright: 
   Copyright (c) 2009 Thomas Sawyer

data/test/02_integer.rdoc

@@ -0,0 +1,256 @@
+= Radix Integer
+
+Radix provides an Integer class for working with integers in various bases.
+
+  require 'radix'
+
+== Initialization
+
+Radix::Integer's initializer can accept either an Integer, String or
+Array as a value and an integer base.
+
+Give an integer value, it will automatically be converted to the base
+specified.
+
+  check do |integer, base, digits|
+    r = Radix::Integer.new(integer, base)
+    r.digits.assert == digits
+  end
+
+  ok  8,  2, [1,0,0,0]
+  ok  4,  2, [1,0,0]
+  ok  8, 10, [8]
+  ok 10, 10, [1, 0]
+  ok  8, 16, [8]
+  ok 16, 16, [1, 0]
+
+Where as a String value is taken to already be in the base given.
+
+  ok "1000", 2, [1,0,0,0]
+  ok  "100", 2, [1,0,0]
+
+  ok  "8", 10, [8]
+  ok "10", 10, [1, 0]
+  ok  "8", 16, [8]
+  ok "10", 16, [1, 0]
+
+And an Array is also taken to be in the base given.
+
+  ok %w[1 0 0 0], 2, [1,0,0,0]
+  ok %w[  1 0 0], 2, [1,0,0]
+
+  ok %w[  8], 10, [8]
+  ok %w[1 0], 10, [1, 0]
+  ok %w[  8], 16, [8]
+  ok %w[1 0], 16, [1, 0]
+
+Integers can also be negative, rather than positive. In each case
+just prepend the value with a minus sign.
+
+  check do |integer, base, digits|
+    r = Radix::Integer.new(integer, base)
+    r.digits.assert == digits
+    r.assert.negative?
+  end
+
+  ok             -8, 2, ['-',1,0,0,0]
+  ok        "-1000", 2, ['-',1,0,0,0]
+  ok  %w[- 1 0 0 0], 2, ['-',1,0,0,0]
+
+If a value has a digit outside of the range of the base an ArgumentError
+will be raised.
+
+  expect ArgumentError do
+    Radix::Integer.new('9', 2)
+  end
+
+Radix provides a convenience extension method to Integer, String and Array
+called #b, to more easily initialize a Radix numeric object. The method simply
+passes the receiver on to `Radix::Integer#new`.
+
+  check do |integer, base, digits|
+    r = integer.b(base)
+    r.assert.is_a?(Radix::Integer)
+    r.digits.assert == digits
+  end
+
+  ok 8, 2, [1,0,0,0]
+  ok 4, 2, [1,0,0]
+
+  ok "1000", 2, [1,0,0,0]
+  ok  "100", 2, [1,0,0]
+
+  ok %w"1 0 0 0", 2, [1,0,0,0]
+  ok   %w"1 0 0", 2, [1,0,0]
+
+== Conversion
+
+Radix integers can ve converted to other bases with the #convert method.
+
+  b = "1000".b(2)
+  d = b.convert(10)
+  d.digits.assert == [8]
+
+We can convert a Radix::Integer to a regular base-10 Integer with the #to_i
+method.
+
+  b = "1000".b(2)
+  d = b.to_i
+  d.assert == 8
+
+== Equality
+
+Radix extend the Integer, String and Array classes with the #b method
+which simplifies the creation of Radix::Integer instances. The following
+return the equivalent instance of Radix::Integer.
+
+  a = 8.b(2)
+  b = "1000".b(2)
+  c = [1, 0, 0, 0].b(2)
+
+  a.assert == b
+  b.assert == c
+  c.assert == a
+
+  a.assert == 8
+  b.assert == 8
+  c.assert == 8
+
+More stringent equality can be had from #eql?, in which the other integer
+must be a Radix::Integer too.
+
+  a.assert.eql?(b)
+  a.refute.eql?(8)
+
+=== Operations
+
+Radix::Integer supports all the usual mathematical operators.
+
+=== Addition
+
+  check do |a, b, x|
+    (a + b).assert == x
+  end
+
+  ok "1000".b(2), "0010".b(2), "1010".b(2)
+  ok "1000".b(2),    "2".b(8), "1010".b(2)
+  ok "1000".b(2),    "2".b(8),   "10".b(10)
+
+A more complex example.
+
+  x = "AZ42".b(62) + "54".b(10)
+  x.assert == "2518124".b(10)
+  x.assert == 2518124
+
+Adding negative integers will, of course, be akin to subtraction.
+
+  ok "1000".b(2), "-0010".b(2), "110".b(2)
+  ok "1000".b(2),    "-2".b(8), "110".b(2)
+  ok "1000".b(2),    "-2".b(8),   "6".b(10)
+
+  ok "-1000".b(2), "0010".b(2), "-110".b(2)
+  ok "-1000".b(2),    "2".b(8), "-110".b(2)
+  ok "-1000".b(2),    "2".b(8),   "-6".b(10)
+
+  ok "-1000".b(2), "-0010".b(2), "-1010".b(2)
+  ok "-1000".b(2),    "-2".b(8), "-1010".b(2)
+  ok "-1000".b(2),    "-2".b(8),   "-10".b(10)
+
+=== Subtraction
+
+  check do |a, b, x|
+    (a - b).assert == x
+  end
+
+  ok "1000".b(2), "10".b(2), "0110".b(2)
+  ok "1000".b(2),  "2".b(8), "0110".b(2)
+  ok "1000".b(2),  "2".b(8), "6".b(8)
+  ok "1000".b(2),  "2".b(8), "6".b(10)
+
+A more complex example.
+
+  x = "AZ42".b(62) - "54".b(10)
+  x.assert == "2518016".b(10)
+  x.assert == 2518016
+
+=== Multiplication
+
+  check do |a, b, x|
+    (a * b).assert == x
+  end
+
+  ok "1000".b(2), "10".b(2), "10000".b(2)
+  ok "1000".b(2),  "2".b(8), "10000".b(2)
+  ok "1000".b(2),  "2".b(8), "20".b(8)
+  ok "1000".b(2),  "2".b(8), "16".b(10)
+
+A more complex example.
+
+  x = "Z42".b(62) * "4".b(10)
+  x.assert == "539160".b(10)
+  x.assert == 539160
+
+=== Division
+
+  check do |a, b, x|
+    (a / b).assert == x
+  end
+
+  ok "1000".b(2), "10".b(2), "100".b(2)
+  ok "1000".b(2),  "2".b(8), "100".b(2)
+  ok "1000".b(2),  "2".b(8), "4".b(8)
+  ok "1000".b(2),  "2".b(8), "4".b(10)
+
+A more complex example.
+
+  x = "AZ42".b(62) / "54".b(10)
+  x.assert == "46630".b(10)
+  x.assert == 46630
+
+=== Power
+
+  check do |a, b, x|
+    (a ** b).assert == x
+  end
+
+  ok "1000".b(2), "10".b(2), 64
+
+=== Modulo
+
+  check do |a, b, x|
+    (a % b).assert == x
+  end
+
+  ok "1000".b(2), "10".b(2), 0
+  ok "1000".b(2), "11".b(2), 2
+
+=== Bitwise Shift
+
+  check do |a, b, x|
+    (a << b).assert == x
+  end
+
+  ok "10".b(2), "10".b(2), "1000".b(2)
+  ok "10".b(2),         2, "1000".b(2)
+  ok "10".b(2),         2, 8
+
+=== Bitwise AND
+
+  check do |a, b, x|
+    (a & b).assert == x
+  end
+
+  ok "1010".b(2), "10".b(2), "10".b(2)
+  ok "1010".b(2),  "2".b(8), "10".b(2)
+
+== Coerce
+
+When a Radix::Integer is the operand in an operation against a regular
+Ruby Integer, the calculation should still work via #coerce.
+
+  check do |a, b, x|
+    (a + b).assert == x
+  end
+
+  ok 10, "10".b(2), "12".b(10)
+