flt 1.0.0

data/Rakefile

@@ -0,0 +1,34 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  load 'tasks/setup.rb'
+end
+
+ensure_in_path 'lib'
+require 'flt/version'
+
+task :default => 'spec:run'
+
+
+PROJ.name = 'flt'
+PROJ.description = "Floating Point Numbers"
+PROJ.authors = 'Javier Goizueta'
+PROJ.email = 'javier@goizueta.info'
+PROJ.version = Flt::VERSION::STRING
+PROJ.rubyforge.name = 'flt'
+PROJ.url = "http://#{PROJ.rubyforge.name}.rubyforge.org"
+PROJ.rdoc.opts = [
+  "--main", "README.txt",
+  '--title', 'Ruby Flt Documentation',
+  "--opname", "index.html",
+  "--line-numbers",
+  "--inline-source"
+  ]
+#PROJ.test.file = 'test/all_tests.rb'
+
+# EOF

data/lib/flt.rb

@@ -0,0 +1,9 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'flt/version'
+require 'flt/support'
+require 'flt/float'
+require 'flt/bigdecimal'
+require 'flt/dec_num'
+require 'flt/bin_num'
+require 'flt/tolerance'

data/lib/flt/b.rb

@@ -0,0 +1,6 @@
+require 'flt/bin_num'
+
+B = Flt::BinNum
+def B(*args)
+  Flt.BinNum(*args)
+end

data/lib/flt/bigdecimal.rb

@@ -0,0 +1,151 @@
+# Support classes for homogeneous treatment of BigDecimal and Num values by defining BigDecimal.context
+
+require 'flt'
+require 'bigdecimal'
+require 'bigdecimal/math'
+
+require 'singleton'
+
+# Context class with some of the Flt::Num context functionality, to allow the use of BigDecimal numbers
+# similarly to other Num values; this eases the implementation of functions compatible with either
+# Num or BigDecimal values.
+class Flt::BigDecimalContext
+
+  include Singleton
+  # TODO: Context class with precision, rounding, etc. (no singleton)
+
+  def num_class
+    BigDecimal
+  end
+
+  def Num(*args)
+    args = *args if args.size==1 && args.first.is_a?(Array)
+    if args.size > 1
+      BigDecimal.new(DecNum(*args).to_s)
+    else
+      x = args.first
+      case x
+      when BigDecimal
+        x
+      when Rational
+        BigDecimal(x.numerator.to_s)/BigDecimal(x.denominator.to_s)
+      else
+        BigDecimal.new(x.to_s)
+      end
+    end
+  end
+
+  def radix
+    10
+  end
+
+  # NaN (not a number value)
+  def nan
+    BigDecimal('0')/BigDecimal('0')
+  end
+
+  def infinity(sign=+1)
+    BigDecimal(sign.to_s)/BigDecimal('0')
+  end
+
+  def zero(sign=+1)
+    BigDecimal("#{(sign < 0) ? '-' : ''}0")
+  end
+
+  def int_radix_power(n)
+    10**n
+  end
+
+  def exact?
+    BigDecimal.limit == 0
+  end
+
+  def precision
+    BigDecimal.limit
+  end
+
+  ROUNDING_MODES = {
+    BigDecimal::ROUND_UP=>:up,
+    BigDecimal::ROUND_DOWN=>:down,
+    BigDecimal::ROUND_CEILING=>:ceiling,
+    BigDecimal::ROUND_FLOOR=>:floor,
+    BigDecimal::ROUND_HALF_UP=>:half_up,
+    BigDecimal::ROUND_HALF_DOWN=>:half_down,
+    BigDecimal::ROUND_HALF_EVEN=>:half_even
+  }
+
+  def rounding
+    ROUNDING_MODES[BigDecimal.mode(BigDecimal::ROUND_MODE, nil)]
+  end
+
+  # Sign: -1 for minus, +1 for plus, nil for nan (note that Float zero is signed)
+  def sign(x)
+    x.sign < 0 ? -1 : +1
+  end
+
+  # Return copy of x with the sign of y
+  def copy_sign(x, y)
+    self_sign = x.sign
+    other_sign = y.is_a?(Integer) ? (y < 0 ? -1 : +1) : y.sign
+    if self_sign && other_sign
+      if self_sign == other_sign
+        x.to_f
+      else
+        -x.to_f
+      end
+    else
+      nan
+    end
+  end
+
+  def split(x)
+    sgn, d, b, e = x.split
+    [sgn<0 ? -1 : +1, d.to_i, e-d.size]
+  end
+
+  # Return the value of the number as an signed integer and a scale.
+  def to_int_scale(x)
+    sgn, d, b, e = x.split
+    c = d.to_i
+    [sgn<0 ? -1 : c, -c, e-d.size]
+  end
+
+  def special?(x)
+    x.nan? || x.infinite?
+  end
+
+  def plus(x)
+    x
+  end
+
+  def minus(x)
+    -x
+  end
+
+  class << self
+
+    def big_decimal_method(*methods) #:nodoc:
+      methods.each do |method|
+        if method.is_a?(Array)
+          float_method, context_method = method
+        else
+          float_method = context_method = method
+        end
+        define_method(context_method) do |x|
+          Num(x).send float_method
+        end
+      end
+    end
+
+  end
+
+  big_decimal_method :nan?, :infinite?, :zero?, :abs
+
+end
+
+# Return a (limited) context object for BigDecimal.
+# This eases the implementation of functions compatible with either Num or BigDecimal values.
+def BigDecimal.context
+  Flt::BigDecimalContext.instance
+end
+

