radix 2.2.0 → 2.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f0f4b9300804a84e011600cde15a9b5e28a70ab8
+  data.tar.gz: 7f1ce98300b3202915b81ff66a6ac2d41312273c
+SHA512:
+  metadata.gz: 3027ac3bf4b775e03227943368ba11a4ccd46fe49492e5d7ef81cee4fa296e8cf1e50ba1e5adbe9a403e4674de91a407eb8f7e23b14371b8fd9fb2de14744172
+  data.tar.gz: a5c9e86fb918a55fb57c4384e3f0e0f5253677a467497144c4464d87bd460701a606bd1cf45ad1f90f10c094453f14eac42d5f4474ff07f128d428725100049e

data/.index

@@ -2,7 +2,7 @@
 revision: 2013
 type: ruby
 sources:
-- var
+- index
 authors:
 - name: Thomas Sawyer
   email: transfire@gmail.com
@@ -29,9 +29,6 @@ resources:
 - type: code
   uri: http://github.com/rubyworks/radix
   label: Source Code
-- type: mail
-  uri: http://groups.google.com/groups/rubyworks-mailinglist
-  label: Mailing List
 - type: bugs
   uri: http://github.com/rubyworks/radix/issues
   label: Issue Tracker
@@ -48,12 +45,12 @@ customs: []
 paths:
   lib:
   - lib
-created: '2009-07-01'
-summary: Convert to and from any base.
-title: Radix
-version: 2.2.0
 name: radix
-description: ! "Radix is a very easy to use Ruby library for converting numbers to
-  and from\nany base. It supports both Integer, Float and Rational numbers, as well
-  as \nrepresentational string-notations that need not be in ASCII order."
-date: '2013-03-20'
+title: Radix
+summary: Convert to and from any base.
+created: '2009-07-01'
+description: "Radix is a very easy to use Ruby library for converting numbers to and
+  from\nany base. It supports both Integer, Float and Rational numbers, as well as
+  \nrepresentational string-notations that need not be in ASCII order."
+version: 2.2.1
+date: '2015-03-02'

data/DEMO.md

@@ -1,57 +1,57 @@
-= Synopsis
+# Synopsis
 
 Radix provides the means of converting to and from any base.
 For example, a number in base 256 can be represented by the array [100, 10]
 (ie. 100**256 + 10**1) and easily converted to base 10.
 
-  [100,10].b(256).to_i  #=> 25610
+    [100,10].b(256).to_i  #=> 25610
 
 We can get an Array representation as well.
 
-  [100,10].b(256).to_a(10)  #=> [2,5,6,1,0]
-  [100,10].b(256).to_a(62)  #=> [6,41,4]
-  [100,10].b(256).to_a(64)  #=> [6,16,10]
+    [100,10].b(256).to_a(10)  #=> [2,5,6,1,0]
+    [100,10].b(256).to_a(62)  #=> [6,41,4]
+    [100,10].b(256).to_a(64)  #=> [6,16,10]
 
 To get a String representation for any base use #to_s.
 
-  [100,10].b(256).to_s(10)  #=> "25610"
-  [100,10].b(256).to_s(62)  #=> "6 41 4"
-  [100,10].b(256).to_s(64)  #=> "6 16 10"
+    [100,10].b(256).to_s(10)  #=> "25610"
+    [100,10].b(256).to_s(62)  #=> "6 41 4"
+    [100,10].b(256).to_s(64)  #=> "6 16 10"
 
 Notice that anything above base 10 is seperated by a space divider. The divider
 can be changed by providing a second argument.
 
-  [100,10].b(256).to_s(64, ':')  #=> "6:16:10"
+    [100,10].b(256).to_s(64, ':')  #=> "6:16:10"
 
 A string representation of a number can be converted upto base 62 (B62).
 
-  "10".b(62).to_s(10)  #=> "62"
-  "zz".b(62).to_s(10)  #=> "3843"
+    "10".b(62).to_s(10)  #=> "62"
+    "zz".b(62).to_s(10)  #=> "3843"
 
 To encode a number with a base greater than 10, use an Array base. Radix
 provides a built-in set of these, such as `BASE::B62`.
 
-  [100,10].b(256).to_s(Radix::BASE::B62)  #=> "6f4"
+    [100,10].b(256).to_s(Radix::BASE::B62)  #=> "6f4"
 
 To use a custom character set, use an array of characters as the base
 rather than an integer. For example we can convert a base 10 number
 to another base 10 number but useing a different encoding.
 
