radix-firstbanco 2.2.0

data/demo/applique/ae.rb

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

data/demo/applique/check.rb

@@ -0,0 +1,7 @@
+def check(&block)
+  @check = block
+end
+
+def ok(*args)
+  @check.call(*args)
+end

data/demo/applique/radix.rb

@@ -0,0 +1 @@
+require 'radix'

data/demo/issues/004_zero_empty_string.md

@@ -0,0 +1,18 @@
+# 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"
+

data/lib/radix.rb

@@ -0,0 +1,31 @@
+require 'radix/base'
+require 'radix/integer'
+require 'radix/float'
+require 'radix/rational'
+
+module Radix
+
+  ##
+  # Returns the metadata contained in Radix.yml
+  #
+  # @return [Hash{String=>String}]
+  def self.metadata
+    @metadata ||= (
+      require 'yaml'
+      YAML.load(File.new(File.dirname(__FILE__) + '/radix.yml'))
+    )
+  end
+
+  ##
+  # Gets value of name in metadata or goes up ancestry.
+  #
+  # @param [Symbol] name
+  #
+  # @return [String]
+  def self.const_missing(name)
+    key = name.to_s.downcase
+    metadata.key?(key) ? metadata[key] : super(name)
+  end
+
+end
+

data/lib/radix.yml

@@ -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/lib/radix/base.rb

