flt 1.2.1 → 1.3.0

data/History.txt

@@ -1,3 +1,13 @@
+== 1.3.0 2010-06-22
+
+* New features
+  - Complex math
+  - Hyperbolic trigonometry
+
+* Bugfixes
+  - Num.context use was counter-intuitive
+  - Various math corrections
+
 == 1.2.1 2010-06-16
 
 * New features

data/Manifest.txt

@@ -9,6 +9,8 @@ lib/flt/num.rb
 lib/flt/support.rb
 lib/flt/dec_num.rb
 lib/flt/math.rb
+lib/flt/trigonometry.rb
+lib/flt/complex.rb
 lib/flt/bin_num.rb
 lib/flt/float.rb
 lib/flt/bigdecimal.rb
@@ -18,6 +20,8 @@ lib/flt/d.rb
 lib/flt/b.rb
 lib/flt/sugar.rb
 setup.rb
+test/generate_trig_data.rb
+test/reader.rb
 test/all_tests.rb
 test/helper.rb
 test/test_basic.rb
@@ -38,5 +42,6 @@ test/test_bin.rb
 test/test_binfloat_conversion.rb
 test/test_bin_arithmetic.rb
 test/test_tol.rb
+test/test_trig.rb
 test/reader.rb
 test/test_num_constructor.rb

data/README.txt

@@ -10,8 +10,8 @@ The Flt::Tolerance classes and the Flt.Tolerance() constructor handle floating p
 tolerances defined in flexible ways.
 
 Context classes are define in the files
-flt/float.rb[link:files/lib/flt/float_rb.html] and
-flt/bigdecimal.rb[link:files/lib/flt/bigdecimal_rb.html]
+flt/float.rb[link:lib/flt/float_rb.html] and
+flt/bigdecimal.rb[link:lib/flt/bigdecimal_rb.html]
 for Float and BigDecimal numbers that aid to the interchangeability of floating point types. This
 represent the only definition of identifiers outside the Flt namespace: the methods
 Float.context() and BigDecimal.context() and some contants in Float.
@@ -375,7 +375,7 @@ This file defines +D+ as a synonym for +DecNum+:
   puts +D('1.234')                                 # -> 1.23
 
 Some convenient methods are added to numeric classes by requiring the optional
-flt/sugar.rb[link:files/lib/flt/sugar_rb.html]. This must be explicitely required
+flt/sugar.rb[link:lib/flt/sugar_rb.html]. This must be explicitely required
 because it could cause conflicts with other extensions of these classes.
 
   require 'flt/sugar'
@@ -401,6 +401,12 @@ decimal point):
   puts 100_000.000_001                            # -> 100000.000001
   puts 100_000.000_001.class                      # -> Float
 
+There's also one important caveat with this notation: negative numbers with a zero integral part must be
+parenthesed (otherwise the minus has no effect because it affects only the null integer part):
+
+  puts -0._5                                      # -> 0.5
+  puts -(0._5)                                    # -> -0.5
+
 == Error analysis
 
 The DecNum#ulp() method returns the value of a "unit in the last place" for a given number under
@@ -502,21 +508,21 @@ Note also that if we normalize a value we will change it's precision to that of
 
 There are two mathematical functions modules analogous to Ruby's Math for Float,
 Flt::DecNum::Math and Flt::BinNum::Math.
-Currently they consist of basic trigonometric functions, including hypot, and the
-constants e and pi.
+Currently they consist of basic trigonometric functions, including hypot, logarithms and the exponential
+function, and the constants e and pi.
 
 Its functions can be accessed in a number of ways:
 
   require 'flt/math'
   DecNum.context(:precision=>10) do |context|
-    # As module functions:
+    # As module functions, using the current context for the enclosing Num class:
     puts DecNum::Math.sin(1)*DecNum::Math.pi        # -> 2.643559064
     # As functions of a context object:
     puts context.sin(1)*context.pi                  # -> 2.643559064
     # Through a math block:
       puts DecNum.context.math{sin(1)*pi}           # -> 2.643559064
       puts DecNum.math{sin(1)*pi}                   # -> 2.643559064