-  base = %w[Q W E R T Y U I O U]
+    base = %w[Q W E R T Y U I O U]
 
-  "10".b(10).to_a(base)  #=> ["W", "Q"]
+    "10".b(10).to_a(base)  #=> ["W", "Q"]
 
-  "10".b(10).to_s(base)  #=> "WQ"
+    "10".b(10).to_s(base)  #=> "WQ"
 
 All of the above holds equally for floating point numbers.
 
-= Radix Integer
+# Radix Integer
 
 Radix provides an Integer class for working with integers in various bases.
 
-  require 'radix'
+    require 'radix'
 
-== Initialization
+## Initialization
 
 Radix::Integer's initializer can accept either an Integer, String or
 Array as a value and an integer base.
@@ -59,260 +59,260 @@ 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
+    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]
+    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 "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]
+    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[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]
+    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
+    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]
+    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
+    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
+    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 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 "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]
+    ok %w"1 0 0 0", 2, [1,0,0,0]
+    ok   %w"1 0 0", 2, [1,0,0]
 
-== Conversion
+## 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]
+    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
+    b = "1000".b(2)
+    d = b.to_i
+    d.assert == 8
 
-== Equality
+## 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 = 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 == b
+    b.assert == c
+    c.assert == a
 
-  a.assert == 8
-  b.assert == 8
-  c.assert == 8
+    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)
+    a.assert.eql?(b)
+    a.refute.eql?(8)
 
-== Operations
+## Operations
 
 Radix::Integer supports all the usual mathematical operators.
 
-=== Addition
+### Addition
 
-  check do |a, b, x|
-    (a + b).assert == x
-  end
+    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)
+    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
+    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), "-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)
+    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
+### Subtraction
 
-  check do |a, b, x|
-    (a - b).assert == x
-  end
+    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)
+    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
+    x = "AZ42".b(62) - "54".b(10)
+    x.assert == "2518016".b(10)
+    x.assert == 2518016
 
-=== Multiplication
+### Multiplication
 
-  check do |a, b, x|
-    (a * b).assert == x
-  end
+    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)
+    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
+    x = "Z42".b(62) * "4".b(10)
+    x.assert == "539160".b(10)
+    x.assert == 539160
 
-=== Division
+### Division
 
-  check do |a, b, x|
-    (a / b).assert == x
-  end
+    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)
+    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
+    x = "AZ42".b(62) / "54".b(10)
+    x.assert == "46630".b(10)
+    x.assert == 46630
 
-=== Power
+### Power
 
-  check do |a, b, x|
-    (a ** b).assert == x
-  end
+    check do |a, b, x|
+      (a ** b).assert == x
+    end
 
-  ok "1000".b(2), "10".b(2), 64
+    ok "1000".b(2), "10".b(2), 64
 
-=== Modulo
+### Modulo
 
-  check do |a, b, x|
-    (a % b).assert == x
-  end
+    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
+    ok "1000".b(2), "10".b(2), 0
+    ok "1000".b(2), "11".b(2), 2
 
-=== Bitwise Shift
+### Bitwise Shift
 
-  check do |a, b, x|
-    (a << b).assert == x
-  end
+    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
+    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
+### Bitwise AND
 
-  check do |a, b, x|
-    (a & b).assert == x
-  end
+    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)
+    ok "1010".b(2), "10".b(2), "10".b(2)
+    ok "1010".b(2),  "2".b(8), "10".b(2)
 
-== Coerce
+## 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
+    check do |a, b, x|
+      (a + b).assert == x
+    end
 
-  ok 10, "10".b(2), "12".b(10)
+    ok 10, "10".b(2), "12".b(10)
 
 
-= Radix Float
+# Radix Float
 
 Radix provides a Float class for working with rational numbers in various bases.
 Actually Radix's implementation of Float is a <i>fixed point</i>, not a 
-<i>floating point</i>.
+*floating point*.
 
-  require 'radix'
+    require 'radix'
 
-  D = Radix::DOT
+    D = Radix::DOT
 
-== Initialization
+## Initialization
 
 Radix::Float's initializer can accept either an Integer, Float, String or
 Array as a value and an integer base.
@@ -320,288 +320,288 @@ Array as a value and an integer base.
 Give a float value, it will automatically be converted to the base
 specified.
 
