appmath 0.0.1

data/lib/interval.rb

@@ -0,0 +1,282 @@
+=begin rdoc
+ruby
+
+Ulrich Mutze, www.ulrichutze.de
+
+Started 2008-11-01 by modifying cpminterval.h and cpminterval.cpp.
+
+Defines class AppMath::Iv.
+
+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.rb'
+
+module AppMath
+
+=begin rdoc
+Class of real closed intervals.
+In most applications of intervals it is an advantage if single real
+values can be considered as intervals of length zero. This is possible
+only for closed intervals, and this is the rational for defining those
+in preference to open intervals. 
+With the attributes @low and @upp, the values x which belong to interval
+are characterized by the formula
+  @low <= x <= @upp .
+Hence the interval is empty (void) iff @low > @upp.
+=end
+
+class Iv
+
+  attr_reader :low, :upp
+
+# Allowed are 0, 1, 2 arguments, which all have to be convertible to R.
+# For no argument the empty interval is created. For one argument, an
+# second argument 0 is understood. For two arguments, these are the
+# boundaries of the interval and the order on input does not matter:
+#   iv1 = Iv.new(2,3); iv2 = Iv.new(3,2) 
+# are thus the same, non-empty, interval, which in mathematical notation
+# would be
+#   [2,3]
+# Finally
+#   iv3 = Iv.new
+# is an empty interval.
+  def initialize(*arg)
+    n = arg.size
+    case n
+    when 0
+      @low = R.c1
+      @upp = R.c0 # notice: epmpty since @low > @upp
+    when 1
+      x = R.c arg[0] 
+      zero = R.c0
+      if x < zero
+        @low = x
+        @upp = zero
+      else
+        @upp = x
+        @low = zero
+      end
+    when 2
+      x = R.c arg[0]
+      y = R.c arg[1]
+      if x < y
+        @low = x
+        @upp = y
+      else
+        @low = y 
+        @upp = x
+      end
+    else
+        fail "Iv.new takes 0 or 1 or 2 arguments, but not " + n.to_s
+    end # case n
+  end  
+  
+=begin rdoc
+  using max and min of an array for defining an interval.
+  The values of the array components are then known to belong to
+  to a closed interval. The smallest such interval is what
+  his method returns.
+=end
+  def Iv.from_array(anArray)
+    n = anArray.size
+    case n
+    when 0
+      Iv.new
+    when 1 
+      a0 = anArray[0]
+      Iv.new(a0)
+    else
+      x0 = anArray[0]
+      x1 = x0
+      anArray.each{ |x|
+        if x < x0 
+          x0 = x
+        elsif x > x1
+          x1 = x
+        else
+        end
+      }
+      Iv.new(x0,x1)
+    end
+  end
+  
+# Returns an ordered equidistant array of n numbers, where the first one 
+# is @low and the last one is @upp. The positive integer n is made from
+# the argument a in a way which depends on whether this argument is integer
+# or not. In the first case it is taken as n and in the second case, the
+# argment is taken as a proposal for the lattice spacing. The actual
+# lattice spacing will be chosen as a fraction of size.
+  def to_array(a)
+    return nil if empty?
+    if a.integer? # then we interpret the argument as an intended number
+      # of lattice points
+      n = a
+    else # then we interprete the argument as an intended lattice spacing
+      d = a.abs
+      fail "can't build a lattice with spacing 0" if d.zero?
+      n = (size/d).round + 1
+    end
+    fail "number of lattice points must be larger than 1" if n < 2
+    res = Array.new
+    res << @low
+    if n > 2
+      na = n - 2
+      d = size / (n-1)
+      x = @low
+      for i in 1..na
+        x += d
+        res << x
+      end
+    end
+    res << @upp
+  end
+ 
+# Returns true iff the interval is empty 
+  def empty?; @low > @upp; end
+  
+# Returns the lower boundary if self is not empty
+# and nil else.
+  def inf
+    return nil if empty?
+    @low
+  end
+  
+# Returns the upper boundary if self is not empty
+# and nil else.
+  def sup
+    return nil if empty?
+    @upp
+  end  
+
+# Returns the midpoint of the interval. 
+  def center
+    nil if empty?
+    (@low + @upp) * R.i2
+  end
+
+# Returns the length of the interval, 0 for the empty one
+  def size
+    s = @upp - @low
+    s >= R.c0 ? s : R.c0
+  end
+ 
+# Indicator function. Returns true if the point x belongs to self
+# and false else.
+  def ind(x)
+    return false if empty?
+    return false if x > @upp
+    return false if x < @low
+    true
+  end
+    
+# Metrical indicator function. Returns the distance of x from the set
+# self if x is outside of self. If it is inside, the return value is
+# minus the distance to the complement of self (which is not an 
+# interval but a well-defined set).
+  def met_ind(x)
+    return nil if empty?
+    y = R.c x
+    dc = (y - center).abs
+    dc - size * R.i2
+  end
+  
+# Returns a real number, which is self's lower end for p == 0.0, self's
+# center for p == 0.5, and self's upper end for p == 1.0 .
+  def put(p)
+    inf + size * p
+  end
+ 
+# minimum closed interval that contains the union
+# join or l.u.b. (lowest upper bound) in lattice terminology 
+  def |(anIv)
+    return anIv if empty?
+    return self if anIv.empty?
+    Iv.from_array [@low, @upp, anIv.low, anIv.upp]
+  end
+ 
+#shifting by a 
+  def +(a); Iv.new(@low + a,@upp + a); end
+
+# multiplying size by a, while preserving the center
+  def *(a)
+    Iv.new(center-(center-@low)*a,center+(@upp-center)*a)
+  end
+ 
+# section, intersection
+# meet or g.l.b (greatest lower bound) in lattice terminology
+  def &(anIv)
+    return Iv.new if empty? || anIv.empty?
+    return Iv.new if @upp < anIv.low || @low > anIv.upp
+    amin = Basics.sup(@low, anIv.low)
+    amax = Basics.inf(@upp, anIv.upp)
+    Iv.new(amin, amax)
+  end
+  
+  def to_s
+    "Iv (" + @low.to_s + "," + @upp.to_s + ")"
+  end
+
+# The function creates a suitable axis sub-division for data ranging
+# from @low to @upp. Let res be the return value of the function. Then
+# res[0] is a proposal for the difference between adjacent axis tics
+# and res[1] is an array of the values to which the proposed tics belong.
+# Thus res[1].first <= @low and res[1].last >= @upp. All numbers are chosen
+# such that they are simple when written down in normal scientific
+# notation and the intention is to simulate the considerations that 
+# determine the axis subdivision of reasonable manually created diagrams. 
+# The argument of the function is a proposal for the number of tics to be 
+# used. Values from 5 to 10 are reasonable. To have a simple logic, we
+# simply enforce that the interval between tics is a simple number.
+# The initial and the final number of the axis division is chosen as 
+# an integer multiple of this inter-tic interval. 
+
+  def axis_division(anPosInteger)
+    fail "can't divide an empty interval" if empty?
+    a = @low
+    b = @upp
+    n = anPosInteger.abs
+    n += 1 if n == 0
+    d = size/n
+    d_ = Basics.cut(d) # this is the essential point
+    fail "Zero division in function axis_division" if d_ == 0.0
+    d_inv=d_.inv;
+    epsilon = R.c 1e-6
+    k_b=(b*d_inv - epsilon).ceil
+      # without the epsilon correction it depends on roundoff 
+      # errors whether b_ becomes too large
+    k_a=(a*d_inv + epsilon).floor
+      # without the epsilon correction it depends on roundoff 
+      # errors whether a_ becomes too small
+    b_=k_b * d_
+    b__ = (k_b - 0.5) * d_
+    a_=k_a * d_
+    res=Array.new
+    while a_ < b__
+      res << a_
+      a_ += d_
+    end
+    res << b_ # we know the last item exactly, and should
+      # not spoil it by arithmetic errors
+    [ d_ , res ]
+  end
+
+end # class Iv
+
+end # AppMath