@@ -0,0 +1,244 @@
+module Radix
+
+  ##
+  # Namespace for common bases defined as reusable constants.
+  #
+  module BASE
+    # Array of chars 0 - 9
+    B10 = ('0'..'9').to_a
+    # Array of chars 0 - 9 + X + E
+    B12 = B10 + ['X', 'E']
+    # Array of chars 0 - 9 + A - F
+    B16 = B10 + ('A'..'F').to_a
+    # Array of chars 0 - 9 + A - Z
+    B36 = B10 + ('A'..'Z').to_a
+    # Array of chars 0 - 9 + A - Z + a - x
+    B60 = B36 + ('a'..'x').to_a
+    # Array of chars 0 - 9 + A - Z + a - z
+    B62 = B36 + ('a'..'z').to_a
+    # Array of chars 0 - 9 + a - f
+    HEX = B10 + ('a'..'f').to_a
+  end
+
+  ##
+  # Radix::Base is a functional model of a base system that can be used for
+  # number conversions.
+  #
+  # Radix::Base is the original Radix API. But with the advent of v2.0
+  # and the new Integer and Float classes, it is essentially deprecated.
+  #
+  # @example Convert any base
+  #   b10 = Radix::Base.new(10)
+  #   b10.convert_base([100, 10], 256)
+  #   #=> [2,5,6,1,0]
+  #
+  # @example Convert to string notation upto base 62
+  #   b10.convert("10", 62)  #=> "62"
+  #
+  # @example Odd notations
+  #   b10 = Radix::Base.new(%w{Q W E R T Y U I O U})
+  #   b10.convert("FF", 16) #=> "EYY"
+  #
+  # @!attribute [r] chars
+  #   @return [Array<String>] The ASCII character set in use.
+  # @!attribute [r] base
+  #   @return [Fixnum] The base level in use.
+  # @!attribute [r] values
+  #   @example Testing base hash default values.
+  #     > test = Radix::Base.new(36)
+  #     > test.values["F"]
+  #     15 
+  #     > test.values["5"]
+  #     5
+  #     > test.values["Y"]
+  #     34
+  #     > test.values["YY"] 
+  #     nil       # Fails because "YY" is not a key in the +values+ hash.
+  #   @return [Hash{String=>Fixnum}]
+  #     A hash of characters and their respective value.
+  class Base
+
+    ##
+    # The characters for this base level.
+    #
+    # @return [Array<String>] The ASCII character set in use.
+    attr :chars
+
+    ##
+    # The base of this instance.
+    #
+    # @return [Fixnum] The base level in use.
+    attr :base
+
+    ##
+    # Hash of characters and values.
+    #
+    # @return [Hash{String=>Fixnum}]
+    #   A hash of characters and their respective value.
+    attr :values
+
+    ##
+    # New Radix using +chars+ representation.
+    #
+    # @param [Array<String>, Numeric] chars
+    #   Array of string representation of number values of the base
+    #   or a Numeric of the Base level.
+    #
+    # @return [void]
+    def initialize(chars=BASE::B62)
+      if ::Numeric === chars
+        chars = BASE::B62[0...chars]
+      end
+      @chars  = chars.map{ |c| c.to_s }
+      @base   = @chars.size
+      @values = Hash[*(0...@base).map { |i| [ @chars[i], i ] }.flatten]
+    end
+
+    ##
+    # Convert a value of given radix_base to that of the base instance.
+    #
+    # @param [String, Numeric, Array<String>] number
+    #   The value in "radix_base" context.
+    #
+    # @param [Radix::Base, Numeric] radix_base
+    #   Numeric for the radix or instance of Radix::Base.
+    #
+    # @example Convert Testing (Binary, Decimal, Hex)
+    #   > b = Radix::Base.new(2)
+    #   > d = Radix::Base.new(10)
+    #   > h = Radix::Base.new(16)
+    #   > d.convert("A", h)
+    #   "10"
+    #   > h.convert("A", d)
+    #   TypeError
+    #   > h.convert(10, d)
+    #   "A"
+    #   > h.convert(10, 10)
+    #   "A"
+    #   > b.convert(10, d)
+    #   "1010"
+    #   > b.convert(10, h)
+    #   "10000"
+    #
+    # @return [String] representation of "number" in self.base level.
+    def convert(number, radix_base)
+      radix_base = Radix::Base.new(radix_base) unless Radix::Base === radix_base
+      case number
+      when ::String, ::Numeric
+        digits = number.to_s.split(//)
+      else
+        digits = number
+      end
+
+      # decode the digits
+      digits = digits.map{ |digit| radix_base.values[digit] }
+
+      # THINK: Is best way to check for base out of bounds?
+      raise TypeError if digits.any?{ |digit| digit.nil? }
+
+      digits = Radix.convert_base(digits, radix_base.base, base)
+      digits = digits.map{ |digit| chars[digit] }
+      digits.join
+    end
+
+    ##
+    # Convert any base to any other base, using array of Fixnum's. Indexes of
+    # the array correspond to values for each column of the number in from_base
+    #
+    # @param [Array<Fixnum>] digits
+    #   Array of values for each digit of source base.
+    #
+    # @param [Fixnum] from_base
+    #   Source Base
+    #
+    # @param [Fixnum] to_base
+    #   Destination Base
+    #
+    # @return [String] The value of digits in from_base converted as to_base.
+    def convert_base(digits, from_base, to_base)
+      bignum = 0
+      digits.each { |digit| bignum = bignum * from_base + digit }
+      converted = []
+      until bignum.zero?
+        bignum, digit = bignum.divmod(to_base)
+        converted.push(digit)
+      end
+      converted << 0 if converted.empty?  # THINK: correct?
+      converted.reverse
+    end
+
+    ##
+    # Encode a string in the radix.
+    #
+    # @param [String] byte_string
+    #   String value in this base. 
+    #
+    # @return [String] Encoded string from this Base.
+    def encode(byte_string)
+      digits = byte_string.unpack("C*")
+      digits = Radix.convert_base(digits, 256, base)
+      digits.map{ |d| @chars[d] }.join
+    end
+
+    ##
+    # Decode a string that was previously encoded in the radix.
+    #
+    # @param [String] encoded
+    #   Encoded string from this Base.
+    #
+    # @return [String] Decoded string of value from this base. 
+    def decode(encoded)
+      digits = encoded.split(//).map{ |c| @values[c] }
+      Radix.convert_base(digits, base, 256).pack("C*")
+    end
+
+  end
+
+  ##
+  # Convert a number of from_base as to_base.
+  #
+  # @param [String, Numeric, Array<String>] number
+  #   The value in context of "radix_base".
+  #
+  # @param [Fixnum, Radix::Base] from_base
+  #   Source Base
+  #
+  # @param [Fixnum, Radix::Base] to_base
+  #   Destination Base
+  #
+  # @return [String]
+  #   The value of `digits` in `from_base` converted into `to_base`.
+  def self.convert(number, from_base, to_base)
+    from_base = Radix::Base.new(from_base) unless Radix::Base === from_base
+    to_base   = Radix::Base.new(to_base)   unless Radix::Base === to_base
+    to_base.convert(number, from_base)
+  end
+
+  ##
+  # Convert any base to any other base, using array of Fixnum's. Indexes of
+  # the array correspond to values for each column of the number in from_base
+  #
+  # @param [Array<Fixnum>] digits
+  #   Array of values for each digit of source base.
+  #
+  # @param [Fixnum] from_base
+  #   Source Base
+  #
+  # @param [Fixnum] to_base
+  #   Destination Base
+  #
+  # @return [String] The value of digits in from_base converted as to_base.
+  def self.convert_base(digits, from_base, to_base)
+    bignum = 0
+    digits.each { |digit| bignum = bignum * from_base + digit }
+    converted = []
+    until bignum.zero?
+      bignum, digit = bignum.divmod(to_base)
+      converted.push(digit)
+    end
+    converted << 0 if converted.empty?  # THINK: correct?
+    converted.reverse
+  end
+
+end
+

data/lib/radix/float.rb

@@ -0,0 +1,456 @@
+require 'radix/numeric'
+
+module Radix
+
+  ##
+  # Advanced float class for Radix conversions and mathematical operations
+  # with other bases. 
+  #
+  # @todo Make fully immutable. After that we can catch @digits and
+  #   the library should be a good bit faster.
+  #
+  # @!attribute [r] value 
+  #   @return [Float] Float's decimal value.
+  # @!attribute [r] base
+  #   @return [Fixnum] The base level of Float instance.
+  # @!attribute [r] code 
+  #   @return [Array<String>, nil] Substitution chars or nil if default.
+  class Float < Numeric
+
+    ##
+    # Internal floating point value.
+    #
+    # @return [Float] Float's decimal value.
+    attr :value
+
+    ##
+    # Base of the number.
+    #
+    # @return [Fixnum] The base level of Float instance.
+    attr :base
+
+    ##
+    # Base encoding table.
+    #
+    # @return [Array<String>, nil] Substitution chars or nil if default.
+    attr :code
+
+    private
+
+    ##
+    # Starts a new instance of the Radix::Float class.
+    #
+    # @param [Radix::Numeric, Numeric, Array, String] value
+    #   The value of the new integer in context of base.
+    #
+    # @param [Fixnum, Array<String>] base
+    #   The base context in which value is determined. Can be an array
+    #   of characters to use in place of default.
+    #
+    # @return [void]    
+    def initialize(value, base=10)
+      @value = parse_value(value, base)
+      @base, @code = parse_base(base)
+    end
+
+    ##
+    # Takes a Radix::Numeric, String or array and returns the decimal float
+    # value for storage in @value.
+    #
+    # @param [Radix::Numeric, Numeric, String, Array<Numeric, String>] value
+    #   The value of the integer in base context.
+    #
+    # @param [Fixnum, Array<String>] base
+    #   The context base of value.
+    #
+    # @return [Float] Float value of Integer.
+    def parse_value(value, base)
+      case value
+      when Float, Integer # Radix
+        parse_numeric(value.to_f, base)
+      when ::Array
+        parse_array(value, base)
+      when ::String
+        parse_string(value, base)
+      when ::Numeric
+        parse_numeric(value.to_f, base)
+      end
+    end
+
+    public
+
+    ##
+    # Makes this Radix::Float a ruby Integer.
+    # 
+    # @return [Integer] Base(10) value as Integer.
+    def to_i
+      to_f.to_i
+    end
+
+    alias_method :to_int, :to_i
+
+    ##
+    # Makes this Radix::Float a ruby float.
+    # 
+    # @return [Float] Base(10) value as Float.
+    def to_f
+      value.to_f
+    end
+
+    ##
+    # Makes this Radix::Float an array using code if defined. Returns an
+    # array using default chars otherwise. 
+    #
+    # @param [Fixnum] base
+    #   Desired base.
+    #
+    # @return [Array<Fixnum, String>] Current base encoded array.
+    def to_a(base=nil)
+      if base
+        convert(base).digits_encoded
+      else
+        digits_encoded
+      end
+    end
+
+    ##
+    # Creates an encoded string in passed base, with passed digit divider.
+    #
+    # @note For base 10 or less does not use a divider unless specified.
+    #
+    # @param [Fixnum, Array<String>] base
+    #   Desired base.
+    #
+    # @param [String] divider
+    #   Desired divider character(s).
+    #
+    # @return [String] Encoded string with specified divider.
+    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
+
+    ##
+    # Creates a string representation of self.
+    #
+    # @return [String] String rep of self.digits and @base.
+    def inspect
+      "#{digits.join(' ')} (#{base})"
+    end
+
+    ##
+    # Returns an array representation of each column's value in decimal chars.
+    #
+    # @return [Array<String, Fixnum>]
+    #   Values per column of @base as array. Prepended with "-" if negative. 
+    def digits
+      i, f = base_conversion(value, base)
+      if negative?
+        ['-'] + i + [DOT] + f
+      else
+        i + [DOT] + f
+      end
+    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
+
+    ##
+    # Returns true if the number is negative?
+    #
+    # @return [Boolean] True if float value is < 0.
+    def negative?
+      value < 0
+    end
+
+    ## 
+    # Creates a new Radix::Float of same value in different base.
+    #
+    # @return [Radix::Float] New float of same value in different base.
+    def convert(new_base)
+      self.class.new(value, new_base)
+    end
+
+    ##
+    # Power exponentional operation.
+    #
+    # @param [#to_f] other
+    #   The exponent by which to raise Float.
+    #
+    # @return [Radix::Float] Result of exponential operation.
+    def **(other)
+      operation(:**, other)
+    end
+
+    ##
+    # Modulo binary operation.
+    #
+    # @param [#to_f] other
+    #
+    # @return [Radix::Float] Modulo result of division operation.
+    def %(other)
+      operation(:%, other)
+    end
+
+    alias_method :modulo, :%
+
+    ##
+    # Returns the absolute value of self in @base.
+    #
+    # @return [Radix::Float] Absolute of @value.
+    def abs
+      self.class.new(value.abs, base)
+    end
+
+    ##
+    # Returns the largest integer greater than or equal to self as a
+    # Radix::Float.
+    #
+    # @return [Radix::Float] 
+    def ceil
+      self.class.new(value.ceil, base)
+    end
+
+    ##
+    # Returns the smallest integer less than or equal to self as a
+    # Radix::Float.
+    #
+    # @return [Radix::Float] 
+    def floor
+      self.class.new(value.floor, base)
+    end
+
+    ##
+    # Returns a new Radix::Float instance of same base, rounded to the nearest 
+    # whole integer.
+    # 
+    # @example Rounding Radix Float
+    #   > round_test = Radix::Float.new(123.03, 16)
+    #   7 11 . 0 7 10 14 1 4 7 10 14 1 (16)
+    #   > round_test.value
+    #   123.03
+    #   > round_test.round
+    #   7 11 . 0 (16)
+    #   > round_test.round.value
+    #   123.0
+    #   > round_test += 0.5
+    #   7 11 . 8 7 10 14 1 4 7 10 14 1 (16)
+    #   > round_test.value
+    #   123.53
+    #   > round_test.round
+    #   7 12 . 0 (16)
+    #   > round_test.round.value
+    #   124.0
+    #
+    # @return [Radix::Float] New Instance
+    def round
+      return self.class.new((value + 0.5).floor, base) if self > 0.0
+      return self.class.new((value - 0.5).ceil,  base) if self < 0.0
+      return self.class.new(0, base)
+    end
+
+    ##
+    # Strict equality requires same class as well as value.
+    #
+    # @param [Object] num
+    #   Object to compare.
+    #
+    # @return [Boolean] True if class and value are equal.
+    def eql?(num)
+      self.class.equal?(num.class) && self == num
+    end
+
+    ##
+    # Simple equality requires equal values only.
+    #
+    # @param [Numeric] other
+    #   Any Numeric instance.
+    #
+    # @return [Boolean] True if values are equal.
+     def ==(other)
+      case other
+      when Float, Integer  # Radix
+        value == other.value
+      else
+        value == other
+      end
+    end
+
+    ##
+    # Comparitive binary operation. Very useful for sorting methods.
+    # 
+    # @param [#to_f] other
+    #   The object to compare value against.
+    #
+    # @example Comparison testing
+    #   > lower = Radix::Float.new(123.00,10)
+    #   1 2 3 . 0 (10)
+    #   > higher = Radix::Float.new(456.00,16)
+    #   1 12 8 . 0 (16)
+    #   > lower <=> higher
+    #   -1
+    #   > lower <=> 123
+    #   0
+    #   > lower <=> "123"
+    #   0
+    #   > higher <=> lower
+    #   1
+    #
+    # @return [Fixnum] Returns -1 for less than, 0 for equal or 1 for more than.
+    def <=>(other)
+      to_f <=> other.to_f
+    end
+
+    #
+    #def infinite?
+    #  digits[0,2] == [0, DOT]
+    #end
+
+    #
+    #def finite?
+    #  !infinite
+    #end
+
+    #
+    #def nan?
+    #  digits[-2,2] == [DOT, 0]
+    #end
+
+    ##
+    # Create a new Radix::Float from value in Base-10.
+    # 
+    # @param [Numeric, Array, String] other
+    #   The value of the new integer in base-10.
+    #
+    # @return [Array<Radix::Float>] An array of the new Float object and self.
+    def coerce(other)
+      [Radix::Float.new(other), self]  
+    end
+
+    private
+
+    ##
+    # Perform passed arithmetic operation.
+    #
+    # @param [#to_f] other
+    #
+    # @return [Radix::Float] Result of binary operation in @base.
+    def operation(op, other)
+      a = self.to_f
+      b = other.to_f
+      x = a.__send__(op, b)
+      Radix::Float.new(x, base)
+
+    end
+
+    ##
+    # Returns two arrays. The integer part and the fractional part of the Float
+    # value in param base.
+    #
+    # @param [Float] value  Float's decimal value.
+    # @param [Fixnum] base  The base level of Float instance.
+    # @param [Fixnum] prec  The # of places to extend F-part.
+    #
+    # @return [Array<(Array[Fixnum], Array[Fixnum])>] 
+    def base_conversion(value, base, prec=10)
+      #if value < 0
+      #  @negative, value = true, value.abs
+      #end
+      value = value.to_f.abs
+
+      i, f = split_float(value)
+
+      a = []
+      while i > 0
+        i, r = i.divmod(base)
+        a << r
+      end
+
+      #c = [] # f-cache 
+      p = prec
+      b = []
+      while !f.zero?
+        k = (f * base)
+        r, f = split_float(k)
+        #c.include?(f) ? break : c << f
+        break if p == 0; p -= 1
+        b << r
+      end
+
+      a << 0 if a.empty?
+      b << 0 if b.empty?
+
+      [a.reverse, b]
+    end
+
+    ##
+    # Convert array of values of a different base to decimal as called by
+    # parse_array.
+    #
+    # @param [Array<Numeric, String>] digits  Representation of Base values.
+    # @param [Fixnum, Array<String>] base  The base to convert from.
+    #
+    # @return [Float] The digits of base converted to decimal.
+    def decimal(digits, base)
+      i, f = split_digits(digits)
+      e = i.size - 1
+      v = 0
+      (i + f).each do |n|
+        v += n * base**e
+        e -= 1
+      end
+      v
+    end
+
+    ##
+    # Returns the I-Part and F-Part of the passed value as arrays of fixnums.
+    # 
+    # @param [Array<Numeric, String>] value
+    #   The array of decimal values per column of @base.
+    #
+    # @return [Array<(Array<Fixnum>, Array<Fixnum>)>]
+    def split_digits(value)
+      if d = value.index(DOT) || value.index('.')
+        i, f = value[0...d], value[d+1..-1]
+      else
+        i, f = value, [0]
+      end
+      i.map!{ |x| x.to_i }
+      f.map!{ |x| x.to_i }
+      return i, f
+    end
+
+    ##
+    # Returns an array of Integer and Float portions of the Radix::Float
+    #
+    # @param [Radix::Float] float  Float value to split
+    #
+    # @return [Array<(Integer, Float)>]
+    def split_float(float)
+      i, f = float.to_s.split('.')
+      return i.to_i, ('0.'+f).to_f
+    end
+
+  end
+
+end
+