-    # And can be included to be used ans private instance methods:
+    # And can be *included* to be used as private instance methods:
       include DecNum::Math
       puts sin(1)*pi                                # -> 2.643559064
   end
@@ -527,10 +533,11 @@ Its functions can be accessed in a number of ways:
 * Binary Floating point type: see the base Flt::Num class and the Flt::BinNum class
 * Floating Point Contexts: see documentation for classes Flt::Num::ContextBase,
   Flt::DecNum::Context and Flt::BinNum::Context
-* Floating Point Tolerance: see the flt/tolerance.rb[link:files/lib/flt/tolerance_rb.html] file
+* Floating Point Tolerance: see the flt/tolerance.rb[link:lib/flt/tolerance_rb.html] file
   and the Flt::Tolerance class
 * Constructors: see Flt.DecNum(), Flt.BinNum() and Flt.Tolerance().
-* Mathematical functions: see Flt::MathBase.
+* Trigonometry functions: see Flt::Trigonometry.
+* Complex number support: see the flt/complex.rb[link:lib/flt/complex_rb.html] file
 
 = DecNum vs BigDecimal
 
@@ -592,7 +599,6 @@ EXPAND+
 = Roadmap
 
 * Trigonometry optimizations
-* Complex support.
 * Implement the missing GDA functions:
   rotate, shift, trim, and, or, xor, invert,
   max, min, maxmag, minmag, comparetotal, comparetotmag

data/lib/flt/bin_num.rb

@@ -11,6 +11,10 @@ class BinNum < Num
       2
     end
 
+    def one_half
+      new [+1, 1, -1]
+    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)

data/lib/flt/complex.rb

