RubyGems - radix - Versions diffs - 2.0.0 → 2.0.1 - Mend

radix 2.0.0 → 2.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (29) hide show

data/doc/applique/ae.rb DELETED

	@@ -1 +0,0 @@
1	- require 'ae/should'

data/doc/applique/qed.rb DELETED

	@@ -1 +0,0 @@
1	- require 'qed/extensions/check'

data/lib/radix/meta/data.rb DELETED

@@ -1,29 +0,0 @@
-Object.__send__(:remove_const, :VERSION) if Object.const_defined?(:VERSION)      # becuase Ruby 1.8~ gets in the way
-module Radix
-  def self.__DIR__
-    File.dirname(__FILE__)
-  end
-  def self.package
-    @package ||= (
-      require 'yaml'
-      YAML.load(File.new(__DIR__ + '/package'))
-    )
-  end
-  def self.profile
-    @profile ||= (
-      require 'yaml'
-      YAML.load(File.new(__DIR__ + '/profile'))
-    )
-  end
-  def self.const_missing(name)
-    key = name.to_s.downcase
-    package[key] || profile[key] || super(name)
-  end
-end

data/lib/radix/meta/package DELETED

@@ -1,8 +0,0 @@
-name    : radix
-version : 2.0.0
-date    : 2010-10-31
-requires:
-  - syckle (build)
-  - qed (test)

data/lib/radix/meta/profile DELETED

@@ -1,21 +0,0 @@
----
-title  : Radix
-suite  : rubyworks
-summary: Convert to and from any base.
-contact: trans <transfire@gmail.com>
-license: Apache 2.0
-authors: Thomas Sawyer
-created: 2009-07-01
-description:
-  Convert to and from any base.
-resources:
-  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/meta/data.rb DELETED

@@ -1,29 +0,0 @@
-Object.__send__(:remove_const, :VERSION) if Object.const_defined?(:VERSION)      # becuase Ruby 1.8~ gets in the way
-module Radix
-  def self.__DIR__
-    File.dirname(__FILE__)
-  end
-  def self.package
-    @package ||= (
-      require 'yaml'
-      YAML.load(File.new(__DIR__ + '/package'))
-    )
-  end
-  def self.profile
-    @profile ||= (
-      require 'yaml'
-      YAML.load(File.new(__DIR__ + '/profile'))
-    )
-  end
-  def self.const_missing(name)
-    key = name.to_s.downcase
-    package[key] || profile[key] || super(name)
-  end
-end

data/meta/package DELETED

@@ -1,8 +0,0 @@
-name    : radix
-version : 2.0.0
-date    : 2010-10-31
-requires:
-  - syckle (build)
-  - qed (test)

data/meta/profile DELETED

@@ -1,21 +0,0 @@
----
-title  : Radix
-suite  : rubyworks
-summary: Convert to and from any base.
-contact: trans <transfire@gmail.com>
-license: Apache 2.0
-authors: Thomas Sawyer
-created: 2009-07-01
-description:
-  Convert to and from any base.
-resources:
-  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 DELETED

@@ -1,256 +0,0 @@
-= 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)

data/test/03_float.rdoc DELETED

@@ -1,294 +0,0 @@
-= 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>.
-  require 'radix'
-  D = Radix::DOT
-== Initialization
-Radix::Float's initializer can accept either an Integer, Float, String or
-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
-  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]
-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
-  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]
-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, 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  "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    "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[  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[  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
-  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
-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
-  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 %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
-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]
-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
-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
-=== 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.assert = b
-  b.assert = c
-  c.assert = a
-  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)
-== Operations
-Radix::Float supports all the usual mathematical operators.
-=== Addition
-  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)
-A more complex example.
-  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), "-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
-  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)
-A more complex example.
-  x = "AZ42.0".b(62) - "54".b(10)
-  x.assert == "2518016.0".b(10)
-  x.assert == 2518016.0
-=== Multiplication
-  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)
-A more complex example.
-  x = "Z42.0".b(62) * "4.0".b(10)
-  x.assert == "539160.0".b(10)
-  x.assert == 539160.0
-=== Division
-  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)
-A more complex example.
-  x = "AZ40.0".b(62) / "62.0".b(10)
-  x.assert == "40614.0".b(10)
-  x.assert == 40614.0
-=== Power
-  check do |a, b, x|
-    (a ** b).assert == x
-  end
-  ok "1000.0".b(2), "10.0".b(2), 64.0
-=== Modulo
-  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
-== 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.0, "10".b(2), "12".b(10)