data/lib/kepler_2d.rb

@@ -0,0 +1,162 @@
+=begin rdoc
+ruby
+
+Ulrich Mutze www.ulrichmutze.de
+
+2008-12-07
+
+Defines classes AppMath::R2 and AppMath::Kep2D.
+
+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.rb'
+
+module AppMath
+
+###################### classes R2 and Kep2D ##############################
+
+# Real vector space of two dimensions
+class R2
+
+  attr :x, true
+  attr :y, true
+  
+  def initialize(x,y)
+    @x = x
+    @y = y
+  end
+  
+  def clone
+    R.new(x,y)
+  end
+  
+  def +(p)
+    R2.new(x + p.x, y + p.y)
+  end
+  
+  def -(p)
+    R2.new(x - p.x, y - p.y)
+  end
+  
+  def *(s)
+    R2.new(x * s, y * s)
+  end
+  
+  def -@
+    R2.new(-x, -y)
+  end
+  
+  def to_s
+    res = "R2(" + x.to_s + ", " + y.to_s + ")"
+  end
+  
+  def abs
+    x.hypot(y)
+  end
+
+# abs squared
+  def abs2
+    x * x + y * y
+  end
+
+# scalar product
+  def spr(p)
+    x * p.x + y * p.y
+  end
+
+# unit vector
+  def uv
+    r = abs
+    if r.zero?
+      clone
+    else 
+      ri = r.inv
+      self * ri
+    end
+  end
+  
+end
+
+# Kepler problem in 2 dimensions
+# mass of the test particle is 1.
+# space-fixed central mass times constant of gravity is @g
+class Kep2D
+
+  def initialize(x,v,g)
+    @t = R.c0
+    @x = x
+    @v = v
+    @g = g
+  end
+
+# acceleration
+  def acc
+    r = @x.abs
+    k = -@g * r**-3
+    @x * k
+  end 
+
+# time step of the direct midpoint integrator, highly symmetric !
+  def step!(dt)
+    h = dt * 0.5
+    @t += h
+    @x += @v * h
+    @v += acc * dt
+    @x += @v * h
+    @t += h
+  end
+  
+  def to_s
+    res = "x = " + @x.to_s + "\n" +
+    "v = " + @v.to_s + "\n" +
+    "t = " + @t.to_s
+  end
+  
+  def get_x 
+    @x.x
+  end
+  
+  def get_y
+    @x.y
+  end
+  
+  def get_t
+    @t
+  end
+
+# total energy
+  def energy
+    @v.abs2 * 0.5 - @g/@x.abs
+  end
+
+# angular momentum
+  def ang_mom
+    @x.x * @v.y - @x.y * @v.x
+  end
+
+# Runge-Lenz vector
+  def lenz
+    @x * @v.abs2 - @x * @v.spr(@x) - @x.uv * @g 
+  end
+  
+end # class Kep2D 
+
+end # AppMath
+

data/lib/linalg.rb

