appmath 0.0.1

data/lib/float_ext.rb

@@ -0,0 +1,223 @@
+=begin rdoc
+ruby
+
+Ulrich Mutze, www.ulrichmutze.de
+
+2008-12-07
+
+Extends the class Float.
+
+Requires no file.
+
+    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 
+
+# Usage:
+#   require 'float_ext.rb'
+#   x = 1.37; y = 0.123
+#   phi = x.arg(y)
+#   r = x.hypot(y)
+#   dx = r * phi.cos - x
+#   dy = r * phi.sin - y
+#
+# Defining all functons of module Math as methods of class Float. 
+# The meaning of functions frexp and ldexp has been changed from 
+# referring to exponent 2 to exponent 10.
+# Notice that code that worked without a statement
+#   require 'float_ext.rb'
+# will work in an identical manner with this statement added. 
+# Only if this is true, extending the functionaliy of standard types is
+# considered acceptable.
+# A few functions, not to be found in module Math have been added.
+# These are methods which are defined in R and thus should be available
+# in Float in order to make R and Float strictly replacable in all code
+# that loads float_ext.rb and rnum.rb.
+# These new functions are:
+#   inv, pseudo_inv, conj, cot, coth, acot, acoth, arg,  
+#   clone, dis, integer?, real?, complex? 
+# Notice also, that for R.prec = 0, the real-number generating functions
+#   R.ran, R.tob, R.c, R.i, R.pi, R.e
+#   R.c0, R.c1, ..., R.c10, R.i2, ... R.i10
+# that normally return R-numbers are forced to return Floats so that it
+# is simple to write programs in such a manner that all real numbers
+# switch their type from Float to R and vice versa. 
+# The class R is coded in a manner that it makes no use of the present 
+# extension of Float, although this would have allowed some code
+# reduction.
+
+class Float
+
+  def sqrt; Math.sqrt(self); end
+  
+  # x.hypot(y) is an efficient and accurate representation of the
+  # square root of x*x + y*y. 
+  def hypot(y); Math.hypot(self,y); end
+  
+  # It is convenient to have inversion (the multiplicative analogon
+  # of the unary - operation) as a member function.
+  def inv; 1.0/self; end
+  
+  # pseudo inverse, which always exists
+  def pseudo_inv; zero? ? 0.0 : 1.0/self; end
+  
+  # (Complex) conjugation, no effect on real numbers.
+  # Supports the unified treatment of real and complex numbers.
+  def conj; self; end
+
+  def exp; Math.exp(self); end
+  # method log (unlike function Math.log) is defined in a mathematically
+  # reasonable manner also for negative arguments.
+  def log; Math.log(abs); end
+  
+  # method log10 (unlike function Math.log10) is defined in a 
+  # mathematically reasonable manner also for negative arguments.
+  def log10; Math.log10(abs); end
+
+  def sin; Math.sin(self); end
+  def sinh; Math.sinh(self); end
+  def asin; Math.asin(self); end
+  def asinh; Math.asinh(self); end
+  
+  def cos; Math.cos(self); end
+  def cosh; Math.cosh(self); end
+  def acos; Math.acos(self); end
+  def acosh; Math.acosh(self); end
+  
+  def tan; Math.tan(self); end
+  def tanh; Math.tanh(self); end
+  def atan; Math.atan(self); end
+  def atan2(x); Math.atan2(self,x); end
+  
+  # The name 'arg' stands for 'agument', which is the name for the 
+  # polar angle of a complex number preferred in the mahematical
+  # literature. So for a complex number z = u + iv we have
+  #   argument(z) = u.arg(v)
+  # Notice also the representation of the absolute value of z:
+  #   |z| = u.hypot(v)
+  # The functions hypot and arg (or atan2) thus prepare the introduction
+  # of complex numbers.
+  def arg(y); Math.atan2(y,self); end
+  
+  def atanh; Math.atanh(self); end
+  
+  # All functions having 'cot' in their name deal with the trigonometric
+  # or hyperbolic cotangent. These functions are so directly related to 
+  # the corresponding 'tan'-functions that they are not included in the
+  # Math and BigMath modules. It is sometimes useful to have them, though.
+  def cot; Math.cos(self)/Math.sin(self); end
+  def coth; Math.cosh(self)/Math.sinh(self); end
+  def acot; Math.atan(1./self); end 
+  def acoth; 0.5 * Math.log( ((self + 1.0)/(self - 1.0)).abs ) end
+  
+  # error function
+  def erf; Math.erf(self); end
+  
+  # complemetary error function
+  def erfc; Math.erfc(self) ; end
+  
+  # Warning! x.frexp differs from Math.frexp(x).
+  # We need exponent 10 not 2,
+  # so we don't use: 
+  #   def frexp; Math.frexp(self);end
+  def frexp 
+  #  puts "arg of frex="+to_s
+    if zero?
+      [ 0.0, 0]
+    elsif self > 0.0
+      y = Math.log10(self)
+      yf = y.floor
+      yfrac = y - yf
+      [ 10.0 ** yfrac, yf.to_i]
+    else
+      y = Math.log10(-self)
+      yf = y.floor
+      yfrac = y - yf
+      [ - 10.0 ** yfrac, yf.to_i]
+    end
+  end
+  
+  # Warning! x.ldexp differs from Math.ldexp(x).
+  # We need exponent 10 not 2,
+  # so we don't use: 
+  #   def ldexp(n); Math.ldexp(self,n);end
+  def ldexp(n); self * (10.0 ** n.to_i); end 
+
+  # One should have this!
+  def clone
+    res = 0.0; res += self; res
+  end
+ 
+# For all Float x, y we have 0 <= x.dis(y) <= 1 and x.dis(x) = 0
+# It is a kind of relative distance which should be in the order
+# of magnitude of the smalles positive representable number
+# if x and y are known to differ only by numerical noise. 
+  def dis(x)
+    xf = x.to_f
+    a = abs
+    b = xf.abs
+    d = (self - xf).abs
+    s = a + b
+    return 0.0 if s.zero?
+    d1 = d/s
+    d < d1 ? d : d1
+  end
+  
+# Since Float 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 be always a clear-cut distinction between
+# integer types and real types.
+  def integer?; false; end  
+
+# Although there may be technical variants in representing real numbers,
+# these all should answer this question with 'yes' since they all
+# model mathematical real numbers. 
+  def real?; true; end
+
+# Not complex, since no second dimesion (filling a plane) is provided. 
+  def complex?; false; end
+
+# Providing the neutral element of addition via a method.
+  def to_0; 0.0; end
+
+# Providing the neutral element of multiplication via a method.
+  def to_1; 1.0; end
+  
+ # Print. Output to console, together with a name which is given by the 
+ # argument.
+  def prn(name)
+    puts " #{name} = " + to_s
+  end 
+
+# Returns a real number, the significand of which has not more
+# than n digits. Notice that there is also a function round
+# which takes no argument and which returns an integer number.
+# This function replaces function Float#round.
+  def round(*arg)
+    n = arg.size
+    case n
+    when 0
+      (self + 0.5).floor # output is integer
+    when 1
+      m = arg[0].to_i
+      x = frexp
+      y = x[0].ldexp(m)
+      (y + 0.5).floor.to_f.ldexp(x[1] - m)
+    else
+      fail "needs 0 or 1 arguments"
+    end
+  end
+  
+end # class Float