-  check do |float, base, digits|
-    r = Radix::Float.new(float, base)
-    r.digits.assert == digits
-  end
+    check do |float, base, digits|
+      r = Radix::Float.new(float, base)
+      r.digits.assert == digits
+    end
 
-  ok  8.5,  2, [1,0,0,0,D,1]
-  ok  4.5,  2, [  1,0,0,D,1]
+    ok  8.5,  2, [1,0,0,0,D,1]
+    ok  4.5,  2, [  1,0,0,D,1]
 
-  ok  8.1, 10, [  8,D,1]
-  ok 10.2, 10, [1,0,D,2]
-  #ok  8.1, 16, [  8,D,1]
-  #ok 16.1, 16, [1,0,D,1]
+    ok  8.1, 10, [  8,D,1]
+    ok 10.2, 10, [1,0,D,2]
+    #ok  8.1, 16, [  8,D,1]
+    #ok 16.1, 16, [1,0,D,1]
 
 Give an integer value, it will automatically be converted to the base
 specified and given a fraction part set to zero.
 
-  check do |float, base, digits|
-    r = Radix::Float.new(float, base)
-    r.digits.assert == digits
-  end
+    check do |float, base, digits|
+      r = Radix::Float.new(float, base)
+      r.digits.assert == digits
+    end
 
-  ok  8,  2, [1,0,0,0,D,0]
-  ok  4,  2, [  1,0,0,D,0]
+    ok  8,  2, [1,0,0,0,D,0]
+    ok  4,  2, [  1,0,0,D,0]
 
-  ok  8, 10, [  8,D,0]
-  ok 10, 10, [1,0,D,0]
-  ok  8, 16, [  8,D,0]
-  ok 16, 16, [1,0,D,0]
+    ok  8, 10, [  8,D,0]
+    ok 10, 10, [1,0,D,0]
+    ok  8, 16, [  8,D,0]
+    ok 16, 16, [1,0,D,0]
 
 Given a float, the same will occur.
 
-  ok  8.0,  2, [1,0,0,0,D,0]
-  ok  4.0,  2, [  1,0,0,D,0]
+    ok  8.0,  2, [1,0,0,0,D,0]
+    ok  4.0,  2, [  1,0,0,D,0]
 
-  ok  8.0, 10, [  8,D,0]
-  ok 10.0, 10, [1,0,D,0]
-  ok  8.0, 16, [  8,D,0]
-  ok 16.0, 16, [1,0,D,0]
+    ok  8.0, 10, [  8,D,0]
+    ok 10.0, 10, [1,0,D,0]
+    ok  8.0, 16, [  8,D,0]
+    ok 16.0, 16, [1,0,D,0]
 
 Where as a String value is taken to already be in the base given.
 
-  ok "1000", 2, [1,0,0,0,D,0]
-  ok  "100", 2, [  1,0,0,D,0]
+    ok "1000", 2, [1,0,0,0,D,0]
+    ok  "100", 2, [  1,0,0,D,0]
 
-  ok  "8", 10, [  8,D,0]
-  ok "10", 10, [1,0,D,0]
-  ok  "8", 16, [  8,D,0]
-  ok "10", 16, [1,0,D,0]
+    ok  "8", 10, [  8,D,0]
+    ok "10", 10, [1,0,D,0]
+    ok  "8", 16, [  8,D,0]
+    ok "10", 16, [1,0,D,0]
 
-  ok "1000.0", 2, [1,0,0,0,D,0]
-  ok  "100.0", 2, [  1,0,0,D,0]
+    ok "1000.0", 2, [1,0,0,0,D,0]
+    ok  "100.0", 2, [  1,0,0,D,0]
 
-  ok    "8.0", 10, [  8,D,0]
-  ok   "10.0", 10, [1,0,D,0]
-  ok    "8.0", 16, [  8,D,0]
-  ok   "10.0", 16, [1,0,D,0]
+    ok    "8.0", 10, [  8,D,0]
+    ok   "10.0", 10, [1,0,D,0]
+    ok    "8.0", 16, [  8,D,0]
+    ok   "10.0", 16, [1,0,D,0]
 
 And an Array is also taken to be in the base given.
 
-  ok %w[1 0 0 0], 2, [1,0,0,0,D,0]
-  ok %w[  1 0 0], 2, [  1,0,0,D,0]
+    ok %w[1 0 0 0], 2, [1,0,0,0,D,0]
+    ok %w[  1 0 0], 2, [  1,0,0,D,0]
 
