appmath 0.0.1

data/bin/kepler_2d_app.rb

@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+=begin rdoc
+ruby
+
+Ulrich Mutze, www.ulrichmutze.de
+
+Studying the conserved quantities in 2-dimensional Kepler motion
+
+=end
+
+=begin
+    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__), '../lib/graph')
+require File.join(File.dirname(__FILE__), '../lib/kepler_2d')
+#require 'graph'
+#require 'kepler_2d'
+
+include AppMath
+
+###################### input area ########################################
+
+# selection parameter, presently only sel = 1
+# See explanations in the corresponding 'when' statement line
+sel = 1
+prec = 6
+
+################### end of input area ####################################
+
+case sel
+
+when 1 # Test of class Kep2D
+  R.prec = prec
+
+# These three numbers give all reals of the application the right type.
+  pi = R.pi
+  zero = R.c0
+  r = R.c 5
+  g = R.c 10
+# No symbol R needed in what follows.  
+
+  puts "r.class = " + r.class.to_s
+  puts "pi.class = " + pi.class.to_s
+
+  vr = (g/r).sqrt
+  v = R2.new(zero,vr)
+  p = R2.new(r,zero)
+  t_tot = pi*r*2/vr
+  omega = (pi * 2)/t_tot
+  n = 100
+  dt = t_tot/(n-1)
+
+  sys = Kep2D.new(p,v,g)
+  e0 = sys.energy
+  am0 = sys.ang_mom
+  le0 = sys.lenz
+
+  arr_x = Array.new
+  arr_y = Array.new
+  arr_e = Array.new
+  arr_am = Array.new
+  arr_le_x = Array.new
+  arr_le_y = Array.new
+  arr_i = Array.new
+
+  for i in 1..n
+    sys.step!(dt)
+    alpha = sys.get_t * omega
+    arr_x << (sys.get_x - r * alpha.cos ).to_f
+    arr_y << (sys.get_y - r * alpha.sin).to_f
+    arr_e << (sys.energy - e0).to_f
+    arr_am << (sys.ang_mom - am0).to_f
+    arr_le_x << (sys.lenz - le0).x.to_f
+    arr_le_y << (sys.lenz - le0).y.to_f
+    arr_i << i.to_f
+  end
+
+  root = TkRoot.new{
+    title "Test of class Kep2D at precision #{R.prec}"
+  }
+ 
+  nx=1200
+  ny=700
+  
+  px = 3
+  py = 2
+ 
+  grs = Graphs.new(root,px,py,nx,ny)
+  
+  gr1 = grs.at(0,0)
+  gr2 = grs.at(0,1)
+  gr3 = grs.at(0,2)
+  gr4 = grs.at(1,0)
+  gr5 = grs.at(1,1)
+  gr6 = grs.at(1,2)
+  
+  gr1.grid_color = 'white'
+  gr1.bgr_color = 'lightgray'
+  gr2.grid_color = 'white'
+  gr2.bgr_color = 'lightgray'
+  gr3.grid_color = 'white'
+  gr3.bgr_color = 'lightgray'
+  
+  gr1.draw(arr_i, arr_le_x, 'red')
+  gr2.draw(arr_i, arr_le_y, 'cyan')
+  gr3.draw(arr_le_x, arr_le_y, 'blue')
+  gr4.draw(arr_i, arr_e, 'white')
+  gr5.draw(arr_i, arr_am, 'magenta')
+  
+  Tk.mainloop
+  
+else 
+
+  puts "unvalid selection, nothing to do"
+
+end 

data/bin/linalg_app.rb

