radix-firstbanco 2.2.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MGZlODI1YTRlZjI2MTZhNGZkYTA2NzhiM2MyNzE4NTc2NmFjNjJkNg==
+  data.tar.gz: !binary |-
+    ZTg3ZmRkOGIzMmJlZjA3ZGJhM2U5Zjg2MDM3NWJhMDJkMjZmMzhkMQ==
+SHA512:
+  metadata.gz: !binary |-
+    Y2M1ZDY0OGNlMzU5NTA3Y2ZhNzBkN2VhNTNhNzQ0NDdlOWY1YzRjMWM4Nzhk
+    ZDQ3NTE4MGEzNmZhZTlkMjNmMGU2ZGIxYTBjYTBjMWY3OGZlODk3YTgwMTFj
+    ZTAyM2YzMWZmMGI1NmVmY2U2NTI4MDQ0MzE2MzM2ZWZlYmI1NmI=
+  data.tar.gz: !binary |-
+    YTg3ZmEyOGI3MTkzMTNiYmZhMTZlYTk3YTdjZGY5NDliOTk1MjkxNTg2YTlh
+    Y2NmOTM2NDFhYTM3MTNlNjJhMjFhODlkMDcxNWY1ZDhiMjA5ZDE3MDFjYmZj
+    Mjg3ZWJjMTI3YWM0NWY2ODg3NTA1ZjhkMDYxMGEwMzY1MTBkOGI=

data/.index

@@ -0,0 +1,59 @@
+---
+revision: 2013
+type: ruby
+sources:
+- var
+authors:
+- name: Thomas Sawyer
+  email: transfire@gmail.com
+organizations: []
+requirements:
+- groups:
+  - build
+  development: true
+  name: ergo
+- groups:
+  - test
+  development: true
+  name: qed
+- groups:
+  - test
+  development: true
+  name: ae
+conflicts: []
+alternatives: []
+resources:
+- type: home
+  uri: http://rubyworks.github.com/radix
+  label: Homepage
+- 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
+repositories:
+- name: upstream
+  scm: git
+  uri: git://github.com/rubyworks/radix.git
+categories: []
+copyrights:
+- holder: ''
+  year: '2009'
+  license: BSD-2-Clause
+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'

data/.yardopts

@@ -0,0 +1,8 @@
+--title Radix
+--readme README.md
+--protected
+--private
+lib
+-
+*.md
+*.txt

data/HISTORY.md

@@ -0,0 +1,95 @@
+# RELEASE HISTORY
+
+## 2.2.0 / 2013-03-20
+
+Good documentation is so under-addressed by most developers that we really
+have to roll out the bright lights when someone comes along and takes 
+up the time consuming mantle of documenting an API in complete detail.
+This is exactly what happened with Radix this last month. A coder going
+by the unassuming handle, **douglascodes**, announced his desire to 
+document Radix and proceeded to do so until YARD pronounced 100%
+completeness. Hey, we think that is worth of a whole version bump and 
+a big shout-out for Douglas!
+
+Changes:
+
+* 100% API documentation coverage. (douglascodes)
+
+
+## 2.1.1 / 2013-02-06
+
+Minor release to fix gemspec. Which, alas, Bundler cannot do without.
+
+Changes:
+
+* Update .gemspec file for latest indexer.
+
+
+## 2.1.0 / 2013-01-31
+
+This release fixes two bugs. The first caused base conversions of `0`
+to return an empty string. Second, the `Float#to_r` extension was
+ using multiplication when it should have been using power. 
+Ruby 1.9 includes `Float#to_r` though, so the use of Radix's *fixed*
+core extension is conditioned on Ruby 1.8 now. This release also 
+updates  the build a bit, primarily converting RDoc documents to 
+Markdown.
+
+Changes:
+
+* Fix issue #5, Float#to_r using times instead of power. (simonratner)
+* Fix issue #4, zero converts to empty string. (bbasata)
+* Convert RDoc documents to Markdown.
+
+
+## 2.0.1 / 2011-10-23
+
+This release is simply an administrative release to update the project
+build configuration. The functionality of the library itself has not
+changed. This release also transitions the project to the BSD-2-Clause
+license.
+
+Changes:
+
+* Modernize build configuration.
+* Switch to BSD-2-Clause license.
+
+
+## 2.0.0 / 2010-10-31
+
+Radix::Number has been deprecate in favor of three separate classes,
+Radix::Integer, Radix::Float and Radix::Rational. In addition
+implementation of these classes has been reworked.
+
+Changes:
+
+* Deprecate Radix::Number
+* Add Radix::Integer
+* Add Radix::Float
+* Add Radix::Rational
+
+
+## 1.1.0 / 2010-09-03
+
+Radix now provides an actual Numeric subclass, Radix::Number, that stores
+the base and can be used like any other Numeric object. This makes it very
+easy to convert and manipulate numbers in any base. The implementation is still
+a bit nascent. For the moment, it only supports the most basic math operators
+and only handles integer values, but future releases will continue to expand
+on it's capabilities.
+
+Changes:
+
+* Add Radix::Number to handle bases like any other numeric.
+* Rename Radix class to Radix::Base.
+
+
+## 1.0.0 / 2009-07-01
+
+This is the initial stand-alone release of Radix,
+ported from the basex.rb library of Ruby Facets.
+
+Changes:
+
+* Happy Birthday!
+