-  ok %w[  8], 10, [  8,D,0]
-  ok %w[1 0], 10, [1,0,D,0]
-  ok %w[  8], 16, [  8,D,0]
-  ok %w[1 0], 16, [1,0,D,0]
+    ok %w[  8], 10, [  8,D,0]
+    ok %w[1 0], 10, [1,0,D,0]
+    ok %w[  8], 16, [  8,D,0]
+    ok %w[1 0], 16, [1,0,D,0]
 
 Passing in an Array with a fraction part, either the DOT constant can be used,
 which is simply the symbol :'.', or the string '.' can be used.
 
-  ok %w[1 0 0 0 . 0], 2, [1,0,0,0,D,0]
-  ok %w[  1 0 0 . 0], 2, [  1,0,0,D,0]
+    ok %w[1 0 0 0 . 0], 2, [1,0,0,0,D,0]
+    ok %w[  1 0 0 . 0], 2, [  1,0,0,D,0]
 
-  ok %w[  8 . 0], 10, [  8,D,0]
-  ok %w[1 0 . 0], 10, [1,0,D,0]
-  ok %w[  8 . 0], 16, [  8,D,0]
-  ok %w[1 0 . 0], 16, [1,0,D,0]
+    ok %w[  8 . 0], 10, [  8,D,0]
+    ok %w[1 0 . 0], 10, [1,0,D,0]
+    ok %w[  8 . 0], 16, [  8,D,0]
+    ok %w[1 0 . 0], 16, [1,0,D,0]
 
 Integers can also be negative, rather than positive. In each case
 just prepend the value with a minus sign.
 
-  check do |float, base, digits|
-    r = Radix::Float.new(float, base)
-    r.digits.assert = digits
-    r.assert.negative?
-  end
+    check do |float, base, digits|
+      r = Radix::Float.new(float, base)
+      r.digits.assert = digits
+      r.assert.negative?
+    end
 
-  ok(            -8, 2, ['-',1,0,0,0,D,0])
-  ok(       "-1000", 2, ['-',1,0,0,0,D,0])
-  ok( %w[- 1 0 0 0], 2, ['-',1,0,0,0,D,0])
+    ok(            -8, 2, ['-',1,0,0,0,D,0])
+    ok(       "-1000", 2, ['-',1,0,0,0,D,0])
+    ok( %w[- 1 0 0 0], 2, ['-',1,0,0,0,D,0])
 
 If a value has a digit outside of the range of the base an ArgumentError
 will be raised.
 
-  expect ArgumentError do
-    Radix::Float.new('9', 2)
-  end
+    expect ArgumentError do
+      Radix::Float.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 |float, base, digits|
-    r = float.b(base)
-    r.assert.is_a?(Radix::Float)
-    r.digits.assert = digits
-  end
+    check do |float, base, digits|
+      r = float.b(base)
+      r.assert.is_a?(Radix::Float)
+      r.digits.assert = digits
+    end
 
-  ok 8.0, 2, [1,0,0,0,D,0]
-  ok 4.0, 2, [  1,0,0,D,0]
+    ok 8.0, 2, [1,0,0,0,D,0]
+    ok 4.0, 2, [  1,0,0,D,0]
 
-  ok "1000.0", 2, [1,0,0,0,D,0]
-  ok  "100.0", 2, [  1,0,0,D,0]
+    ok "1000.0", 2, [1,0,0,0,D,0]
+    ok  "100.0", 2, [  1,0,0,D,0]
 
-  ok %w"1 0 0 0 . 0", 2, [1,0,0,0,D,0]
-  ok   %w"1 0 0 . 0", 2, [  1,0,0,D,0]
+    ok %w"1 0 0 0 . 0", 2, [1,0,0,0,D,0]
+    ok   %w"1 0 0 . 0", 2, [  1,0,0,D,0]
 
-== Conversion
+## Conversion
 
 Radix integers can ve converted to other bases with the #convert method.
 
-  b = "1000.0".b(2)
-  d = b.convert(10)
-  d.digits.assert == [8,D,0]
+    b = "1000.0".b(2)
+    d = b.convert(10)
+    d.digits.assert == [8,D,0]
 
 We can convert a Radix::Float to a regular base-10 Float with the #to_f
 method.
 
