appmath 0.0.1

data/lib/appmath_basics.rb

@@ -0,0 +1,118 @@
+=begin rdoc
+ruby
+
+Ulrich Mutze, www.ulrichmutze.de 
+
+2008-12-09
+
+Defines the module AppMath::Basics.
+
+Requires files rnum and float_ext.
+
+The intention is that a statement
+  require 'appmath_basics.rb'
+allows us to use in the following a programming style in which the concept
+of real numbers is handled in a flexibel manner so that switching from
+standard type Float to arbitrary precision type R can be achieved
+by a single statement of the type
+  R.prec = 0 ( for using Float)
+or 
+  R.prec = 100 ( for using R with 100 decimal places ) 
+All modules and classes to be defined furtheron within the module
+  AppMath
+will require appmath_basics.rb and will use real numbers in the manner
+indicated above.
+    Copyright (C) 2008  Ulrich Mutze
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+=end 
+
+require File.join(File.dirname(__FILE__), 'rnum')
+require File.join(File.dirname(__FILE__), 'float_ext')
+#require 'rnum'
+#require 'float_ext'
+
+# A Module which collects concepts of applied mathematics and of physics.
+module AppMath 
+
+# A Module which collects simple utility functions.
+module Basics
+
+# Returns the larger of the two numbers a and b.
+def Basics.sup(a, b)
+  a <= b ? b : a
+end 
+
+# Returns the smaller of the two numbers a and b.
+def Basics.inf(a, b)
+  a < b ? a : b
+end 
+
+# Returns the sign of a as a real number.
+def Basics.sign(a)
+  if a > R.c0
+    R.c1
+  elsif a < R.c0
+    -R.c1
+  else
+    R.c0
+  end
+end
+
+# Returns 'a with the sign of b'. Programming idiom frequently used in
+# the 'Numerical Recipes in C' by Press et al.
+def Basics.sign2(a, b)
+  b >= R.c0 ? a.abs : -a.abs
+end
+
+# Returns the nearest number to x, which up to sign and power of 10
+# is one of the numbers in the array c in the function
+# body. For instance,
+#   c = [1,2,5,7.5,10]
+# In a sense, here cutting is a more drastic version of rounding.
+# It will be used in order to create reasonable axis subdivsion in
+# graphical representation of data.
+def Basics.cut(x)
+  fail "x is not a number" if x.nan?
+  fail "x is not finite" if x.infinite?
+  c = [R.c1,R.c2,R.c5,R.c(7.5),R.c10]
+  return R.c0 if x.zero? 
+  s = Basics.sign(x)
+  y1 = x.abs
+  ylog = y1.log10
+  ylogInt = ylog.floor
+  yMantisse = ylog - ylogInt
+  y = R.c10 ** yMantisse
+  fail "Basics.cut(): !(1 <= y)" if !(R.c1 <= y)
+  fail "Basics.cut(): !(y < 10)" if !(y < R.c10)
+  i = 0
+  while y > c[i] 
+    i += 1
+  end
+  cd = c.length
+  fail "unexpected failure in function Basics.cut" if i < 0 || i >= cd
+  yu = c[i] # yu is the smallest c[k] which is larger or equal to y
+  if i==0
+    yf = yu
+  else
+    fail "unexpected failure in function Basics.cut" if (i-1) < 0 || (i-1) >= cd
+    yl = c[i-1]
+    yf = yu-y <y -yl ? yu : yl # now yf is the c[k] which is nearest to y
+  end
+  return yf.ldexp(ylogInt) * s # sign and exponent are restored
+end  
+
+end # Basics
+
+end # module AppMath

data/lib/cnum.rb