@@ -0,0 +1,312 @@
+# Complex number support for Flt::Num types.
+#
+# Complex is extended to handle properly components of Num types.
+#
+# Examples:
+#   require 'flt/complex'
+#   include Flt
+#   DecNum.context(:precision=>4) do
+#     puts (Complex(1,2)*DecNum(2)).abs.inspect            # => DecNum('4.472')
+#   end
+#
+# Complex functions are provided through Num.ccontext object, Context#.cmath blocks and CMath modules.
+#
+# Examples:
+#   require 'flt/complex'
+#   include Flt
+#   DecNum.context.precision = 10
+#   puts DecNum.ccontext.sqrt(-2)                           # => 0+1.414213562i
+#   puts DecNum.ccontext(:precision=>5).sqrt(-2)            # => 0+1.4142i
+#   puts DecNum.context(:precision=>6).cmath{sqrt(-2)}      # => 0+1.41421i
+#
+# CMath Examples:
+#   DecNum.context(:precision=>5) do
+#     puts DecNum::CMath.sqrt(-2)                           # => 0+1.4142i
+#   end
+#   DecNum.context.precision = 10
+#   include DecNum::CMath
+#   puts sqrt(-2)                                           # => 0+1.414213562i
+#
+
+require 'flt/math'
+require 'complex'
+
+class Complex
+
+  alias abs! abs
+  def abs
+    num_class.nil? ? abs! : num_class.context.hypot(real, imag)
+  end
+
+  alias polar! polar
+  def polar
+    num_class.nil? ? polar! : [num_class.context.hypot(real, imag), num_class.context.atan2(imag, real)]
+  end
+
+  # alias power! **
+  # def **(other)
+  #   if classnum_class_num.nil? && other.class_num.nil?
+  #     self.power!(other)
+  #   else
+  #     num_class.ccontext.power(self, other)
+  #   end
+  # end
+
+  private
+
+  def num_class
+    real.kind_of?(Flt::Num) ? real.class : imag.kind_of?(Flt::Num) ? imag.class : nil
+  end
+
+end # Complex
+
+module Flt
+
+  class ComplexContext # consider: < Num::ContextBase
+
+    def initialize(context)
+      @context = context
+    end
+
+    def num_class
+      @context.num_class
+    end
+
+    def math
+      num_class.context
+    end
+
+    def Num(z)
+      if z.kind_of?(Complex)
+        Complex.rectangular(*z.rectangular.map{|v| @context.num_class[v]})
+      else
+        Complex.rectangular(@context.num_class[z])
+      end
+    end
+
+    def abs(z)
+      z.abs
+    end
+
+    def self.math_function(mth, negative_arg_to_complex=false, extra_prec=3, &blk)
+      class_eval do
+        define_method mth do |*args|
+          is_complex = args.detect{|z| z.kind_of?(Complex)}
+          if is_complex || (negative_arg_to_complex && args.first<0)
+            num_class.context(:extra_precision=>extra_prec) do |mth|
+              #Complex.rectangular *blk[mth, *args].map{|v| @context.plus(v)}
+              Complex.rectangular *instance_exec(mth,*args,&blk).map{|v| @context.plus(v)}
+            end
+          else
+            @context.send(mth, *args) # Num(@context.send(mth, *args)) ?
+          end
+        end
+      end
+    end
+
+    math_function :exp do |mth, z|
+      re_exp = mth.exp(z.real)
+      [re_exp * mth.cos(z.imag), re_exp * mth.sin(z.imag)]
+    end
+
+    math_function :log, true do |mth, x, *args| # we can do |mth, x, b=nil| in Ruby 1.9 but not in 1.8
+      b = args.first
+      r, theta = Num(x).polar
+      [mth.log(r, b), theta]
+    end
+
+    math_function :ln, true do |mth, x|
+      r, theta = Num(x).polar
+      [mth.ln(r), theta]
+    end
+
+    math_function :log2, true do |mth, x|
+      r, theta = Num(x).polar
+      [mth.log2(r), theta]
+    end
+
+    math_function :log10, true do |mth, x|
+      r, theta = Num(x).polar
+      [mth.log10(r), theta]
+    end
+
+    math_function :power, true, 4 do |mth, x, y|
+      if (y.respond_to?(:zero?) && y.zero?) || y==0
+        [1,0]
+      else
+        r, theta = Num(x).polar
+        ore, oim = y.kind_of?(Complex) ? y.rectangular : [y, 0]
+        log_r = mth.ln(r)
+        nr = mth.exp(ore*log_r - oim*theta)
+        ntheta = theta*ore + oim*log_r
+        [nr*mth.cos(ntheta), nr*mth.sin(ntheta)]
+      end
+    end
+
+    def sqrt(z)
+      z_is_complex = z.kind_of?(Complex)
+      if z_is_complex || z<0
+        if z_is_complex
+          re = im = nil
+          num_class.context(:extra_precision=>3) do |mth|
+            z = Num(z)
+            i_sign = z.imag.sign
+            r = abs(z)
+            x = z.real
+            re = ((r+x)/2).sqrt
+            im = ((r-x)/2).sqrt.copy_sign(i_sign)
+          end
+          fix_rect(re, im)
+        else
+          Complex(0, @context.sqrt(-z))
+        end
+      else
+        @context.sqrt(z)
+      end
+    end
+
+    math_function :sin do |mth, z|
+      [mth.sin(z.real)*mth.cosh(z.imag), mth.cos(z.real)*mth.sinh(z.imag)]
+    end
+
+    math_function :cos do |mth, z|
+      [mth.cos(z.real)*mth.cosh(z.imag), -mth.sin(z.real)*mth.sinh(z.imag)]
+    end
+
+    math_function :tan do |mth, z|
+      mth.cmath{sin(z)/cos(z)}.rectangular
+    end
+
+    math_function :atan do |mth, z|
+      i = Complex(0,mth.num_class[1])
+      mth.cmath{i*ln((i+z)/(i-z))*num_class.one_half}.rectangular
+    end
+
+    math_function :sinh do |mth, z|
+      [mth.sinh(z.real)*mth.cos(z.imag), mth.cosh(z.real)*mth.sin(z.imag)]
+    end
+
+    math_function :cosh do |mth, z|
+      [mth.cosh(z.real)*mth.cos(z.imag), mth.sinh(z.real)*mth.sin(z.imag)]
+    end
+
+    math_function :tanh do |mth, z|
+      mth.cmath{sinh(z)/cosh(z)}.rectangular
+    end
+
+    math_function :asinh do |mth, z|
+      mth.cmath{ln(z+sqrt(z*z+1))}.rectangular
+    end
+
+    def asin(z)
+      z_is_complex = z.kind_of?(Complex)
+      if z_is_complex || z.abs>1
+        # z = Complex(1) unless z_is_complex
+        i = Complex(0,@context.num_class[1])
+        fix num_class.context(:extra_precision=>3).cmath {
+          -i*ln(i*z + sqrt(1-z*z))
+        }
+      else
+        @context.asin(z)
+      end
+    end
+
+    def acos(z)
+      z_is_complex = z.kind_of?(Complex)
+      if z_is_complex || z.abs>1
+        # z = Complex(1) unless z_is_complex
+        i = Complex(0,@context.num_class[1])
+        fix num_class.context(:extra_precision=>3).cmath {
+          -i*ln(z + i*sqrt(1-z*z))
+        }
+      else
+        @context.acos(z)
+      end
+    end
+
+    def acosh(z)
+      z_is_complex = z.kind_of?(Complex)
+      if z_is_complex || z<=1
+        # z = Complex(1) unless z_is_complex
+        fix num_class.context(:extra_precision=>3).cmath{ ln(z + sqrt(z*z-1)) }
+      else
+        @context.acosh(z)
+      end
+    end
+
+    def atanh(z)
+      z_is_complex = z.kind_of?(Complex)
+      if z_is_complex || z.abs>1
+        # z = Complex(1) unless z_is_complex
+        i = Complex(0,@context.num_class[1])
+        fix num_class.context(:extra_precision=>3).cmath{ num_class.one_half*ln((1+z)/(1-z)) }
+      else
+        @context.atanh(z)
+      end
+    end
+
+    extend Forwardable
+    def_delegators :@context, :pi
+
+
+    private
+
+    def fix_rect(re, im)
+      Complex(@context.plus(re), @context.plus(im))
+    end
+
+    def fix_polar(r, theta)
+      num_class.context(:extra_precision=>3) do |mth|
+        re = r*mth.cos(theta)
+        im = r*mth.sin(theta)
+      end
+      fix_rect(re, im)
+    end
+
+    def fix(z)
+      fix_rect *z.rectangular
+    end
+
+  end # ComplexContext
+
+  class Num
+
+    def self.ccontext(*args)
+      ComplexContext(self.context(*args))
+    end
+
+    class ContextBase
+      def cmath(*parameters, &blk)
+        # if ComplexContext is derived from ContextBase: return ComplexContext(self).math(*parameters, &blk)
+        num_class.context(self) do
+          if parameters.empty?
+            Flt.ComplexContext(num_class.context).instance_eval &blk
+          else
+            Flt.xiComplexContext(num_class.context).instance_exec *parameters, &blk
+          end
+        end
+      end
+    end
+
+  end # Num
+
+  module_function
+  def ComplexContext(context)
+    ComplexContext.new(context)
+  end
+
+  module DecNum::CMath
+    include MathBase
+    num_class(DecNum){num_class.ccontext}
+    math_function *Trigonometry.public_instance_methods
+    math_function :exp, :log, :log2, :log10, :sqrt
+  end
+
+  module BinNum::CMath
+    include MathBase
+    num_class(BinNum){num_class.ccontext}
+    math_function *Trigonometry.public_instance_methods
+    math_function :exp, :log, :log2, :log10, :sqrt
+  end
+
+end # Flt

data/lib/flt/dec_num.rb

@@ -44,27 +44,6 @@ class DecNum < Num
     def initialize(*options)
       super(DecNum, *options)
     end
-
-    # Power. See DecNum#power()
-    def power(x,y,modulo=nil)
-      _convert(x).power(y,modulo,self)
-    end
-
-    # Returns the base 10 logarithm
-    def log10(x)
-      _convert(x).log10(self)
-    end
-
-    # Exponential function: e**x
-    def exp(x)
-      _convert(x).exp(self)
-    end
-
-    # Returns the natural (base e) logarithm
-    def ln(x)
-      _convert(x).ln(self)
-    end
-
   end
 
   # the DefaultContext is the base for new contexts; it can be changed.