-  b = "1000.0".b(2)
-  d = b.to_f
-  d.assert == 8.0
+    b = "1000.0".b(2)
+    d = b.to_f
+    d.assert == 8.0
 
 We can convert a Radix::Float to a regular base-10 Integer with the #to_i
 method.
 
-  b = "1000.0".b(2)
-  d = b.to_i
-  d.assert == 8
+    b = "1000.0".b(2)
+    d = b.to_i
+    d.assert == 8
 
-=== Equality
+### Equality
 
 Radix extend the Integer, String and Array classes with the #b method
 which simplifies the creation of Radix::Float instances. The following
 return the equivalent instance of Radix::Float.
 
-  a = 8.0.b(2)
-  b = "1000.0".b(2)
-  c = [1,0,0,0,'.',0].b(2)
+    a = 8.0.b(2)
+    b = "1000.0".b(2)
+    c = [1,0,0,0,'.',0].b(2)
 
-  a.assert = b
-  b.assert = c
-  c.assert = a
+    a.assert = b
+    b.assert = c
+    c.assert = a
 
-  a.assert = 8.0
-  b.assert = 8.0
-  c.assert = 8.0
+    a.assert = 8.0
+    b.assert = 8.0
+    c.assert = 8.0
 
 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.0)
+    a.assert.eql?(b)
+    a.refute.eql?(8.0)
 
-== Operations
+## Operations
 
 Radix::Float supports all the usual mathematical operators.
 
-=== Addition
+### Addition
 
-  check do |a, b, x|
-    (a + b).assert = x
-  end
+    check do |a, b, x|
+      (a + b).assert = x
+    end
 
-  ok "1000.0".b(2), "0010.0".b(2), "1010.0".b(2)
-  ok "1000.0".b(2),    "2.0".b(8), "1010.0".b(2)
-  ok "1000.0".b(2),    "2.0".b(8),   "10.0".b(10)
+    ok "1000.0".b(2), "0010.0".b(2), "1010.0".b(2)
+    ok "1000.0".b(2),    "2.0".b(8), "1010.0".b(2)
+    ok "1000.0".b(2),    "2.0".b(8),   "10.0".b(10)
 
 A more complex example.
 
-  x = "AZ42.0".b(62) + "54.0".b(10)
-  x.assert == "2518124.0".b(10)
-  x.assert == 2518124.0
+    x = "AZ42.0".b(62) + "54.0".b(10)
+    x.assert == "2518124.0".b(10)
+    x.assert == 2518124.0
 
 Adding negative integers will, of course, be akin to subtraction.
 
-  ok "1000.0".b(2), "-0010".b(2), "110.0".b(2)
-  ok "1000.0".b(2),    "-2".b(8), "110.0".b(2)
-  ok "1000.0".b(2),    "-2".b(8),   "6.0".b(10)
+    ok "1000.0".b(2), "-0010".b(2), "110.0".b(2)
+    ok "1000.0".b(2),    "-2".b(8), "110.0".b(2)
+    ok "1000.0".b(2),    "-2".b(8),   "6.0".b(10)
 
-  ok "-1000.0".b(2), "0010".b(2), "-110.0".b(2)
-  ok "-1000.0".b(2),    "2".b(8), "-110.0".b(2)
-  ok "-1000.0".b(2),    "2".b(8),   "-6.0".b(10)
+    ok "-1000.0".b(2), "0010".b(2), "-110.0".b(2)
+    ok "-1000.0".b(2),    "2".b(8), "-110.0".b(2)
+    ok "-1000.0".b(2),    "2".b(8),   "-6.0".b(10)
 
-  ok "-1000.0".b(2), "-0010".b(2), "-1010.0".b(2)
-  ok "-1000.0".b(2),    "-2".b(8), "-1010.0".b(2)
-  ok "-1000.0".b(2),    "-2".b(8),   "-10.0".b(10)
+    ok "-1000.0".b(2), "-0010".b(2), "-1010.0".b(2)
+    ok "-1000.0".b(2),    "-2".b(8), "-1010.0".b(2)
+    ok "-1000.0".b(2),    "-2".b(8),   "-10.0".b(10)
 
-=== Subtraction
+### Subtraction
 
-  check do |a, b, x|
-    (a - b).assert == x
-  end
+    check do |a, b, x|
+      (a - b).assert == x
+    end
 