data/lib/graph.rb

@@ -0,0 +1,415 @@
+=begin rdoc
+ruby
+
+Ulrich Mutze, www.urichmutze.de 
+
+2008-12-07
+
+Defines classes AppMath::Graph, AppMath::Graphs,
+AppMath::[Sin, Cos, ArcSin, Ex, Log, ArcTan, ArcCos, ArcCot,
+Erf, Erfc]
+
+Requires files interval and tk
+
+    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__), 'interval')
+require 'tk'
+#require 'interval'
+
+
+module AppMath
+
+=begin rdoc
+class for representing a 'window to the real world'
+With the x-direction there is associated a real interval, and with
+the y-directon there is also associated a real interval. With these intervals
+there are associated integer numbers width and height, which govern the 
+'pixelation' of these intervals.
+=end
+class Graph
+
+  attr :fac, true
+  attr :bgr_color
+  attr :n_div, true
+  attr :grid_color, true
+  attr :text_color, true
+ 
+ # Setting the background color.
+  def bgr_color=(color)  
+    @@bgr = color
+    clear(@@bgr)
+  end
+ 
+ # Specifes the parent window, pixel sizes in x- and y-directons, and
+ # the intervals of x-values and y-alues associated with the
+ # graphical window.
+  def initialize(parent,nx,ny,iv_x,iv_y)
+    @fac = R.c 1.04
+    @bgr_color = 'lightgreen'
+    @n_div = 5
+    @grid_color = 'darkgray'
+    @text_color = 'black'
+    
+    @parent = parent
+    @w = nx
+    @h = ny
+    set_size_x!(iv_x)
+    set_size_y!(iv_y)
+      # sets @a, @b, @c, @d, @ivx, @ivy
+    col = @bgr_color
+    @canvas = TkCanvas.new(parent){
+      width nx
+      height ny
+      background col
+    }
+    @canvas.pack
+  end
+
+# Returns the interval of x-values.
+  def ivx; @ivx; end
+
+# Returns the interval of y-values.
+  def ivy; @ivy; end
+
+# Clearing the graphical window by painting it uniformly
+# with a given color.
+  def clear(color=@bgr_color)
+    magic = 2 # not expected to need this
+    TkcRectangle.new(@canvas, 0, 0, @w + magic, @h + magic, 
+      'width'=> 0, 'fill' => color)
+  end
+
+# Setting vertical lines associated with an array of x-values
+# (given as the first argument) in a color (given as the second
+# argument).
+  def grid_x(anArray, color=@grid_color)
+    anArray.each{ |x|
+      pa = ipos(x,@ivy.low)
+      pb = ipos(x,@ivy.upp)
+      line = TkcLine.new(@canvas,pa[0],pa[1],pb[0],pb[1])
+      line.fill(color)
+    }
+  end
+  
+# Setting horizontal lines associated with an array of y-values
+# (given as the first argument) in a color (given as the second
+# argument).
+  def grid_y(anArray, color=@grid_color)
+    anArray.each{ |y|
+      pa = ipos(@ivx.low,y)
+      pb = ipos(@ivx.upp,y)
+      line = TkcLine.new(@canvas,pa[0],pa[1],pb[0],pb[1])
+      line.fill(color)
+    }
+  end
+
+# Drawing a polygon which is determined by an array of
+# x-values and an array of y-values (if these don't have equal
+# length, the smaller of he two sizes is active) in a given
+# color. If the hird argument is true, the intervals of x-values
+# and y-values get adjusted in a manner that the whole polygon can
+# be represented and that the coordinate ranges can be described
+# by simple numbers in the style as numerical ranges for printed
+# diagrams are typically selected.
+
+  def draw(arr_x, arr_y, color, auto_adjust = true)
+  #  clear(@bgr_color)
+    nx = arr_x.length
+    ny = arr_y.length
+    n = Basics.inf(nx,ny)
+    if auto_adjust
+      ivx_e = Iv.from_array(arr_x) * @fac # the values to be shown
+        # should stay a bit apat from the rim of the diagram
+      ivy_e = Iv.from_array(arr_y) * @fac
+      divx = ivx_e.axis_division(@n_div)
+      divy = ivy_e.axis_division(@n_div)
+      d_x = divx[0]
+      d_y = divy[0]
+      v_x = divx[1]
+      v_y = divy[1]
+      ivxNew = Iv.new(v_x.first, v_x.last)  
+      ivyNew = Iv.new(v_y.first, v_y.last)
+      set_size_x!(ivxNew)
+      set_size_y!(ivyNew)
+      grid_x(v_x, grid_color)
+      grid_y(v_y, grid_color)
+    end
+    
+    for i in 1...n
+      xa = arr_x[i-1]
+      xb = arr_x[i]
+      ya = arr_y[i-1]
+      yb = arr_y[i]
+      pa = ipos(xa,ya)
+      pb = ipos(xb,yb)
+      line = TkcLine.new(@canvas,pa[0],pa[1],pb[0],pb[1])
+      line.fill(color)
+    end
+    if @bgr_color != @text_color # only then writing the text works, and
+      # so we have a method to avoid writing text
+# some magic numbers here    
+      t_x = (@w * 0.1).to_i 
+      t_y = (@h * 0.1).to_i
+      t_w = (@w * 0.75).to_i
+      t_h = (@h * 0.02).to_i
+      t_h = Basics.sup(t_h,10)
+
+      font_text = "LucidaConsole "+t_h.to_s
+
+      xl = @ivx.low.to_s
+      xu = @ivx.upp.to_s
+      yl = @ivy.low.to_s
+      yu = @ivy.upp.to_s
+    
+      x_text=xl + " < x < " + xu + " , dx_grid = " + d_x.to_s
+      y_text=yl + " < y < " + yu + " , dy_grid = " + d_y.to_s
+      full_text = x_text + "\n\n" + y_text
+    
+      txt=TkcText.new(@canvas,t_x,t_y){
+        anchor "nw"
+        width t_w 
+        text full_text
+        font font_text
+      }
+      txt.fill(@text_color)
+    end
+  end
+ 
+# Drawing a polygon which represents function f. The x-values
+# to be used for creating this polygon are determined by 
+# interval @ivx and the number n of points. f is assumed to be
+# a 'function object' in the sense that it dfines a method 'at'
+# so that f.at(x) is what one normally would write as f(x). So
+# 'at' replaces C++'s operator(). Of course, the last argument 
+# allows auto-scaling of the y-range.
+
+  def draw_func(f, n, color = 'red', auto_adjust_y = true)
+    arr_x = @ivx.to_array(n)
+    arr_y = Array.new(n, 0.0)
+    for i in 0...n
+      xi = arr_x[i]
+      yi = f.at(xi)
+      arr_y[i] = yi.to_f
+    end
+    draw(arr_x, arr_y, color, auto_adjust_y)
+  end
+  
+# integer (pixel-wise) position associated with a point
+# (x,y) in x,y-space. Notice that this is given by a simple
+# (and efficient) formula if the auxiliar quantities
+# @a, @b, @c, @d got their value by means of the next two functions.
+
+  def ipos x, y
+    [@a + @b * x, @c + @d * y]
+  end
+ 
+# Setting the active interval of x-values and the 
+# auxiliar quantities @a and @b.
+  def set_size_x!(aIv)
+    @ivx = aIv
+    @b = (@w - 1.0)/@ivx.size
+    @a = -@b * @ivx.low
+  end
+
+# Setting the active interval of y-values and the 
+# auxiliar quantities @c and @d.
+  def set_size_y!(aIv)
+    @ivy = aIv
+    @d = (1.0 - @h)/@ivy.size
+    @c = -@d * @ivy.upp
+  end
+    
+end # class Graph 
+
+# The code
+#   root = TkRoot.new{ title 'Test of ...'}
+#   g = Graphs.new(root,3,2,1000,700)
+# generates a 2 times 3 matrix of Graph-objects
+#   g.at(0,0), g.at(0,1), g.at(0,2)
+#   g.at(1,0), g.at(1,1), g.at(1,2)
+# which together make up a rectangle of 1000 pixels in x-direction
+# and 700 pixels in y-direction. Notice that the matrix is a grid 
+# with 3 items in x-direction and 2 items in y-direction.
+# Since these items are of class Graph, they can be used for graphical
+# representations of arrays and of functions without needing support fom 
+# the present class Graphs.
+class Graphs
+
+  attr_reader :px,:py,:mx,:my,:grs
+
+# Generating a (py,px)-matrix of Graph-objects, in an rectangular area
+# which is a (ny,nx)-matrix of pixels.
+  def initialize(parent,px,py,nx,ny)
+    zero = R.c0
+    one = R.c1
+    @px = px
+    @py = py
+    @mx = nx / @px
+    @my = ny / @py
+    ivx = Iv.new(zero,one)
+    ivy = Iv.new(zero,one)
+    @grs = Array.new
+    py.times{ |r|
+      gr = Array.new
+      px.times{ |c|
+        fr = TkFrame.new(parent).grid('row' => r, 'column' => c)
+        gr << Graph.new(fr,@mx,@my,ivx,ivy)
+      }
+      @grs << gr
+    }
+  end
+
+# Access function. For a Graphs-object g, one has the Graph-objects
+#   g.at(i,j), 0 <= i < p.py, 0 <= j < g.px . 
+# All integer values are allowed and these then are understood 
+# periodically.
+  def at(i,j)
+    return @grs[i.to_i%@py][j.to_i%@px]
+  end
+
+end
+
+# Function objects for testing Graph#draw_func
+# with functions for which the precision of function evaluation
+# is enforced. This enforced precison is set with the creation of the
+# function object.
+
+class Sin
+  
+  def initialize(n = R.prec)
+    @precMem = R.prec
+    @precLoc = n
+  end
+
+  def at(x)
+    R.prec = @precLoc
+    y = R.c(x).sin
+    R.prec = @precMem; y
+  end
+end  
+
+class Cos
+  def initialize(n = R.prec)
+    @precMem = R.prec
+    @precLoc = n
+  end
+  def at(x)
+    R.prec = @precLoc
+    y = R.c(x).cos
+    R.prec = @precMem; y
+  end
+end  
+
+class ArcSin
+  def initialize(n = R.prec)
+    @precMem = R.prec
+    @precLoc = n
+  end
+  def at(x)
+    R.prec = @precLoc
+    y = R.c(x).asin
+    R.prec = @precMem; y
+  end
+end  
+
+class Exp
+  def initialize(n = R.prec)
+    @precMem = R.prec
+    @precLoc = n
+  end
+  def at(x)
+    R.prec = @precLoc
+    y = R.c(x).exp
+    R.prec = @precMem; y
+  end
+end  
+
+class Log
+  def initialize(n = R.prec)
+    @precMem = R.prec
+    @precLoc = n
+  end
+  def at(x)
+    R.prec = @precLoc
+    y = R.c(x).log
+    R.prec = @precMem; y
+  end
+end  
+
+class ArcTan
+  def initialize(n = R.prec)
+    @precMem = R.prec
+    @precLoc = n
+  end
+  def at(x)
+    R.prec = @precLoc
+    y = R.c(x).atan
+    R.prec = @precMem; y
+  end
+end 
+
+class ArcCos
+  def initialize(n = R.prec)
+    @precMem = R.prec
+    @precLoc = n
+  end
+  def at(x)
+    R.prec = @precLoc
+    y = R.c(x).acos
+    R.prec = @precMem; y
+  end
+end 
+
+class ArcCot
+  def initialize(n = R.prec)
+    @precMem = R.prec
+    @precLoc = n
+  end
+  def at(x)
+    R.prec = @precLoc
+    y = R.c(x).acot
+    R.prec = @precMem; y
+  end
+end 
+
+class Erf
+  def initialize(n = R.prec)
+    @precMem = R.prec
+    @precLoc = n
+  end
+  def at(x)
+    R.prec = @precLoc
+    y = R.c(x).erf
+    R.prec = @precMem; y
+  end
+end 
+
+class Erfc
+  def initialize(n = R.prec)
+    @precMem = R.prec
+    @precLoc = n
+  end
+  def at(x)
+    R.prec = @precLoc
+    y = R.c(x).erfc
+    R.prec = @precMem; y
+  end
+end 
+
+end # AppMath
+