@@ -0,0 +1,193 @@
+#!/usr/bin/env ruby
+=begin rdoc
+ruby
+
+Ulrich Mutze www.ulrichmutze.de
+
+2008-11-30
+
+Experimentation with Singular Value Decomposition in R
+
+=end 
+
+=begin
+    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__), '../lib/linalg')
+require File.join(File.dirname(__FILE__), '../lib/cnum')
+
+include AppMath
+
+###################### input area ########################################
+
+# selection parameter
+# n = 2 test class Vet 
+# n = 3 test class Mat and it is the most telling of the tests
+sel = 3
+
+# prec = 0 for Float computation , ... = 20 (e.g. precision 20, i.e. 20 
+# decimal places).
+prec = 0
+
+# We treat a random (n,n)-matrix for sel = 3 and a random n-vector
+# for sel = 2.
+n = 50
+
+verbose = false
+complex = false
+
+################### end of input area ####################################
+
+
+R.prec = prec
+
+case sel
+when 1 
+  n = 100
+  zero = complex ? C.zero : R.zero
+  
+  t1 = Time.now
+  a = Mat.tob(n,12, complex)
+  w = Vec.new(n,zero)
+  v = Mat.new(n,n,zero)
+  
+  if verbose
+    a.prn("a_input")
+  end
+  aMem = a.clone
+  
+  if complex
+    csvdcmp(a,w,v)
+  else
+    Mat.svdcmp(a,w,v)
+  end
+  
+  u = a
+  
+  aRec = u * Mat.new(w) * v.trp
+  
+  utu = u.trp * u
+  vtv = v.trp * v
+  
+  utu1 = utu.to_1
+  vtv1 = vtv.to_1
+  
+  if verbose
+    utu.prn("utu")
+    vtv.prn("vtv")
+  end
+  
+  s = R.c0
+  
+  l = aMem
+  r = aRec
+  ds = l.dis(r)
+  ds.prn("ds1")
+  s += ds
+  
+  l = utu
+  r = utu1
+  ds = l.dis(r)
+  ds.prn("ds2")
+  s += ds
+  
+  l = vtv
+  r = vtv1
+  ds = l.dis(r)
+  ds.prn("ds3")
+  s += ds
+  
+  t2 = Time.now
+  
+  if verbose
+    a.prn("a_output")
+    puts
+    w.prn("w_output")
+    puts
+    v.prn("v_output")
+  end
+  puts
+  s.prn("error sum")
+  (t2-t1).prn("computation time")
+  
+when 2
+  Vec.test(n,verbose,complex)
+  
+when 3
+  Mat.test(n,verbose,complex)  
+  
+when 4
+  R.test(137,verbose)  
+  
+when 5
+  C.test(137,verbose)  
+  
+when 6
+  n = 16
+  w = Vec.tob(n,137)
+  w.prn("w")
+  wpi = w.pseudo_inv
+  wpi.prn("wpi")
+  
+when 7
+  t1 = Time.now
+  x = R.new("1.23456789E123")
+  diff = (x.sin**2 + x.cos**2 - 1).abs.log10.round
+  t2 = Time.now
+  dt = t2-t1
+  puts "diff = #{diff}, computation time was #{dt} s"
+  
+when 8
+# input
+  prec = 9
+  dim = 32
+  i = 137
+  dig_round = 6
+  complex = false
+# computation  
+  R.prec = prec
+  x = Vec.tob(dim,i,complex)
+  x.each{ |x|
+    puts x.round(dig_round).to_s
+  }
+  
+when 9
+  prec = "f"
+  R.prec = prec
+  n = 20
+  for i in 1..n
+ #   puts R.ran(i).to_s
+    puts R.tob(i).to_s
+  end
+
+when 10
+  for i in 0..8
+    R.prec = 20*i
+    # some computation, e. g.
+    x = [R.c2, R.i2, R.i(0.33333),R.ran(137), R.tob(3)] 
+    puts "precision set to #{R.prec}"
+    x.each{ |x|
+      diff = x.sin**2 +x.cos**2 - 1
+      puts "x = #{x.round(6)}, diff = #{diff}"
+    }
+  end
+  
+else 
+  puts "Not even under construction"
+  
+end # case
+

data/bin/rnum_app.rb