-  ok "1000.0".b(2), "10".b(2), "110.0".b(2)
-  ok "1000.0".b(2),  "2".b(8), "110.0".b(2)
-  ok "1000.0".b(2),  "2".b(8), "6.0".b(8)
-  ok "1000.0".b(2),  "2".b(8), "6.0".b(10)
+    ok "1000.0".b(2), "10".b(2), "110.0".b(2)
+    ok "1000.0".b(2),  "2".b(8), "110.0".b(2)
+    ok "1000.0".b(2),  "2".b(8), "6.0".b(8)
+    ok "1000.0".b(2),  "2".b(8), "6.0".b(10)
 
 A more complex example.
 
-  x = "AZ42.0".b(62) - "54".b(10)
-  x.assert == "2518016.0".b(10)
-  x.assert == 2518016.0
+    x = "AZ42.0".b(62) - "54".b(10)
+    x.assert == "2518016.0".b(10)
+    x.assert == 2518016.0
 
-=== Multiplication
+### Multiplication
 
-  check do |a, b, x|
-    (a * b).assert = x
-  end
+    check do |a, b, x|
+      (a * b).assert = x
+    end
 
-  ok "1000.0".b(2), "10".b(2), "10000.0".b(2)
-  ok "1000.0".b(2),  "2".b(8), "10000.0".b(2)
-  ok "1000.0".b(2),  "2".b(8), "20.0".b(8)
-  ok "1000.0".b(2),  "2".b(8), "16.0".b(10)
+    ok "1000.0".b(2), "10".b(2), "10000.0".b(2)
+    ok "1000.0".b(2),  "2".b(8), "10000.0".b(2)
+    ok "1000.0".b(2),  "2".b(8), "20.0".b(8)
+    ok "1000.0".b(2),  "2".b(8), "16.0".b(10)
 
 A more complex example.
 
-  x = "Z42.0".b(62) * "4.0".b(10)
-  x.assert == "539160.0".b(10)
-  x.assert == 539160.0
+    x = "Z42.0".b(62) * "4.0".b(10)
+    x.assert == "539160.0".b(10)
+    x.assert == 539160.0
 
-=== Division
+### Division
 
-  check do |a, b, x|
-    (a / b).assert = x
-  end
+    check do |a, b, x|
+      (a / b).assert = x
+    end
 
-  ok "1000.0".b(2), "10".b(2), "100.0".b(2)
-  ok "1000.0".b(2),  "2".b(8), "100.0".b(2)
-  ok "1000.0".b(2),  "2".b(8), "4.0".b(8)
-  ok "1000.0".b(2),  "2".b(8), "4.0".b(10)
+    ok "1000.0".b(2), "10".b(2), "100.0".b(2)
+    ok "1000.0".b(2),  "2".b(8), "100.0".b(2)
+    ok "1000.0".b(2),  "2".b(8), "4.0".b(8)
+    ok "1000.0".b(2),  "2".b(8), "4.0".b(10)
 
 A more complex example.
 
-  x = "AZ40.0".b(62) / "62.0".b(10)
-  x.assert == "40614.0".b(10)
-  x.assert == 40614.0
+    x = "AZ40.0".b(62) / "62.0".b(10)
+    x.assert == "40614.0".b(10)
+    x.assert == 40614.0
 
-=== Power
+### Power
 
-  check do |a, b, x|
-    (a ** b).assert == x
-  end
+    check do |a, b, x|
+      (a ** b).assert == x
+    end
 
-  ok "1000.0".b(2), "10.0".b(2), 64.0
+    ok "1000.0".b(2), "10.0".b(2), 64.0
 
-=== Modulo
+### Modulo
 
-  check do |a, b, x|
-    (a % b).assert == x
-  end
+    check do |a, b, x|
+      (a % b).assert == x
+    end
 
-  ok "1000.0".b(2), "10".b(2), 0
-  ok "1000.0".b(2), "11".b(2), 2
+    ok "1000.0".b(2), "10".b(2), 0
+    ok "1000.0".b(2), "11".b(2), 2
 
-== Coerce
+## 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
+    check do |a, b, x|
+      (a + b).assert == x
+    end
 
-  ok 10.0, "10".b(2), "12".b(10)
+    ok 10.0, "10".b(2), "12".b(10)
 
 
-= Radix Rational
+# Radix Rational
 
-  require 'radix'
+    require 'radix'
 
-== Initialization
+## Initialization
 
 Radix::Rational's initializer takes a numerator and a denominator,
 either of which can be an Integer, Float, String or Array along witha