data/LICENSE.txt

@@ -0,0 +1,23 @@
+BSD-2-Clause License
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR  SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/README.md

@@ -0,0 +1,100 @@
+# Radix
+
+[Website](http://rubyworks.github.com/radix) ·
+[Report Issue](http://github.com/rubyworks/radix/issues) ·
+[Source Code](http://github.com/rubyworks/radix)     
+[![Build Status](https://secure.travis-ci.org/rubyworks/radix.png)](http://travis-ci.org/rubyworks/radix)
+[![Gem Version](https://badge.fury.io/rb/radix.png)](http://badge.fury.io/rb/radix)    
+[![Flattr Me](http://api.flattr.com/button/flattr-badge-large.png)](http://flattr.com/thing/324911/Rubyworks-Ruby-Development-Fund)
+
+
+Radix is a very easy to use Ruby library for converting numbers to and from
+any base. It supports both Integer, Float and Rational numbers, as well as 
+representational string-notations that need not be in ASCII order.
+
+
+## Features
+
+* Convert to and from any base.
+* Convert Integers, Floats and Rational numbers.
+* Define custom encoding and character sets.
+* Can be used to encode/decode bytecode strings.
+* Very intuitive API.
+
+
+## Usage
+
+Base conversions with ASCII ordered notations are easy in Ruby.
+
+```ruby
+255.to_s(16)   #=> "FF"
+
+"FF".to_i(16)  #=> 255
+```
+
+But Ruby reaches it's limit at base 36.
+
+```ruby
+255.to_s(37)   #=> Error
+```
+
+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]`
+(`100**256 + 10**1`) and can be convert to base 10.
+
+```ruby
+[100,10].b(256).to_a(10)  #=> [2,5,6,1,0]
+```
+
+Or, to get a string representation for any base up to 62.
+
+```ruby
+[100,10].b(256).to_s(10)  #=> "25610"
+```
+
+A string representation of a number can be converted too, again,
+up to base 62.
+
+```ruby
+"10".b(62).to_s(10)  #=> "62"
+```
+
+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 using a different encoding.
+
+```ruby
+base = [:Q, :W, :E, :R, :T, :Y, :U, :I, :O, :U]
+
+"10".b(10).to_a(base)  #=> [:W, :Q]
+```
+
+To learn more have a look at the [QED Demo](http://rubydoc.info/gems/radix/file/DEMO.md).
+
+
+## Installing
+
+To install with RubyGems simply open a console and type:
+
+    $ gem install radix
+
+Radix follows [Ruby Setup](http://rubyworks.github.com/setup) package standard
+so it can also be installed in an FHS compliant manner using setup.rb.
+
+
+## Special Thanks
+
+Special thanks to **douglascodes** for taking the time to fully document
+Radix's API. Documentation is an under-addressed and time-consuming affair,
+so your contribution is greatly appreciated. Thank you, Douglas!
+
+
+## Copyrights
+
+Copyright (c) 2009 Rubyworks
+
+This program is distributable in accordance with the *BSD-2-Clause* license.
+
+See LICENSE.txt for details.
+

data/demo/01_synopsis.md

@@ -0,0 +1,46 @@
+# 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
+
+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]
+
+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"
+
+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"
+
+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"
+
+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"
+
+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]
+
+    "10".b(10).to_a(base)  #=> ["W", "Q"]
+
+    "10".b(10).to_s(base)  #=> "WQ"
+
+All of the above holds equally for floating point numbers.

data/demo/02_integer.md

@@ -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)
+