@@ -0,0 +1,615 @@
+=begin rdoc
+ruby
+
+Ulrich Mutze  www.ulrichmutze.de
+
+Started 2008-12-03 by modifying cpmc.h and cpmc.cpp
+
+Defining a class C of complex numbers.
+
+Defines the class AppMath::C.
+
+Requires file appmath_basics.
+
+    Copyright (C) 2008  Ulrich Mutze
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+=end 
+
+require File.join(File.dirname(__FILE__), 'appmath_basics')
+#require 'appmath_basics'
+
+module AppMath 
+
+# Class of arbitrary precision complex numbers. The underlying real numbers may be Float
+# or R.
+class C < Numeric 
+
+  attr_reader :re, :im
+
+  def initialize(*arg)
+    n = arg.size
+    case n
+    when 0
+      @re = R.c0
+      @im = R.c0
+    when 1
+      a0 = arg[0]
+      if a0.integer? || a0.real?
+        @re = R.c a0
+        @im = R.c0
+      elsif a0.complex? 
+        @re = R.c a0.re
+        @im = R.c a0.im
+      else
+        fail "can't construct a C from this argument"
+      end
+    when 2
+      a0 = R.c arg[0]; a1 = R.c arg[1]
+        @re = a0
+        @im = a1
+    else
+       fail "can't construct a C from more than two arguments"
+    end
+  end
+  
+ def clone; C.new(@re,@im); end
+
+# The constant 0.
+  def C.zero
+    C.new
+  end
+  
+# The constant 1.  
+  def C.one
+    C.new(R.c1,R.c0)
+  end
+# The constant i  
+  def C.i
+    C.new(R.c0,R.c1)
+  end
+
+# Random value (sine-floor random generator).
+#
+# Chaotic function from the integers into the
+# subset [0,1] x [0,1] of C
+
+  def C.ran(anInteger)
+    ai = anInteger.to_i * 2
+    x1 = R.ran(ai)
+    x2 = R.ran(ai + 1)
+    C.new(x1,x2)
+  end 
+  
+# Test object.
+#
+# Needed for automatic tests of arithmetic relations. Intended
+# to give numbers which rapidly change sign and order of 
+# magnitude when the argument grows regularly e.g.
+# as in 1,2,3,... . However, suitibility as a random generator is
+# not the focus. If the second argument is 'true', the result
+# is multplied by a number << 1 in order to prevent the result
+# from overloading the exponential function.
+
+  def C.tob(anInteger, small = false)
+    ai = anInteger.to_i * 2
+    x1 = R.tob(ai,small)
+    x2 = R.tob(ai + 1,small)
+    C.new(x1,x2)
+  end
+ 
+# Unary minus operator. It returns the C-object -self.
+  def -@; C.new(-@re, -@im); end
+  
+# Unary plus operator. It returns the C-object self.
+  def +@; self; end  
+
+# (Complex) conjugation, no effect on real numbers.
+# Supports the unified treatment of real and complex numbers.
+  def conj; C.new(@re, -@im); end  
+ 
+# Returns self times i. 
+  def ti; self * C.i; end
+
+# Returns self divided by i. 
+  def dbi; self * C.new(0,-1); end
+
+# Returns the absolute value of self.
+  def abs; @re.hypot(@im); end
+   
+# Returns the absolute value squared of self.
+  def abs2; @re * @re + @im * @im; end
+  
+# Returns the argument (i.e. the polar angle) of self.
+  def arg; @re.arg(@im); end
+    
+# Redefining coerce from Numeric.
+# This allows writing 1 + C.new(137) instead of C.new(137) + 1
+# or C.new(137) + R.c1.
+#-- Notice that the order in the resulting array is essential for
+# correct functionality.
+  def coerce(a)
+    [ C.new(a), self]
+  end
+ 
+# The order relation is here lexicographic ordering based on the
+# agreement that re is the 'first letter' and im the 'second letter'
+# of 'the word'. Needed only for book-keeping purposes.
+  def <=> (a)
+    cr = @re <=> a.re
+    return cr unless cr.zero?
+    ci = @im <=> a.im
+    return ci unless ci.zero?
+    return 0
+  end
+
+# Returns 'true' if self equals zero.
+  def zero?; @re.zero? && @im.zero?; end
+  
+# Returns 'true' if self is 'not a number' (NaN).
+  def nan?; @re.nan? || @im.nan?; end
+ 
+# Returns 'true' if the real art or the iaginary part of self is
+# infinite.
+  def infinite?; @re.infinite? || @im.infinite?; end
+
+# Since R is not Fixnum or Bignum we return 'false'. In scientific
+# computation there may be the need to use various types of 
+# 'real number types' but there should always a clear-cut distinction
+# between integer types and real types.
+  def integer?; false; end
+  
+# Supports the unified treatment of real and complex numbers. 
+  def real?; false; end
+  
+# Supports the unified treatment of real and complex numbers.  
+  def complex?; true; end
+  
+# Returns the C-object self + a. 
+  def +(a)
+    if a.integer? || a.real?
+      b = R.c a
+      C.new(@re + b, @im)
+    elsif a.complex?
+      C.new(@re + a.re, @im + a.im)
+    else
+      fail "cannot add this argument to a complex number"
+    end
+  end
+  
+# Returns the C-object self - a. 
+  def -(a)
+    if a.integer? || a.real?
+      b = R.c a
+      C.new(@re - b, @im)
+    elsif a.complex?
+      C.new(@re - a.re, @im - a.im)
+    else
+      fail "cannot subtract this argument from a complex number"
+    end  
+    
+  end  
+
+ # Returns the C-object self * a. 
+  def *(a)
+    if a.integer? || a.real?
+      b = R.c a
+      C.new(@re * b, @im * b)
+    elsif a.complex?
+      C.new(@re * a.re - @im * a.im , @re * a.im + @im * a.re )
+    else
+      fail "cannot multiply a complex number with this argument"
+    end
+  end
+ 
+ # Returns the C-object self / a. 
+  def /(a)
+    if a.integer? || a.real?
+      b = R.c a
+      C.new(@re / b, @im / b)
+    elsif a.complex?
+      r2 = a.abs2
+      C.new((@re * a.re + @im * a.im)/r2 , (@im * a.re - @re * a.im)/r2 )
+    else
+      fail "cannot divide a complex number by this argument"
+    end
+  end
+ 
+# Exponential function.
+  def exp; C.new(@im.cos, @im.sin) * @re.exp; end
+
+# Exponential function of the argument multiplied by C.i
+  def expi; (self * C.i).exp; end
+ 
+
+# Natural logarithm. 
+  def log; C.new(abs.log,arg); end
+
+# Returns the a-th power of self. A may be integer, real, or
+# complex. The result is always complex.
+  def **(a)
+    return C.nan if nan?
+    if a.integer?
+      if a.zero?
+        C.one
+      elsif a == 1
+        self
+      elsif a == -1
+        inv
+      else
+        b = a.abs
+        res = self
+        for i in 1...b
+          res *= self
+        end
+        if a < 0
+          res = res.inv
+        end
+        res
+      end
+    elsif a.real?
+      b = C.new(a)
+      (log * b).exp
+    elsif a.complex?
+      (log * a).exp
+    else
+      fail "Argument not acceptable as an exponent"
+    end
+  end
+
+# Returns the zero-element which belongs to the same class than self  
+  def to_0; C.zero; end
+
+# Returns the unit-element which belongs to the same class than self  
+  def to_1; C.one; end
+  
+# Returns the inverse 1/self.
+  def inv
+     C.one / self
+  end
+
+# Returns 'true' iff self == C(0,0)
+  def zero?; @re.zero? && @im.zero?; end
+ 
+# The pseudo_inverse of zero is zero, and equal to the inverse for
+# all other arguments.
+  def pseudo_inv
+     zero? ? C.zero : C.one / self
+  end
+  
+# For the return value res we have res.int? true and (self - res).abs <= 0.5  
+  def round(n)
+    u = @re.round(n)
+    v = @im.round(n)
+    C.new(u,v)
+  end
+  
+# Returns the square root of self.
+  def sqrt
+    self ** R.i2
+  end
+  
+# Returns a kind of relative distance between self and aR.
+# The return value varies from 0 to 1, where 1 means maximum dissimilarity
+# of the arguments.
+# Such a function is needed for testing the validity of arithmetic laws,
+# which, due to numerical noise, should not be expected to be fulfilled
+# exactly.
+  def dis(aC)
+    a = abs
+    b = aC.abs
+    d = (self - aC).abs
+    s = a + b
+    return R.c0 if s.zero?
+    d1 = d/s
+    Basics.inf(d,d1)
+  end
+
+# Conversion to String.
+  def to_s; "C(#{@re}, #{@im})"; end
+ 
+ # Printing the value together with a label
+  def prn(name)
+    puts "#{name} = " + to_s
+  end  
+#=begin  
+
+# Sine.
+  def sin 
+    (expi - (-self).expi) * C.new(0,-R.i2)
+  end
+
+# Cosine.
+  def cos
+    (expi + (-self).expi) * R.i2
+  end
+
+# Tangent.
+  def tan
+    sin / cos
+  end
+
+# Cotangent.
+  def cot
+    cos / sin
+  end
+
+# Hyperbolic sine.
+  def sinh; (exp - (-self).exp) * R.i2; end
+
+# Hyperbolic cosine.
+  def cosh; (exp + (-self).exp) * R.i2; end
+ 
+# Hyperbolic tangent. 
+  def tanh
+    s = exp - (-self).exp
+    c = exp + (-self).exp
+    s/c
+  end
+
+# Hyperbolic cotangent.
+  def coth
+    s = exp - (-self).exp
+    c = exp + (-self).exp
+    c/s
+  end
+  
+# Inverse hyperbolic sine.
+  def asinh
+     ((self * self + C.one).sqrt + self).log
+  end
+  
+# Inverse hyperbolic cosine.
+  def acosh
+    ((self * self - C.one).sqrt + self).log
+  end 
+
+# Inverse hyperbolic tangent.
+  def atanh
+    ((C.one + self)/(C.one - self)).log * R.i2
+  end  
+  
+# Inverse hyperbolic cotangent.
+  def acoth
+    ((self + C.one)/(self - C.one)).log * R.i2
+  end 
+
+# Inverse sine.
+  def asin
+    ti.asinh.dbi
+  end
+  
+# Inverse cosine.
+  def acos
+    acosh.dbi
+  end  
+  
+# Inverse tangent.
+  def atan 
+    ti.atanh.dbi
+  end
+
+# Inverse cotangent.
+  def acot 
+    ti.acoth.ti
+  end  
+  
+# Consistency test for class C
+# This is intended to keep the class consistent despite of modifications. 
+# The first argument influences the numbers which are selected for the
+# test. Returned is a sum of numbers each of which should be numerical
+# noise and so the result has to be << 1 if the test is to indicate 
+# success.
+# For instance, on my system 
+#
+#   Doing C.test(n = 137, verbose = false) for R.dig = 100:
+#   *************************************************
+#   class of s is AppMath::R
+#   class of s is AppMath::R .
+#   The error sum s is 0.95701879151814897746312007872622225589589551941
+#   73186692168823486932509515793972625242699350133964052E-98 .
+#   It should be close to 0.
+#   Computation time was 1.062 seconds.
+  
+  def C.test(n0, verbose = false )
+    puts "Doing C.test(n = #{n0}, verbose = #{verbose})" +
+      " for R.dig = #{R.dig}:"
+    puts "*************************************************"
+    t1 = Time.now
+    small = true # otherwise not all inverse function tests work well 
+    s = R.c0
+    puts "class of s is " + s.class.to_s
+    i = n0
+    a = C.tob(i,small) 
+    i += 1
+    b = C.tob(i,small)
+    i += 1
+    c = C.tob(i,small)
+    i += 1
+    
+    if verbose
+      a.prn("a")
+      b.prn("b")
+      c.prn("c")
+    end
+  
+    r = 2 + a
+    l = a + 2
+    ds = r.dis(l)
+    puts "coerce 2 + a: ds = " + ds.to_s if verbose
+    s += ds
+    
+    r =  a + 1.234
+    l =  a + R.c(1.234)
+    ds = r.dis(l)
+    puts "coerce a + float: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = (a + b) * c
+    l = a * c + b * c
+  
+    ds = r.dis(l)
+    puts "Distributive law for +: ds = " + ds.to_s if verbose
+    s += ds
+    
+    r = (a - b) * c
+    l = a * c - b * c
+    ds = r.dis(l)
+    puts "Distributive law for -: ds = " + ds.to_s if verbose
+    s += ds
+    
+    r = (a * b) * c
+    l = b * (c * a)
+    ds = r.dis(l)
+    puts "Multiplication: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = (a * b) / c
+    l = (a / c) * b
+    ds = r.dis(l)
+    puts "Division: ds = " + ds.to_s if verbose
+    s += ds
+    
+    r = C.one
+    l = a * a.inv
+    ds = r.dis(l)
+    puts "inv: ds = " + ds.to_s if verbose
+    s += ds
+ 
+    r = 1/a
+    l = a.inv
+    ds = r.dis(l)
+    puts "inv and 1/x: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = b
+    l = -(-b)
+    ds = r.dis(l)
+    puts "Unary minus is idempotent: ds = " + ds.to_s if verbose
+    s += ds
+    x = -a
+    y = x + a
+    r = y
+    l = C.zero
+    ds = r.dis(l)
+    puts "Unary -: ds = " + ds.to_s if verbose
+    s += ds
+    
+    l = a
+    x = a.sqrt
+    r = x * x
+    s = r.dis(l)
+    puts "square root: ds = " + ds.to_s if verbose
+    s += ds
+    
+    n = 11
+    l = a ** n
+    r = a ** C.new(n)
+    ds = r.dis(l)
+    puts "power with integer exponent: ds = " + ds.to_s if verbose
+    s += ds
+    
+    n = -7
+    l = a ** n
+    r = a ** C.new(n)
+    ds = r.dis(l)
+    puts "power with negative integer exponent: ds = " + ds.to_s if verbose
+    s += ds
+    
+    l = -C.one
+    r = (C.i * R.pi).exp
+    ds = r.dis(l)
+    puts "Euler's relation: ds = " + ds.to_s if verbose
+    s += ds
+  
+    l = a.sin * b.cos + a.cos * b.sin
+    r = (a + b).sin
+    ds = r.dis(l)
+    puts "Addition theorem for sin: ds = " + ds.to_s if verbose
+    s += ds
+    
+    l = a.exp * b.exp
+    r = (a + b).exp
+    ds = r.dis(l)
+    puts "Addition theorem for exp: ds = " + ds.to_s if verbose
+    s += ds
+
+    l = b.exp
+    r = l.log.exp
+    ds = r.dis(l)
+    puts "exp and log: ds = " + ds.to_s if verbose
+    s += ds
+    
+    l = c.sin
+    r = l.asin.sin
+    ds = r.dis(l)
+    puts "sin and asin: ds = " + ds.to_s if verbose
+    s += ds
+   
+    l = b.cos
+    r = l.acos.cos
+    ds = r.dis(l)
+    puts "cos and acos: ds = " + ds.to_s if verbose
+    s += ds
+    
+    l = a.tan
+    r = l.atan.tan
+    ds = r.dis(l)
+    puts "tan and atan: ds = " + ds.to_s if verbose
+    s += ds
+
+    l = a.cot
+    r = l.acot.cot
+    ds = r.dis(l)
+    puts "cot and acot: ds = " + ds.to_s if verbose
+    s += ds
+    
+    l = c.sinh
+    r = l.asinh.sinh
+    ds = r.dis(l)
+    puts "sinh and asinh: ds = " + ds.to_s if verbose
+    s += ds
+    
+    l = a.cosh
+    r = l.acosh.cosh
+    ds = r.dis(l)
+    puts "cosh and acosh: ds = " + ds.to_s if verbose
+    s += ds
+    
+    l = b.tanh
+    r = l.atanh.tanh
+    ds = r.dis(l)
+    puts "tanh and atanh: ds = " + ds.to_s if verbose
+    s += ds
+   
+    l = a.coth
+    r = l.acoth.coth
+    ds = r.dis(l)
+    puts "coth and acoth: ds = " + ds.to_s if verbose
+    s += ds
+    
+    t2 = Time.now
+    puts "class of s is " + s.class.to_s + " ."
+    puts "The error sum s is " + s.to_s + " ."
+    puts "It should be close to 0."
+    puts "Computation time was #{t2-t1} seconds."
+    s
+  end
+   
+  protected :coerce
+ 
+end # class C
+
+end # module AppMath
+