@@ -0,0 +1,1309 @@
+=begin rdoc
+ruby
+
+Ulrich Mutze, www.urichmutze.de 
+
+Linear algebra of vectors and matrices 
+
+Defines classes AppMath::Vec and AppMath::Mat.
+
+Requires files appmath_basics and random.
+
+2008-12-03
+
+    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 File.join(File.dirname(__FILE__), 'random')
+#require 'appmath_basics'
+#require 'random'
+
+module AppMath 
+
+# Vector space of arbitrary dimension. 
+# The intended usage is that the components
+# of a vector are all either real or complex.
+# Since 
+#   x = Vec.new(anyArray); x[1] = anyObject
+# works, there is no guaranty for type-uniformity
+# of the components of a vector. 
+
+class Vec
+  include Enumerable
+  include Comparable
+  
+  attr :x, true
+
+# Returns the 'dimension' of the vector, i.e. the number of its
+# components. 
+  def dim; @x.size; end
+
+# These are the 3 mehods to generate a vector via 'new'
+#   a = Vec.new(anArray)
+#   b = Vec.new(aVec)
+#   c = Vec.new(aPositiveInteger, aRealOrComplex)
+  def initialize(*arg)
+    case arg.size
+    when 1
+      a0 = arg[0]
+      if a0.is_a?(Array)
+        @x = Array.new(a0)
+       # @x = a0 # seems to work but can't be safe
+      elsif a0.is_a?(Vec)
+        @x = Array.new(a0.x)
+      else
+        fail "object can't be used to build a vector"
+      end
+    when 2
+      n = arg[0]
+      fail "first argument has to be an integer" unless n.integer?
+      fail "first argument must be non-negative" unless n >= 0
+      @x = Array.new(n,arg[1])
+    end
+  end
+
+# Returns an independent copy of self.
+  def clone
+    Vec.new(self)
+  end
+
+# Test object.
+#
+# Returns a Vec res such that res.dim == n. Vector res depends rather
+# chaotically on the integer argument i. If the last argument is
+# 'false' res will have R-typed components, and C-typed components else.
+  def Vec.tob(n,i,complex=false)
+    vi = complex ? C.tob(i) : R.tob(i)
+    res=Vec.new(n, vi)
+    if complex 
+      rg1 = Ran.new(-vi.re,vi.re)
+      rg2 = Ran.new(-vi.im,vi.im)
+      for j in 1..res.dim
+        res[j] = C.new(rg1.ran,rg2.ran)
+      end
+    else
+      rg = Ran.new(-vi,vi)
+      for j in 1..res.dim
+        res[j] = rg.ran
+      end
+    end
+    res
+  end 
+
+# Gives the pseudoinverse of the vector self.
+# This means that all components get inverted except those that are
+# close to zero in comparison to the component with the largest
+# absolute value.
+# For small components c ( |c| ~ acc * sup |self[i]| ) a continuous
+# transition between the inverse and zero becomes operational.
+  
+  def pseudo_inv(acc=0)
+    n = dim
+    fail "dim = 0" if n.zero?
+    res = clone
+    if acc.zero? # most common case, thus first and without ordering 
+     # overhead
+      for i in 1..n 
+        si = self[i]
+        res[i] = si.zero? ? si.to_0 : si.inv
+      end
+    else
+      arr = @x.clone
+      arr.each{ |v| v = v.abs }
+      arr.sort!
+      a_max = arr.last
+      eta = a_max * acc
+      eta *= 0.5
+      eta *= eta
+      for i in 1..n 
+        si = self[i]
+        ni = si * si + eta
+        res[i] = si / ni
+      end
+    end
+    res
+  end
+
+# Valid indexes start with 1 not with 0.
+# Read access to the components also works via indexes such as
+#   y = x[3]
+  def [](i)
+    @x[i-1]
+  end
+ 
+# Valid indexes start with 1 not with 0.
+# Write access to the components also works via indexes such as
+#   x[1] = 3.14
+  def []=(i,a)
+    @x[i-1] = a
+  end
+  
+# Returns self + v, where v is a Vec 
+  def +(v)
+    fail "object can't be added to a Vec" unless v.is_a?(Vec)
+    fail "dimension mismatch" unless dim == v.dim
+    res = clone
+    for i in 1..dim
+      res[i] += v[i]
+    end
+    res
+  end
+ 
+# Returns self - v , where v is a Vec 
+  def -(v)
+    fail "object can't be subtracted from a Vec" unless v.is_a?(Vec)
+    fail "dimension mismatch" unless dim == v.dim
+    res = clone
+    for i in 1..dim
+      res[i] -= v[i]
+    end
+    res
+  end
+ 
+# Returns self * s, where s has the same type as the components of self. 
+  def *(s)
+    res = clone
+    for i in 1..dim
+      res[i] *= s
+    end
+    res
+  end
+  
+# Returns -self.
+  def -@
+    res = clone
+    for i in 1..dim
+      res[i] = -res[i]
+    end
+    res
+  end
+  
+# Returns a string which consists of a list of the strings which
+# represent the components.  
+  def to_s
+    res = "\n Vec"
+    for i in 0...dim
+      res += "\n    " + x[i].to_s
+    end
+    res + "\n end Vec"
+  end
+  
+# Prints the content of self and naming the output. 
+  def prn(name)
+    for i in 1..dim 
+      puts " #{name}[#{i}] = " + self[i].to_s
+    end
+  end  
+  
+# The order relation is here lexicographic ordering of lists. 
+# Needed only for book-keeping purposes. 
+# Defines the functionality of self as a Comparable.
+  def <=> (v)
+    d1 = dim; d2 = v.dim
+    if d1 < d2
+      return -1
+    elsif d1 > d2 
+      return 1
+    else
+      for i in 0...d1
+        ci = x[i] <=> v.x[i]
+        return ci unless ci == 0
+      end
+    end
+    return 0
+  end
+  
+# Defines the functionality of self as an Enumerable.
+  def each
+    @x.each{ |c| yield c}
+  end
+  
+# Returns the scalar product (self|v). The complex
+# conjugation (which acts trivially on R) affects here the
+# first factor. This is the convention preferred in physics.
+  def spr(v)
+    fail "dimension mismatch" unless dim == v.dim
+    return nil if dim.zero?
+    s = self[1].conj * v[1] 
+    for i in 2..dim
+      s += self[i].conj * v[i] 
+    end
+    s
+  end
+ 
+# Returns a 'modified scalar product' in which no
+# complex conjugation is involved.
+  def convolution(v)
+    fail "dimension mismatch" unless dim == v.dim
+    return nil if dim.zero?
+    s = self[1] * v[1] 
+    for i in 2..dim
+      s += self[i] * v[i] 
+    end
+    s
+  end
+  
+# Returns the square of absolute value of self.
+  def abs2
+    spr(self)
+  end
+  
+# Returns the absolute value of self. This is also 
+# known as the L2-norm.
+  def abs
+    if complex?
+      abs2.re.sqrt
+    else
+      abs2.sqrt
+    end
+  end
+
+# Returns a unit vector which has the same direction as self,
+# (or self if this is the zero-vector).
+  def uv
+    r = abs
+    if r.zero?
+      clone
+    else 
+      ri = r.inv
+      self * ri
+    end
+  end
+ 
+# Returns a relative distance between self and v. 
+  def dis(v)
+    a = abs
+    b = v.abs
+    d = (self - v).abs
+    s = a + b
+    return R.c0 if s.zero?
+    d1 = d/s
+    Basics.inf(d,d1)
+  end
+ 
+# Returns 'true' if the first component is complex. Notice
+# that the normal usage of Vec is to have all components
+# of the same type.
+  def complex? 
+    return nil if dim.zero?
+    @x[0].complex?
+  end
+ 
+# Consistency test of class Vec. 
+  def Vec.test(n0, verbose = true , complex = false)
+    puts "Doing Vec.test( n = #{n0}, verbose = #{verbose}, " +
+    "complex = #{complex}) for R.prec = #{R.prec}:"
+    puts "*************************************************"
+    
+    t1 = Time.now
+    s = R.c0
+    puts "class of s is " + s.class.to_s
+    i = n0
+    a = Vec.tob(n0, i, complex) 
+    i += 1
+    b = Vec.tob(n0, i, complex) 
+    i += 1
+    c = Vec.tob(n0, i, complex) 
+    i += 1
+    s1 = complex ? C.ran(i) : R.ran(i)
+    i += 1
+    s2 = complex ? C.ran(i) : R.ran(i)
+  
+    r = (a + b) + c
+    l = a + (b + c)
+    ds = r.dis(l)
+    puts "associativity: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = (a - b) + c
+    l = a - (b - c)
+    ds = r.dis(l)
+    puts "associativity 2: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = (a + b) * s1
+    l = a * s1 + b * s1
+    ds = r.dis(l)
+    puts "distributivity: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = c * (s1*s2)
+    l = (c * s1) * s2
+    ds = r.dis(l)
+    puts "distributivity of multiplication by scalars: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = a
+    l = -(-a)
+    ds = r.dis(l)
+    puts "idempotency of unary minus: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = (a + b).spr(c)
+    l = a.spr(c) + b.spr(c)
+    ds = r.dis(l)
+    puts "distributivity of spr: ds = " + ds.to_s if verbose
+    s += ds
+    
+    t2 = Time.now
+  
+    if verbose
+      puts
+      a.prn("a")
+      puts
+      b.prn("b")
+      puts
+      c.prn("c")
+      puts
+      s1.prn("s1")
+      puts
+      s2.prn("s2")
+    end
+
+    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).to_s
+    s
+  end
+
+end # Vec
+
+# Matrix space of arbitrary dimension. 
+# The intended usage is that the elements
+# of a matrix are all either real or complex.
+# Since one is allowed to change any matrix element into
+# any object there is no guaranty for type-uniformity
+# of the elements of a matrix. 
+ 
+class Mat
+  include Enumerable
+  include Comparable
+  attr :x, true
+
+# Returns the 'dimension' of the matrix, i.e. the number of its
+# row-vectors. This thus is m for a 'm times n - matrix'.
+  def dim; @x.size; end
+ 
+# Let self be a (m,n)-matrix (also called a  m times n matrix)
+# then dim1 == m
+  def dim1; @x.size; end
+
+# Let self be a (m,n)-matrix (also called a  m times n matrix)
+# then dim2 == n
+  def dim2
+    return 0 if dim.zero?
+    self[1].dim
+  end
+
+# These are the 5 mehods to generate a matrix via 'new'
+#   m1 = Mat.new(aMat)
+#   m2 = Mat.new(anArrayOfVec)
+#   m3 = Mat.new(aVec)
+#   m4 = Mat.new(aPositiveInteger, aRealOrComplex)
+#   m5 = Mat.new(aPositiveInteger, aPositiveInteger, aRealOrComplex)
+# Here, m1 is a copy of aMat, m2 is a matrix which has as row
+# vectors, the components of anArrayOfVec. If these vectors have
+# not all he same dimension, failure results; m3 is a square matrix
+# in which only the main diagonal may have non-zero elements,
+# and in which ths diagonal is given as aVec; m4 is a square matrix
+# with the dimension given by the first argument, and with all matrix
+# elements equal to the second argment; m5 is a rectangular matrix
+# with dim1 and dim2 given by the first and the second argument, and
+# with all matrix elements equal to the third argument. 
+
+  def initialize(*arg)
+    case arg.size
+    when 0
+      @x = Array.new
+    when 1 # ok if this is a Matrix or an array of Vectors
+      a0 = arg[0]
+      if a0.is_a?(Mat)
+        @x = Array.new(a0.x)
+      elsif a0.is_a?(Array)
+        n = a0.size
+        if n.zero?
+          @x = Array.new
+        else
+          misfit = 0
+          a0.each{|c|
+            misfit += 1 unless c.is_a?(Vec)
+          }
+          fail "input must consist of Vec-objects" unless misfit.zero?
+          misfit2 = 0
+          d2 = a0[1].dim
+          a0.each{|c|
+            misfit2 += 1 unless c.dim == d2
+          }
+          fail "input Vec-objects must agree in dimension" unless 
+            misfit.zero?
+          @x = a0.clone
+        end
+      elsif a0.is_a?(Vec) # make a diagonal matrix
+        n = a0.dim
+        if n.zero?
+          @x = Array.new
+        else
+          c = a0[1].to_0
+          vc = Vec.new(n,c)
+          @x = Array.new(n,vc)
+          for i in 1..n
+            s!(i,i,a0[i])
+          end
+        end
+      else
+        fail "no reasonable construction available for this argument"
+      end
+    when 2 # make a square matrix, the diagonal filled with one element
+      # (all others zero)
+      n = arg[0]
+      a = arg[1]
+      zero = a.to_0
+      vc = Vec.new(n,zero)
+      @x = Array.new(n,vc)
+      for i in 1..n
+        vi = Vec.new(vc)
+        vi[i] = a
+        @x[i-1] = vi
+      end
+    when 3 # make rectangular matrix filled with one element
+      n1 = arg[0]
+      fail "first argument must be integer" unless n1.integer?
+      n2 = arg[1]
+      fail "second argument must be integer" unless n2.integer?
+      a = arg[2]
+      vc = Vec.new(n2,a)
+      @x = Array.new(n1,vc)
+    else
+      fail "no construction for more than 3 arguments"
+    end
+  end
+
+# Returns an independent copy of self.
+  def clone
+    Mat.new(self)
+  end
+  
+# Generates a test object, here a n times n matrix with random
+# elements. This object depends rather chaotically on the
+# integer parameter i.
+# If the last argument is 'false' the test matrix will have R-typed 
+# elements, and C-typed elements else.
+  def Mat.tob(n,i, complex = false)
+    if complex
+      ri = C.tob(i)
+      zero = ri.to_0
+      res=Mat.new(n, n, zero)
+      rg1 = Ran.new(-ri.re,ri.re)
+      rg2 = Ran.new(-ri.im,ri.im)
+      for j in 1..n
+        for k in 1..n
+          yjk = C.new(rg1.ran,rg2.ran)
+          res.s!(j,k,yjk)
+        end
+      end
+      res
+    else
+      ri = R.tob(i)
+      zero = ri.to_0
+      res=Mat.new(n, n, zero)
+      rg = Ran.new(-ri,ri)
+      for j in 1..n
+        for k in 1..n
+          yjk = rg.ran
+          res.s!(j,k,yjk)
+        end
+      end
+      res
+    end
+  end 
+  
+# Singular value decomposition. Slightly modified fom Press et al.
+# Only needed as a algorithmic tool. The method for the end-user
+# is method pseudo_inv.
+  def Mat.svdcmp(a, w, v)
+
+    m = a.dim1; n = a.dim2
+    fail "svdcmp: bad frame of a" unless m >= n
+    fail "svdcmp: bad frame of w" unless n == w.dim
+    fail "svdcmp: bad frame of v" unless v.dim1 == n && v.dim2 == n
+    fail "svdcmp: dim = 0 as input" if m.zero? || n.zero?
+  
+    iter_max=40
+    a11 = a[1][1]
+    zero =a11.to_0
+    one = a11.to_1
+    two = one + one
+    rv1 = Vec.new(n,zero)
+    g = zero; scale = zero; anorm = zero
+    for i in 1..n 
+      l = i + 1
+      rv1[i] = scale * g
+      g = zero; s = zero; scale = zero
+      if i <= m
+        for k in i..m; scale += a[k][i].abs; end
+        if scale.nonzero?
+          for k in i..m
+            aki = a[k][i]
+            aki /= scale
+            a.s!(k,i,aki)
+            s += aki * aki
+          end
+          f = a[i][i]
+          g = - Basics.sign2(s.sqrt,f)
+          h = f * g - s
+          a.s!(i,i,f - g)
+          for j in l..n
+            s = zero
+            for k in i..m; s += a[k][i] * a[k][j]; end
+            f = s/h
+            for  k in i..m 
+              akj = a[k][j]
+              akj += f * a[k][i]
+              a.s!(k,j,akj)
+            end
+          end # for j in l..n
+          for k in i..m
+            aki = a[k][i]
+            aki *= scale
+            a.s!(k,i,aki)
+          end
+        end # scale != zero
+      end # i <= m
+      w[i] = scale * g
+      g = zero; s = R.c0; scale = zero
+      if i <= m && i != n
+        for k in l..n; scale += a[i][k].abs; end
+        if scale.nonzero?
+          for k in l..n
+            aik = a[i][k]
+            aik /= scale
+            a.s!(i,k,aik)
+            s += aik * aik
+          end
+          f = a[i][l]
+          g = - Basics.sign2(s.sqrt,f)
+          h = f * g - s
+          a.s!(i,l,f - g)
+          for k in l..n; rv1[k] = a[i][k]/h ; end
+          for j in l..m
+            s = zero
+            for k in l..n; s += a[j][k] * a[i][k]; end
+            for k in l..n
+              ajk = a[j][k]
+              ajk += s * rv1[k]
+              a.s!(j,k,ajk)
+            end
+          end # for j in l..m
+          for k in l..n; aik = a[i][k]; aik *= scale; a.s!(i,k,aik); end
+        end # if scale != zero
+      end # if i <= m && i != n
+      anorm = Basics.sup(anorm,w[i].abs + rv1[i].abs)
+    end # for i in 1..n 
+    i = n
+    while i >= 1
+      if i < n
+        if g.nonzero?
+          for j in l..n; v.s!(j,i, (a[i][j]/a[i][l])/g); end
+          for j in l..n
+            s = zero
+            for k in l..n; s += a[i][k] * v[k][j]; end
+            for k in l..n
+              vkj =v[k][j]
+              vkj += s * v[k][i]
+              v.s!(k,j,vkj)
+            end
+          end # for j in l..n
+        end # if g.notzero!
+        for j in l..n; v.s!(i,j,zero); v.s!(j,i,zero); end
+      end # if i< n
+      v.s!(i,i,one)
+      g = rv1[i]
+      l = i
+      i -= 1
+    end # while i >= 1
+  
+    i = Basics.inf(m,n)
+    while i >= 1
+      l = i + 1
+      g = w[i]
+      for j in l..n; a.s!(i,j,zero); end
+      if g.nonzero?
+        g = one/g
+        for j in l..n
+          s = zero
+          for k in l..m; s += a[k][i] * a[k][j]; end
+          f = (s/a[i][i]) * g
+          for k in i..m
+            akj = a[k][j]; akj += f * a[k][i]; a.s!(k,j,akj)
+          end
+        end # for j in l..n
+        for j in i..m; aji = a[j][i]; aji *= g; a.s!(j,i,aji); end
+      else
+        for j in i..m; a.s!(j,i,zero); end
+      end # if g.nonzero?  
+      aii = a[i][i]; aii += one; a.s!(i,i,aii)
+      i -= 1
+    end # while i >= 1
+  
+    k = n
+    while k >=1
+      for its in 1..iter_max
+        flag = 1
+        l = k
+        while l >= 1
+          nm = l - 1
+          if rv1[l].abs + anorm == anorm
+            flag = 0
+            break
+          end # if rv1[l].abs + anorm == anorm
+          break if w[nm].abs + anorm == anorm
+          l -= 1
+        end #  while l >= 1
+        if flag.nonzero?
+          c = zero
+          s = one
+          for i in l..k
+            f = s * rv1[i]
+            rv1[i] = c * rv1[i]
+            break if f.abs + anorm == anorm
+            g = w[i]
+            h = f.hypot(g)
+            w[i] = h
+            h = one/h
+            c = g * h
+            s = -f * h
+            for j in 1..m
+              y = a[j][nm]; z = a[j][i]; 
+              a.s!(j,nm,y*c+z*s); a.s!(j,i,z*c-y*s)
+            end # for j in 1..m
+          end # for i in l..k
+        end # if flag.nonzero?
+        z = w[k]
+        if l == k
+          if z < zero
+            w[k] = -z
+            for j in 1..n; v.s!(j,k,-v[j][k]); end 
+          end # if z < zero
+          break
+        end # if l == k
+        fail "no convergence in #{iter_max} iterations" if its == iter_max
+        x = w[l]; nm = k - 1; y = w[nm]; g = rv1[nm]; h = rv1[k]
+        f = ((y-z) * (y+z) + (g-h) * (g+h))/(h*y*two)
+        g = f.hypot(one)
+        f = ((x-z)*(x+z)+h*((y/(f+Basics.sign2(g,f)))-h))/x;
+        c = one; s = one
+        for j in l..nm
+          i = j + 1; g = rv1[i]; y =w[i]; h = s * g; g = c * g
+          z = f.hypot(h)
+          rv1[j] = z
+          c = f/z
+          s = h/z
+          f = x*c+g*s; g = g*c-x*s; h=y*s; y *= c;
+          for jj in 1..n
+            x=v[jj][j]; z=v[jj][i];
+            v.s!(jj,j,x*c+z*s); v.s!(jj,i,z*c-x*s)
+          end # for jj in 1..n
+          z = f.hypot(h)
+          w[j] = z
+          if z.nonzero?
+            z = one/z; c = f * z; s = h * z
+          end # if z.nonzero?
+          f=c*g+s*y; x=c*y-s*g;
+          for jj in 1..m
+            y=a[jj][j]; z=a[jj][i]
+            a.s!(jj,j,y*c+z*s); a.s!(jj,i,z*c-y*s)
+          end # for jj in 1..m
+        end # for j in l..nm
+        rv1[l] = zero
+        rv1[k] = f
+        w[k] = x
+      end # for its in 1..iter_max
+      k -= 1
+    end # while k >=1
+  end   
+ 
+# Reading row vectors. Valid indexes are 1,...,dim1.
+  def [](i)
+    @x[i-1]
+  end
+  
+  # Setting row vectors.  Valid indexes are 1,...,dim1.
+  # Notice that setting matrix elements via [][]= is not permanent.
+  # For setting matrix elements the method s! is provided.
+  def []=(i,a) 
+    @x[i-1] = a
+  end
+
+# The 's' stands for 'set (value)' and the '!' this is a method by which
+# self changes (non-constant or mutating method). 
+
+  def s!(i,j,a)
+    si = Vec.new(self[i]) # don't change the row-vector self[i]
+      # itself. Such changes are subject to subtle side effects.
+      # Worcing on a copy is safe.
+    si[j] = a   # changing si here is normal syntax 
+    self[i] = si # this is OK, of course 
+      # self[i] = Vec.new(si) would work too, but would cause more work 
+  end
+
+# Returns a string which consists of a list of the strings which
+# represent the row-vectors.
+  def to_s
+    res = "\n Mat"
+    for i in 0...dim
+      res += "\n    " + x[i].to_s
+    end
+    res + "\n end Mat"
+  end
+
+# Prints the content of self and naming the output. 
+  def prn(name)
+    for i in 1..dim1 
+      for j in 1..dim2
+        puts " #{name}[#{i}][#{j}] = " + self[i][j].to_s
+      end
+    end
+  end
+  
+ # Unary minus operator. Returns - self.
+  def -@
+    res = clone
+    for i in 1..dim
+      res[i] = -res[i]
+    end
+    res
+  end
+ 
+ # Returns self + v, where v is a Mat
+  def +(v)
+    fail "Object can't be added to a Mat." unless v.is_a?(Mat)
+    fail "Dimension mismatch." unless dim == v.dim
+    res = clone
+    for i in 1..dim
+      res[i] += v[i]
+    end
+    res
+  end
+  
+# Returns self - v , where v is a Mat 
+  def -(v)
+    fail "Object can't be subtracted from a Mat." unless v.is_a?(Mat)
+    fail "Dimension mismatch." unless dim == v.dim
+    res = clone
+    for i in 1..dim
+      res[i] -= v[i]
+    end
+    res
+  end
+
+# Returns the transposed of self.
+  def trp # implementation without s!
+    d1 = dim1
+    d2 = dim2
+    fail "dim1 == 0" if d1.zero?
+    fail "dim2 == 0" if d2.zero?
+    zero = @x[0][0].to_0
+    # self has d1 row-vectors of length d2. 
+    # The result of transposing has d2 row-vectors of length d1.
+    v = Array.new(d2)
+    for j in 0...d2
+      vj = Vec.new(d1,zero)
+      for i in 0...d1
+        vj.x[i] = @x[i].x[j]
+      end
+      v[j] = vj
+    end
+    Mat.new(v)
+  end
+
+# Returns the Hermitian conjugate of self.
+  def conj
+    d1 = dim1
+    d2 = dim2
+    fail "dim1 == 0" if d1.zero?
+    fail "dim2 == 0" if d2.zero?
+    zero = @x[0].x[0].to_0
+    res = Mat.new(d2,d1,zero)
+    for i in 0...d1
+      for j in 0...d2
+        sij = @x[i].x[j]
+        res.s!(j+1,i+1,sij.conj)
+      end
+    end
+    res
+  end
+
+
+# 'to zero' Returns a matrix with he same dimensions
+# as self, but with all matrix elements set to zero.
+
+  def to_0
+    d1 = dim1
+    d2 = dim2
+    fail "dim1 == 0" if d1.zero?
+    fail "dim2 == 0" if d2.zero?
+    zero = @x[0].x[0].to_0
+    Mat.new(d2,d1,zero)
+  end
+  
+# 'to one'. Returns a matrix with he same dimensions
+# as self, but with all matrix elements set to 1.
+  def to_1
+    d1 = dim1
+    d2 = dim2
+    fail "dim1 == 0" if d1.zero?
+    fail "dim2 == 0" if d2.zero?
+    fail "dim1 != dim2" unless d1 == d2
+    unit = @x[0].x[0].to_1
+    diag = Vec.new(d1,unit)
+    Mat.new(diag)
+  end
+
+=begin
+# Multiplication of a Mat with either a Mat, Vec, or Numeric
+  def *(v)
+    d1 = dim1
+    fail "dim1 == 0" if d1.zero?
+    d2 = dim2
+    fail "dim2 == 0" if d2.zero?
+    zero=@x[0].x[0].to_0
+    if v.is_a?(Mat)
+      d3 = v.dim1
+      fail "dimenson mismatch" unless d3 == d2
+      d4 = v.dim2
+      fail "dim4 == 0" if d4.zero?
+      res = Mat.new(d1,d4,zero)
+      for i in 0...d1
+        ip = i + 1
+        for j in 0...d4
+          vij = zero
+          jp = j + 1
+          for k in 0...d2
+            vij += @x[i].x[k] * v.x[k].x[j]
+          end
+          res.s!(ip, jp, vij)
+        end
+      end
+    elsif v.is_a?(Vec) 
+      d3 = v.dim
+      fail "dimenson mismatch" unless d3 == d2
+      res = Vec.new(d1,zero)
+      for i in 0...d1
+        vi = zero
+        for j in 0...d2
+          vi += @x[i].x[j] * v.x[j]
+        end
+        res.x[i] = vi
+      end
+    elsif v.is_a?(Numeric) # multiplication with scalar
+      res = clone
+      for i in 1..d1
+        res[i] *= v
+      end
+    else
+      fail "can't multiply with this object"
+    end
+    res
+  end
+=end  
+
+# Multiplication of a Mat with either a Mat, Vec, or Numeric
+  def *(v)
+    d1 = dim1
+    fail "dim1 == 0" if d1.zero?
+    d2 = dim2
+    fail "dim2 == 0" if d2.zero?
+    zero=@x[0].x[0].to_0
+    if v.is_a?(Mat)
+      d3 = v.dim1
+      fail "dimenson mismatch" unless d3 == d2
+      d4 = v.dim2
+      fail "dim4 == 0" if d4.zero?
+    # we better produce the d1 row-vectors in turn
+      a = Array.new(d1)
+      for i in 0...d1
+        vi = Vec.new(d4,zero)
+        for j in 0...d4
+          vij = zero
+          for k in 0...d2
+            vij += @x[i].x[k] * v.x[k].x[j]
+          end
+          vi.x[j] = vij
+        end
+        a[i] = vi
+      end
+      res = Mat.new(a)
+    elsif v.is_a?(Vec) 
+      d3 = v.dim
+      fail "dimenson mismatch" unless d3 == d2
+      res = Vec.new(d1,zero)
+      for i in 0...d1
+        vi = zero
+        for j in 0...d2
+          vi += @x[i].x[j] * v.x[j]
+        end
+        res.x[i] = vi
+      end
+    elsif v.is_a?(Numeric) # multiplication with scalar
+      res = clone
+      for i in 1..d1
+        res[i] *= v
+      end
+    else
+      fail "can't multiply with this object"
+    end
+    res
+  end
+ 
+# The order relation is here lexicographic ordering of lists. 
+# Needed only for book-keeping purposes.  
+  def <=> (v)
+    d1 = dim; d2 = v.dim
+    if d1 < d2
+      return -1
+    elsif d1 > d2 
+      return 1
+    else
+      for i in 1..d1
+        ci = self[i] <=> v[i]
+        return ci unless ci == 0
+      end
+    end
+    return 0
+  end
+  
+  def each
+    @x.each{ |c| yield c}
+  end
+ 
+ # Scalar product of matrices. 
+  def spr(v)
+    fail "dimension mismatch" unless dim == v.dim
+    return nil if dim.zero?
+    s = self[1].spr(v[1]) 
+    for i in 2..dim
+      s += self[i].spr(v[i]) 
+    end
+    s
+  end
+  
+  # Square of absolute value.
+  def abs2
+    spr(self)
+  end
+  
+# Absolute value, always real  
+  def abs
+    if complex?
+      abs2.re.sqrt
+    else
+      abs2.sqrt
+    end
+  end
+ 
+# Relative distance between matrices 
+  def dis(v)
+    a = abs
+    b = v.abs
+    d = (self - v).abs
+    s = a + b
+    return R.c0 if s.zero?
+    d1 = d/s
+    d < d1 ? d : d1
+  end
+  
+  def square?
+    dim1 == dim2
+  end
+  
+  def complex? 
+    return nil if dim.zero?
+    @x[0].complex?
+  end
+  
+# Returns the pseudo-inverse (als known as Penrose inverse) of self.
+# If the argument acc is not zero, the discontinous treatment of singular
+# values near zero is replaced by a continuous one.
+# Notice that the pseudo inverse always exists, and that the pseudo-
+# inverse of a (m,n)-matrix is a (n,m)-matrix.
+# If the argument acc is not zero, the pseudo-inverse is the first
+# component of a 4-array res, which also contains the the
+# intermediary quantities a, w, v resulting from the call
+#   Mat.svdcmp(a,w,v). a == res[1], w == res[2], v == res[3].
+# Especially the list w of the original singular values is thus made
+# accessible, so that one can judge whether their processing controlled
+# by the parameter acc was reasonable.
+# The pseudo_inverse is the most useful and stable mehod to solve 
+# linear equations: Let a be a (m,n)-matrix, and b a m-vector.
+# The equation 
+#   a * x = b (i)
+# determines a n-vector x as
+#   x = a.pseudo_inv * b
+# which is a solution of (i) if there is one. If there are many solutions
+# it is the one of minimum absolute value, and if there is no solution
+# it comes closest to be a solution: It minimizes the defect
+#   (a * x - b).abs
+# Simply great! No need for LU-decompositions any more.
+
+  def pseudo_inv(acc = 0)
+    if complex?
+      fail "Pseudo inverse not yet impemented for complex matrices"
+    end
+    m = dim1
+    fail "dim1 == 0" if m.zero?
+    n=dim2
+    fail "dim2 == 0" if n.zero?
+    rightframe = m >= n
+    a = clone
+    a = a.trp if rightframe == false
+    m = a.dim1;  n = a.dim2
+    zero = a[1][1].to_0
+    v = Mat.new(n,n,zero)
+    w = Vec.new(n,zero)
+    vr = Mat.new(n,m,zero) #  sic
+    Mat.svdcmp(a,w,v)
+    wi = w.pseudo_inv(acc)  # w does not come out orderd
+    for i in 1..n
+      for j in 1..m
+        sum = zero
+        for k in 1..n
+          sum += v[i][k] * wi[k] * a[j][k]
+        end
+        vr.s!(i,j,sum)
+      end
+    end
+    vr = vr.trp if rightframe == false
+    if acc.zero? 
+      vr
+    else
+      [vr,a,w,v]
+    end
+  end
+
+# In most cases ('up to a subst of measure zero') the pseudo-inverse
+# is also the inverse.
+  def inv
+    pseudo_inv
+  end
+
+# Consistency test of class Mat. 
+  def Mat.test(n0, verbose = true, complex = false )
+    puts "Doing Mat.test( n = #{n0}, verbose = #{verbose}," +
+    " complex = #{complex} ) for R.prec = #{R.prec}:"
+    puts "******************************************************"
+    t1 = Time.now
+    s = R.c0
+    puts "class of s is " + s.class.to_s
+    i = n0 + 137
+    a = Mat.tob(n0, i, complex) 
+    i += 1
+    b = Mat.tob(n0, i, complex) 
+    i += 1
+    c = Mat.tob(n0, i, complex) 
+    x = Vec.tob(n0, i, complex) 
+    i += 1
+    y = Vec.tob(n0, i, complex) 
+    i += 1
+    s1 = complex ? C.ran(i) : R.ran(i)
+    i += 1
+    s2 = complex ? C.ran(i) : R.ran(i)
+  
+    unit = a.to_1
+  
+    a0 = a.clone
+    b0 = b.clone
+    c0 = c.clone
+  
+    abc0 = a0.abs + b0.abs + c0.abs
+  
+    ac = a.clone
+    a = b
+    r = a
+    l = b
+    ds = r.dis(l)
+    puts "assignment of variables: ds = " + ds.to_s if verbose
+    s += ds
+  
+    a = ac
+    r = a
+    l = ac
+    ds = r.dis(l)
+    puts "assignment of variables 2: ds = " + ds.to_s if verbose
+    s += ds
+   
+    r = (a + b) + c
+    l = a + (b + c)
+    ds = r.dis(l)
+    puts "associativity of +: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = (a - b) + c
+    l = a - (b - c)
+    ds = r.dis(l)
+    puts "associativity of -: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = (a * b) * c
+    l = a * (b * c)
+    ds = r.dis(l)
+    puts "associativity of *: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = (a + b) * s1
+    l = a * s1 + b * s1
+    ds = r.dis(l)
+    puts "distributivity of multiplication by scalars: ds = " + 
+      ds.to_s if verbose
+    s += ds
+  
+    r = c * (s1*s2)
+    l = (c * s1) * s2
+    ds = r.dis(l)
+    puts "distributivity of multiplication by scalars: ds = " + 
+      ds.to_s if verbose
+    s += ds
+  
+    r = a
+    l = -(-a)
+    ds = r.dis(l)
+    puts "idempotency of unary minus: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = (a + b).spr(c)
+    l = a.spr(c) + b.spr(c)
+    ds = r.dis(l)
+    puts "distributivity of spr: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = (a + b) * c
+    l = a * c + b * c
+    ds = r.dis(l)
+    puts "distributivity of matrix multiplication: ds = " + 
+      ds.to_s if verbose
+    s += ds
+  
+    r = (a * b) * x
+    l = a * (b * x)
+    ds = r.dis(l)
+    puts "action on vectors 1: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = (a + b) * x
+    l = a * x + b * x
+    ds = r.dis(l)
+    puts "action on vectors 2: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = b * (x + y)
+    l = b * x + b * y
+    ds = r.dis(l)
+    puts "action on vectors 3: ds = " + ds.to_s if verbose
+    s += ds
+  
+    r = c * (x * s1)
+    l = (c * s1) * x 
+    ds = r.dis(l)
+    puts "action on vectors 4: ds = " + ds.to_s if verbose
+    s += ds
+
+    if complex == false
+      r = unit
+      l = a * a.pseudo_inv
+      ds = r.dis(l)
+      puts "pseudo inverse is right inverse: ds = " + ds.to_s if verbose
+      s += ds
+  
+      r = unit
+      l = a.pseudo_inv * a
+      ds = r.dis(l)
+      puts "pseudo inverse is left inverse: ds = " + ds.to_s if verbose
+      s += ds
+    else
+      puts "test of pseudo inverse left out, since not implemented for complex"
+    end
+  
+    aMem = a.clone
+    bMem = b.clone
+    cMem = c.clone
+  
+# Testing the access functions, under harsh conditions with
+# inserting double transposition
+
+    for i in 1..a.dim1
+      for j in 1..a.dim2
+        b.s!(i,j,a[i][j]) # copies a to b
+      end
+    end
+    
+    l = a
+    r = a.trp.trp
+    ds = r.dis(l)
+    puts "test of double transposition: ds = " + ds.to_s if verbose
+    s += ds
+  
+    for i in 1..b.dim1
+      for j in 1..b.dim2
+        c.s!(i,j,b[i][j]) # copies b to c
+      end
+    end
+  # Finally c should have the content of a
+  
+    r = a
+    l = c
+    ds = r.dis(l)
+    puts "test of access functions: ds = " + ds.to_s if verbose
+    s += ds
+  
+    a = aMem; b = bMem; c = cMem
+  
+    abc = a.abs + b.abs + c.abs
+  
+    l = abc
+    r = abc0
+    ds = r.dis(l)
+    puts "heavy test of assignment: ds = " + ds.to_s if verbose
+  
+    t2 = Time.now
+  
+    if verbose
+      puts
+      a.prn("a")
+      puts
+      b.prn("b")
+      puts
+      c.prn("c")
+      puts
+      s1.prn("s1")
+      puts
+      s2.prn("s2")
+      puts
+      x.prn("x")
+      puts
+      y.prn("y")
+    end
+  
+    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).to_s
+    s
+  end
+
+end # Mat
+
+end # module AppMath