@@ -0,0 +1,199 @@
+#!/usr/bin/env ruby
+=begin rdoc
+ruby
+
+Ulrich Mutze, www.ulrichmutze.de
+
+Simple test application for real and complex numbers and for graphical
+representation of curves.
+
+=end
+
+=begin
+    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 
+
+=begin
+History:
+2008-11-01
+Experimentation with BigDecimal
+The most useful thing to do seems to create a class of reals 
+of arbitrary precission.
+Unfortunately many functions are implemented by the
+most simple power series expansion. These have to reimplemented to become
+useful.
+I should do this! action!
+UM 2008-11-04: essentially done! For final testing I should have a
+graphical test facility which I'm developing presently
+Aritmetics seems to be pretty fast
+Add the case R=Float for @@dig=0 (or <= 0 ?) action! done
+perhaps 10^x as primary and e^x=exp(x) as derived from it, could be faster
+and more accurate action! done
+=end 
+
+require File.join(File.dirname(__FILE__), '../lib/graph')
+require File.join(File.dirname(__FILE__), '../lib/cnum')
+#require 'graph'
+#require 'cnum'
+
+include AppMath
+
+
+###################### input area ########################################
+# selection parameter
+# See explanations in the corresponding 'when' statement line
+sel = 1
+
+################### end of input area ####################################
+case sel
+when 1 # Test of classes Graphs and R and function objects
+
+# precision for the overall computation
+  prec1 = 0
+# precision for the red curves
+  prec2 = 2
+# pixels in x-direction  
+  nx = 1200
+# pixels in y-direction    
+  ny = 750
+# Number of points of each function graph  
+  n = 100
+# The functions are represented over the x-interval [ -x_max , + x_max ]  
+  x_max = 8.5
+  
+  ##### end of input for sel = 1 #########################################
+  
+  R.prec = prec1
+
+  root = TkRoot.new{
+    t2 = prec2 == 2 ? " (slide-rule precision) " : ""
+    title "Functions evaluated at precision #{prec2}" + t2
+  }
+
+  px = 3 # number of sub-windows is 6 = 3 * 2
+  py = 2
+ 
+  grs = Graphs.new(root,px,py,nx,ny)
+  
+  gr1 = grs.at(0,0)
+  gr2 = grs.at(0,1)
+  gr3 = grs.at(0,2)
+  gr4 = grs.at(1,0)
+  gr5 = grs.at(1,1)
+  gr6 = grs.at(1,2)
+
+  auto = true
+  color1 = 'white'
+  
+  xl=R.c(x_max)
+  ivx=Iv.new(-xl,xl)
+  gr1.set_size_x!(ivx)
+  gr2.set_size_x!(ivx)
+  gr3.set_size_x!(ivx)
+  gr4.set_size_x!(ivx*2)
+  gr5.set_size_x!(ivx*2)
+  gr6.set_size_x!(ivx)
+  gr1.draw_func(Exp.new,n,color1,auto)
+  gr2.draw_func(Sin.new,n,color1,auto)
+  gr3.draw_func(Cos.new,n,color1,auto)
+  gr4.draw_func(Log.new,n,color1,auto)
+  gr5.draw_func(Erfc.new,n,color1,auto)
+  gr6.draw_func(ArcTan.new,n,color1,auto) 
+  
+
+  # The algorithms for the functions work even for 
+  # prec2 = 1. Of course, the x-values have to be taken from
+  # a more accurate computation (with precision prec1).
+  auto = false
+  color2 = 'red' 
+  
+  gr1.text_color = gr1.bgr_color
+  gr2.text_color = gr2.bgr_color
+  gr3.text_color = gr3.bgr_color
+  gr4.text_color = gr4.bgr_color
+  gr5.text_color = gr5.bgr_color
+  gr6.text_color = gr6.bgr_color
+  gr1.draw_func(Exp.new(prec2),n,color2,auto)
+  gr2.draw_func(Sin.new(prec2),n,color2,auto)
+  gr3.draw_func(Cos.new(prec2),n,color2,auto)
+  gr4.draw_func(Log.new(prec2),n,color2,auto)
+  gr5.draw_func(Erfc.new(prec2),n,color2,auto)
+  gr6.draw_func(ArcTan.new(prec2),n,color2,auto)
+
+  Tk.mainloop
+
+when 2 # test of R.test, changing the accuracy from call to call
+  count = R.c0
+  s = R.c0
+  verbose = false
+ # cases = [-1]
+ # param = [137]
+  cases = [0,20,40]
+  param = [0, 137]
+  cases.each{ |x|
+    param.each{ |y|
+      R.prec = x
+      d = R.test(y,verbose)
+      s += d
+      count += 1
+    }
+  }
+  res = s/count
+  puts "res = " + res.to_s
+
+when 3 # simple computations with default accuracy
+  x = R.new(-100)
+  y = x.exp
+  puts "y="+y.to_s
+
+  a = R.new(250)
+  d = a.sin**2 + a.cos**2 - 1
+  puts d.to_s
+  
+when 4 # testing complex arithmetics and functions
+  dig = 100
+  R.prec = dig
+  C.test(137,false)
+  
+when 5 # testing input formats
+  R.prec = "F"
+  x = [R.c("3.45E-45"),  R.c(2),  R.c(1.25e13),  R.c("4000.1e-1")]
+  x.each{ |x|
+    puts " x = #{x}"
+  }
+  
+when 6 # testing R.new
+  R.prec = 6
+  x = R.new("-6.6666666666666666")
+  puts "x=" + x.to_s
+  R.prec = 40
+  i = 10000000
+  j = 123456789
+  a = R.new(i * j)
+  b = R.new(1e-23)
+  c = R.new("-117.07e99")
+  R.prec = 100 # same as R.prec = 1e2
+  d = R.new(1e66)
+  e = R.new("1E666")
+  arr = [a,b,c,d,e]
+  arr.each{ |x|
+    x.prn("#{x}")
+  }
+
+else 
+  puts "unvalid selection, nothing to do"
+
+end