@@ -610,154 +610,173 @@ an integer base.
 Give a integer value, it will automatically be converted to the base
 specified.
 
-  check do |num, dem, base, eqf|
-    r = Radix::Rational.new(num, dem, base)
-    r.assert == eqf
-  end
+    check do |num, dem, base, eqf|
+      r = Radix::Rational.new(num, dem, base)
+      r.assert == eqf
+    end
 
-  ok  1, 2,  2,  0.5
-  ok  1, 1,  2,  1.0
+    ok  1, 2,  2,  0.5
+    ok  1, 1,  2,  1.0
 
-  ok  8, 1, 10,  8.0
-  ok  8, 5, 10,  1.6
-  ok  8, 8, 10,  1.0
+    ok  8, 1, 10,  8.0
+    ok  8, 5, 10,  1.6
+    ok  8, 8, 10,  1.0
 
-  ok 10, 1, 10, 10.0
-  ok 10, 2, 10,  5.0
-  ok 10, 5, 10,  2.0
+    ok 10, 1, 10, 10.0
+    ok 10, 2, 10,  5.0
+    ok 10, 5, 10,  2.0
 
-  ok  8, 1, 16,  8.0
-  ok 16, 1, 16, 16.0
+    ok  8, 1, 16,  8.0
+    ok 16, 1, 16, 16.0
 
-== Reduction
+## Reduction
 
-  check do |a, x|
-    r = a.reduce
-    r.assert == x
-  end
+    check do |a, x|
+      r = a.reduce
+      r.assert == x
+    end
 
-  ok [10,5].br(10),  [2,1].br(10)
-  ok [30,3].br(10), [10,1].br(10)
+    ok [10,5].br(10),  [2,1].br(10)
+    ok [30,3].br(10), [10,1].br(10)
 
-== Operations
+## Operations
 
-=== Addition
+### Addition
 
-  check do |a, b, x|
-    r = a + b
-    r.assert == x
-  end
+    check do |a, b, x|
+      r = a + b
+      r.assert == x
+    end
 
-  ok [8,5].br(10), [1,2].br(10), [21,10].br(10)
+    ok [8,5].br(10), [1,2].br(10), [21,10].br(10)
 
-  ok [8,5].br(10), 1, [13,5].br(10)
+    ok [8,5].br(10), 1, [13,5].br(10)
 
-  ok [8,5].br(10), 0.5, [21,10].br(10)
+    ok [8,5].br(10), 0.5, [21,10].br(10)
 
-=== Subtraction
+### Subtraction
 
-  check do |a, b, x|
-    r = a - b
-    r.assert == x
-  end
+    check do |a, b, x|
+      r = a - b
+      r.assert == x
+    end
 
-  ok [8,5].br(10), [1,2].br(10), [11,10].br(10)
+    ok [8,5].br(10), [1,2].br(10), [11,10].br(10)
 
-=== Multiplication
+### Multiplication
 
-  check do |a, b, x|
-    r = a * b
-    r.assert == x
-  end
+    check do |a, b, x|
+      r = a * b
+      r.assert == x
+    end
 
-  ok [8,5].br(10), [1,2].br(10), [8,10].br(10)
+    ok [8,5].br(10), [1,2].br(10), [8,10].br(10)
 
-=== Division
+### Division
 
-  check do |a, b, x|
-    r = a / b
-    r.assert == x
-  end
+    check do |a, b, x|
+      r = a / b
+      r.assert == x
+    end
 
-  ok [8,5].br(10), [1,2].br(10), [16,5].br(10)
+    ok [8,5].br(10), [1,2].br(10), [16,5].br(10)
 
 
-= Radix::Base
+# Radix::Base
 
 The Radix::Base class is an encapsulatin of a numeric base. By creating
 an instance of Base one can convert numbers to and from other bases.
 
-  require 'radix/base'
+    require 'radix/base'
 
-== Base Instance
+## Base Instance
 
 First let's try something we all know, converting decimal to hexideciaml.
 To do this we setup the radix base objects for each base.
 
-  b10 = Radix::Base.new(Radix::BASE::B10)
-  b16 = Radix::Base.new(Radix::BASE::B16)
+    b10 = Radix::Base.new(Radix::BASE::B10)
+    b16 = Radix::Base.new(Radix::BASE::B16)
 
 Now we can covert from one base to the other.
 