data/lib/flt/bin_num.rb

@@ -0,0 +1,250 @@
+require 'flt/num'
+require 'flt/float'
+
+module Flt
+
+class BinNum < Num
+
+  class << self
+    # Numerical base.
+    def radix
+      2
+    end
+
+    # Integral power of the base: radix**n for integer n; returns an integer.
+    def int_radix_power(n)
+      (n < 0) ? (2**n) : (1<<n)
+    end
+
+    # Multiply by an integral power of the base: x*(radix**n) for x,n integer;
+    # returns an integer.
+    def int_mult_radix_power(x,n)
+      x * ((n < 0) ? (2**n) : (1<<n))
+    end
+
+    # Divide by an integral power of the base: x/(radix**n) for x,n integer;
+    # returns an integer.
+    def int_div_radix_power(x,n)
+      x / ((n < 0) ? (2**n) : (1<<n))
+    end
+  end
+
+  # This is the Context class for Flt::BinNum.
+  #
+  # The context defines the arithmetic context: rounding mode, precision,...
+  #
+  # BinNum.context is the current (thread-local) context for DecNum numbers.
+  class Context < Num::ContextBase
+
+    # See Flt::Num::ContextBase#new() for the valid options
+    #
+    # See also the context constructor method Flt::Num.Context().
+    def initialize(*options)
+      super(BinNum, *options)
+    end
+
+    # The special values are normalized for binary floats: this keeps the context precision in the values
+    # which will be used in conversion to decimal text to yield more natural results.
+
+    # Normalized epsilon; see Num::Context.epsilon()
+    def epsilon(sign=+1)
+      super.normalize
+    end
+
+    # Normalized strict epsilon; see Num::Context.epsilon()
+    def strict_epsilon(sign=+1)
+      super.normalize
+    end
+
+    # Normalized strict epsilon; see Num::Context.epsilon()
+    def half_epsilon(sign=+1)
+      super.normalize
+    end
+
+  end # BinNum::Context
+
+  class <<self # BinNum class methods
+
+    def base_coercible_types
+      unless defined? @base_coercible_types
+        @base_coercible_types = super.merge(
+          Float=>lambda{|x, context|
+            if x.nan?
+              BinNum.nan
+            elsif x.infinite?
+              BinNum.infinity(x<0 ? -1 : +1)
+            elsif x.zero?
+              BinNum.zero(Float.context.sign(x))
+            else
+              Float.context.split(x)
+            end
+          }
+        )
+      end
+      @base_coercible_types
+    end
+
+  end
+
+  # the DefaultContext is the base for new contexts; it can be changed.
+  # DefaultContext = BinNum::Context.new(
+  #                            :precision=>113,
+  #                            :emin=> -16382, :emax=>+16383,
+  #                            :rounding=>:half_even,
+  #                            :flags=>[],
+  #                            :traps=>[DivisionByZero, Overflow, InvalidOperation],
+  #                            :ignored_flags=>[],
+  #                            :capitals=>true,
+  #                            :clamp=>true)
+  DefaultContext = BinNum::Context.new(
+                             :exact=>false, :precision=>53, :rounding=>:half_even,
+                             :emin=> -1025, :emax=>+1023,                             :flags=>[],
+                             :traps=>[DivisionByZero, Overflow, InvalidOperation],
+                             :ignored_flags=>[],
+                             :capitals=>true,
+                             :clamp=>true)
+
+  ExtendedContext = BinNum::Context.new(DefaultContext,
+                             :traps=>[], :flags=>[], :clamp=>false)
+
+  IEEEHalfContext = BinNum::Context.new(
+                            :precision=>1,
+                            :emin=> -14, :emax=>+15,
+                            :rounding=>:half_even,
+                            :flags=>[],
+                            :traps=>[DivisionByZero, Overflow, InvalidOperation],
+                            :ignored_flags=>[],
+                            :capitals=>true,
+                            :clamp=>true)
+
+  IEEESingleContext = BinNum::Context.new(
+                            :precision=>24,
+                            :emin=> -126, :emax=>+127,
+                            :rounding=>:half_even,
+                            :flags=>[],
+                            :traps=>[DivisionByZero, Overflow, InvalidOperation],
+                            :ignored_flags=>[],
+                            :capitals=>true,
+                            :clamp=>true)
+
+  IEEEDoubleContext = BinNum::Context.new(
+                            :precision=>53,
+                            :emin=> -1022, :emax=>+1023,
+                            :rounding=>:half_even,
+                            :flags=>[],
+                            :traps=>[DivisionByZero, Overflow, InvalidOperation],
+                            :ignored_flags=>[],
+                            :capitals=>true,
+                            :clamp=>true)
+
+  IEEEQuadContext = BinNum::Context.new(
+                            :precision=>113,
+                            :emin=> -16382, :emax=>+16383,
+                            :rounding=>:half_even,
+                            :flags=>[],
+                            :traps=>[DivisionByZero, Overflow, InvalidOperation],
+                            :ignored_flags=>[],
+                            :capitals=>true,
+                            :clamp=>true)
+
+  IEEEExtendedContext = BinNum::Context.new(
+                            :precision=>64,
+                            :emin=> -16382, :emax=>+16383,
+                            :rounding=>:half_even,
+                            :flags=>[],
+                            :traps=>[DivisionByZero, Overflow, InvalidOperation],
+                            :ignored_flags=>[],
+                            :capitals=>true,
+                            :clamp=>true)
+
+  if Float::RADIX==2
+    FloatContext = BinNum::Context.new(
+                               :precision=>Float::MANT_DIG,
+                               :rounding=>Support::AuxiliarFunctions.detect_float_rounding,
+                               :emin=>Float::MIN_EXP-1, :emax=>Float::MAX_EXP-1,
+                               :flags=>[],
+                               :traps=>[DivisionByZero, Overflow, InvalidOperation],
+                               :ignored_flags=>[],
+                               :capitals=>true,
+                               :clamp=>true)
+  end
+
+
+  # A BinNum value can be defined by:
+  # * A String containing a decimal text representation of the number
+  # * An Integer
+  # * A Rational
+  # * A Float
+  # * Another BinNum value.
+  # * A sign, coefficient and exponent (either as separate arguments, as an array or as a Hash with symbolic keys).
+  #   This is the internal representation of DecNum, as returned by DecNum#split.
+  #   The sign is +1 for plus and -1 for minus; the coefficient and exponent are
+  #   integers, except for special values which are defined by :inf, :nan or :snan for the exponent.
+  # * Any other type for which custom conversion is defined in the context.
+  #
+  # An optional Context can be passed as the last argument to override the current context; also a hash can be passed
+  # to override specific context parameters.
+  #
+  # Except for custome defined conversions and text (String) input, BinNums are constructed with the precision
+  # specified by the input parameters (i.e. with the exact value specified by the parameters)
+  # and the context precision is ignored. If the BinNum is defined by a decimal text numeral, it is converted
+  # to a binary BinNum using the context precision.
+  #
+  # The Flt.BinNum() constructor admits the same parameters and can be used as a shortcut for DecNum creation.
+  def initialize(*args)
+    super(*args)
+  end
+
+  def number_of_digits
+    @coeff.is_a?(Integer) ? _nbits(@coeff) : 0
+  end
+
+  # Specific to_f conversion TODO: check if it represents an optimization
+  if Float::RADIX==2
+    def to_f
+      if special?
+        super
+      else
+        Math.ldexp(@sign*@coeff, @exp)
+      end
+    end
+  end
+
+  # Exact BinNum to DecNum conversion: preserve BinNum value.
+  #
+  # The current DecNum.context determines the valid range and the precision
+  # (if its is not :exact the result will be rounded)
+  def to_decimal_exact(dec_context=nil)
+    Num.convert_exact(self, DecNum, dec_context)
+  end
+
+  # Approximate BinNum to DecNum conversion.
+  #
+  # Convert to decimal so that if the decimal is converted to a BinNum of the same precision
+  # and with same rounding (i.e. BinNum.from_decimal(x, context)) the value of the BinNum
+  # is preserved, but use as few decimal digits as possible.
+  def to_decimal(*args)
+    Num.convert(self, DecNum, *args)
+  end
+
+  # DecNum to BinNum conversion.
+  def BinNum.from_decimal(x, binfloat_context=nil)
+    Flt.BinNum(x.to_s, binfloat_context)
+  end
+
+  # Unit in the last place: see Flt::Num#ulp()
+  #
+  # For BinNum the result is normalized
+  def ulp(context=nil, mode=:low)
+    super(context, mode).normalize(context)
+  end
+
+end
+
+module_function
+def BinNum(*args)
+  BinNum.Num(*args)
+end
+
+
+end # Flt