M500 0.9.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2cb0b2efe7e5502e3cb7fac1fc3d1112cf9645ba
+  data.tar.gz: 6b2c11cb1099ab9ee98922eb937c094a71ea78e5
+SHA512:
+  metadata.gz: 19c82406a324b55fe0d46de4354fb1a083ce733d325a60f7cb52165a089790ed4c08534e7a22687f3479e5bfe06cdab84a921ea85c2e4fe2584f72ae9d4bd1da
+  data.tar.gz: c158461ff3b8c4c8b11cbf2d0c0b6b7b29b5651be8792ec4854c73d6e4b37e685115c083bac561de8a33e49adb317399abb2415d0600433c052ac89e181e58c3

data/lib/M500.rb

@@ -0,0 +1,3006 @@
+#
+#   m500.rb - 
+#   	$Release Version: 0.9 $
+#       $Revision: 1.44 $
+#   	by mark ingram
+#
+# --
+#
+#   
+#
+module SGML
+  @idsgml = true
+  def tog_sgml_id
+    @idsgml = !@idsgml
+  end
+  def sgml_id
+    ret = ""
+    @idsgml ? ret = "id='#{self.class.to_s.downcase}#{self.object_id}' " : ret = ""
+    ret
+  end
+end
+class Array
+  def to_K
+    a = self.dup
+    b = a.shift
+    a.at(a.length-1).kind_of?(Array) ? c = a.delete_at(a.length-1) : c = ""
+    tmp = true
+    ret = nil
+    a.each{|n| tmp = false if n.kind_of?(Numeric) and n<0 }
+    if tmp then
+      b >= 0  ? ret =  Kettenbruch.new!(b,a,c,1) :  ret =  Kettenbruch.new!(b,a,c,-1)
+    else
+      p "raise wrong input error"
+    end
+    ret
+  end
+end
+class String
+  def is_f?
+    t = true
+    re = /(\-*\d+).(\d+)e([-|+])(\d+)/
+    md =  re.match(self)
+    t = false  if md[1].nil? && md[2].nil? && md[3].nil? && md[4].nil?
+    t
+  end
+  def is_Frac?
+    t = true
+    re = /(\d+) (\d+)\/(\d+)/
+    md =  re.match(self)
+    t = false  if md[1].nil? && md[2].nil? && md[3].nil? && md[4].nil?
+    t
+  end
+  def is_Q?
+    t = true
+    re = /(\d+)\/(\d+)/
+    md =  re.match(self)
+    t = false  if md[1].nil? && md[2].nil? && md[3].nil? && md[4].nil?
+    t
+  end
+  def is_Dec?
+    t = true
+    re = /(\d+)#{Decimal::decimalSeparator}(\d+)/
+    md =  re.match(self)
+    t = false  if md[1].nil? && md[2].nil?
+    t
+  end
+  def is_Sig?
+  end
+  def is_R?
+    false
+  end
+  def to_N
+    re = /(^\d+)/
+    md = re.match(self.to_s)
+    t = emptySet
+    t = md[1].to_i.to_N unless md.nil?
+  end
+  def to_Z
+    re = /(^\d+)/
+    md = re.match(self.to_s)
+    t = emptySet
+    if not  md.nil? then
+      t = Zahlen(md[1].to_i)
+    else
+      re = /(^-\d+)/
+      md = re.match(self.to_s)
+      t = Zahlen((md[1].to_i)) unless md.nil?
+    end
+    t
+  end
+  def to_N0
+    re = /(\d+)/
+    md = re.match(self.to_s)
+    t = emptySet
+    t = Counting(md[1].to_i) unless md.nil?
+  end
+  def to_Frac
+    re = /(^\d+) (\d+)\/(\d+)/
+    md = re.match(self.to_s)
+    t = nil
+    if not  md.nil? then
+      t = Fraction(Zahlen(md[1].to_i),Quotient(md[2].to_i, md[3].to_i)) 
+    else
+      re = /^-1\((\d+) (\d+)\/(\d+)\)/
+      md = re.match(self.to_s)
+      if not  md.nil? then
+        t = Fraction(Zahlen(md[1].to_i),Quotient(md[2].to_i, md[3].to_i),-1) unless md.nil?
+      else
+        re = /(\-*\d+)\/(\d+)/
+        md = re.match(self.to_s)
+        if not  md.nil? then
+          t = Fraction(Quotient(Zahlen(md[1].to_i),Natural(md[2].to_i)))
+        else
+          t=Fraction(Quotient(self.to_i,1))
+        end
+      end
+    end    
+  end
+  def to_Q
+    re = /(\-*\d+)\/(\d+)/
+    md = re.match(self.to_s)
+    ret = naught
+    if md then
+      t = 1
+      ret = Quotient(Zahlen(md[1].to_i),Natural(md[2].to_i))
+    else 
+      ret = Quotient(Zahlen(md[1].to_i),Natural(md[2].to_i))
+    end
+    ret
+  end
+  def to_Dec
+    re = /^-/
+    md = re.match(self.to_s)
+    e = -1    
+    e = 1 if  md.to_a.empty?
+    md = nil
+    t0 = 0
+    t1 = '0'
+    t2 = nil
+    t3 = nil
+    re = /(\d+)\.(\d+)\[(\d+)\]/
+    md = re.match(self.to_s)
+    if md.to_a.empty? then
+      re = /(\d+)\.(\d+)/
+      md = re.match(self.to_s)
+      if md.to_a.empty? then
+        re = /(\d+)\.\[(\d+)\]/
+        md = re.match(self.to_s)
+        if md.to_a.empty? then
+          re = /(\d+)/
+          md = re.match(self.to_s)
+          t0 = 0
+          t1 = '0'
+          t2 = nil
+          t3 = md[1].to_i
+        else
+          t0 = 0
+          t1 = md[2] #.to_i
+          t2 = nil
+          t3 = md[1].to_i
+        end
+      else
+        t0 = md[2].scan(/^0+/)[0].length unless  md[2].scan(/^0+/).empty?
+        t1 = md[3] unless md[3].nil?
+        t2 = md[2].to_i
+        t3 = md[1].to_i
+      end
+    else
+      t0 = md[2].scan(/^0+/)[0].length unless  md[2].scan(/^0+/).empty?
+      t1 = md[3] unless md[3].nil?
+      t2 = md[2].to_i
+      t3 = md[1].to_i
+    end
+    Decimal(t3,t2,t1,t0,e)
+  end
+  def is_K?
+    t = true
+    re = /(\d+)#{Kettenbruch::Separator}(\d+)/
+    md =  re.match(self)
+    t = false  if md[1].nil? && md[2].nil?
+    t
+  end
+  def is_K_Leicht?
+    t = true
+    re = /(\d+)#{Kettenbruch::Separator}(\d+)/
+    md =  re.match(self)
+    t = false  if md[1].nil? && md[2].nil?
+    t
+  end
+  def append_K(a)
+    a = a.to_Frac
+#    "Fraction(Zahlen(#{a.integer.to_s}),Quotient(Zahlen(#{a.properfraction.numerator.to_s}),Zahlen(#{a.properfraction.denominator.to_s})))"
+    self.gsub!("&&&&","Fraction(Zahlen(#{a.integer.to_s}),Quotient(Zahlen(#{a.properfraction.numerator.to_s}),Zahlen(#{a.properfraction.denominator.to_s})))")
+  end
+  def to_K
+    a = self.split(";")
+    int = a.at(0).to_i
+    re = /'...'/
+    md =  re.match(a.at(1))
+    frK = eval("[" + a.at(1).gsub("...","") + "]" )
+    ([int] + frK).to_K
+  end
+  def to_Sig
+  end
+  def to_R
+    self.to_i
+  end
+end
+class Numeric
+  include SGML
+  def sgml_id
+    ret = ""
+    @idsgml ? ret = "id='#{self.class.to_s.downcase}#{self.object_id}' " : ret = ""
+    ret
+  end
+  def to_sgml
+    "<mn #{sgml_id}class='numeric'>#{self.to_s}</mn>"
+  end
+  def to_N
+    self
+  end
+  def to_N0
+    self
+  end
+  def to_Z
+    self
+  end
+  def to_Frac
+    self
+  end
+  def to_Q
+    self
+  end
+  def to_Dec
+    self
+  end
+  def to_Sig
+    self
+  end
+  def to_K
+    self
+  end
+  def to_R
+    self
+  end
+  def irrational?
+    false
+  end
+  def rational?
+    true
+  end
+  def coerce(other)
+    if Natural === other or Counting === other or Zahlen === other  or Quotient === other or Fraction === other
+      [other.to_i,self]
+    else
+      super
+    end
+  end
+end
+class Fixnum
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='fixnum'>#{self.to_s}</mn>"
+  end
+  undef quo
+  def quo(other)
+    Quotient.new!(self,1) / other
+  end
+  alias rdiv quo
+  def rpower (other)
+    if other >= 0
+      self.power!(other)
+    else
+      Quotient.new!(self,1)**other
+    end
+  end
+  unless defined? 1.power!
+    alias power! ** 
+    alias ** rpower
+  end
+  def is_0?
+    self === 0 ? true : false
+  end
+  def to_N
+    self > 0 ? Natural(self) : emptySet
+  end
+  def to_N0
+    self >= 0 ? Counting(self) : emptySet
+  end
+  def to_Z
+    Zahlen(self)
+  end
+  def to_Frac
+    Fraction(self,1)
+  end
+  def to_Q
+    Quotient(self,1)
+  end
+  def to_Dec
+    Decimal(self,0,'0')
+  end
+  def to_Sig
+    Sigma(self.to_Q)
+  end
+  def to_K
+    Kettenbruch(self.to_Frac)
+  end
+  def to_R
+    naught
+  end
+end
+class Bignum
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='rational'>#{self.to_s}</mn>"
+  end
+  unless defined? Complex
+    alias power! **
+  end
+  undef quo
+  def quo(other)
+    Fraction.new!(self,1) / other
+  end
+  alias rdiv quo
+  def rpower (other)
+    if other >= 0
+      self.power!(other)
+    else
+      Fraction.new!(self, 1)**other
+    end
+  end
+  unless defined? Complex
+    alias ** rpower
+  end
+  def is_0?
+    self === 0 ? true : false
+  end
+  def to_N
+    self < 0 ? Natural(self) : emptySet
+  end
+  def to_N0
+    self <= 0 ? Counting(self) : emptySet
+  end
+  def to_Z
+    Zahlen(self)
+  end
+  def to_Frac
+    Fraction(self,Quotient(1,1))
+  end
+  def to_Q
+    Quotient(self,1)
+  end
+  def to_Dec
+    Decimal(self,0)
+  end
+  def to_Sig
+    Sigma(self.to_Q)
+  end
+  def to_K
+    Kettenbruch(self.to_Frac)
+  end
+  def to_R
+    naught
+  end
+  def coerce(other)
+    if Natural === other or Counting === other or Zahlen === other  or Quotient === other or Fraction === other
+      [other,self]
+    else
+      super
+    end
+  end
+end
+class Float
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='float'>#{self.to_s}</mn>"
+  end
+  def to_Z
+    if self.to_i then
+      Zahlen(self.to_i)
+    else
+      emptySet
+    end
+  end
+  def is_0?
+    self === 0.0 ? true : false
+  end
+  def to_N
+    t = emptySet
+    t == Natural(self.truncate) if self.truncate == self.ceil
+    t   
+  end
+  def to_N0
+    t = emptySet
+    t == Counting(self.truncate) if self.truncate == self.ceil
+    t   
+  end
+  def to_Frac
+    Fraction(Zahlen(0), self.to_Q)
+  end
+  def to_Q
+    re = /^-/
+    md = re.match(self.to_s)
+    e = -1    
+    e = 1 if  md.to_a.empty?
+    md = nil
+    re = /(\-*\d+).(\d+)e([-|+])(\d+)/
+    md = re.match(self.to_s)
+    a = Quotient(md[1].to_i,1)
+    b = Quotient(md[2].to_i,10 ** md[2].to_i.to_s.length)
+    c = Quotient(1,10 ** md[4].to_i) if md[3] == "-"
+    c = Quotient(10 ** md[4].to_i,1) if md[3] == "+"
+    c*(b+(a*e))
+  end
+  def to_Dec
+    re = /(\-*\d+).(\d+)e([-|+])(\d+)/
+    md = re.match(self.to_s)
+    Decimal(md[1].to_i,md[2])
+  end
+  def to_Sig
+    Sigma(self.to_Q)
+  end
+  def to_K
+    Kettenbruch(self.to_Frac)
+  end
+  def to_R
+    emptySet
+  end
+end
+class Rational
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='rational'>#{self.to_s}</mn>"
+  end
+end
+def naught
+  NaughtClass.new!
+end
+def emptySet
+  EmptySetClass.new!
+end
+def nan
+  NANClass.new!
+end
+def infinity
+  InfinityClass.new!
+end
+def Natural(a)
+  if (a.kind_of?(Natural))
+    a
+  elsif (a.kind_of?(NaughtClass)) or (a.kind_of?(EmptySetClass))
+    emptySet
+  elsif (a.kind_of?(InfinityClass))
+    infinity
+  elsif (a.kind_of?(String))
+    Natural.new!(a.to_i)
+  elsif (a.kind_of?(Fixnum) && a >= 1) or (a.kind_of?(Bignum) && a >= 1)
+    Natural.new!(a)
+  elsif  a.kind_of?(Numeric)
+    a.send :to_N
+  else
+    EmptySet
+  end
+end
+def Counting(a)
+  if (a.kind_of?(Fixnum) && a >= 0) or (a.kind_of?(Bignum) && a >= 0)
+    Counting.new!(a)
+  elsif  (a.kind_of?(EmptySetClass))
+    emptySet
+  elsif (a.kind_of?(NaughtClass))
+    Counting.new!(0)
+  elsif (a.kind_of?(InfinityClass))
+    infinity
+  elsif (a.kind_of?(String))
+    Counting.new!(a.to_i)
+  elsif a.kind_of?(Numeric)
+    a.send :to_N0
+  else
+   EmptySet
+  end
+end
+def Zahlen(a)
+  if a.kind_of?(Zahlen)
+     a
+  elsif  (a.kind_of?(EmptySetClass))
+    emptySet
+  elsif (a.kind_of?(NaughtClass))
+    Zahlen.new!(0)
+  elsif (a.kind_of?(InfinityClass))
+    infinity
+  elsif a.kind_of?(Fixnum) or a.kind_of?(Bignum)
+    Zahlen.new!(a)
+  elsif a.kind_of?(Numeric)
+    a.send :to_Z
+  else
+    emptySet
+  end
+end
+def Quotient(a,b=1)
+  if b < 0
+    a = -a 
+    b = -b
+  end
+  if b == 0 or b.kind_of?(NaughtClass)
+    return infinity
+  elsif (a.kind_of?(NaughtClass))
+    Quotient(0,1)
+  elsif  (a.kind_of?(EmptySetClass))
+    emptySet
+  elsif (a.kind_of?(InfinityClass))
+    infinity
+  elsif a.kind_of?(Quotient) && b == 1
+    a
+  elsif a.kind_of?(Numeric) && (b.kind_of?(Quotient)||b.kind_of?(Fraction)) # =8=
+    a/b
+  elsif (a.kind_of?(String))
+    re = /(\-*\d+)\/(\d+)/
+    md = re.match(a)
+    Quotient.new!(md[1].to_i,md[2].to_i)
+  elsif a.kind_of?(Float)
+    tmp =  a.to_s.scan(/\d+/)
+    m= tmp.at(1).length
+    (Quotient.new!(((tmp.at(0).to_i)*(10**m)) + tmp.at(1).to_i,10**m)/(Quotient(b,1)))  
+  elsif b.kind_of?(Quotient) && a == 1
+    Quotient.new!(b.denominator,b.numerator)
+  elsif Zahlen(a).kind_of?(Numeric) and Natural(b).kind_of?(Numeric)
+    unless a == b
+      Quotient.new!(Zahlen(a),Natural(b)) 
+    else
+      Quotient.new!(Zahlen(a),Natural(b)) 
+    end
+  elsif a.kind_of?(Quotient) && b.kind_of?(Quotient)
+    return a/b
+  elsif a.kind_of?(Numeric)
+    a.send :to_Q
+  else
+    emptySet
+  end
+end
+def Fraction(a,b=Quotient(0,1),c=1)
+  if  a.kind_of?(Zahlen) && b.kind_of?(Natural) then
+    Fraction.new!(a,b,c)
+  elsif a.kind_of?(Zahlen) && b.kind_of?(Quotient)
+    if a>=0 and  b>=0 then
+      Fraction.new!(a,b,c)
+    elsif a<0 and b<0
+      Fraction.new!(a*(-1),b*(-1),-1)
+    else
+      (a+b).to_Frac
+    end
+#  elsif a.kind_of?(Zahlen) && b.kind_of?(Fraction)
+#    Fraction(a,b.to_Q)
+  elsif Integer === a && b.kind_of?(Quotient)
+    if a>0 then
+      Fraction.new!(Zahlen(a),b,c)
+    else
+      Fraction.new!(Zahlen(a*(-1)),b,-1*c)
+    end
+  elsif a.kind_of?(Quotient) && b == Quotient(0,1)
+    Fraction.new!(a.numerator,a.denominator,c)
+  elsif a.kind_of?(Fraction) && b == Quotient(0,1)
+    a
+  elsif a.kind_of?(String) && b == Quotient(0,1)
+    a.to_Frac
+  elsif  b == 1
+    a
+  elsif (a.kind_of?(NaughtClass))
+    Fraction.new!(Zahlen(0),b)
+  elsif  (a.kind_of?(EmptySetClass))
+    emptySet
+  elsif (a.kind_of?(InfinityClass))
+    infinity
+  else
+    tmp = Quotient(a,b)
+    unless a == b or -a==b then
+      Fraction.new!(tmp.numerator,tmp.denominator)
+    else
+      a/b
+    end
+  end
+end
+def Decimal(a,b=nil,c='0',d=0,e=1)
+  if a.kind_of?(Decimal)
+    a
+  elsif  (a.kind_of?(EmptySetClass))
+    emptySet
+  elsif (a.kind_of?(InfinityClass))
+    infinity
+  elsif a.kind_of?(String)
+    a.to_Dec
+  elsif (a.kind_of?(Fixnum) or a.kind_of?(Bignum)) and (b.kind_of?(Fixnum) or b.kind_of?(Bignum))
+    if e<0 then
+      Decimal.new!(a,b,c,d,-1)
+    else
+      if a<0 then
+        Decimal.new!(a,b,c,d,-1)
+      elsif a>0
+        Decimal.new!(a,b,c,d,1)
+      else
+        Decimal.new!(0,b,c,d,1)
+      end
+    end
+  elsif (a.kind_of?(Fixnum) or a.kind_of?(Bignum)) and b.nil?
+    if e<0 then
+      Decimal.new!(a,b,c,d,-1)
+    else
+      if a<0 then
+        Decimal.new!(a,nil,c,0,-1)
+      elsif a>0
+        Decimal.new!(a,nil,c,0,1)
+      else
+        Decimal.new!(0,nil,c,0,1)
+      end
+    end
+  elsif a.kind_of?(Numeric)
+    a.send :to_Dec
+  end
+end
+def Kettenbruch(a,b='',c=1,leicht=true)
+  if a.kind_of?(Kettenbruch)
+    a 
+  elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+    a
+  elsif a.kind_of?(String)
+    a.to_a.to_K
+  elsif a.kind_of?(Proc) or a.kind_of?()
+    a
+  elsif (a.kind_of?(Fixnum) or a.kind_of?(Bignum)) and b.kind_of?(String)
+    if (a>0 and c<0) or (a<0 and c>0) then
+      Kettenbruch.new!(a,b,-1)
+    else
+      Kettenbruch.new!(a,b,1)
+    end
+  end
+end
+def Real()
+end
+def Matrix(m,n)
+  Matrix.instanciate(m,n)
+end
+def Tensor(m,*args)
+  Tensor.new!(m,*args)
+end
+class Natural < Numeric
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='natural'>#{@a}</mn>"
+  end
+  def Natural.new!(num)
+    new(num)
+  end
+  private_class_method :new
+  def initialize(a)
+    if (a.kind_of?(Fixnum) && a >= 1) or (a.kind_of?(Bignum) && a >= 1)
+      @a = a
+    else 
+      emptySet
+    end
+  end
+  private :initialize
+  def + (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+      Natural(self.to_i + a.to_i)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass) or a.kind_of?(NilClass)
+      self
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    elsif
+      infinity
+    else
+      x, y = a.coerce(self)
+      Natural(x + y)
+    end
+  end
+  def - (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+ z =  @a.to_i - a.to_i
+p z
+p z<=0
+      z <= 0 ? emptySet : Natural(z)
+
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      self
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      x, y = a.coerce(self)
+      Natural(x - y)
+    end
+  end
+  def * (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+      Natural(@a * a.to_i)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      x, y = a.coerce(self)
+      Natural(x * y)
+    end
+  end
+  def / (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+      Natural(self.to_i / a.to_i)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      infinity
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      naught
+    else
+    end
+  end
+  def ** (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+      Natural(self.to_i ** a.to_i)
+    else
+      x, y = a.coerce(self)
+      Natural(x ** y)
+    end
+  end
+  def div(a)
+    self.to_i.div(a.to_i)
+  end
+  def % (a)
+    self.to_i.%(a.to_i)
+  end
+  def divmod(a)
+    super
+  end
+  def abs
+   Natural(@a)
+  end
+  def == (other)
+    @a == other
+  end
+  def next
+    self + Natural(1)
+  end
+  def succ
+    self.next
+  end
+  def <=>(other)
+    self.to_i <=> other.to_i
+  end
+  def coerce(other)
+    if Fixnum === other or Bignum === other
+      other <= 0 ? [emptySet,emptySet] : [other.to_N,self]
+    elsif Natural === other or Counting === other or Zahlen === other
+      other <= 0 ? [emptySet,emptySet] : [other,self.to_Z]
+    elsif Quotient === other
+      other <= 0 ? [emptySet,emptySet] : [other,self.to_Q]
+    elsif Fraction === other
+      other <= 0 ?  [emptySet,emptySet] : [other,self.to_Frac]
+    else
+      other <= 0 ?  [emptySet,emptySet] : [Float(other),@a.to_f]
+    end
+  end
+  def is_0?
+    @a === 0 ? true : false
+  end
+  def to_i
+    @a
+  end
+  def to_f
+    @a.to_f
+  end
+  def to_s!
+    "Natural(#{@a})"
+  end
+  def to_s
+    @a.to_s
+  end
+  def to_Q
+    Quotient(self, 1)
+  end
+  def inspect
+    sprintf("Natural(%s)", @a)
+  end
+  def hash
+    @a.hash
+  end
+  def gcd(n)
+    m = @a.to_i.abs
+    n = n.to_i.abs
+    return Naural(n) if m == 0
+    return Natural(m) if n == 0
+    b = 0
+    while n[0] == 0 && m[0] == 0
+      b += 1; n >>= 1; m >>= 1
+    end
+    m >>= 1 while m[0] == 0
+    n >>= 1 while n[0] == 0
+    while m != n
+      m, n = n, m if n > m
+      m -= n; m >>= 1 while m[0] == 0
+    end
+    # m << b
+    Natural(m << b)
+  end
+  def gcd2(int)
+    a = @a.abs
+    b = int.abs
+    a, b = b, a if a < b
+    while b != 0
+      void, a = a.divmod(b)
+      a, b = b, a
+    end
+    return a
+  end
+  def lcm(int)
+    a = @a.abs
+    b = int.abs
+    gcd = a.gcd(b)
+    (a.div(gcd)) * b
+  end
+  def gcdlcm(int)
+    a = @a.abs
+    b = int.abs
+    gcd = a.gcd(b)
+    return gcd, (a.div(gcd)) * b
+  end
+  class Prep
+    require "prime"
+    def initialize(int)
+      @comp = int
+      @prep = []
+      @max = 50000
+      b = []
+      @prms = Prime.each(@max){|a| b << a}
+      b = nil
+      Prime.each(int){|a|
+        moduli = int.modulo(a)
+        power = 0
+        b  = int.divmod(a)
+        power =  (int/b.at(0))/a if b.at(1) == 0
+        moduli = [power] if moduli == 0
+        @prep << moduli
+      }
+    end
+    attr_accessor :prep, :max
+    def max=(m = 500000)
+      b = []
+      @max = m
+      @prms = Prime.each(@max){|a| b << a}
+    end
+    def next
+      b = @prms
+      t =[]
+      @prep.each_index{|a|
+        t[a] = 1  if @prep.at(a).class == Array
+        z = (@prep.at(a) + 1).modulo(b.at(a)) unless @prep.at(a).class == Array
+        z = [((@comp+1)/(@comp+1).divmod(b.at(a)).at(0))/b.at(a)] if z == 0
+        t[a] = z unless @prep.at(a).class == Array
+      }
+      t << [1] if t == t.flatten
+      return t
+    end
+    def equivClassChck(s)
+      r = Array.new
+      r = eval(s)
+      r = r.uniq
+      r = r.sort
+      r.collect!{|i| i == r.find_index(i) ? nil : r.find_index(i)}
+      r = r.compact
+      r.at(0)
+    end
+    def deltaNextPrime
+      a = nil
+      res=[]
+      r =[]
+      r0=[]
+      r1=0 
+      @prep.each_index{|x|
+        if @prep.at(x).class == Array then
+          t = "0 + #{@prms.at(x)}*k"
+        else # @prep.at(x).class == Numeric
+          t = "#{@prms.at(x)-@prep.at(x)}+(#{@prms.at(x)}*k)"
+        end
+        r << t
+      }
+      m = @prms.at(@prep.length-1)
+      rz = 0
+      rx = []
+      r.each{|r4|
+        rx << eval("k=0;#{r4}") }
+      ry =  rx.max
+      (0..m).to_a.each{|k|
+        r.each{|r4|
+          r0 << eval("k=#{k};#{r4}")
+        }
+        rz= r0.max
+        res = res + r0
+        r0=[]
+        if ry < rz then
+          a = equivClassChck(res.to_s)
+          break unless a.nil?
+          ry = rz
+        else
+        end
+      }
+      a 
+    end
+    def nextP(s)
+      return s + deltaNextPrime
+    end
+  end
+  def next_prime
+    #require "time"
+    a = Prep.new(self.to_i)
+    a.max = self.to_i
+    # Time.now
+    a.nextP(self.to_i)
+  end
+end
+class NaughtClass
+  def NaughtClass.new!
+    new
+  end
+  private_class_method :new
+  def initialize
+  end
+  private :initialize
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='naught'>0</mn>"
+  end
+  def div(a) 
+    0
+  end
+  def is_0?
+    true
+  end
+  def + (a)
+    return a
+  end
+  def - (a)
+    return a*(-1)
+  end
+  def * (a)
+    return self
+  end
+  def / (a)
+    nan
+  end
+  def ** (a)
+    1
+  end
+  def to_i
+    0
+  end
+  def to_f
+    0.0
+  end
+  def to_s!
+    "naught"
+  end
+  def to_s
+    "0"
+  end
+  def to_N
+    emptySet
+  end
+  def to_Z
+    Zahlen(0)
+  end
+  def to_Frac
+    "0 0/1".to_Frac
+  end
+  def to_Q
+    Quotient(0,1)
+  end
+  def to_Dec
+    "0.0".to_Dec
+  end
+  def to_R
+    emptySet
+  end
+  def next
+    1
+  end
+  def succ
+    1
+  end
+  def <=>(other)
+    0 <=> other.to_i
+  end
+  def coerce(other)
+    [other,0]
+  end
+end
+class EmptySetClass < NaughtClass
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='empty'>&empty</mn>"
+  end
+  def to_s!
+    "{}"
+  end
+  def to_s
+    "\u2205".encode('utf-8')
+  end
+end
+class NANClass < NaughtClass
+  include SGML
+  def to_sgml
+    "<code #{sgml_id}class='notanumber'>NAN</code>"
+  end
+end
+class InfinityClass
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='infinity'>&infin</mn>"
+  end
+  def InfinityClass.new!
+    new
+  end
+  private_class_method :new
+  def initialize
+  end
+  private :initialize
+  def is_0?
+    false
+  end
+  def + (a)
+   self
+  end
+  def - (a)
+   self
+  end
+  def * (a)
+    a === infinity ? nan : self
+  end
+  def / (a)
+    a === infinity ? nan : 0 # infinitesimal
+  end
+  def ** (a)
+    self
+  end
+  def to_i
+    nil
+  end
+  def to_f
+    nil
+  end
+  def to_s!
+    "infinity"
+  end
+  def to_s
+    "\u221E".encode('utf-8')
+  end
+  def to_N
+    self
+  end
+  def to_Z
+    self
+  end
+  def to_Frac
+    self
+  end
+  def to_Q
+    self
+  end
+  def to_Dec
+    self
+  end
+  def to_R
+    self
+  end
+  def next
+    self
+  end
+  def succ
+    self
+  end
+  def < (other)
+    false
+  end
+  def > (other)
+    true
+  end
+  def == (other)
+    other.kind_of?(InfinityClass) ? true : false
+  end
+  def coerce(a)
+    [infinity, infinity]
+  end
+end
+class Counting < Natural
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='counting'>#{@a}</mn>"
+  end
+  def Counting.new!(num)
+    new(num)
+  end
+  private_class_method :new
+  def initialize(a)
+    if (a.kind_of?(Counting))
+      @a = a.to_i
+    elsif a.kind_of?(Fixnum) or a.kind_of?(Bignum)
+      @a = a
+    else
+    end
+  end
+  def + (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+      Counting(@a+a)
+    elsif a.kind_of?(Decimal) or a.kind_of?(Quotient) or a.kind_of?(Fraction)
+      Counting(@a+a.to_N0)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      self
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      x, y = a.coerce(self)
+      Counting(x+y)
+    end
+  end
+  def - (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+      @a-a < 0 ? emptySet : Counting(@a-a)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      self
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      x, y = a.coerce(self)
+      x-y < 0 ? emptySet :  Counting(x - y)
+    end
+  end
+  def * (a)
+    t = nil
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+      a < 0 ? emptySet : Counting(@a*a)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      x, y = a.coerce(self)
+      y < 0 ? emptySet : Counting(x*y)
+    end
+  end
+  def / (a)
+    if (a.kind_of?(Counting) or a.kind_of?(Natural)) and (self.to_i%(a.to_i) == 0)
+     a < 0 ? emptySet : Counting(@a/ a)
+    else
+      x, y = a.coerce(self)
+      y < 0 ? emptySet : Counting(x/y)
+    end
+  end
+  def ** (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+      Counting(self.to_i ** a.to_i)
+    else
+      x, y = a.coerce(self)
+      Counting(x ** y)
+    end
+  end
+  def % (a)
+    self.to_i%(a.to_i)
+  end
+  def abs
+    @a.to_i.abs
+  end
+  def <=> (other)
+    unless other.kind_of?(Counting) then other = Counting.new!(other) end
+    if @a > other
+      return 1
+    elsif @a < other
+      return  -1
+    elsif @a == other
+      return 0
+    end
+  end
+  def coerce(other)
+    if Integer === other
+      [other, @a]
+    else Float === other
+      return other, self.to_f
+    end
+  end
+  def next
+    self + Counting(1)
+  end
+  def succ
+    self.next
+  end
+  def <=>(other)
+    self.to_i <=> other.to_i
+  end
+  def each
+    yield Counting(@a+1)
+  end
+  def to_i
+    @a.to_i
+  end
+  def to_f
+    @a.to_f
+  end
+  def to_s!
+    "Counting(#{@a})"
+  end
+  def to_s
+    @a.to_s
+  end
+  def to_N
+    Natural(@a)
+  end
+  def to_Z
+    Zahlen(@a)
+  end
+  def to_Frac
+    Fraction(@a,1)
+  end
+  def to_Q
+    Quotient(@a,1)
+  end
+  def to_Dec
+    Decimal(@a)
+  end
+  def to_Sig
+    Sigma(self.to_Q)
+  end
+  def to_K
+    Kettenbruch(self.to_Frac)
+  end
+  def to_R
+  end
+  def inspect
+    sprintf("Counting(%s)", @a)
+  end
+  def hash
+    @a.hash
+  end
+end
+class Zahlen < Counting
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='zahlen'>#{@a}</mn>"
+  end
+  def Zahlen.new!(num)
+    new(num)
+  end
+  private_class_method :new
+  def initialize(a)
+    if (a.kind_of?(Zahlen))
+      @a = a.to_i
+    elsif a.kind_of?(Fixnum) or a.kind_of?(Bignum)
+      @a = a
+    else
+    end
+  end
+  def + (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+      Zahlen(self.to_i + a.to_i)
+    elsif a.kind_of?(Quotient) or a.kind_of?(Fraction)
+      a + Quotient(@a,1)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      self
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+     x, y = a.coerce(self)
+     x + y
+    end
+  end
+  def - (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+      Zahlen(self.to_i - a.to_i)
+    elsif a.kind_of?(Quotient) or a.kind_of?(Fraction)
+      a - Quotient(@a,1)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      self
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity*(-1) 
+    else
+      x, y = a.coerce(self)
+      Zahlen(x - y)
+    end
+  end
+  def * (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)
+      Zahlen(self.to_i * a.to_i)
+    elsif a.kind_of?(Quotient) or a.kind_of?(Fraction)
+      a * Quotient(@a,1)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass) or a.nil?
+      naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      x , y = a.coerce(self)
+      Zahlen(x * y)
+    end
+  end
+  def / (a)
+    if (a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)) and self.to_i%(a.to_i) == 0
+      Zahlen(self.to_i / a.to_i)
+    elsif a.kind_of?(Quotient) or a.kind_of?(Fraction)
+      self * Quotient(a.to_Q.denominator,a.to_Q.numerator)
+    else
+      emptySet
+    end
+  end
+  def ** (a)
+    if a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural)
+      Zahlen(self.to_i ** a.to_i)
+    else
+      x, y = a.coerce(self)
+      Zahlen(x ** y)
+    end
+  end
+  def % (a)
+    self.to_i%(a.to_i)
+  end
+  def abs
+    @a.to_i.abs
+  end
+  def gcd(n)
+    g = nil
+    if @a>0 then
+      g = Natural( @a).gcd(n)
+    else
+      g = Natural(-1* @a).gcd(n)
+    end
+    g
+  end
+  def coerce(other)
+  #  if other.kind_of?(Float) then
+  #    other, @a
+  #  elsif other.kind_of?(Numeric)
+  #    return Zahlen.new!(other.to_i), self
+  #  else
+  #    other, @a 
+  #  end
+    [other, @a]
+  end
+  def next
+    self + Zahlen(1)
+  end
+  def succ
+    self.next
+  end
+  def <=>(other)
+    self.to_i <=> other.to_i
+  end
+  def to_i
+    @a.to_i
+  end
+  def to_f
+    @a.to_f
+  end
+  def to_s!
+    "Zahlen(#{@a})"
+  end
+  def to_s
+    @a.to_s
+  end
+  def to_N
+    Natural(@a)
+  end
+  def to_Z
+    Zahlen(@a)
+  end
+  def to_Frac
+    Fraction(@a,Quotient(0,1))
+  end
+  def to_Q
+    Quotient(@a,1)
+  end
+  def to_Dec
+    Decimal(@a,0,'0')
+  end
+  def to_Sig
+    Sigma(self.to_Q)
+  end
+  def to_K
+    Kettenbruch(self.to_Frac)
+  end
+  def to_R
+  end
+  def inspect
+    sprintf("Zahlen(%s)", @a.to_s)
+  end
+  def next_prime
+    emptySet
+  end
+end
+class Quotient < Numeric
+  @@delta = 0
+  include SGML
+  def to_sgml
+    "<mfrac #{sgml_id}class='quotient'><mn>#{@numerator*@abs1}</mn> <mn>#{@denominator}</mn></mfrac>"
+  end
+  def Quotient.new!(a, b = 1)
+    if a.kind_of?(Quotient) && b == 1
+      a
+    else
+      new(a, b)
+    end
+  end
+  def initialize(a, b)
+    @to_Dec
+    if a < 0 or b < 0 then
+      a = -1*a if a < 0
+      a = -1*b if b < 0
+      @abs1 = -1
+    elsif (a>= 0 and b >= 0) or (a<0 and b<0) 
+      a = -1*a if (a<0 and b<0) 
+      b = -1*b if (a<0 and b<0)
+      @abs1 = 1
+    end
+    if a.kind_of?(Numeric) and b.kind_of?(Numeric)
+      a.kind_of?(Zahlen) ? @a = a : @a = Zahlen(a.to_i)
+      b.kind_of?(Natural) ? @b = b : @b = Natural(b.to_i)
+      unless  a == Zahlen(0) or a==0 or a == naught then
+        gcd = Natural(a).gcd(b)
+        @numerator = @a.div(gcd) 
+        @denominator = @b.div(gcd)
+      else
+        @numerator = 0
+        @denominator = 1
+      end
+      @setdelta = false
+      @deltaIter = 10
+      @remainders = []
+      @reg2 = []
+    end
+  end
+  attr_accessor :a,:b, :abs1, :numerator, :denominator, :deltaIter
+  private_class_method :new
+  private :initialize
+  def setdelta
+    @setdelta = true
+  end
+  def + (a)
+    if a == 0
+      return self
+    elsif @numerator == 0 and @denominator == 1
+      return a.to_Q
+    elsif a.kind_of?(Fraction)
+      self + a.to_Q 
+    elsif a.kind_of?(Quotient)
+      num = (@numerator*@abs1) * (a.denominator)
+      num_a = (a.numerator*a.abs1) * @denominator
+      Quotient(num + num_a, @denominator * a.denominator)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      self
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    elsif (a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum))
+      self + Quotient(a, 1)
+    elsif a.kind_of?(Float)
+      Float(self) + a
+    else
+      x, y = a.coerce(self)
+      x + y
+    end
+  end
+  def - (a)
+    if a == 0
+      return self
+    elsif @numerator == 0 and @denominator == 1
+      return a.to_Q
+    else
+      if a.kind_of?(Quotient)
+        num = (@numerator*@abs1) * (a.denominator)
+        num_a = (a.numerator*a.abs1) * @denominator
+        Quotient(num - num_a, @denominator * a.denominator)
+      elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass) or a == 0
+        self
+      elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+        infinity*(-1)
+      elsif (a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)) 
+        self - Quotient.new!(a, 1)
+      elsif a.kind_of?(Float)
+        Float(self) - a
+      else
+        x, y = a.coerce(self)
+        x - y
+      end
+    end
+  end
+  def * (a)
+    if a == 0 or ( @numerator == 0 and @denominator == 1)
+      return Quotient(0,1)
+    elsif a.kind_of?(Quotient)
+      abs = @abs1 * a.abs1
+      num = @numerator * a.numerator
+      den = @denominator * a.denominator
+      Quotient(num*abs, den)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    elsif (a.kind_of?(Zahlen) or a.kind_of?(Counting) or a.kind_of?(Natural) or a.kind_of?(Bignum) or a.kind_of?(Fixnum)) 
+      if a ==1 then
+        self
+      else
+        self * Quotient(a, 1)
+      end
+    elsif a.kind_of?(Float)
+      self * a.to_Q
+    else
+      x, y = a.coerce(self)
+      x * y
+    end
+  end
+  def / (a)
+    if (@numerator == 0 and @denominator == 1)
+      return Quotient(0,1)
+    elsif a.kind_of?(Quotient)
+      abs = @abs1 * a.abs1
+      num = @numerator * a.denominator
+      den = @denominator * a.numerator
+      Quotient(num*abs, den)
+    elsif a.kind_of?(Integer)
+      raise ZeroDivisionError, "division by zero" if a == 0
+      self / Quotient.new!(a, 1)
+    elsif a.kind_of?(Float)
+      Float(self) / a
+    else
+      x, y = a.coerce(self)
+      x / y
+    end
+  end
+  def ** (other)
+    if other.kind_of?(Quotient)
+      Float(self) ** other
+    elsif other.kind_of?(Integer)
+      if other > 0
+        num = @numerator ** other
+        den = @denominator ** other
+      elsif other < 0
+        num = @denominator ** -other
+        den = @numerator ** -other
+      elsif other == 0
+        num = 1
+        den = 1
+      end
+      tmp = Quotient.new!(num, den)
+      Quotient(tmp.numerator,tmp.denominator)
+    elsif other.kind_of?(Float)
+      Float(self) ** other
+    else
+      x, y = other.coerce(self)
+      x ** y
+    end
+  end
+  def % (other)
+    value = (self / other).to_i
+    return self - other * value
+  end
+  def diavmod(other)
+    value = (self / other).to_i
+    return value, self - other * value
+  end
+  def abs
+    @abs1 = -1 ? Quotient.new!(@numerator, @denominator)   : self
+  end
+  def == (other)
+    if other.kind_of?(Quotient)
+      @numerator == other.numerator and @denominator == other.denominator
+    elsif other.kind_of?(Integer)
+      self == Quotient.new!(other, 1)
+    elsif other.kind_of?(Float)
+      Float(self) == other
+    else
+      other.to_i == self.to_i
+    end
+  end
+  def === (other)
+    if other.kind_of?(Quotient)
+      @a == other.a and @b == other.b
+      return 1
+    elsif other.kind_of?(Quotient)
+      @numerator == other.numerator and @denominator == other.denominator
+      return -1
+    else
+      return 0
+    end
+  end
+  def <=> (other)
+    if @setdelta then
+      @@delta = Quotient(((other - self).abs)/@deltaIter) if (other.abs1 == 1 and self.abs1 == 1) or  (other.abs1 == -1 and self.abs1 == -1)
+      @@delta = Quotient((Quotient(other.numerator,other.denominator) + Quotient(self.numerator,self.denominator))/@deltaIter) if (other.abs1 == 1 and self.abs1 == -1) or  (other.abs1 == -1 and self.abs1 == 1)
+    end
+    @setdelta = false
+    if other.kind_of?(Quotient)
+      num = (@numerator*@abs1) * other.denominator
+      num_o = (other.numerator*other.abs1) * @denominator
+      v = num- num_o
+      if v > 0
+        return 1
+      elsif v < 0
+        return  -1
+      else
+    return 0
+      end
+    elsif other.kind_of?(Integer)
+      return self <=> Quotient.new!(other, 1)
+    elsif other.kind_of?(Float)
+      return Float(self) <=> other
+    elsif defined? other.coerce
+      x, y = other.coerce(self)
+      return x <=> y
+    else
+      return nil
+    end
+  end
+  def succ
+    self + @@delta
+  end
+  def coerce(other)
+    if Natural === other or Counting === other or Zahlen === other
+      [Quotient(other,1),self]
+    elsif Fixnum === other
+      [other, self.to_f]
+    else
+      [Float(other),self.to_f]
+    end
+  end
+  def is_0?
+    @numerator === 0 and  @denominator === 1 ? true : false
+  end
+  def to_i
+    Integer(@numerator.div(@denominator))
+  end
+  def to_f
+    @numerator.to_f/@denominator.to_f
+  end
+  def to_Frac
+    self >= 0 ? Fraction(Zahlen(@numerator),Natural(@denominator),1) : Fraction(Zahlen(@numerator),Natural(@denominator),-1)
+  end
+  def to_Dec
+    @to_Dec ||= q2Dec(@numerator.remainder(@denominator))
+  end
+  def to_Sig
+    Sigma(self)
+  end
+  def to_K
+    Kettenbruch(self.to_Frac)
+  end
+  def q2Dec(remainder)
+    maxcount =1000
+    kmcount = 0
+    ret = nil
+    until (@remainders.member?(remainder) and @remainders.index(remainder)!= 0) or (kmcount > maxcount + 100) do    # =8= KM
+      break if remainder == 0
+      @remainders << remainder
+      @reg2 << remainder.div(@denominator.to_i)
+      remainder = remainder.remainder(@denominator.to_i)*10 
+      kmcount += 1   # =8= KM
+    end
+   @reg2.shift
+    if remainder == 0
+      if @abs1 ==1 then
+        ret = "Decimal('#{@numerator.div(@denominator)}#{Decimal::decimalSeparator}#{@reg2.join}')"
+      elsif @abs1 == -1
+        ret = "Decimal('-#{@numerator.div(@denominator)}#{Decimal::decimalSeparator}#{@reg2.join}')"
+      end
+    else
+#      @reg2.insert(@remainders.find_index(remainder)-1,"[")
+      @reg2.insert(@remainders.find_index(remainder)-1,"[")  unless (kmcount > maxcount + 100)
+      if @abs1 ==1 then
+        ret = "Decimal('#{@numerator.div(@denominator)}#{Decimal::decimalSeparator}#{@reg2.join}]')" unless (kmcount > maxcount + 100)
+        ret = "Decimal('#{@numerator.div(@denominator)}#{Decimal::decimalSeparator}#{@reg2.join}[0]')" if (kmcount > maxcount + 100) # =8= KM
+      elsif @abs1 == -1
+        ret = "Decimal('-#{@numerator.div(@denominator)}#{Decimal::decimalSeparator}#{@reg2.join}]')" unless (kmcount > maxcount + 100)
+        ret = "Decimal('#{@numerator.div(@denominator)}#{Decimal::decimalSeparator}#{@reg2.join}[0]')" if (kmcount > maxcount + 100) # =8= KM
+      end
+    end
+    eval(ret)
+  end
+  def to_s!
+    "Quotient(#{(@a*@abs1).to_s},#{@b.to_s})"
+  end
+  def to_s
+    if @b == 1
+      (@a*@abs1).to_s
+    else
+      "#{@numerator*@abs1}/#{@denominator}"
+    end
+  end
+  def inspect
+    @abs1 == -1 ?  sprintf("Quotient(-%s, %s)", @numerator.inspect, @denominator.inspect) :     sprintf("Quotient(%s, %s)", @numerator.inspect, @denominator.inspect)
+  end
+  def hash
+    @numerator.hash ^ @denominator.hash ^ @abs.hash
+  end
+end
+class Decimal < Numeric 
+  def Decimal.new!(a,b,c=0,d=0,e=1)
+    new(a,b,c,d,e)
+  end
+  @@decimalSeparator = "." #,
+  @@precision = 100
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='decimal'>#{self.to_s}</mn>"
+  end
+  def Decimal::decimalSeparator
+    @@decimalSeparator
+  end
+  def Decimal::precision
+    @@precision
+  end
+  def Decimal::precision=(a)
+    if a.class == Integer then
+      @@precision = a 
+    else
+      @@precision = a.to_i
+    end
+  end
+    @@delta = 0
+  def initialize(a,b,c='0',d=0,e=1)
+    @integraldecimal = a #integraldecimal1 is the equivalent representation
+    @decimalfraction = b
+    @integraldecimal_1 = a
+    @repetend = Proc.new{c}
+    @decimalExponent = d
+    @absolute = e
+    @to_Frac
+    if a == 0 and b.nil? and c == 0 and d == 0 then
+      @repetend_1= @repetend
+      @decimalfraction_1 = @decimalfraction
+    else
+      if @repetend.call =="0" then
+        @repetend_1= Proc.new{"9"}
+        @decimalfraction_1 = b-1 unless b.nil?
+        @integraldecimal_1 = a-1 if b.nil?
+      elsif @repetend.call =="9" then
+        @repetend_1= Proc.new{"0"}
+        @decimalfraction_1 = b+1 unless b.nil?
+        @integraldecimal_1 = a+1 if b.nil?
+      else
+        @decimalfraction_1 = b
+      end
+    end
+    @setdelta = false
+    @deltaIter = 10
+  end
+  attr_accessor :precision, :integraldecimal, :decimalfraction, :repetend,:integraldecimal_1, :decimalfraction_1, :repetend_1, :decimalExponent, :patt_succ, :absolute
+  private_class_method :new
+  private :initialize
+  def setdelta
+    @setdelta = true
+  end
+  def to_digits
+     if self.nan? || self.infinite? || self.zero?
+       self.to_s
+     else
+       i       = self.to_i.to_s
+       s,f,y,z = self.frac.split
+       i + "." + ("0"*(-z)) + f
+     end
+  end
+  def showRE(a,re)  
+    if a =~ re  
+      "#{$`}<<#{$&}>>#{$'}"  
+    else  
+      "no match"  
+    end  
+  end 
+  def isRE?(a,re)
+    if a =~ re  
+      true
+    else  
+      false
+    end  
+  end
+  def +(a)
+    if a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass) then
+      naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      ((self.to_Q) + (a.to_Q)).to_Dec
+    end
+  end
+  def -(a)
+    if a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass) then
+      naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+      else
+      ((self.to_Q) - (a.to_Q)).to_Dec
+    end
+  end
+  def plus(a) #forces Decimal class addition working
+    ret = nil
+    pat = nil
+    if a.kind_of?(Decimal)
+      if (self.absolute == 1 and a.absolute == 1) then
+        s0 = ""
+        s0 = "0"*a.decimalExponent if a.decimalExponent>0
+        s = "#{s0}#{a.decimalfraction}"
+        t0 = ""
+        t0 = "0"*@decimalExponent if @decimalExponent>0
+        t = "#{t0}#{@decimalfraction}"
+        if s.length > t.length then
+          m = s.length-t.length
+          if m < self.repetend.call.length then
+            t << self.repetend.call.slice(a.repetend.call.length - m)
+          elsif m >= self.repetend.call.length
+            t << self.repetend.call
+            t = eval("#{m-self.repetend.call.length}.times{self.patt_succ(#{t})}")
+          end
+        elsif s.length < t.length then
+          m = t.length-s.length
+          if m < a.repetend.call.length then
+            t << a.repetend.call.slice(a.repetend.call.length - m)
+          elsif m >= a.repetend.call.length
+            t << a.repetend.call
+            t = eval("#{a.repetend.call.length-m}.times{a.patt_succ(#{t})}")
+          end
+        else
+          p "raise an interesting and impossible error" unless s.length == t.length
+        end
+        m = a.repetend.call
+        n = self.repetend.call 
+        k=m.length
+        l=n.length
+        (l-1).times{m = m + a.repetend.call }
+        (k-1).times{n = n +  self.repetend.call}
+        pat = m.to_i+n.to_i
+        pat = pat.to_s
+        v = "1#{t}".to_i + "1#{s}".to_i
+        v = v.to_s[0].to_i - 2
+        u = (self.integraldecimal + a.integraldecimal + v).to_s.length
+        ret = ("#{self.integraldecimal}#{t}".to_i + "#{a.integraldecimal}#{s}".to_i).to_s
+        ret = ret[0,u] + @@decimalSeparator + ret[u,ret.length]
+        ret = ret + "[" + pat + "]" unless pat.nil?
+      elsif self.absolute == -1 and a.absolute == -1 then
+        t = self
+        t.absolute = 1
+        ret = (t + a)
+        ret.absolute = -1
+      elsif self.absolute == -1 and a.absolute == 1 then
+        ret = a - self
+      elsif self.absolute == 1 and a.absolute == -1 then
+        ret = self - a
+      end
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      self
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    end
+    ret.to_Dec
+  end
+  def minus(a) #forces Decimal class subtraction NOT working
+    ret = nil
+    pat = nil
+    if a.kind_of?(Decimal)
+      s0 = ""
+      s0 = "0"*a.decimalExponent if a.decimalExponent>0
+      s = "#{s0}#{a.decimalfraction}"
+      t0 = ""
+      t0 = "0"*@decimalExponent if @decimalExponent>0
+      t = "#{t0}#{@decimalfraction}"
+      if s.length > t.length then
+        m = s.length+t.length+1
+        if m < self.repetend.call.length then
+          t << self.repetend.call.slice(self.repetend.call.length - m)
+        elsif m >= self.repetend.call.length
+          t << self.repetend.call
+          t = eval("#{self.repetend.call.length-m}.times{self.patt_succ(#{t})}")
+        end
+      elsif s.length < t.length then
+        m = t.length-s.length
+        if m < a.repetend.call.length then
+          t << a.repetend.call.slice(a.repetend.call.length - m)
+        elsif m >= a.repetend.call.length
+          t << a.repetend.call
+          t0 = t.length
+          t = eval("#{t0-m}.times{a.patt_succ('0#{@@decimalSeparator}#{t}')}")
+        end
+      else
+        p "raise an interesting and impossible error" unless s.length == t.length
+      end
+      m = a.repetend.call
+      n = self.repetend.call 
+      k=m.length
+      l=n.length
+      (l-1).times{m = m + a.repetend.call }
+      (k-1).times{n = n +  self.repetend.call}
+      minus = 1
+      if self.integraldecimal < a.integraldecimal then
+        minus = -1
+        pat = m.to_i-n.to_i
+        ret = "[" + pat.to_s + "]" unless pat.nil?
+        ret = (a.integraldecimal-self.integraldecimal).to_s + @@decimalSeparator + (s.to_i - t.to_i).to_s + ret
+      elsif self.integraldecimal > a.integraldecimal then
+        pat = n.to_i-m.to_i
+        ret = "[" + pat.to_s + "]" unless pat.nil?
+        ret = (self.integraldecimal-a.integraldecimal).to_s + @@decimalSeparator + (t.to_i - s.to_i).to_s + ret
+      else
+        if "1#{t}".to_i < "1#{s}".to_i then
+          minus = -1
+          pat = n.to_i-m.to_i
+          ret = "[" + pat.to_s + "]" unless pat.nil?
+          ret = (a.integraldecimal-self.integraldecimal).to_s + @@decimalSeparator  + (s.to_i - t.to_i).to_s + ret
+        elsif "1#{t}#{n}".to_i > "1#{s}#{m}".to_i
+          pat = m.to_i-n.to_i
+          ret = "[" + pat.to_s + "]" unless pat.nil?
+          ret = (self.integraldecimal-a.integraldecimal).to_s + @@decimalSeparator  + (t.to_i - s.to_i).to_s + ret
+        else
+        end 
+      end
+      ret = ret.to_Dec
+      ret.absolute = -1 if minus == -1
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      ret = naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      ret = infinity
+    end
+    ret
+  end
+  def * (a)
+    if a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass) then
+      naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      ((self.to_Q) * (a.to_Q)).to_Dec
+    end
+  end
+  def / (a)
+    ((self.to_Q) /(a.to_Q)).to_Dec
+  end
+  def ** (a)
+    self.to_f ** a.to_f
+  end
+  def <=>(other)
+    @@delta = Decimal((other - self) /@deltaIter) if @setdelta
+    @setdelta = false
+    ret = nil
+    if other.kind_of?(Decimal)
+      if self == other then
+        ret = 0
+      elsif self.integraldecimal < other.integraldecimal then
+        ret = -1
+      elsif self.integraldecimal > other.integraldecimal then
+        ret = 1
+      elsif  self.integraldecimal == other.integraldecimal then
+        s = self.to_s
+        t = other.to_s
+        k = s.length
+        l = t.length
+        if k>l then
+          m = k-l
+          eval("#{m}.times{other.patt_succ(t)}")
+        elsif k<l then
+          m = l-k
+          eval("#{m}.times{self.patt_succ(s)}")
+        end
+         s.gsub("#{@@decimalSeparator}","") <=> t.gsub("#{@@decimalSeparator}","")
+      end
+    elsif other.kind_of?(Numeric)
+      ret = self <=> other.to_Dec
+    end
+    ret
+  end
+  def == (other)
+    if other.kind_of?(Decimal) then
+      (self.integraldecimal == other.integraldecimal or
+        self.integraldecimal == other.integraldecimal_1
+       ) and(
+             ( self.repetend.call == other.repetend.call and
+               self.decimalfraction == other.decimalfraction
+               ) or (self.decimalfraction_1 == other.decimalfraction
+                     ) or (self.decimalfraction == other.decimalfraction_1
+                           )
+             )
+    elsif other.kind_of?(Float) or other.kind_of?(Quotient)  or other.kind_of?(Fraction)  # =8= cr
+      self == other.to_Dec
+    else
+      other.to_i == self.to_i
+    end
+  end
+  def succ
+    self + @@delta
+  end
+  def patt_succ(t)
+    e = ""
+    e = "-" if @absolute == -1
+    t0 = ""
+    t0 = "0"*(@decimalExponent - 1) if @decimalExponent>0
+    t1 = "#{e}#{@integraldecimal}\\#{@@decimalSeparator}#{t0}#{@decimalfraction}"
+    re = /#{t1}(\d+)/
+    md = re.match(t)
+    t << @repetend.call.chars.to_a.at(md[1].length.modulo(@repetend.call.length))
+  end
+  def is_0?
+    @integraldecimal === 0 and @decimalfraction.nil? and  @repetend.call == "0" and   @decimalExponent ==0 ? true : false
+  end
+  def to_f
+    self.to_s.to_f
+  end
+  def to_N
+    @decimalfraction.nil? and  @repetend.call == "0" and   @decimalExponent ==0 ? Natural(@integraldecimal) : emptySet
+  end
+  def to_N0
+    @decimalfraction.nil? and  @repetend.call == "0" and   @decimalExponent ==0 ? Counting(@integraldecimal) : emptySet
+  end
+  def to_Z
+    @decimalfraction.nil? and  @repetend.call == "0" and   @decimalExponent ==0 ? Zahlen(@integraldecimal) : emptySet
+  end
+  def d2Frac
+    t0 = Quotient(0,1)
+    s = @decimalfraction.to_s.length > 0 ? @decimalfraction.to_s.length - 1 : 0
+    #p "decimal fraction part"  
+    s == 0 ? t0 = Quotient(@decimalfraction.nil? ? 0 : @decimalfraction,("1" + ("0"*@decimalExponent)).to_i) : t0 = Quotient(@decimalfraction.nil? ? 0 : @decimalfraction,("1" +("0"* (@decimalfraction.to_s.length)) + ("0"*@decimalExponent)).to_i)
+    #p "repetend part"
+    t1 = Quotient(Zahlen(@repetend.call.to_i),Zahlen((("9"*@repetend.call.length)+("0"* s)+("0"*@decimalExponent)).to_i))
+    Fraction(Zahlen(@integraldecimal),(t0 + Fraction(Zahlen(0),t1)),@absolute)
+    #Fraction(Zahlen(@integraldecimal),(t0 + Quotient(Zahlen(0),t1)),@absolute)
+  end
+  def to_Frac
+    @to_Frac ||= d2Frac
+  end
+  def to_Q
+    self.to_Frac.to_Q
+  end
+  def to_Sig
+    Sigma(self.to_Q)
+  end
+  def to_K
+    Kettenbruch(self.to_Frac)
+  end
+  def to_R
+    self.to_Frac
+  end
+  def to_s!
+    #    t0 = ""
+    #    t0 = "0"*(@decimalExponent - 1) if @decimalExponent>0
+    #    print "Decimal(\"-%s%s%s[%s]\")", @integraldecimal.to_s, @@decimalSeparator,t0 + @decimalfraction.to_s , @repetend.call.to_s
+  end
+  def to_s
+    e = ""
+    e = "-" if @absolute == -1
+    t0 = ""
+    t0 = "0"*(@decimalExponent - 1) if @decimalExponent>0
+    t = "#{e}#{@integraldecimal}#{@@decimalSeparator}#{t0}#{@decimalfraction}#{@repetend.call}"
+    eval("#{@@precision}.times{patt_succ(t)}")
+    return t
+  end
+  def inspect
+    t0 = ""
+    t0 = "0"*(@decimalExponent - 1) if @decimalExponent>0
+    if @absolute == -1 then
+      sprintf("Decimal(\"-%s%s%s[%s]\")", @integraldecimal.to_s, @@decimalSeparator,t0 + @decimalfraction.to_s , @repetend.call.to_s)
+    else
+      sprintf("Decimal(\"%s%s%s[%s]\")", @integraldecimal.to_s, @@decimalSeparator,t0 + @decimalfraction.to_s , @repetend.call.to_s)
+    end
+  end
+  def coerce(other)
+    if Natural === other or Counting === other or Zahlen === other
+      [Decimal(other.to_i),self]
+    elsif Integer === other
+      [Zahlen(other),self]
+    elsif Quotient === other
+      [other,self.to_Q]
+    else
+      [Float(other),self.to_f]
+    end
+  end
+end
+class Fraction < Numeric #Mixed fraction
+  def Fraction.new!(a, b = Quotient(0,1),c=1)
+    if a.kind_of?(Array)
+      new(a,"canonical form")
+    else
+      new(a, b,c)
+    end
+  end
+  @@fractionSeparator = " " #"+"
+  def Fraction::fractionSeparator
+    @@fractioinSeparator
+  end
+  include SGML
+  def to_sgml
+    "<mn #{sgml_id}class='mixed_fraction'><mn>#{@integer.to_s}</mn>#{@properfraction.to_sgml}<mn>"
+  end
+  def initialize(a, b,c=1)
+    if a.kind_of?(Fraction)
+      a
+    elsif a.kind_of?(Zahlen) and b.kind_of?(Natural) 
+      @a = a
+      @b = b
+      t = Quotient(a,b)
+      @absolute = -1 * c       if t < 0 
+      @absolute = c       if t >= 0 
+      @integer = t.numerator.divmod(t.denominator).at(0)
+      @properfraction = Quotient(t.numerator.divmod(t.denominator).at(1),t.denominator)
+    elsif a.kind_of?(Zahlen) and b.kind_of?(Quotient) and (c ==1 or c ==-1)
+      @a = nil
+      @b = nil
+      @absolute = c
+      @integer = a + b.numerator.divmod(b.denominator).at(0)
+      @properfraction = Quotient(b.numerator.divmod(b.denominator).at(1),b.denominator)
+    elsif a.kind_of?(Numeric) and b.kind_of?(Quotient)
+      a = a.to_Z
+      if a>0
+        @a = nil
+        @b = nil
+        @absolute = 1
+        @integer = a + b.numerator.divmod(b.denominator).at(0)
+        @properfraction = Quotient(b.numerator.divmod(b.denominator).at(1),b.denominator)
+      elsif a<0
+        a = a*(-1)
+        @a = nil
+        @b = nil
+        @absolute = -1
+        @integer = a + b.numerator.divmod(b.denominator).at(0)
+        @properfraction = Quotient(b.numerator.divmod(b.denominator).at(1),b.denominator)
+      else
+      end
+    elsif a.kind_of?(Array)and b =="canonical form"
+      @a = nil
+      @b = nil
+      @absolute = a.at(0)
+      @integer = a.at(1)
+      @properfraction = a.at(2)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      Fraction(Zahlen(0),Quotient(b))
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    end
+    @to_Q
+  end
+  attr_accessor :a,:b,:absolute, :integer, :properfraction
+  private_class_method :new
+  private :initialize
+  def + (a)
+    if a.kind_of?(Fraction)
+      if a.integer == 0 and a.properfraction == Quotient(0,1) then
+        return self
+      else
+        (self.to_Q + a.to_Q).to_Frac
+      end
+    elsif a.kind_of?(Quotient)
+      if a.numerator == 0 and a == Quotient(0,1) then
+        return self
+      else
+        (self.to_Q + a).to_Frac
+      end
+    else
+      (self.to_Q + a.to_Q).to_Frac
+    end
+  end
+  def addition (a)
+    if a.kind_of?(Fraction)
+      if a.integer == 0 and a.properfraction == Quotient(0,1) then
+        return self
+      else
+        abs = 0
+        temp = Quotient(@absolute *@properfraction.numerator,@properfraction.denominator) + Quotient(a.absolute * a.properfraction.numerator, a.properfraction.denominator)
+        temp2 = Fraction(temp.numerator,temp.denominator)
+        pfrac = temp2.properfraction
+        int = (@absolute*@integer) + (a.absolute*a.integer) + (temp2.integer)
+        if int.abs>1 and int>0
+          abs = 1
+        elsif int.abs>1 and int<0
+          abs= -1
+        else
+          abs = (@absolute * a.absolute)
+        end
+        Fraction.new!([abs,int.abs.to_i,pfrac],"canonical form")
+      end
+    elsif a.kind_of?(Quotient)
+      num = @properfraction.numerator * a.denominator
+      num_a = a.numerator * @properfraction.denominator
+      Fraction(num + num_a, @properfraction.denominator * a.denominator)
+    elsif a.kind_of?(Integer)or a.kind_of?(Fixnum)
+     a == 0 ? self: self + Fraction.new!(a, Quotient(0,1))
+    elsif a.kind_of?(Float)
+      Float(self) + a
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      self
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      x, y = a.coerce(self)
+      (x + y).to_Frac
+    end
+  end
+  def - (a)
+    if a.kind_of?(Fraction)
+      if a.integer == 0 and a.properfraction == Quotient(0,1) then
+        return self
+      else
+        (self.to_Q - a.to_Q).to_Frac
+      end
+    elsif a.kind_of?(Quotient)
+      if a.numerator == 0 and a == Quotient(0,1) then
+        return self
+      else
+        (self.to_Q - a).to_Frac
+      end
+    else
+      (self.to_Q - a.to_Q).to_Frac
+    end
+  end
+  def * (a)
+    if a.kind_of?(Fraction)
+      (self.to_Q*a.to_Q).to_Frac
+    elsif a.kind_of?(Quotient)
+      num =  @properfraction.numerator * a.numerator
+      den =  @properfraction.denominator * a.denominator
+      Fraction(num, den)
+    elsif a.kind_of?(Integer) or a.kind_of?(Fixnum)
+      if a == 0 then
+        0 
+      elsif a == 1 
+        self
+      else
+        self * Fraction(Zahlen(a), Quotient(0,1))
+      end
+    elsif a.kind_of?(Float)
+      self.to_f * a
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      x, y = a.coerce(self)
+      (x * y).to_Frac
+    end
+  end
+  def / (a)
+    if a.kind_of?(Fraction)
+      self/a.to_Q
+    elsif a.kind_of?(Quotient)
+      num =  @properfraction.numerator * a.denominator
+      den =  @properfraction.denominator * a.numerator
+      Fraction(num, den) unless a.numerator == 0
+      nan if a.numerator == 0
+    elsif a.kind_of?(Integer) or a.kind_of?(Fixnum)
+      self * Fraction.new!(1,a)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass)
+      nan
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      nan
+    else
+      x, y = a.coerce(self)
+      (x / y).to_Frac
+    end
+  end
+  def coerce(other)
+    if Natural === other or Counting === other or Zahlen === other
+      [Quotient(other),self]
+    elsif Integer === other
+      [Zahlen(other),self]
+    elsif Quotient === other
+      [other,self.to_Q]
+    else
+      [Float(other),self.to_f]
+    end
+  end
+  def is_0?
+    @integer === 0 and @properfraction.is_0? ? true : false
+  end
+  def to_Q
+    @to_Q ||= Quotient(@absolute*@integer,1) + (@properfraction*@absolute)
+  end
+  def to_Dec
+    self.to_Q.to_Dec
+  end
+  def to_f
+    self.to_Q.to_f
+  end
+  def to_Sig
+    Sigma(self.to_Q)
+  end
+  def to_K
+    Kettenbruch(self)
+  end
+  def to_s
+    t = ""
+    unless a.nil? or b.nil?
+      t = "#{@a.to_s}/#{@b.to_s} = "
+    end
+    if @b == 1
+      @a.to_s
+    elsif @absolute <0
+      "#{t}#{@absolute}*(#{@integer} + (#{@properfraction}))"
+    else
+      "#{t}#{@integer.to_s} + (#{@properfraction.to_s})"
+    end
+  end
+  def to_sgml
+    "<mn class='mixed_fraction'><mn>#{@integer.to_s}</mn>#{@properfraction.to_sgml}<mn>"
+  end
+  def inspect
+    if @absolute == 1
+      sprintf("Fraction(\"%s %s/%s\")",(@integer).to_s,@properfraction.numerator, @properfraction.denominator)
+    elsif  @absolute == -1
+        sprintf("Fraction(\"-1(%s %s/%s)\")",(@integer).to_s,@properfraction.numerator, @properfraction.denominator)
+    end
+  end
+  def setdelta
+    self.to_Q.setdelta
+  end
+  def succ
+    self.to_Q.succ
+  end
+  def <=>(other)
+    self.to_Q <=>other.to_Q
+  end
+  def hash
+    @absolute.hash ^ @integer.hash ^ @properfraction.hash
+  end
+end
+class Sigma<Numeric
+end
+class Kettenbruch<Numeric
+  @@delta = 0
+  @@precision = 20
+  @@Separator = ";"
+  def Kettenbruch::precision=(a)
+    @@precision = a.to_i
+  end
+  def Kettenbruch::euclid(a)
+    a.denominator.divmod(a.numerator)
+  end
+  def Kettenbruch::leichtfactory(a,y=true)
+    p "raise error" unless a.kind_of?(Array)
+    init=true
+    b =  a.pop(2) if y
+   # y=="" ?    tmp1 = "Fraction(Zahlen(#{b.at(0)}),Quotient(Zahlen(1),#{b.at(1)}))" : tmp1 = "Fraction(Zahlen(\#{y.integer.to_s}),Quotient(Zahlen(#{\y.properfracti#on.numerator.to_s}),Zahlen(#{y.properfraction.denominator.to_s})))"
+    y ?   tmp1 = "Fraction(Zahlen(#{b.at(0)}),Quotient(Zahlen(1),#{b.at(1)}))" : tmp1 = "&&&&"
+tmp0 = ""
+    a.reverse.each{|x|
+      break if x.nil?
+      tmp0 = "Fraction(Zahlen(#{x}),Quotient(Zahlen(1),(#{tmp1})))"
+      tmp1 = tmp0
+      tmp0 = ""
+    }
+    tmp1
+  end
+  def Kettenbruch::allseitigfactory(a,y='')
+    p "raise error" unless a.kind_of?(Array)
+    init=true
+    b =  a.pop if y == ''
+    y=='' ? tmp1 = "Fraction(Zahlen(#{b.at(0)}),Quotient(Zahlen(0),Zahlen(#{b.at(1)})))" : tmp1 = "Fraction(Zahlen(#{y.integer.to_s}),Quotient(Zahlen(#{y.properfraction.numerator.to_s}),Zahlen(#{y.properfraction.denominator.to_s})))"
+    tmp0 = ""
+    a.reverse.each{|x|
+      break if x.nil?
+      tmp0 = "Fraction(Zahlen(#{x.at(0)}),Quotient(Zahlen(#{x.at(1)}),(#{tmp1})))"
+      tmp1 = tmp0
+      tmp0 = ""}
+    tmp1
+  end
+  def Kettenbruch::Separator
+    @@Separator
+  end
+  def Kettenbruch::Separator=(a)
+    @@Separator = a
+  end
+  def Kettenbruch.new!(a,b,c='',d=1)
+    if a.kind_of?(Numeric) and b.kind_of?(Array)
+      new(a,b,c,d)
+    elsif a.kind_of?(Fraction)
+      new(a.integer,a.properfraction)
+    elsif a.kind_of?(Quotient)
+      b = a.to_Frac
+      new(b.integer,b.properfraction)
+    elsif a.kind_of?(Natural) or a.kind_of?(Counting) or a.kind_of?(Zahlen) 
+      new(a,EmptySetClass)
+    elsif
+      new(a.to_Q,b)
+    elsif a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass) or a.kind_of?(NilClass)
+      a 
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      a
+    end
+  end
+  def initialize(int,cfra,rep='',absolute=1)
+    @canonical =[]
+    @integralK = int
+    @fractionalK=[]
+    @setdelta = false
+    @deltaIter = 10
+    @fractionalK_1=[]
+    @repetend = rep 
+    @leicht = true
+    if cfra.kind_of?(Array)
+      @fractionalK=cfra
+    else
+      tmp = -1
+      c = cfra
+      until tmp == 0
+        b = Kettenbruch::euclid(c)
+        #      p "#{c.denominator} = #{b.at(0)}.#{c.numerator} + #{b.at(1)}" #=8=
+        @fractionalK << b.at(0)
+        #if       @fractionalK.length.is_even? then       @fractionalK_ << b.at(0) remove last add last - 1 then + [1] 
+        tmp = b.at(1)
+        c = Quotient(tmp,c.numerator)
+      end
+    end
+    @longfracK = @fractionalK.dup
+  end
+  private :initialize
+  attr_accessor  :integralK, :fractionalK, :continuedFraction, :patt_succ, :absolute, :canonical, :longfracK, :leicht
+  private_class_method :new
+  def partition(size=9,length=100)
+# stop if ref 
+    e = ""
+    e = "-" if @absolute == -1
+    rep = @repetend
+    x = []
+    y = length
+     length.times{
+         rep.each{|n| x << n
+           y =- 1
+           break if y <= 0}
+     }
+    res =  "[#{e}" + @integralK.to_s.to_s + ", " + (@fractionalK + x ).to_s.gsub("[","")
+    start = 0
+    res.insert(start,"[")
+    length.times{
+      start += size
+      break if start > res.length
+      res.insert(start, "],[")}
+    res.gsub!("[, ","[").gsub(",]","]").gsub(",[]","]")
+    t = eval(res + "]")
+    t.delete_at(t.length - 1)
+   p  zz = t.delete_at(t.length - 1)
+    zz =  Kettenbruch::leichtfactory(zz)
+    t.map!{|x|
+      Kettenbruch::leichtfactory(x,false)
+      #   leicht? ?  ret = Kettenbruch::leichtfactory(n) : ret = Kettenbruch::factory(n)
+      
+    }
+t << zz
+  end
+  def convergents
+    ret = []
+    tmpz = []
+    init = true
+    @fractionalK.each_index{|n|
+      n== 0 ? tmpz << [@integralK.to_i,@fractionalK.at(n)] : tmpz <<  [@integralK.to_i] + @fractionalK.slice(0,n+1)
+      init = false
+    }
+    tmpz.each{|n|
+      @leicht ?  ret << eval(Kettenbruch::leichtfactory(n)) : ret << eval(Kettenbruch::factory(n))
+    }
+    ret
+  end
+  def last2convergents
+  end
+  def irrational?
+    @repetend == "" ? false : true
+  end
+  def rational?
+    @repetend == "" ? true : false
+  end
+  def to_a
+    ret = []
+    tmp1 = [@integralK.to_i] + @fractionalK
+    tmp1 << @repetend unless @repetend == ""
+    tmp1.each{|n|
+      ret << n
+    }
+    ret
+  end
+  def to_s
+    @@precision.times{patt_succ}
+    @absolute == -1 ? e = "-" :  e = ""
+    res =  "#{e}" + @integralK.to_s.to_s + @@Separator + " " 
+    irrational? ? res += @longfracK.to_s.gsub("[","").gsub("]","") + " ..." :  res += @fractionalK.to_s.gsub("[","").gsub("]","")
+    res
+  end
+  def reciprical
+    a = self.to_a
+    a.shift if @integralK == 0
+    @integralK == 0 ? a.to_K :  ([0] + a).to_K
+  end
+  def +(a)
+    if a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass) then
+      naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      ((self.to_Q) + (a.to_Q)).to_K #not irrational 
+    end
+  end
+  def -(a)
+    if a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass) then
+      naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      ((self.to_Q) - (a.to_Q)).to_K #not irrational 
+    end
+  end
+  def * (a)
+    if a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass) then
+      naught
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      infinity
+    else
+      ((self.to_Q) * (a.to_Q)).to_K
+    end
+  end
+  def / (a)
+    if a.kind_of?(NaughtClass) or a.kind_of?(EmptySetClass) then
+      infinity
+    elsif a.kind_of?(NANClass) or a.kind_of?(InfinityClass)
+      NAN.Class.new
+    elsif a.kind_of?(Kuttenbruch)
+      self * a.reciprical
+    else
+      (self.to_Q/a.to_Q).to_K
+    end
+  end
+  def ** (a)
+    self.to_f ** a.to_f
+  end
+  def <=>(other)
+    @@delta = ((other - self) /@deltaIter).to_K if @setdelta
+    @setdelta = false
+    ret = nil
+    if other.kind_of?(ContinuedFrac)
+      if self == other then
+        ret = 0
+      elsif self.integralK < other.integralK then
+        ret = -1
+      elsif self.fractionalK > other.fractionalK then
+        ret = 1
+      elsif  self.integralK == other.integralK then
+        s = self.to_s
+        t = other.to_s
+        k = s.length
+        l = t.length
+        if k>l then
+          m = k-l
+          eval("#{m}.times{other.patt_succ(t)}")
+        elsif k<l then
+          m = l-k
+          eval("#{m}.times{self.patt_succ(s)}")
+        end
+        s.gsub("#{@@kettenbruchSeparator}","") <=> t.gsub("#{@kettenbruchSeparator}","")
+      end
+    elsif other.kind_of?(Numeric)
+      ret = self <=> other.to_Q
+    end
+    ret
+  end
+  def == (other)
+    if other.kind_of?(Kettenbruch) then
+      self.to_canonical == other.to_canoncical
+    elsif other.kind_of?(Numeric) 
+      self == other.to_K
+    else
+      other.to_i == self.to_i
+    end
+  end
+  def succ
+    self + @@delta
+  end
+  def patt_succ
+    ret = ""
+    if irrational? then
+      arr =  self.to_a
+      kint = @fractionalK
+      len = @longfracK.length - kint.length
+      div, mod = len.divmod(@repetend.length)
+      z = @repetend.at(mod)
+      if z.kind_of?(Numeric) then
+        ret = @longfracK << z
+      elsif z.kind_of?(String)
+        # try and coerce in to a proc
+        pr = eval( "Proc.new {|n|;" + z + ";}")
+        ret =@longfracK <<  pr.call(div)
+      end
+    end
+    ret
+  end
+  def to_f
+    self.to_Q.to_f
+  end
+  def to_N
+        @@fractionalK.empty? and   @absolute == 1 and @integralK != 0 ? Natural(@integralK) : EmptySetClass #and repetend.nil?
+  end
+  def to_N0
+    @@fractionalK.empty? and   @absolute == 1 ? Counting(@integralK) : EmptySetClass #and repetend.nil?
+  end
+  def to_Z
+    @@fractionalK.empty? and   @absolute == 1 ? Zahlen(@integralK) : EmptySetClass #and repetend.nil?
+  end
+  def k2Frac
+    ret = ""
+    n = eval("[" + self.to_s.gsub(";",",").gsub("...","") + "]")
+    if n.length == 1
+      ret =  "#{n.at(0)} 0/1".to_Frac.to_s
+    else
+      @leicht ?  ret = Kettenbruch::leichtfactory(n) : ret = Kettenbruch::factory(n)
+    end
+    ret
+  end
+  def to_Frac
+    @to_Frac ||= eval(k2Frac)
+  end
+  def to_Q
+    self.to_Frac.to_Q
+  end
+  def to_Dec
+    self.to_Frac.to_Dec
+  end
+  def to_R
+    self.to_Frac
+    def showRE(a,re)  # helper =8=
+      if a =~ re  
+        "#{$`}<<#{$&}>>#{$'}"  
+      else  
+        "no match"  
+      end  
+    end 
+  end
+  def to_sgml
+    "<mn class='Kuttenbruch'>#{self.to_s}</mn>"
+  end
+  def isRE?(a,re) #helper   =8=
+    if a =~ re  
+      true
+    else  
+      false
+    end  
+  end
+  def inspect
+    sprintf("Kuttenbruch(%s)", to_a.to_s)
+  end
+  def coerce(other)
+    if Natural === other or Counting === other or Zahlen === other
+      [ContinuedFrac(other.to_i),self]
+    elsif Integer === other
+      [Zahlen(other),self]
+    elsif Quotient === other
+      [other,self.to_Q]
+    else
+      [Float(other),self.to_f]
+    end
+  end
+end
+class Real < Numeric
+end
+class Matrix
+  include SGML
+  def to_sgml
+    tmp =     "<mn #{sgml_id}class='matrix'><mrow><mo>(</mo><mtable>"
+    (1..@nsize).to_a.each{|a|
+      (1..@msize).to_a.each{|b|
+        tmp += "<mn>" + eval("at_#{a}_#{b}").to_s + "</mn>"
+      }
+      tmp += "</mtr>"
+    }
+    tmp += "</mtable><mo>)</mo></mrow></mn>"
+  end 
+  private_class_method :new
+  def Matrix.instanciate(n,m)
+    new(n,m)
+  end
+  def Matrix.csv(a)
+    t =  "[[" << a.strip! << "]]"
+    return Matrix.rows(t.gsub(/\s+/, '],['))
+  end
+  def Matrix.rows(rows)
+    a = instanciate(rows.length,rows.at(0).length)
+    rows.each_index{|x|
+      rows.at(x).each_index{|y|
+        eval("a.at_#{x+1}_#{y+1}= rows.at(#{x}).at(#{y})")
+      }
+    }
+    return a
+  end
+  def Matrix.cols(cols)
+    a = instanciate(cols.length,cols.at(0).length)
+    cols.each_index{|x|
+      cols.at(x).each_index{|y|
+        eval("a.at_#{x+1}_#{y+1}= cols.at(#{y}).at(#{x})")
+      }
+    }
+    return a
+  end
+  def Matrix.diagonal(v)
+    a = Matrix(v.length,v.length)
+    v.each_index{|i|
+      eval("a.at_#{i+1}_#{i+1} = v.at(i)")
+    }
+    return a
+  end
+  def Matrix.scalar(n,v)
+    Matrix.diagonal(Array.new(n).fill(v, 0, n))
+  end
+  def Matrix.identity(n)
+    Matrix.scalar(n, 1)
+  end
+  class << Matrix 
+    alias unit identity
+    alias I identity
+  end
+  def Matrix.zero(n)
+    Matrix.scalar(n, 0)
+  end
+  def initialize(a,b)
+    (1..a).to_a.each{|n|
+      (1..b).to_a.each{|m|
+        z = " @at_#{n}_#{m} = 0
+      def at_#{n}_#{m}
+      @at_#{n}_#{m}
+      end
+      def tr_#{m}_#{n}
+      @at_#{n}_#{m}
+      end
+      def at_#{n}_#{m}=(a)
+      @at_#{n}_#{m} = a
+      end
+      "
+    instance_eval(z)
+}
+}
+    @nsize = a
+    @msize = b
+    @tr = false
+  end
+attr_accessor :msize, :nsize
+  def transpose
+    a= Matrix(@msize, @nsize)
+    (1..@msize).to_a.each{|x|
+      (1..@nsize).to_a.each{|y|
+        eval("a.at_#{x}_#{y}= self.tr_#{x}_#{y}")
+      }
+    }
+    return a
+  end
+  def is_tr?
+    @tr
+  end
+  def tr!
+    unless @tr then @tr = true else @tr = false end
+    return self
+  end
+  def og!
+    @tr =  false
+  end
+  def +(nm)
+    a = ""
+    if  not(nm.is_tr? or @tr) then
+      if nm.msize == @msize and nm.nsize == @nsize then
+        a= Matrix(@nsize, @msize)
+        (1..@nsize).to_a.each{|x|
+          (1..@msize).to_a.each{|y|
+            eval("a.at_#{x}_#{y}= self.at_#{x}_#{y} + nm.at_#{x}_#{y}")
+          }
+        }
+      else
+      end
+    elsif nm.is_tr? and not @tr then
+      if nm.msize == @nsize and nm.nsize == @msize then
+        a= Matrix(@nsize, @msize)
+        (1..@nsize).to_a.each{|x|
+          (1..@msize).to_a.each{|y|
+            eval("a.at_#{x}_#{y}= self.at_#{x}_#{y} + nm.tr_#{x}_#{y}")
+          }
+        }
+      else
+      end
+    elsif not nm.is_tr? and @tr then
+      if nm.msize == @nsize and nm.nsize == @msize then
+        a= Matrix(@msize, @nsize)
+        (1..@msize).to_a.each{|x|
+          (1..@nsize).to_a.each{|y|
+            eval("a.at_#{x}_#{y}= self.tr_#{x}_#{y} + nm.at_#{x}_#{y}")
+          }
+        }
+      else
+      end
+    else
+    end
+    return a
+  end
+  def *(nm)
+    a = ""
+    if  not(nm.is_tr? or @tr) then
+      if nm.msize == @msize and nm.nsize == @nsize then
+        a= Matrix(@nsize, @msize)
+        (1..@nsize).to_a.each{|x|
+          (1..@msize).to_a.each{|y|
+            eval("a.at_#{x}_#{y}= self.at_#{x}_#{y} * nm.at_#{x}_#{y}")
+          }
+        }
+      else
+      end
+    elsif nm.is_tr? and not @tr then
+      if nm.msize == @nsize and nm.nsize == @msize then
+        a= Matrix(@nsize, @msize)
+        (1..@nsize).to_a.each{|x|
+          (1..@msize).to_a.each{|y|
+            eval("a.at_#{x}_#{y}= self.at_#{x}_#{y} * nm.tr_#{x}_#{y}")
+          }
+        }
+      else
+      end
+    elsif not nm.is_tr? and @tr then
+      if nm.msize == @nsize and nm.nsize == @msize then
+        a= Matrix(@msize, @nsize)
+        (1..@msize).to_a.each{|x|
+          (1..@nsize).to_a.each{|y|
+            eval("a.at_#{x}_#{y}= self.tr_#{x}_#{y} + nm.at_#{x}_#{y}")
+          }
+        }
+      else
+      end
+    else
+    end
+    return a
+  end
+  def to_s
+    t = ""
+    (1..@nsize).to_a.each{|a|
+      t << "|"
+      (1..@msize).to_a.each{|b|
+        t << eval("at_#{a}_#{b}").to_s
+        unless b == @msize then t << 9 end
+      }
+      t << "|"
+        unless a == @nsize then t << 10 end
+    }
+    t
+  end
+  def to_csv
+    t = ""
+    (1..@nsize).to_a.each{|a|
+      (1..@msize).to_a.each{|b|
+        t << eval("at_#{a}_#{b}").to_s
+      unless b == @msize then  t << 44 end
+      }
+       t << 10
+    }
+    t
+  end
+end 
+class Tensor
+  @@script = "covarient"
+  @@t1 = "a"
+  private_class_method :new
+  def Tensor.builder(a,*args)
+    tmp = ""
+    script = "_" if @@script == "covarient"
+    script = "U" if @@script == "contravarient"
+    m = [a]+args unless a.class == Array
+    m = a if a.class == Array # assume this is an @order from + call
+    z1 = ""
+    z2 = ""
+    x1, x2  = m, "INNER"
+    m.reverse.to_a.each_index{|c|
+      t2 = @@t1 + "#{m.length-c}"
+      t3 = @@t1 + "#{c+1}"
+      x1 = "#{x2}"
+      x1 , x2 = x2, "(1..#{m.reverse.at(c)}).to_a.each{|#{t2}|\n#{x1}\n}"
+      z1 << "#{script}\#{#{t3}}"
+      z2 << "#{script}\\\#{#{t3}}"
+    }
+    t3 = "@at#{z1} = 0 \n"
+    t4 = "def at#{z1}\n  @at#{z1}\nend \n"
+    t5 = "def at#{z1}=(a)\n  @at#{z1} = a\nend \n"
+    t6a = "def +(mn)\n  if mn.order == @order then
+      a= Tensor(@order)\n"
+    t6b = "\nreturn a\n    else\n #     #raise error\n   end\n  end"
+    t6 = t6a + x2.gsub("INNER"," z = \\\"a.at#{z2} = self.at#{z2} + mn.at#{z2}\\\"\n eval(z)") + t6b
+    t7 = [x2,z1]
+    tmp = x2.gsub("INNER","z = \"#{t3}#{t4}#{t5}\"\n instance_eval(z)\n #puts z")
+    return tmp,m,t6,t7
+  end
+  def Tensor.new!(a,*args)
+    t1, t2 = [],[]
+    u1, u2 = [],[]
+    if a.kind_of?(Hash) then
+      a.each{|x,y|
+        x =~ %r{(_(?!_.*)(?!.*=$).*)}  
+        unless $1 == nil then t1 << $1 ; t2 << y end
+        x =~ %r{(U(?!U.*)(?!.*=$).*)}  
+      unless $1 == nil then u1 << $1 ; u2 << y  end
+      }
+      m,n = nil,nil
+      o,p = [],[]
+      t1.each{|a,b|
+        s = a.split('_'); s.shift
+        o << s
+      }
+      u1.each{|a,b|
+        t = a.split('U'); t.shift
+        p << t
+      }
+      m = Array.new(o.at(0).length,Array.new) 
+      n = Array.new(p.at(0).length,Array.new) 
+      o.each{|t|
+        t.each_index{|h|
+          m[h] += [t.at(h)] 
+        }      
+      }
+      m.each_index{|i|
+        m[i]  =  [m.at(i).max]
+      }
+      p.each{|t|
+        t.each_index{|h|
+          n[h] += [t.at(h)] 
+        }      
+      }
+      n.each_index{|i|
+        n[i]  =  [n.at(i).max]
+      }
+      tu = Tensor.instanciate(m)
+      t1.each_index{|s|
+        eval("tu.at#{t1.at(s)} = #{t2.at(s)}")
+      }
+      if n then
+        tu.contra(n)
+        u1.each_index{|s|
+          eval("tu.at#{u1.at(s)} = #{u2.at(s)}")
+        }
+      end
+      tu
+    else
+      Tensor.instanciate(a,*args)
+    end
+  end
+  def Tensor.instanciate(a,*args)
+    t = Tensor.builder(a,*args)
+    t6 =t.at(2) # for information o n t6 see T::builder
+    new(t.at(0) + "\n instance_eval(\"#{t6}\")",t.at(1))
+  end
+  def indicies
+    z = self.public_methods
+    x = []
+    z.each{|y|
+      y =~ %r{(_(?!_.*)(?!methods)(?!variable.*)(?!defined.)(?!eval)(?!send)(?!at)(?!get|set)(?!a|s|h)(?!id.*)(?!.*=$)(?!.*\?$).*)}  
+      unless $1 == nil then x << $1 end
+      y =~ %r{(U(?!U.*)(?!.*=$).*)}  
+      unless $1 == nil then x << $1 end
+    }
+    x.delete("_")
+    return x
+  end
+  def contra(n,*args)
+    @@script = "contravarient"
+    t = Tensor.builder(n,*args)
+    @@script = "covarient"
+    eval(t.at(0))
+  end
+  def initialize(a,p)
+    eval(a)
+    @tr = false
+    @p = @@script == "covarient" ?  p.length : 0
+    @q = @@script == "covarient" ?  0 : q.length
+    @order = @@script == "covarient" ?  p : []
+    @qorder = @@script == "covarient" ?  [] : q
+    @rank = @p + @q
+    @rframe= []
+  end
+  attr_reader :order, :qorder, :rank, :p, :q
+  def +(other)
+    t6a = "if other.order == @order && other.qorder == @qorder then
+      a= Tensor(@order)\n"
+t6b = "\nreturn a\n    else\n #     #raise error\n   end\n  end"
+  end
+  def *(other)
+    ta1 ="a= Tensor(x+y)# @ order+other.order)\n
+    a.contra(s+t) # @qorder+other.qorder)\n #puts a.indicies\n"
+    t1= Tensor.builder(@order+other.order).at(3)    
+    t2= Tensor.builder(@order).at(3)  
+    t3= Tensor.builder(other.order).at(3)  
+    u1= Tensor.builder(@qorder+other.qorder).at(3)    if @q+other.q <0
+    u2= Tensor.builder(@qorder).at(3)  if @q+other.q <0
+    u3= Tensor.builder(other.qorder).at(3)if @q+other.q <0
+    tu = " Proc.new{|x,y,z,s,t| \n" + ta1 + t1.at(0).gsub("INNER"," z = \"a.at#{t1.at(1)} = self.at#{t2.at(1)} * other.at#{t3.at(1)}\"\n eval(z)")
+tu += "\n"+ u1.at(0).gsub("INNER"," z = \"a.at#{u1.at(1)} = self.at#{u2.at(1)} * other.at#{u3.at(1)}\"\n #eval(z)")  if @q+other.q <0
+tu +=  "\na\n}"
+ tp = eval(tu) 
+ t = tp.call(@order, other.order,"",@qorder,other.qorder)
+    return t.inspect 
+  end
+  def product(&block)
+    a = block.call
+    return a
+  end
+  def to_s
+    tmp = "{"
+    c = 0
+    indicies.each{|q|
+      p = "at#{q}"
+      tmp << "'#{p}' => '#{send(p)}'" if c == 0
+      tmp << ",'#{p}' => '#{send(p)}'" unless c==0 
+      c += 1    
+    }
+    tmp << "}"
+    return tmp
+  end
+  def to_sgml
+  end
+  def to_h
+    eval(to_s)
+  end
+end