-  b16.convert("16" , b10).should == "10"
-  b16.convert("160", b10).should == "A0"
-  b16.convert("255", b10).should == "FF"
+    b16.convert("16" , b10).should == "10"
+    b16.convert("160", b10).should == "A0"
+    b16.convert("255", b10).should == "FF"
 
 To confirm, lets convert from hexidecimal back to decimal.
 
-  b10.convert("10", b16).should == "16"
-  b10.convert("A0", b16).should == "160"
-  b10.convert("FF", b16).should == "255"
+    b10.convert("10", b16).should == "16"
+    b10.convert("A0", b16).should == "160"
+    b10.convert("FF", b16).should == "255"
 
 If we are happy with standard encodings then we can simply provide an
 integer base, rather than a Radix::Base object.
 
-  b10.convert("10", 16).should == "16"
-  b10.convert("A0", 16).should == "160"
-  b10.convert("FF", 16).should == "255"
+    b10.convert("10", 16).should == "16"
+    b10.convert("A0", 16).should == "160"
+    b10.convert("FF", 16).should == "255"
 
 Now let's try a more down to earth base, my favorite,
 senary, or base six.
 
-  b6  = Radix::Base.new(0..5)
-  b6.convert("39", 10).should == "103"
+    b6  = Radix::Base.new(0..5)
+    b6.convert("39", 10).should == "103"
 
 And the notations need not be in ASCII order. Odd alternate notations
 can be used as well.
 
-  b10 = Radix::Base.new([:Q, :W, :E, :R, :T, :Y, :U, :I, :O, :U])
-  b10.convert("FF", 16) #=> "EYY"
+    b10 = Radix::Base.new([:Q, :W, :E, :R, :T, :Y, :U, :I, :O, :U])
+    b10.convert("FF", 16) #=> "EYY"
 
-== Encoding and Decoding
+## Encoding and Decoding
 
 Radix::Base instances can also be used to encode and decode strings.
 
-  b16.encode("CHARLIE").should == "434841524C4945"
-  b16.decode("434841524C4945").should == "CHARLIE"
+    b16.encode("CHARLIE").should == "434841524C4945"
+    b16.decode("434841524C4945").should == "CHARLIE"
 
-== Module Methods
+## Module Methods
 
 For further convenience, Radix::base provides functions to convert to and from
 standard notations upto 62 without creating an instance of Radix::Base.
 
-  Radix.convert("10", 16, 10).should == "16"
-  Radix.convert("A0", 16, 10).should == "160"
-  Radix.convert("FF", 16, 10).should == "255"
+    Radix.convert("10", 16, 10).should == "16"
+    Radix.convert("A0", 16, 10).should == "160"
+    Radix.convert("FF", 16, 10).should == "255"
 
 Let's try that again with the maximum base supported.
 
-  Radix.convert(     "62", 10, 62).should == "10"
-  Radix.convert("8814542", 10, 62).should == "az42"
+    Radix.convert(     "62", 10, 62).should == "10"
+    Radix.convert("8814542", 10, 62).should == "az42"
 
-  Radix.convert(     "10", 62, 10).should == "62"
-  Radix.convert(   "az42", 62, 10).should == "8814542"
+    Radix.convert(     "10", 62, 10).should == "62"
+    Radix.convert(   "az42", 62, 10).should == "8814542"
 
 Finally, we will demonstrate how to convert bases larger than 62.
 These can only be represented as arrays since there are not enough
 latin characters to represent them.
 
-  Radix.convert_base([100, 10], 256, 10).should == [2, 5, 6, 1, 0]
-  Radix.convert_base([2, 5, 6, 1, 0], 10, 256).should == [100, 10]
-  Radix.convert_base([1, 0, 1, 0, 1], 2, 10).should == [2, 1]
+    Radix.convert_base([100, 10], 256, 10).should == [2, 5, 6, 1, 0]
+    Radix.convert_base([2, 5, 6, 1, 0], 10, 256).should == [100, 10]
+    Radix.convert_base([1, 0, 1, 0, 1], 2, 10).should == [2, 1]
+
+
+# Zero becomes empty string (#4)
+
+Example of the issue:
+
+    0.b(10).to_s  #=> ""
+
+I would expect "0" as a result.
+
+    0.b(10).to_s  #=> "0"
+
+Okay, lets make sure this works for Floats.
+
+    0.0.b(10).to_s  #=> "0.0"
+
+And Rationals too.
+
+    [0,1].br(10).to_s  #=> "0/1"