/[escript]/trunk/escript/py_src/generateutil

Diff of /trunk/escript/py_src/generateutil

Parent Directory | Revision Log | View Patch Patch

-trunk/esys2/escript/py_src/generateutil
revision 154 by jgs,
Mon Nov  7 05:51:17 2005 UTC
+trunk/escript/py_src/generateutil
revision 291 by gross,
Fri Dec  2 03:10:06 2005 UTC
 Line 4
  """
  program generates parts of the util.py and the test_util.py script
  """
- u_prog ="import esys.escript\n"
+ test_header=""
- u_prog+="import numarray\n"
+ test_header+="import unittest\n"
- u_prog+="import math\n"
+ test_header+="import numarray\n"
+ test_header+="from esys.escript import *\n"
+ test_header+="from esys.finley import Rectangle\n"
+ test_header+="class Test_util2(unittest.TestCase):\n"
+ test_header+="   RES_TOL=1.e-7\n"
+ test_header+="   def setUp(self):\n"
+ test_header+="       self.__dom =Rectangle(11,11,2)\n"
+ test_header+="       self.functionspace = FunctionOnBoundary(self.__dom)\n"
+ test_tail=""
+ test_tail+="suite = unittest.TestSuite()\n"
+ test_tail+="suite.addTest(unittest.makeSuite(Test_util2))\n"
+ test_tail+="unittest.TextTestRunner(verbosity=2).run(suite)\n"
+ case_set=["float","array","constData","taggedData","expandedData","Symbol"]
+ shape_set=[ (),(2,), (4,5), (6,2,2),(3,2,3,4)]
  t_prog=""
+ t_prog_with_tags=""
+ t_prog_failing=""
+ u_prog=""
+ def wherepos(arg):
+    if arg>0.:
+       return 1.
+    else:
+       return 0.
+ class OPERATOR:
+     def __init__(self,nickname,rng=[-1000.,1000],test_expr="",math_expr=None,
+                 numarray_expr="",symbol_expr=None,diff=None,name=""):
+             self.nickname=nickname
+             self.rng=rng
+             self.test_expr=test_expr
+             if math_expr==None:
+                self.math_expr=test_expr.replace("%a1%","arg")
+             else:
+                self.math_expr=math_expr
+             self.numarray_expr=numarray_expr
+             self.symbol_expr=symbol_expr
+             self.diff=diff
+             self.name=name
- func= [ ["atan", [-100.,100.], "math.atan(%a%)"],
-         ["log", [1.e-8,10.], "math.log(%a%)"]
-       ]
  import random
  import numarray
  import math
  finc=1.e-6
+ def getResultCaseForBin(case0,case1):
+     if case0=="float":
+         if case1=="float":
+             case="float"
+         elif case1=="array":
+             case="array"
+         elif case1=="constData":
+             case="constData"
+         elif case1=="taggedData":
+             case="taggedData"
+         elif case1=="expandedData":
+             case="expandedData"
+         elif case1=="Symbol":
+             case="Symbol"
+         else:
+                 raise ValueError,"unknown case1=%s"%case1
+     elif case0=="array":
+         if case1=="float":
+             case="array"
+         elif case1=="array":
+             case="array"
+         elif case1=="constData":
+             case="constData"
+         elif case1=="taggedData":
+             case="taggedData"
+         elif case1=="expandedData":
+             case="expandedData"
+         elif case1=="Symbol":
+             case="Symbol"
+         else:
+                 raise ValueError,"unknown case1=%s"%case1
+     elif case0=="constData":
+         if case1=="float":
+             case="constData"
+         elif case1=="array":
+             case="constData"
+         elif case1=="constData":
+             case="constData"
+         elif case1=="taggedData":
+             case="taggedData"
+         elif case1=="expandedData":
+             case="expandedData"
+         elif case1=="Symbol":
+             case="Symbol"
+         else:
+                 raise ValueError,"unknown case1=%s"%case1
+     elif case0=="taggedData":
+         if case1=="float":
+             case="taggedData"
+         elif case1=="array":
+             case="taggedData"
+         elif case1=="constData":
+             case="taggedData"
+         elif case1=="taggedData":
+             case="taggedData"
+         elif case1=="expandedData":
+             case="expandedData"
+         elif case1=="Symbol":
+             case="Symbol"
+         else:
+                 raise ValueError,"unknown case1=%s"%case1
+     elif case0=="expandedData":
+         if case1=="float":
+             case="expandedData"
+         elif case1=="array":
+             case="expandedData"
+         elif case1=="constData":
+             case="expandedData"
+         elif case1=="taggedData":
+             case="expandedData"
+         elif case1=="expandedData":
+             case="expandedData"
+         elif case1=="Symbol":
+             case="Symbol"
+         else:
+                 raise ValueError,"unknown case1=%s"%case1
+     elif case0=="Symbol":
+         if case1=="float":
+             case="Symbol"
+         elif case1=="array":
+             case="Symbol"
+         elif case1=="constData":
+             case="Symbol"
+         elif case1=="taggedData":
+             case="Symbol"
+         elif case1=="expandedData":
+             case="Symbol"
+         elif case1=="Symbol":
+             case="Symbol"
+         else:
+                 raise ValueError,"unknown case1=%s"%case1
+     else:
+             raise ValueError,"unknown case0=%s"%case0
+     return case
  def makeArray(shape,rng):
     l=rng[1]-rng[0]
     out=numarray.zeros(shape,numarray.Float64)
     if len(shape)==0:
-        out=random.random()
+        out=l*random.random()+rng[0]
     elif len(shape)==1:
         for i0 in range(shape[0]):
                     out[i0]=l*random.random()+rng[0]
-Line 45 
 def makeArray(shape,rng):
+Line 176 
 def makeArray(shape,rng):
         raise SystemError,"rank is restricted to 4"
     return out
- def makeResult2(val,case):
-    if isinstance(val,float):
-        out=val
-    elif len(val.shape)==0:
-        out=val[0]
-    elif len(val.shape)==1:
-        out=val[0]
-        for i0 in range(val.shape[0]):
-            if case == "Lsup":
-                out=max(out,abs(val[i0]))
-            elif case == "sup":
-                out=max(out,val[i0])
-            else:
-                out=min(out,val[i0])
-    elif len(val.shape)==2:
-        out=val[0,0]
-        for i0 in range(val.shape[0]):
-           for i1 in range(val.shape[1]):
-                if case == "Lsup":
-                    out=max(out,abs(val[i0,i1]))
-                elif case == "sup":
-                    out=max(out,val[i0,i1])
-                else:
-                    out=min(out,val[i0,i1])
-    elif len(val.shape)==3:
-        out=val[0,0,0]
-        for i0 in range(val.shape[0]):
-           for i1 in range(val.shape[1]):
-              for i2 in range(val.shape[2]):
-                if case == "Lsup":
-                    out=max(out,abs(val[i0,i1,i2]))
-                elif case == "sup":
-                    out=max(out,val[i0,i1,i2])
-                else:
-                    out=min(out,val[i0,i1,i2])
-    elif len(val.shape)==4:
-        out=val[0,0,0,0]
-        for i0 in range(val.shape[0]):
-           for i1 in range(val.shape[1]):
-              for i2 in range(val.shape[2]):
-                 for i3 in range(val.shape[3]):
-                    if case == "Lsup":
-                        out=max(out,abs(val[i0,i1,i2,i3]))
-                    elif case == "sup":
-                        out=max(out,val[i0,i1,i2,i3])
-                    else:
-                        out=min(out,val[i0,i1,i2,i3])
-    else:
-        raise SystemError,"rank is restricted to 4"
-    return out
- def makeResult(val,f):
+ def makeResult(val,test_expr):
     if isinstance(val,float):
-        out=eval(f[2].replace("%a%","val"))
+        out=eval(test_expr.replace("%a1%","val"))
     elif len(val.shape)==0:
-        out=eval(f[2].replace("%a%","val"))
+        out=eval(test_expr.replace("%a1%","val"))
     elif len(val.shape)==1:
         out=numarray.zeros(val.shape,numarray.Float64)
         for i0 in range(val.shape[0]):
-                    out[i0]=eval(f[2].replace("%a%","val[i0]"))
+                    out[i0]=eval(test_expr.replace("%a1%","val[i0]"))
     elif len(val.shape)==2:
         out=numarray.zeros(val.shape,numarray.Float64)
         for i0 in range(val.shape[0]):
            for i1 in range(val.shape[1]):
-                    out[i0,i1]=eval(f[2].replace("%a%","val[i0,i1]"))
+                    out[i0,i1]=eval(test_expr.replace("%a1%","val[i0,i1]"))
     elif len(val.shape)==3:
         out=numarray.zeros(val.shape,numarray.Float64)
         for i0 in range(val.shape[0]):
            for i1 in range(val.shape[1]):
               for i2 in range(val.shape[2]):
-                    out[i0,i1,i2]=eval(f[2].replace("%a%","val[i0,i1,i2]"))
+                    out[i0,i1,i2]=eval(test_expr.replace("%a1%","val[i0,i1,i2]"))
     elif len(val.shape)==4:
         out=numarray.zeros(val.shape,numarray.Float64)
         for i0 in range(val.shape[0]):
            for i1 in range(val.shape[1]):
               for i2 in range(val.shape[2]):
                  for i3 in range(val.shape[3]):
-                    out[i0,i1,i2,i3]=eval(f[2].replace("%a%","val[i0,i1,i2,i3]"))
+                    out[i0,i1,i2,i3]=eval(test_expr.replace("%a1%","val[i0,i1,i2,i3]"))
+    else:
+        raise SystemError,"rank is restricted to 4"
+    return out
+ def makeResult2(val0,val1,test_expr):
+    if isinstance(val0,float):
+       if isinstance(val1,float):
+           out=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1"))
+       elif len(val1.shape)==0:
+           out=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1"))
+       elif len(val1.shape)==1:
+           out=numarray.zeros(val1.shape,numarray.Float64)
+           for i0 in range(val1.shape[0]):
+                      out[i0]=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1[i0]"))
+       elif len(val1.shape)==2:
+           out=numarray.zeros(val1.shape,numarray.Float64)
+           for i0 in range(val1.shape[0]):
+              for i1 in range(val1.shape[1]):
+                    out[i0,i1]=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1[i0,i1]"))
+       elif len(val1.shape)==3:
+           out=numarray.zeros(val1.shape,numarray.Float64)
+           for i0 in range(val1.shape[0]):
+              for i1 in range(val1.shape[1]):
+                 for i2 in range(val1.shape[2]):
+                      out[i0,i1,i2]=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1[i0,i1,i2]"))
+       elif len(val1.shape)==4:
+           out=numarray.zeros(val1.shape,numarray.Float64)
+           for i0 in range(val1.shape[0]):
+              for i1 in range(val1.shape[1]):
+                 for i2 in range(val1.shape[2]):
+                    for i3 in range(val1.shape[3]):
+                       out[i0,i1,i2,i3]=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1[i0,i1,i2,i3]"))
+       else:
+           raise SystemError,"rank of val1 is restricted to 4"
+    elif len(val0.shape)==0:
+       if isinstance(val1,float):
+           out=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1"))
+       elif len(val1.shape)==0:
+           out=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1"))
+       elif len(val1.shape)==1:
+           out=numarray.zeros(val1.shape,numarray.Float64)
+           for i0 in range(val1.shape[0]):
+                      out[i0]=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1[i0]"))
+       elif len(val1.shape)==2:
+           out=numarray.zeros(val1.shape,numarray.Float64)
+           for i0 in range(val1.shape[0]):
+              for i1 in range(val1.shape[1]):
+                    out[i0,i1]=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1[i0,i1]"))
+       elif len(val1.shape)==3:
+           out=numarray.zeros(val1.shape,numarray.Float64)
+           for i0 in range(val1.shape[0]):
+              for i1 in range(val1.shape[1]):
+                 for i2 in range(val1.shape[2]):
+                      out[i0,i1,i2]=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1[i0,i1,i2]"))
+       elif len(val1.shape)==4:
+           out=numarray.zeros(val1.shape,numarray.Float64)
+           for i0 in range(val1.shape[0]):
+              for i1 in range(val1.shape[1]):
+                 for i2 in range(val1.shape[2]):
+                    for i3 in range(val1.shape[3]):
+                       out[i0,i1,i2,i3]=eval(test_expr.replace("%a1%","val0").replace("%a2%","val1[i0,i1,i2,i3]"))
+       else:
+           raise SystemError,"rank of val1 is restricted to 4"
+    elif len(val0.shape)==1:
+       if isinstance(val1,float):
+            out=numarray.zeros(val0.shape,numarray.Float64)
+            for i0 in range(val0.shape[0]):
+               out[i0]=eval(test_expr.replace("%a1%","val0[i0]").replace("%a2%","val1"))
+       elif len(val1.shape)==0:
+           out=numarray.zeros(val0.shape,numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               out[i0]=eval(test_expr.replace("%a1%","val0[i0]").replace("%a2%","val1"))
+       elif len(val1.shape)==1:
+           out=numarray.zeros(val0.shape,numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               out[i0]=eval(test_expr.replace("%a1%","val0[i0]").replace("%a2%","val1[i0]"))
+       elif len(val1.shape)==2:
+           out=numarray.zeros(val0.shape+val1.shape[1:],numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for j1 in range(val1.shape[1]):
+                  out[i0,j1]=eval(test_expr.replace("%a1%","val0[i0]").replace("%a2%","val1[i0,j1]"))
+       elif len(val1.shape)==3:
+           out=numarray.zeros(val0.shape+val1.shape[1:],numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for j1 in range(val1.shape[1]):
+                  for j2 in range(val1.shape[2]):
+                     out[i0,j1,j2]=eval(test_expr.replace("%a1%","val0[i0]").replace("%a2%","val1[i0,j1,j2]"))
+       elif len(val1.shape)==4:
+           out=numarray.zeros(val0.shape+val1.shape[1:],numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for j1 in range(val1.shape[1]):
+                  for j2 in range(val1.shape[2]):
+                     for j3 in range(val1.shape[3]):
+                        out[i0,j1,j2,j3]=eval(test_expr.replace("%a1%","val0[i0]").replace("%a2%","val1[i0,j1,j2,j3]"))
+       else:
+          raise SystemError,"rank of val1 is restricted to 4"
+    elif len(val0.shape)==2:
+       if isinstance(val1,float):
+            out=numarray.zeros(val0.shape,numarray.Float64)
+            for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                    out[i0,i1]=eval(test_expr.replace("%a1%","val0[i0,i1]").replace("%a2%","val1"))
+       elif len(val1.shape)==0:
+           out=numarray.zeros(val0.shape,numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                    out[i0,i1]=eval(test_expr.replace("%a1%","val0[i0,i1]").replace("%a2%","val1"))
+       elif len(val1.shape)==1:
+           out=numarray.zeros(val0.shape,numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                    out[i0,i1]=eval(test_expr.replace("%a1%","val0[i0,i1]").replace("%a2%","val1[i0]"))
+       elif len(val1.shape)==2:
+           out=numarray.zeros(val0.shape+val1.shape[2:],numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                  out[i0,i1]=eval(test_expr.replace("%a1%","val0[i0,i1]").replace("%a2%","val1[i0,i1]"))
+       elif len(val1.shape)==3:
+           out=numarray.zeros(val0.shape+val1.shape[2:],numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                  for j2 in range(val1.shape[2]):
+                     out[i0,i1,j2]=eval(test_expr.replace("%a1%","val0[i0,i1]").replace("%a2%","val1[i0,i1,j2]"))
+       elif len(val1.shape)==4:
+           out=numarray.zeros(val0.shape+val1.shape[2:],numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                  for j2 in range(val1.shape[2]):
+                     for j3 in range(val1.shape[3]):
+                        out[i0,i1,j2,j3]=eval(test_expr.replace("%a1%","val0[i0,i1]").replace("%a2%","val1[i0,i1,j2,j3]"))
+       else:
+          raise SystemError,"rank of val1 is restricted to 4"
+    elif len(val0.shape)==3:
+       if isinstance(val1,float):
+            out=numarray.zeros(val0.shape,numarray.Float64)
+            for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                   for i2 in range(val0.shape[2]):
+                       out[i0,i1,i2]=eval(test_expr.replace("%a1%","val0[i0,i1,i2]").replace("%a2%","val1"))
+       elif len(val1.shape)==0:
+           out=numarray.zeros(val0.shape,numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                   for i2 in range(val0.shape[2]):
+                       out[i0,i1,i2]=eval(test_expr.replace("%a1%","val0[i0,i1,i2]").replace("%a2%","val1"))
+       elif len(val1.shape)==1:
+           out=numarray.zeros(val0.shape,numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                   for i2 in range(val0.shape[2]):
+                       out[i0,i1,i2]=eval(test_expr.replace("%a1%","val0[i0,i1,i2]").replace("%a2%","val1[i0]"))
+       elif len(val1.shape)==2:
+           out=numarray.zeros(val0.shape+val1.shape[2:],numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                   for i2 in range(val0.shape[2]):
+                       out[i0,i1,i2]=eval(test_expr.replace("%a1%","val0[i0,i1,i2]").replace("%a2%","val1[i0,i1]"))
+       elif len(val1.shape)==3:
+           out=numarray.zeros(val0.shape,numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                  for i2 in range(val0.shape[2]):
+                       out[i0,i1,i2]=eval(test_expr.replace("%a1%","val0[i0,i1,i2]").replace("%a2%","val1[i0,i1,i2]"))
+       elif len(val1.shape)==4:
+           out=numarray.zeros(val0.shape+val1.shape[3:],numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                  for i2 in range(val0.shape[2]):
+                     for j3 in range(val1.shape[3]):
+                        out[i0,i1,i2,j3]=eval(test_expr.replace("%a1%","val0[i0,i1,i2]").replace("%a2%","val1[i0,i1,i2,j3]"))
+       else:
+          raise SystemError,"rank of val1 is rargs[1]estricted to 4"
+    elif len(val0.shape)==4:
+       if isinstance(val1,float):
+            out=numarray.zeros(val0.shape,numarray.Float64)
+            for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                   for i2 in range(val0.shape[2]):
+                      for i3 in range(val0.shape[3]):
+                          out[i0,i1,i2,i3]=eval(test_expr.replace("%a1%","val0[i0,i1,i2,i3]").replace("%a2%","val1"))
+       elif len(val1.shape)==0:
+           out=numarray.zeros(val0.shape,numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                   for i2 in range(val0.shape[2]):
+                      for i3 in range(val0.shape[3]):
+                          out[i0,i1,i2,i3]=eval(test_expr.replace("%a1%","val0[i0,i1,i2,i3]").replace("%a2%","val1"))
+       elif len(val1.shape)==1:
+           out=numarray.zeros(val0.shape,numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                   for i2 in range(val0.shape[2]):
+                      for i3 in range(val0.shape[3]):
+                          out[i0,i1,i2,i3]=eval(test_expr.replace("%a1%","val0[i0,i1,i2,i3]").replace("%a2%","val1[i0]"))
+       elif len(val1.shape)==2:
+           out=numarray.zeros(val0.shape+val1.shape[2:],numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                   for i2 in range(val0.shape[2]):
+                      for i3 in range(val0.shape[3]):
+                          out[i0,i1,i2,i3]=eval(test_expr.replace("%a1%","val0[i0,i1,i2,i3]").replace("%a2%","val1[i0,i1]"))
+       elif len(val1.shape)==3:
+           out=numarray.zeros(val0.shape,numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                  for i2 in range(val0.shape[2]):
+                      for i3 in range(val0.shape[3]):
+                          out[i0,i1,i2,i3]=eval(test_expr.replace("%a1%","val0[i0,i1,i2,i3]").replace("%a2%","val1[i0,i1,i2]"))
+       elif len(val1.shape)==4:
+           out=numarray.zeros(val0.shape,numarray.Float64)
+           for i0 in range(val0.shape[0]):
+               for i1 in range(val0.shape[1]):
+                  for i2 in range(val0.shape[2]):
+                     for i3 in range(val0.shape[3]):
+                        out[i0,i1,i2,i3]=eval(test_expr.replace("%a1%","val0[i0,i1,i2,i3]").replace("%a2%","val1[i0,i1,i2,i3]"))
+       else:
+          raise SystemError,"rank of val1 is restricted to 4"
     else:
         raise SystemError,"rank is restricted to 4"
     return out
- def mkText(case,name,a,a1=None):
+ def mkText(case,name,a,a1=None,use_tagging_for_expanded_data=False):
           t_out=""
-          if case in ["float","array" ]:
+          if case=="float":
             if isinstance(a,float):
                  t_out+="      %s=%s\n"%(name,a)
-            elif len(a)==1:
+            elif a.rank==0:
                  t_out+="      %s=%s\n"%(name,a)
             else:
                  t_out+="      %s=numarray.array(%s)\n"%(name,a.tolist())
+          elif case=="array":
+            if isinstance(a,float):
+                 t_out+="      %s=numarray.array(%s)\n"%(name,a)
+            elif a.rank==0:
+                 t_out+="      %s=numarray.array(%s)\n"%(name,a)
+            else:
+                 t_out+="      %s=numarray.array(%s)\n"%(name,a.tolist())
           elif case=="constData":
             if isinstance(a,float):
                t_out+="      %s=Data(%s,self.functionspace)\n"%(name,a)
-            elif len(a)==1:
+            elif a.rank==0:
                t_out+="      %s=Data(%s,self.functionspace)\n"%(name,a)
             else:
                t_out+="      %s=Data(numarray.array(%s),self.functionspace)\n"%(name,a.tolist())
-Line 148 
 def mkText(case,name,a,a1=None):
+Line 453 
 def mkText(case,name,a,a1=None):
             if isinstance(a,float):
                t_out+="      %s=Data(%s,self.functionspace)\n"%(name,a)
                t_out+="      %s.setTaggedValue(1,%s)\n"%(name,a1)
-            elif len(a)==1:
+            elif a.rank==0:
                t_out+="      %s=Data(%s,self.functionspace)\n"%(name,a)
                t_out+="      %s.setTaggedValue(1,%s)\n"%(name,a1)
             else:
                t_out+="      %s=Data(numarray.array(%s),self.functionspace)\n"%(name,a.tolist())
-               t_out+="      %s.setTaggedValue(1,%s)\n"%(name,a1.tolist())
+               t_out+="      %s.setTaggedValue(1,numarray.array(%s))\n"%(name,a1.tolist())
           elif case=="expandedData":
-            t_out+="      msk_%s=whereNegative(self.functionspace.getX()[0]-0.5)\n"%name
+            if use_tagging_for_expanded_data:
-            if isinstance(a,float):
+               if isinstance(a,float):
-               t_out+="      %s=msk_%s*%s+(1.-msk_%s)*%s\n"%(name,name,a,name,a1)
+                  t_out+="      %s=Data(%s,self.functionspace)\n"%(name,a)
-            elif len(a)==1:
+                  t_out+="      %s.setTaggedValue(1,%s)\n"%(name,a1)
-               t_out+="      %s=msk_%s*%s+(1.-msk_%s)*%s\n"%(name,name,a,name,a1)
+               elif a.rank==0:
-            else:
+                  t_out+="      %s=Data(%s,self.functionspace)\n"%(name,a)
-               t_out+="      %s=msk_%s*%s+(1.-msk_%s)*%s\n"%(name,name,a.tolist(),name,a1.tolist())
+                  t_out+="      %s.setTaggedValue(1,%s)\n"%(name,a1)
+               else:
+                  t_out+="      %s=Data(numarray.array(%s),self.functionspace)\n"%(name,a.tolist())
+                  t_out+="      %s.setTaggedValue(1,numarray.array(%s))\n"%(name,a1.tolist())
+               t_out+="      %s.expand()\n"%name
+            else:
+               t_out+="      msk_%s=whereNegative(self.functionspace.getX()[0]-0.5)\n"%name
+               if isinstance(a,float):
+                    t_out+="      %s=msk_%s*(%s)+(1.-msk_%s)*(%s)\n"%(name,name,a,name,a1)
+               elif a.rank==0:
+                    t_out+="      %s=msk_%s*numarray.array(%s)+(1.-msk_%s)*numarray.array(%s)\n"%(name,name,a,name,a1)
+               else:
+                    t_out+="      %s=msk_%s*numarray.array(%s)+(1.-msk_%s)*numarray.array(%s)\n"%(name,name,a.tolist(),name,a1.tolist())
           elif case=="Symbol":
             if isinstance(a,float):
                t_out+="      %s=Symbol(shape=())\n"%(name)
-            elif len(a)==1:
+            elif a.rank==0:
                t_out+="      %s=Symbol(shape=())\n"%(name)
             else:
                t_out+="      %s=Symbol(shape=%s)\n"%(name,str(a.shape))
           return t_out
- #==================
- case="inner"
- for arg0 in ["float","array","Symbol","constData","taggedData","expandedData"]:
-    for arg1 in ["float","array","Symbol","constData","taggedData","expandedData"]:
-      for sh0 in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
-         sh1=sh0
-         if (len(sh0)==0 or not arg0=="float") and (len(sh1)==0 or not arg1=="float"):
-           tname="test_%s_%s_rank%s_%s_rank%s"%(case,arg0,len(sh0),arg1,len(sh1))
-           t_prog+="   def %s(self):\n"%tname
-           a0=makeArray(sh0,[-1,1])
-           a0_1=makeArray(sh0,[-1,1])
-           a1=makeArray(sh1,[-1,1])
-           a1_1=makeArray(sh1,[-1,1])
-           t_prog+=mkText(arg0,"arg0",a0,a0_1)
-           t_prog+=mkText(arg1,"arg1",a1,a1_1)
-           t_prog+="      res=%s(arg0,arg1)\n"%case
- print t_prog
+ def mkTypeAndShapeTest(case,sh,argstr):
-/0
+     text=""
+     if case=="float":
- #==================
+          text+="      self.failUnless(isinstance(%s,float),\"wrong type of result.\")\n"%argstr
- cases=["Scalar","Vector","Tensor", "Tensor3","Tensor4"]
+     elif case=="array":
+          text+="      self.failUnless(isinstance(%s,numarray.NumArray),\"wrong type of result.\")\n"%argstr
+          text+="      self.failUnlessEqual(%s.shape,%s,\"wrong shape of result.\")\n"%(argstr,str(sh))
+     elif case in ["constData","taggedData","expandedData"]:
+          text+="      self.failUnless(isinstance(%s,Data),\"wrong type of result.\")\n"%argstr
+          text+="      self.failUnlessEqual(%s.getShape(),%s,\"wrong shape of result.\")\n"%(argstr,str(sh))
+     elif case=="Symbol":
+          text+="      self.failUnless(isinstance(%s,Symbol),\"wrong type of result.\")\n"%argstr
+          text+="      self.failUnlessEqual(%s.getShape(),%s,\"wrong shape of result.\")\n"%(argstr,str(sh))
+     return text
+ def mkCode(txt,args=[],intend=""):
+     s=txt.split("\n")
+     if len(s)>1:
+        out=""
+        for l in s:
+         out+=intend+l+"\n"
+     else:
+         out="%sreturn %s\n"%(intend,txt)
+     c=1
+     for r in args:
+       out=out.replace("%%a%s%%"%c,r)
+     return out
+ def innerTEST(arg0,arg1):
+     if isinstance(arg0,float):
+        out=numarray.array(arg0*arg1)
+     else:
+        out=(arg0*arg1).sum()
+     return out
+ def outerTEST(arg0,arg1):
+     if isinstance(arg0,float):
+        out=numarray.array(arg0*arg1)
+     elif isinstance(arg1,float):
+        out=numarray.array(arg0*arg1)
+     else:
+        out=numarray.outerproduct(arg0,arg1).resize(arg0.shape+arg1.shape)
+     return out
+ def tensorProductTest(arg0,arg1,sh_s):
+     if isinstance(arg0,float):
+        out=numarray.array(arg0*arg1)
+     elif isinstance(arg1,float):
+        out=numarray.array(arg0*arg1)
+     elif len(sh_s)==0:
+        out=numarray.outerproduct(arg0,arg1).resize(arg0.shape+arg1.shape)
+     else:
+        l=len(sh_s)
+        sh0=arg0.shape[:arg0.rank-l]
+        sh1=arg1.shape[l:]
+        ls,l0,l1=1,1,1
+        for i in sh_s: ls*=i
+        for i in sh0: l0*=i
+        for i in sh1: l1*=i
+        out1=numarray.outerproduct(arg0,arg1).resize((l0,ls,ls,l1))
+        out2=numarray.zeros((l0,l1),numarray.Float)
+        for i0 in range(l0):
+           for i1 in range(l1):
+               for i in range(ls): out2[i0,i1]+=out1[i0,i,i,i1]
+        out=out2.resize(sh0+sh1)
+     return out
+ def testMatrixMult(arg0,arg1,sh_s):
+      return numarray.matrixmultiply(arg0,arg1)
+ def testTensorMult(arg0,arg1,sh_s):
+      if len(arg0)==2:
+         return numarray.matrixmultiply(arg0,arg1)
+      else:
+         if arg1.rank==4:
+           out=numarray.zeros((arg0.shape[0],arg0.shape[1],arg1.shape[2],arg1.shape[3]),numarray.Float)
+           for i0 in range(arg0.shape[0]):
+            for i1 in range(arg0.shape[1]):
+             for i2 in range(arg0.shape[2]):
+              for i3 in range(arg0.shape[3]):
+               for j2 in range(arg1.shape[2]):
+                for j3 in range(arg1.shape[3]):
+                      out[i0,i1,j2,j3]+=arg0[i0,i1,i2,i3]*arg1[i2,i3,j2,j3]
+         elif arg1.rank==3:
+           out=numarray.zeros((arg0.shape[0],arg0.shape[1],arg1.shape[2]),numarray.Float)
+           for i0 in range(arg0.shape[0]):
+            for i1 in range(arg0.shape[1]):
+             for i2 in range(arg0.shape[2]):
+              for i3 in range(arg0.shape[3]):
+               for j2 in range(arg1.shape[2]):
+                      out[i0,i1,j2]+=arg0[i0,i1,i2,i3]*arg1[i2,i3,j2]
+         elif arg1.rank==2:
+           out=numarray.zeros((arg0.shape[0],arg0.shape[1]),numarray.Float)
+           for i0 in range(arg0.shape[0]):
+            for i1 in range(arg0.shape[1]):
+             for i2 in range(arg0.shape[2]):
+              for i3 in range(arg0.shape[3]):
+                      out[i0,i1]+=arg0[i0,i1,i2,i3]*arg1[i2,i3]
+         return out
+ #=======================================================================================================
+ # tensor multiply
+ #=======================================================================================================
+ # oper=["generalTensorProduct",tensorProductTest]
+ # oper=["matrixmult",testMatrixMult]
+ oper=["tensormult",testTensorMult]
+ for case0 in ["float","array","Symbol","constData","taggedData","expandedData"]:
+   for sh0 in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
+    for case1 in ["float","array","Symbol","constData","taggedData","expandedData"]:
+      for sh1 in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
+        for sh_s in [ (),(3,), (2,3), (2,4,3),(4,2,3,2)]:
+           if (len(sh0+sh_s)==0 or not case0=="float") and (len(sh1+sh_s)==0 or not case1=="float") \
+                and len(sh0+sh1)<5 and len(sh0+sh_s)<5 and len(sh1+sh_s)<5:
+             # if len(sh_s)==1 and len(sh0+sh_s)==2 and (len(sh_s+sh1)==1 or len(sh_s+sh1)==2)): # test for matrixmult
+             if ( len(sh_s)==1 and len(sh0+sh_s)==2 and ( len(sh1+sh_s)==2 or len(sh1+sh_s)==1 )) or (len(sh_s)==2 and len(sh0+sh_s)==4 and (len(sh1+sh_s)==2 or len(sh1+sh_s)==3 or len(sh1+sh_s)==4)):  # test for tensormult
+               case=getResultCaseForBin(case0,case1)
+               use_tagging_for_expanded_data= case0=="taggedData" or case1=="taggedData"
+               text="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+               # tname="test_generalTensorProduct_%s_rank%s_%s_rank%s_offset%s"%(case0,len(sh0+sh_s),case1,len(sh_s+sh1),len(sh_s))
+               #tname="test_matrixmult_%s_rank%s_%s_rank%s"%(case0,len(sh0+sh_s),case1,len(sh_s+sh1))
+               tname="test_tensormult_%s_rank%s_%s_rank%s"%(case0,len(sh0+sh_s),case1,len(sh_s+sh1))
+               # if tname=="test_generalTensorProduct_array_rank1_array_rank2_offset1":
+               # print tnametest_generalTensorProduct_Symbol_rank1_Symbol_rank3_offset1
+               text+="   def %s(self):\n"%tname
+               a_0=makeArray(sh0+sh_s,[-1.,1])
+               if case0 in ["taggedData", "expandedData"]:
+                   a1_0=makeArray(sh0+sh_s,[-1.,1])
+               else:
+                   a1_0=a_0
- for case in range(len(cases)):
+               a_1=makeArray(sh_s+sh1,[-1.,1])
-   for d in [ None , "d", 1, 2 , 3]:
+               if case1 in ["taggedData", "expandedData"]:
-          if not d==None or cases[case]=="Scalar":
+                   a1_1=makeArray(sh_s+sh1,[-1.,1])
-             t_prog+="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+               else:
-             tname="test_Symbol_%s_d%s"%(cases[case],d)
+                   a1_1=a_1
-             t_prog+="   def %s(self):\n"%tname
+               r=oper[1](a_0,a_1,sh_s)
-             if d=="d":
+               r1=oper[1](a1_0,a1_1,sh_s)
-                t_prog+="      s=%sSymbol(dim=self.functionspace)\n"%(cases[case])
+               text+=mkText(case0,"arg0",a_0,a1_0,use_tagging_for_expanded_data)
-                t_prog+="      d=self.functionspace.getDim()\n"
+               text+=mkText(case1,"arg1",a_1,a1_1,use_tagging_for_expanded_data)
-                sh="("
+               #text+="      res=matrixmult(arg0,arg1)\n"
-                for i in range(case):
+               text+="      res=tensormult(arg0,arg1)\n"
-                  if i==0:
+               #text+="      res=generalTensorProduct(arg0,arg1,offset=%s)\n"%(len(sh_s))
-                   sh+=d
+               if case=="Symbol":
-                  else:
+                  c0_res,c1_res=case0,case1
-                   sh+=","+d
+                  subs="{"
-                sh+=")"
+                  if case0=="Symbol":
-             else:
+                     text+=mkText("array","s0",a_0,a1_0)
-                t_prog+="      s=%sSymbol(dim=%s)\n"%(cases[case],d)
+                     subs+="arg0:s0"
-                sh=()
+                     c0_res="array"
-                for i in range(case): sh=sh+(d,)
+                  if case1=="Symbol":
-             t_prog+="      self.failUnlessEqual(s.getRank(),%s,\"wrong rank.\")\n"%case
+                     text+=mkText("array","s1",a_1,a1_1)
-             t_prog+="      self.failUnlessEqual(s.getShape(),%s,\"wrong shape.\")\n"%str(sh)
+                     if not subs.endswith("{"): subs+=","
-             t_prog+="      self.failUnlessEqual(s.getDim(),%s,\"wrong spatial dimension.\")\n"%d
+                     subs+="arg1:s1"
-             t_prog+="      self.failUnlessEqual(s.getArgument(),[],\"wrong arguments.\")\n"
+                     c1_res="array"
+                  subs+="}"
- print t_prog
+                  text+="      sub=res.substitute(%s)\n"%subs
+                  res="sub"
+                  text+=mkText(getResultCaseForBin(c0_res,c1_res),"ref",r,r1)
+               else:
+                  res="res"
+                  text+=mkText(case,"ref",r,r1)
+               text+=mkTypeAndShapeTest(case,sh0+sh1,"res")
+               text+="      self.failUnless(Lsup(%s-ref)<=self.RES_TOL*Lsup(ref),\"wrong result\")\n"%res
+               if case0 == "taggedData" or case1 == "taggedData":
+                   t_prog_with_tags+=text
+               else:
+                   t_prog+=text
+ print test_header
+ # print t_prog
+ print t_prog_with_tags
+ print test_tail
 /0
- for sh in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
+ #=======================================================================================================
-   for d in [ None , "domain", 1, 2 , 3]:
+ # outer/inner
-     for args in [ [], ["s2"], [1,-1.] ]:
+ #=======================================================================================================
-          t_prog+="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+ oper=["inner",innerTEST]
-          tname="def test_Symbol_rank%s_d%s_nargs%s"%(len(sh),d,len(args))
+ # oper=["outer",outerTEST]
-          t_prog+="   %s(self):\n"%tname
+ for case0 in ["float","array","Symbol","constData","taggedData","expandedData"]:
-          t_prog+="      s2=ScalarSymbol()\n"
+   for sh1 in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
-          if args==["s2"]:
+    for case1 in ["float","array","Symbol","constData","taggedData","expandedData"]:
-             a="[s2]"
+      for sh0 in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
-          else:
+         if (len(sh0)==0 or not case0=="float") and (len(sh1)==0 or not case1=="float") \
-             a=str(args)
+            and len(sh0+sh1)<5:
-          if d=="domain":
+               use_tagging_for_expanded_data= case0=="taggedData" or case1=="taggedData"
-             t_prog+="      s=Symbol(shape=%s,dim=self.functionspace.getDim(),args=%s)\n"%(str(sh),a)
-             d2="self.functionspace.getDim()"
+               text="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
-          else:
+               tname="test_%s_%s_rank%s_%s_rank%s"%(oper[0],case0,len(sh0),case1,len(sh1))
-             t_prog+="      s=Symbol(shape=%s,dim=%s,args=%s)\n"%(sh,d,a)
+               text+="   def %s(self):\n"%tname
-             d2=str(d)
+               a_0=makeArray(sh0,[-1.,1])
+               if case0 in ["taggedData", "expandedData"]:
-          t_prog+="      self.failUnlessEqual(s.getRank(),%s,\"wrong rank.\")\n"%len(sh)
+                   a1_0=makeArray(sh0,[-1.,1])
-          t_prog+="      self.failUnlessEqual(s.getShape(),%s,\"wrong shape.\")\n"%str(sh)
+               else:
-          t_prog+="      self.failUnlessEqual(s.getDim(),%s,\"wrong spatial dimension.\")\n"%d2
+                   a1_0=a_0
-          t_prog+="      self.failUnlessEqual(s.getArgument(),%s,\"wrong arguments.\")\n\n"%a
-          t_prog+="      ss=s.substitute({s:numarray.zeros(%s)})\n"%str(sh)
-          t_prog+="      self.failUnless(isinstance(ss,numarray.NumArray),\"value after substitution is not numarray.\")\n"
-          t_prog+="      self.failUnlessEqual(ss.shape,%s,\"value after substitution has not expected shape\")\n"%str(sh)
-          t_prog+="      try:\n        s.substitute({s:numarray.zeros((5,))})\n        fail(\"illegal substition was successful\")\n"
-          t_prog+="      except TypeError:\n        pass\n\n"
-          ###
-          for sh2 in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
-              if len(sh+sh2)<5:
-                  t_prog+="      dsdarg=s.diff(Symbol(shape=%s))\n"%str(sh2)
-                  if  len(sh+sh2)==0:
-                     t_prog+="      self.failUnless(isinstance(dsdarg,float),\"ds/ds() has wrong type.\")\n"
-                  else:
-                     t_prog+="      self.failUnless(isinstance(dsdarg,numarray.NumArray),\"ds/ds%s has wrong type.\")\n"%str(sh2)
-                     t_prog+="      self.failUnlessEqual(dsdarg.shape,%s,\"ds/ds%s has wrong shape.\")\n"%(str(sh+sh2),str(sh2))
-                  t_prog+="      self.failIf(Lsup(dsdarg)>0.,\"ds/ds%s has wrong value.\")\n"%str(sh2)
-          if len(sh)<3:
-             t_prog+="\n      dsds=s.diff(s)\n"
-             if  len(sh)==0:
-                t_prog+="      self.failUnless(isinstance(dsds,float),\"ds/ds has wrong type.\")\n"
-                t_prog+="      self.failUnlessEqual(dsds,1.,\"ds/ds has wrong value.\")\n"
-             else:
-                t_prog+="      self.failUnless(isinstance(dsds,numarray.NumArray),\"ds/ds has wrong type.\")\n"
-                t_prog+="      self.failUnlessEqual(dsds.shape,%s,\"ds/ds has wrong shape.\")\n"%str(sh+sh)
-                if len(sh)==1:
-                    for i0 in range(sh[0]):
-                          for i2 in range(sh[0]):
-                                if i0==i2:
-                                     v=1.
-                                else:
-                                     v=0.
-                                t_prog+="      self.failUnlessEqual(dsds[%s,%s],%s,\"ds/ds has wrong value at (%s,%s).\")\n"%(i0,i2,v,i0,i2)
-                else:
-                    for i0 in range(sh[0]):
-                       for i1 in range(sh[1]):
-                          for i2 in range(sh[0]):
-                             for i3 in range(sh[1]):
-                                if i0==i2 and i1==i3:
-                                     v=1.
-                                else:
-                                     v=0.
-                                t_prog+="      self.failUnlessEqual(dsds[%s,%s,%s,%s],%s,\"ds/ds has wrong value at (%s,%s,%s,%s).\")\n"%(i0,i1,i2,i3,v,i0,i1,i2,i3)
-          ###
-          t_prog+="\n"
-          for i in range(len(args)):
-              t_prog+="      self.failUnlessEqual(s.getArgument(%s),%s,\"wrong argument %s.\")\n"%(i,str(args[i]),i)
-          t_prog+="      sa=s.getSubstitutedArguments({s2:-10})\n"
-          t_prog+="      self.failUnlessEqual(len(sa),%s,\"wrong number of substituted arguments\")\n"%len(args)
-          if args==["s2"]:
-                 t_prog+="      self.failUnlessEqual(sa[0],-10,\"wrongly substituted argument 0.\")\n"
-          else:
-              for i in range(len(args)):
-                 t_prog+="      self.failUnlessEqual(sa[%s],%s,\"wrongly substituted argument %s.\")\n"%(i,str(args[i]),i)
-          t_prog+="\n"
-          for arg in ["10.", "10", "SymbolMatch", "SymbolMisMatch", \
-                                        "DataMatch","DataMisMatch", "NumArrayMatch", "NumArrayMisMatch"]:
-              if arg in ["10.", "10"]:
-                 a=str(arg)
-                 if len(sh)==0:
-                    t_prog+="      self.failUnless(s.isAppropriateValue(%s),\"%s is appropriate substitute\")\n"%(a,arg)
-                 else:
-                    t_prog+="      self.failIf(s.isAppropriateValue(%s),\" %s is not appropriate substitute\")\n"%(a,arg)
-              elif arg in ["SymbolMatch", "SymbolMisMatch"]:
-                   if arg=="SymbolMatch":
-                    t_prog+="      self.failUnless(s.isAppropriateValue(Symbol(shape=%s,dim=%s)),\"Symbol is appropriate substitute\")\n"%(str(sh),d)
-                   else:
-                    if isinstance(d,int):
-                       t_prog+="      self.failIf(s.isAppropriateValue(Symbol(shape=%s,dim=%s)),\"Symbol is not appropriate substitute (dim)\")\n"%(str(sh),d+1)
-                    else:
-                       t_prog+="      self.failIf(s.isAppropriateValue(Symbol(shape=%s)),\"Symbol is not appropriate substitute (shape)\")\n"%((5,))
-              elif arg in ["DataMatch","DataMisMatch"]:
+               a_1=makeArray(sh1,[-1.,1])
-                   if arg=="DataMatch" and d=="domain":
+               if case1 in ["taggedData", "expandedData"]:
-                    t_prog+="      self.failUnless(s.isAppropriateValue(escript.Data(0.,%s,self.functionspace)),\"Data is appropriate substitute\")\n"%str(sh)
+                   a1_1=makeArray(sh1,[-1.,1])
-                   elif arg=="DataMisMatch":
+               else:
-                       t_prog+="      self.failIf(s.isAppropriateValue(escript.Data(0.,%s,self.functionspace)),\"Data is not appropriate substitute (shape)\")\n"%(str((5,)))
+                   a1_1=a_1
-              else:
+               r=oper[1](a_0,a_1)
-                   if arg=="NumArrayMatch":
+               r1=oper[1](a1_0,a1_1)
-                    t_prog+="      self.failUnless(s.isAppropriateValue(numarray.zeros(%s)),\"NumArray is appropriate substitute\")\n"%str(sh)
+               text+=mkText(case0,"arg0",a_0,a1_0,use_tagging_for_expanded_data)
-                   else:
+               text+=mkText(case1,"arg1",a_1,a1_1,use_tagging_for_expanded_data)
-                       t_prog+="      self.failIf(s.isAppropriateValue(numarray.zeros(%s)),\"NumArray is not appropriate substitute (shape)\")\n"%(str((5,)))
+               text+="      res=%s(arg0,arg1)\n"%oper[0]
- print t_prog
+               case=getResultCaseForBin(case0,case1)
+               if case=="Symbol":
+                  c0_res,c1_res=case0,case1
+                  subs="{"
+                  if case0=="Symbol":
+                     text+=mkText("array","s0",a_0,a1_0)
+                     subs+="arg0:s0"
+                     c0_res="array"
+                  if case1=="Symbol":
+                     text+=mkText("array","s1",a_1,a1_1)
+                     if not subs.endswith("{"): subs+=","
+                     subs+="arg1:s1"
+                     c1_res="array"
+                  subs+="}"
+                  text+="      sub=res.substitute(%s)\n"%subs
+                  res="sub"
+                  text+=mkText(getResultCaseForBin(c0_res,c1_res),"ref",r,r1)
+               else:
+                  res="res"
+                  text+=mkText(case,"ref",r,r1)
+               text+=mkTypeAndShapeTest(case,sh0+sh1,"res")
+               text+="      self.failUnless(Lsup(%s-ref)<=self.RES_TOL*Lsup(ref),\"wrong result\")\n"%res
+               if case0 == "taggedData" or case1 == "taggedData":
+                   t_prog_with_tags+=text
+               else:
+                   t_prog+=text
+ print test_header
+ # print t_prog
+ print t_prog_with_tags
+ print test_tail
 /0
+ #=======================================================================================================
+ # basic binary operation overloading (tests only!)
+ #=======================================================================================================
+ oper_range=[-5.,5.]
+ for oper in [["add" ,"+",[-5.,5.]],
+              ["sub" ,"-",[-5.,5.]],
+              ["mult","*",[-5.,5.]],
+              ["div" ,"/",[-5.,5.]],
+              ["pow" ,"**",[0.01,5.]]]:
+    for case0 in case_set:
+      for sh0 in shape_set:
+        for case1 in case_set:
+          for sh1 in shape_set:
+            if not case0=="array" and \
+                (not case0=="float" or len(sh0)==0) and (not case1=="float" or len(sh1)==0) and \
+                (sh0==() or sh1==() or sh1==sh0) and \
+                not (case0 in ["float","array"] and  case1 in ["float","array"]):
+               use_tagging_for_expanded_data= case0=="taggedData" or case1=="taggedData"
+               text="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+               tname="test_%s_overloaded_%s_rank%s_%s_rank%s"%(oper[0],case0,len(sh0),case1,len(sh1))
+               text+="   def %s(self):\n"%tname
+               a_0=makeArray(sh0,oper[2])
+               if case0 in ["taggedData", "expandedData"]:
+                   a1_0=makeArray(sh0,oper[2])
+               else:
+                   a1_0=a_0
+               a_1=makeArray(sh1,oper[2])
- for case in ["Lsup", "sup", "inf"]:
+               if case1 in ["taggedData", "expandedData"]:
-    for args in ["float","array","constData","taggedData","expandedData"]:
+                   a1_1=makeArray(sh1,oper[2])
-      for sh in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
-        if not args=="float" or len(sh)==0:
-          t_prog+="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
-          tname="def test_%s_%s_rank%s"%(case,args,len(sh))
-          t_prog+="   %s(self):\n"%tname
-          if args in ["float","array" ]:
-            a=makeArray(sh,[-1,1])
-            r=makeResult2(a,case)
-            if len(sh)==0:
-               t_prog+="      arg=%s\n"%a
-            else:
-               t_prog+="      arg=numarray.array(%s)\n"%a.tolist()
-            t_prog+="      ref=%s\n"%r
-            t_prog+="      res=%s(arg)\n"%case
-            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
-            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
-          elif args== "constData":
-            a=makeArray(sh,[-1,1])
-            r=makeResult2(a,case)
-            if len(sh)==0:
-               t_prog+="      arg=Data(%s,self.functionspace)\n"%(a)
-            else:
-               t_prog+="      arg=Data(numarray.array(%s),self.functionspace)\n"%(a.tolist())
-            t_prog+="      ref=%s\n"%r
-            t_prog+="      res=%s(arg)\n"%case
-            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
-            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
-          elif args in [ "taggedData","expandedData"]:
-            a=makeArray(sh,[-1,1])
-            r=makeResult2(a,case)
-            a1=makeArray(sh,[-1,1])
-            r1=makeResult2(a1,case)
-            if case in ["Lsup","sup"]:
-                r=max(r,r1)
-            else:
-                r=min(r,r1)
-            if len(sh)==0:
-               if args=="expandedData":
-                  t_prog+="      arg=Data(%s,self.functionspace,True)\n"%(a)
                else:
-                  t_prog+="      arg=Data(%s,self.functionspace)\n"%(a)
+                   a1_1=a_1
-               t_prog+="      arg.setTaggedValue(1,%s)\n"%a
+               r1=makeResult2(a1_0,a1_1,"%a1%"+oper[1]+"%a2%")
+               r=makeResult2(a_0,a_1,"%a1%"+oper[1]+"%a2%")
+               text+=mkText(case0,"arg0",a_0,a1_0,use_tagging_for_expanded_data)
+               text+=mkText(case1,"arg1",a_1,a1_1,use_tagging_for_expanded_data)
+               text+="      res=arg0%sarg1\n"%oper[1]
+               case=getResultCaseForBin(case0,case1)
+               if case=="Symbol":
+                  c0_res,c1_res=case0,case1
+                  subs="{"
+                  if case0=="Symbol":
+                     text+=mkText("array","s0",a_0,a1_0)
+                     subs+="arg0:s0"
+                     c0_res="array"
+                  if case1=="Symbol":
+                     text+=mkText("array","s1",a_1,a1_1)
+                     if not subs.endswith("{"): subs+=","
+                     subs+="arg1:s1"
+                     c1_res="array"
+                  subs+="}"
+                  text+="      sub=res.substitute(%s)\n"%subs
+                  res="sub"
+                  text+=mkText(getResultCaseForBin(c0_res,c1_res),"ref",r,r1)
+               else:
+                  res="res"
+                  text+=mkText(case,"ref",r,r1)
+               if isinstance(r,float):
+                  text+=mkTypeAndShapeTest(case,(),"res")
+               else:
+                  text+=mkTypeAndShapeTest(case,r.shape,"res")
+               text+="      self.failUnless(Lsup(%s-ref)<=self.RES_TOL*Lsup(ref),\"wrong result\")\n"%res
+               if case0 in [ "constData","taggedData","expandedData"] and case1 == "Symbol":
+                  t_prog_failing+=text
+               else:
+                  if case0 == "taggedData" or case1 == "taggedData":
+                     t_prog_with_tags+=text
+                  else:
+                     t_prog+=text
+ print test_header
+ # print t_prog
+ # print t_prog_with_tags
+ print t_prog_failing
+ print test_tail
+/0
+ #=======================================================================================================
+ # basic binary operations (tests only!)
+ #=======================================================================================================
+ oper_range=[-5.,5.]
+ for oper in [["add" ,"+",[-5.,5.]],
+              ["mult","*",[-5.,5.]],
+              ["quotient" ,"/",[-5.,5.]],
+              ["power" ,"**",[0.01,5.]]]:
+    for case0 in case_set:
+      for case1 in case_set:
+        for sh in shape_set:
+          for sh_p in shape_set:
+            if len(sh_p)>0:
+               resource=[-1,1]
             else:
-               if args=="expandedData":
+               resource=[1]
-                  t_prog+="      arg=Data(numarray.array(%s),self.functionspace,True)\n"%(a.tolist())
+            for sh_d in resource:
+             if sh_d>0:
+                sh0=sh
+                sh1=sh+sh_p
+             else:
+                sh1=sh
+                sh0=sh+sh_p
+             if (not case0=="float" or len(sh0)==0) and (not case1=="float" or len(sh1)==0) and \
+                len(sh0)<5 and len(sh1)<5:
+               use_tagging_for_expanded_data= case0=="taggedData" or case1=="taggedData"
+               text="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+               tname="test_%s_%s_rank%s_%s_rank%s"%(oper[0],case0,len(sh0),case1,len(sh1))
+               text+="   def %s(self):\n"%tname
+               a_0=makeArray(sh0,oper[2])
+               if case0 in ["taggedData", "expandedData"]:
+                   a1_0=makeArray(sh0,oper[2])
                else:
-                  t_prog+="      arg=Data(numarray.array(%s),self.functionspace)\n"%(a.tolist())
+                   a1_0=a_0
-               t_prog+="      arg.setTaggedValue(1,%s)\n"%a1.tolist()
-            t_prog+="      res=%s(arg)\n"%case
-            t_prog+="      ref=%s\n"%r
-            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
-            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
- print t_prog
+               a_1=makeArray(sh1,oper[2])
+               if case1 in ["taggedData", "expandedData"]:
+                   a1_1=makeArray(sh1,oper[2])
+               else:
+                   a1_1=a_1
+               r1=makeResult2(a1_0,a1_1,"%a1%"+oper[1]+"%a2%")
+               r=makeResult2(a_0,a_1,"%a1%"+oper[1]+"%a2%")
+               text+=mkText(case0,"arg0",a_0,a1_0,use_tagging_for_expanded_data)
+               text+=mkText(case1,"arg1",a_1,a1_1,use_tagging_for_expanded_data)
+               text+="      res=%s(arg0,arg1)\n"%oper[0]
+               case=getResultCaseForBin(case0,case1)
+               if case=="Symbol":
+                  c0_res,c1_res=case0,case1
+                  subs="{"
+                  if case0=="Symbol":
+                     text+=mkText("array","s0",a_0,a1_0)
+                     subs+="arg0:s0"
+                     c0_res="array"
+                  if case1=="Symbol":
+                     text+=mkText("array","s1",a_1,a1_1)
+                     if not subs.endswith("{"): subs+=","
+                     subs+="arg1:s1"
+                     c1_res="array"
+                  subs+="}"
+                  text+="      sub=res.substitute(%s)\n"%subs
+                  res="sub"
+                  text+=mkText(getResultCaseForBin(c0_res,c1_res),"ref",r,r1)
+               else:
+                  res="res"
+                  text+=mkText(case,"ref",r,r1)
+               if isinstance(r,float):
+                  text+=mkTypeAndShapeTest(case,(),"res")
+               else:
+                  text+=mkTypeAndShapeTest(case,r.shape,"res")
+               text+="      self.failUnless(Lsup(%s-ref)<=self.RES_TOL*Lsup(ref),\"wrong result\")\n"%res
+               if case0 == "taggedData" or case1 == "taggedData":
+                   t_prog_with_tags+=text
+               else:
+                   t_prog+=text
+ print test_header
+ # print t_prog
+ print t_prog_with_tags
+ print test_tail
 /0
+ # print t_prog_with_tagsoper_range=[-5.,5.]
- for case in ["Lsup", "sup", "inf"]:
+ for oper in [["add" ,"+",[-5.,5.]],
-    for args in ["float","array","constData","taggedData","expandedData"]:
+              ["sub" ,"-",[-5.,5.]],
-      for sh in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
+              ["mult","*",[-5.,5.]],
-        if not args=="float" or len(sh)==0:
+              ["div" ,"/",[-5.,5.]],
-          t_prog+="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+              ["pow" ,"**",[0.01,5.]]]:
-          tname="def test_%s_%s_rank%s"%(case,args,len(sh))
+    for case0 in case_set:
-          t_prog+="   %s(self):\n"%tname
+      for sh0 in shape_set:
-          if args in ["float","array" ]:
+        for case1 in case_set:
-            a=makeArray(sh,[-1,1])
+          for sh1 in shape_set:
-            r=makeResult2(a,case)
+            if (not case0=="float" or len(sh0)==0) and (not case1=="float" or len(sh1)==0) and \
-            if len(sh)==0:
+                (sh0==() or sh1==() or sh1==sh0) and \
-               t_prog+="      arg=%s\n"%a
+                not (case0 in ["float","array"] and  case1 in ["float","array"]):
-            else:
+               text="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
-               t_prog+="      arg=numarray.array(%s)\n"%a.tolist()
+               tname="test_%s_%s_rank%s_%s_rank%s"%(oper[0],case0,len(sh0),case1,len(sh1))
-            t_prog+="      ref=%s\n"%r
+               text+="   def %s(self):\n"%tname
-            t_prog+="      res=%s(arg)\n"%case
+               a_0=makeArray(sh0,oper[2])
-            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
+               if case0 in ["taggedData", "expandedData"]:
-            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
+                   a1_0=makeArray(sh0,oper[2])
-          elif args== "constData":
-            a=makeArray(sh,[-1,1])
-            r=makeResult2(a,case)
-            if len(sh)==0:
-               t_prog+="      arg=Data(%s,self.functionspace)\n"%(a)
-            else:
-               t_prog+="      arg=Data(numarray.array(%s),self.functionspace)\n"%(a.tolist())
-            t_prog+="      ref=%s\n"%r
-            t_prog+="      res=%s(arg)\n"%case
-            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
-            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
-          elif args in [ "taggedData","expandedData"]:
-            a=makeArray(sh,[-1,1])
-            r=makeResult2(a,case)
-            a1=makeArray(sh,[-1,1])
-            r1=makeResult2(a1,case)
-            if case in ["Lsup","sup"]:
-                r=max(r,r1)
-            else:
-                r=min(r,r1)
-            if len(sh)==0:
-               if args=="expandedData":
-                  t_prog+="      arg=Data(%s,self.functionspace,True)\n"%(a)
                else:
-                  t_prog+="      arg=Data(%s,self.functionspace)\n"%(a)
+                   a1_0=a_0
-               t_prog+="      arg.setTaggedValue(1,%s)\n"%a
-            else:
+               a_1=makeArray(sh1,oper[2])
-               if args=="expandedData":
+               if case1 in ["taggedData", "expandedData"]:
-                  t_prog+="      arg=Data(numarray.array(%s),self.functionspace,True)\n"%(a.tolist())
+                   a1_1=makeArray(sh1,oper[2])
                else:
-                  t_prog+="      arg=Data(numarray.array(%s),self.functionspace)\n"%(a.tolist())
+                   a1_1=a_1
-               t_prog+="      arg.setTaggedValue(1,%s)\n"%a1.tolist()
+               r1=makeResult2(a1_0,a1_1,"%a1%"+oper[1]+"%a2%")
-            t_prog+="      res=%s(arg)\n"%case
+               r=makeResult2(a_0,a_1,"%a1%"+oper[1]+"%a2%")
-            t_prog+="      ref=%s\n"%r
+               text+=mkText(case0,"arg0",a_0,a1_0)
-            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
+               text+=mkText(case1,"arg1",a_1,a1_1)
-            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
+               text+="      res=arg0%sarg1\n"%oper[1]
+               case=getResultCaseForBin(case0,case1)
+               if case=="Symbol":
+                  c0_res,c1_res=case0,case1
+                  subs="{"
+                  if case0=="Symbol":
+                     text+=mkText("array","s0",a_0,a1_0)
+                     subs+="arg0:s0"
+                     c0_res="array"
+                  if case1=="Symbol":
+                     text+=mkText("array","s1",a_1,a1_1)
+                     if not subs.endswith("{"): subs+=","
+                     subs+="arg1:s1"
+                     c1_res="array"
+                  subs+="}"
+                  text+="      sub=res.substitute(%s)\n"%subs
+                  res="sub"
+                  text+=mkText(getResultCaseForBin(c0_res,c1_res),"ref",r,r1)
+               else:
+                  res="res"
+                  text+=mkText(case,"ref",r,r1)
+               if isinstance(r,float):
+                  text+=mkTypeAndShapeTest(case,(),"res")
+               else:
+                  text+=mkTypeAndShapeTest(case,r.shape,"res")
+               text+="      self.failUnless(Lsup(%s-ref)<=self.RES_TOL*Lsup(ref),\"wrong result\")\n"%res
+               if case0 in [ "constData","taggedData","expandedData"] and case1 == "Symbol":
+                  t_prog_failing+=text
+               else:
+                  if case0 == "taggedData" or case1 == "taggedData":
+                     t_prog_with_tags+=text
+                  else:
+                     t_prog+=text
+ # print u_prog
+ # 1/0
+ print test_header
  print t_prog
+ # print t_prog_with_tags
-/0
+ # print t_prog_failing
+ print test_tail
+ # print t_prog_failing
+ print test_tail
+ #=======================================================================================================
+ # unary operations:
+ #=======================================================================================================
+ func= [
+ OPERATOR(nickname="log10",\
+          rng=[1.e-3,100.],\
+          test_expr="math.log10(%a1%)",\
+          math_expr="math.log10(%a1%)",\
+          numarray_expr="numarray.log10(%a1%)",\
+          symbol_expr="log(%a1%)/log(10.)",\
+          name="base-10 logarithm"),
+ OPERATOR(nickname="wherePositive",\
+          rng=[-100.,100.],\
+          test_expr="wherepos(%a1%)",\
+          math_expr="if arg>0:\n  return 1.\nelse:\n  return 0.",
+          numarray_expr="numarray.greater(arg,numarray.zeros(arg.shape,numarray.Float))",\
+          name="mask of positive values"),
+ OPERATOR(nickname="whereNegative",\
+          rng=[-100.,100.],\
+          test_expr="wherepos(-%a1%)",\
+          math_expr="if arg<0:\n  return 1.\nelse:\n  return 0.",
+          numarray_expr="numarray.less(arg,numarray.zeros(arg.shape,numarray.Float))",\
+          name="mask of positive values"),
+ OPERATOR(nickname="whereNonNegative",\
+          rng=[-100.,100.],\
+          test_expr="1-wherepos(-%a1%)", \
+          math_expr="if arg<0:\n  return 0.\nelse:\n  return 1.",
+          numarray_expr="numarray.greater_equal(arg,numarray.zeros(arg.shape,numarray.Float))",\
+          symbol_expr="1-wherePositive(%a1%)",\
+          name="mask of non-negative values"),
+ OPERATOR(nickname="whereNonPositive",\
+          rng=[-100.,100.],\
+          test_expr="1-wherepos(%a1%)",\
+          math_expr="if arg>0:\n  return 0.\nelse:\n  return 1.",
+          numarray_expr="numarray.less_equal(arg,numarray.zeros(arg.shape,numarray.Float))",\
+          symbol_expr="1-whereNegative(%a1%)",\
+          name="mask of non-positive values"),
+ OPERATOR(nickname="whereZero",\
+          rng=[-100.,100.],\
+          test_expr="1-wherepos(%a1%)-wherepos(-%a1%)",\
+          math_expr="if abs(%a1%)<=tol:\n  return 1.\nelse:\n  return 0.",
+          numarray_expr="numarray.less_equal(abs(%a1%)-tol,numarray.zeros(arg.shape,numarray.Float))",\
+          name="mask of zero entries"),
+ OPERATOR(nickname="whereNonZero",\
+          rng=[-100.,100.],\
+          test_expr="wherepos(%a1%)+wherepos(-%a1%)",\
+          math_expr="if abs(%a1%)>tol:\n  return 1.\nelse:\n  return 0.",\
+          numarray_expr="numarray.greater(abs(%a1%)-tol,numarray.zeros(arg.shape,numarray.Float))",\
+          symbol_expr="1-whereZero(arg,tol)",\
+          name="mask of values different from zero"),
+ OPERATOR(nickname="sin",\
+          rng=[-100.,100.],\
+          test_expr="math.sin(%a1%)",
+          numarray_expr="numarray.sin(%a1%)",\
+          diff="cos(%a1%)",\
+          name="sine"),
+ OPERATOR(nickname="cos",\
+          rng=[-100.,100.],\
+          test_expr="math.cos(%a1%)",
+          numarray_expr="numarray.cos(%a1%)",\
+          diff="-sin(%a1%)",
+          name="cosine"),
+ OPERATOR(nickname="tan",\
+          rng=[-100.,100.],\
+          test_expr="math.tan(%a1%)",
+          numarray_expr="numarray.tan(%a1%)",\
+          diff="1./cos(%a1%)**2",
+          name="tangent"),
+ OPERATOR(nickname="asin",\
+          rng=[-0.99,0.99],\
+          test_expr="math.asin(%a1%)",
+          numarray_expr="numarray.arcsin(%a1%)",
+          diff="1./sqrt(1.-%a1%**2)",
+          name="inverse sine"),
+ OPERATOR(nickname="acos",\
+          rng=[-0.99,0.99],\
+          test_expr="math.acos(%a1%)",
+          numarray_expr="numarray.arccos(%a1%)",
+          diff="-1./sqrt(1.-%a1%**2)",
+          name="inverse cosine"),
+ OPERATOR(nickname="atan",\
+          rng=[-100.,100.],\
+          test_expr="math.atan(%a1%)",
+          numarray_expr="numarray.arctan(%a1%)",
+          diff="1./(1+%a1%**2)",
+          name="inverse tangent"),
+ OPERATOR(nickname="sinh",\
+          rng=[-5,5],\
+          test_expr="math.sinh(%a1%)",
+          numarray_expr="numarray.sinh(%a1%)",
+          diff="cosh(%a1%)",
+          name="hyperbolic sine"),
+ OPERATOR(nickname="cosh",\
+          rng=[-5.,5.],
+          test_expr="math.cosh(%a1%)",
+          numarray_expr="numarray.cosh(%a1%)",
+          diff="sinh(%a1%)",
+          name="hyperbolic cosine"),
+ OPERATOR(nickname="tanh",\
+          rng=[-5.,5.],
+          test_expr="math.tanh(%a1%)",
+          numarray_expr="numarray.tanh(%a1%)",
+          diff="1./cosh(%a1%)**2",
+          name="hyperbolic tangent"),
+ OPERATOR(nickname="asinh",\
+          rng=[-100.,100.], \
+          test_expr="numarray.arcsinh(%a1%)",
+          math_expr="numarray.arcsinh(%a1%)",
+          numarray_expr="numarray.arcsinh(%a1%)",
+          diff="1./sqrt(%a1%**2+1)",
+          name="inverse hyperbolic sine"),
+ OPERATOR(nickname="acosh",\
+          rng=[1.001,100.],\
+          test_expr="numarray.arccosh(%a1%)",
+          math_expr="numarray.arccosh(%a1%)",
+          numarray_expr="numarray.arccosh(%a1%)",
+          diff="1./sqrt(%a1%**2-1)",
+          name="inverse hyperolic cosine"),
+ OPERATOR(nickname="atanh",\
+          rng=[-0.99,0.99], \
+          test_expr="numarray.arctanh(%a1%)",
+          math_expr="numarray.arctanh(%a1%)",
+          numarray_expr="numarray.arctanh(%a1%)",
+          diff="1./(1.-%a1%**2)",
+          name="inverse hyperbolic tangent"),
+ OPERATOR(nickname="exp",\
+          rng=[-5.,5.],
+          test_expr="math.exp(%a1%)",
+          numarray_expr="numarray.exp(%a1%)",
+          diff="self",
+          name="exponential"),
+ OPERATOR(nickname="sqrt",\
+          rng=[1.e-3,100.],\
+          test_expr="math.sqrt(%a1%)",
+          numarray_expr="numarray.sqrt(%a1%)",
+          diff="0.5/self",
+          name="square root"),
+ OPERATOR(nickname="log",    \
+          rng=[1.e-3,100.],\
+          test_expr="math.log(%a1%)",
+          numarray_expr="numarray.log(%a1%)",
+          diff="1./arg",
+          name="natural logarithm"),
+ OPERATOR(nickname="sign",\
+          rng=[-100.,100.], \
+          math_expr="if %a1%>0:\n  return 1.\nelif %a1%<0:\n  return -1.\nelse:\n  return 0.",
+          test_expr="wherepos(%a1%)-wherepos(-%a1%)",
+          numarray_expr="numarray.sign(%a1%)",
+          symbol_expr="wherePositive(%a1%)-whereNegative(%a1%)",\
+          name="sign"),
+ OPERATOR(nickname="abs",\
+          rng=[-100.,100.], \
+          math_expr="if %a1%>0:\n  return %a1% \nelif %a1%<0:\n  return -(%a1%)\nelse:\n  return 0.",
+          test_expr="wherepos(%a1%)*(%a1%)-wherepos(-%a1%)*(%a1%)",
+          numarray_expr="abs(%a1%)",
+          diff="sign(%a1%)",
+          name="absolute value")
+               ]
  for f in func:
-    u_prog+="def %s(arg):\n"%f[0]
+    symbol_name=f.nickname[0].upper()+f.nickname[1:]
-    u_prog+="   \"\"\"\n"
+    if f.nickname!="abs":
-    u_prog+="   returns %s of argument arg\n\n"%f[0]
+       u_prog+="def %s(arg):\n"%f.nickname
-    u_prog+="   @param arg: argument\n"
+       u_prog+="   \"\"\"\n"
-    u_prog+="   @type arg: C{float}, L{escript.Data}, L{Symbol}, L{numarray.NumArray}.\n"
+       u_prog+="   returns %s of argument arg\n\n"%f.name
-    u_prog+="   @rtype:C{float}, L{escript.Data}, L{Symbol}, L{numarray.NumArray} depending on the type of arg.\n"
+       u_prog+="   @param arg: argument\n"
-    u_prog+="   @raises TypeError: if the type of the argument is not expected.\n"
+       u_prog+="   @type arg: C{float}, L{escript.Data}, L{Symbol}, L{numarray.NumArray}.\n"
-    u_prog+="   \"\"\"\n"
+       u_prog+="   @rtype:C{float}, L{escript.Data}, L{Symbol}, L{numarray.NumArray} depending on the type of arg.\n"
-    u_prog+="   if isinstance(arg,numarray.NumArray):\n"
+       u_prog+="   @raises TypeError: if the type of the argument is not expected.\n"
-    u_prog+="       return numarray.%s(arg)\n"%f[0]
+       u_prog+="   \"\"\"\n"
-    u_prog+="   elif isinstance(arg,escript.Data):\n"
+       u_prog+="   if isinstance(arg,numarray.NumArray):\n"
-    u_prog+="       return arg._%s(arg)\n"%f[0]
+       u_prog+=mkCode(f.numarray_expr,["arg"],2*"   ")
-    u_prog+="   elif isinstance(arg,float):\n"
+       u_prog+="   elif isinstance(arg,escript.Data):\n"
-    u_prog+="       return math.%s(arg)\n"%f[0]
+       u_prog+=mkCode("arg._%s()"%f.nickname,[],2*"   ")
-    u_prog+="   elif isinstance(arg,int):\n"
+       u_prog+="   elif isinstance(arg,float):\n"
-    u_prog+="       return math.%s(float(arg))\n"%f[0]
+       u_prog+=mkCode(f.math_expr,["arg"],2*"   ")
-    u_prog+="   elif isinstance(arg,Symbol):\n"
+       u_prog+="   elif isinstance(arg,int):\n"
-    u_prog+="       return Symbol_%s(arg)\n"%f[0]
+       u_prog+=mkCode(f.math_expr,["float(arg)"],2*"   ")
-    u_prog+="   else:\n"
+       u_prog+="   elif isinstance(arg,Symbol):\n"
-    u_prog+="       raise TypeError,\"%s: Unknown argument type.\"\n"%f[0]
+       if f.symbol_expr==None:
-    u_prog+="class Symbol_%s(DependendSymbol):\n"%f[0]
+          u_prog+=mkCode("%s_Symbol(arg)"%symbol_name,[],2*"   ")
-    u_prog+="   \"\"\"\n"
+       else:
-    u_prog+="   Symbol of the result of the %s function\n"%f[0]
+          u_prog+=mkCode(f.symbol_expr,["arg"],2*"   ")
-    u_prog+="   \"\"\"\n"
+       u_prog+="   else:\n"
-    u_prog+="   def __init__(self,arg):\n"
+       u_prog+="      raise TypeError,\"%s: Unknown argument type.\"\n\n"%f.nickname
-    u_prog+="      \"\"\"\n"
+    if f.symbol_expr==None:
-    u_prog+="      initialization %s function with argument arg\n"%f[0]
+       u_prog+="class %s_Symbol(DependendSymbol):\n"%symbol_name
-    u_prog+="      @param arg: argument of function\n"
+       u_prog+="   \"\"\"\n"
-    u_prog+="      @type arg: L{Symbol}.\n"
+       u_prog+="   L{Symbol} representing the result of the %s function\n"%f.name
-    u_prog+="      \"\"\"\n"
+       u_prog+="   \"\"\"\n"
-    u_prog+="      DependendSymbol.__init__(self,args=[arg],shape=arg.getShape(),dim=arg.getDim())\n"
+       u_prog+="   def __init__(self,arg):\n"
-    u_prog+="   def __str__(self):\n"
+       u_prog+="      \"\"\"\n"
-    u_prog+="      \"\"\"\n"
+       u_prog+="      initialization of %s L{Symbol} with argument arg\n"%f.nickname
-    u_prog+="      string representation of the object\n"
+       u_prog+="      @param arg: argument of function\n"
-    u_prog+="      @rtype: C{str}\n"
+       u_prog+="      @type arg: typically L{Symbol}.\n"
-    u_prog+="      \"\"\"\n"
+       u_prog+="      \"\"\"\n"
-    u_prog+="      return \"%s(%%s)\"%%str(self.getArgument(0))\n"%f[0]
+       u_prog+="      DependendSymbol.__init__(self,args=[arg],shape=arg.getShape(),dim=arg.getDim())\n"
-    u_prog+="   def substitute(self,argvals):\n"
+       u_prog+="\n"
-    u_prog+="      \"\"\"\n"
-    u_prog+="      assigns new values to symbols in the definition of the symbol\n      The method replaces the L{Symbol} u by argvals[u] in the expression defining this object.\n\n"
+       u_prog+="   def getMyCode(self,argstrs,format=\"escript\"):\n"
-    u_prog+="      @param argvals: new values assigned to symbols\n"
+       u_prog+="      \"\"\"\n"
-    u_prog+="      @type argvals: C{dict} with keywords of type L{Symbol}.\n"
+       u_prog+="      returns a program code that can be used to evaluate the symbol.\n\n"
-    u_prog+="      @return: result of the substitution process. Operations are executed as much as possible.\""
-    u_prog+="      @rtype: L{escript.Symbol}, C{float}, L{escript.Data}, L{numarray.NumArray} depending on the degree of substitution\n"
+       u_prog+="      @param argstrs: gives for each argument a string representing the argument for the evaluation.\n"
-    u_prog+="      raise: TypeError: if a value for a L{Symbol} cannot be substituted.\n"
+       u_prog+="      @type argstrs: C{str} or a C{list} of length 1 of C{str}.\n"
-    u_prog+="      \"\"\"\n"
+       u_prog+="      @param format: specifies the format to be used. At the moment only \"escript\" ,\"text\" and \"str\" are supported.\n"
-    u_prog+="      if argval.has_key(self): \n"
+       u_prog+="      @type format: C{str}\n"
-    u_prog+="         if self.isAppropriateValue(arg):\n"
+       u_prog+="      @return: a piece of program code which can be used to evaluate the expression assuming the values for the arguments are available.\n"
-    u_prog+="            return argval[self] \n"
+       u_prog+="      @rtype: C{str}\n"
-    u_prog+="         else:\n"
+       u_prog+="      @raise: NotImplementedError: if the requested format is not available\n"
-    u_prog+="            raise TypeError,\"%s: new value is not appropriate.\"\n"
+       u_prog+="      \"\"\"\n"
-    u_prog+="      else:\n"
+       u_prog+="      if isinstance(argstrs,list):\n"
-    u_prog+="         arg=self.getSubstitutedArguments(argvals)[0]\n"
+       u_prog+="          argstrs=argstrs[0]\n"
-    u_prog+="         return %s(arg)\n"%f[0]
+       u_prog+="      if format==\"escript\" or format==\"str\"  or format==\"text\":\n"
-    u_prog+="   def getMyCode(self,argstrs,format=\"escript\"):\n"
+       u_prog+="         return \"%s(%%s)\"%%argstrs\n"%f.nickname
-    u_prog+="       \"\"\"\n"
+       u_prog+="      else:\n"
-    u_prog+="       returns a program code that can be used to evaluate the symbol.\n"
+       u_prog+="         raise NotImplementedError,\"%s_Symbol does not provide program code for format %%s.\"%%format\n"%symbol_name
-    u_prog+="\n"
+       u_prog+="\n"
-    u_prog+="       @param argstrs: gives for each argument a string representing of the argument for the evaluation.\n"
-    u_prog+="       @type argstrs: C{list} of C{str}.\n"
+       u_prog+="   def substitute(self,argvals):\n"
-    u_prog+="       @param format: specifies the format to be used. At the moment only \"escript\" is supported.\n"
+       u_prog+="      \"\"\"\n"
-    u_prog+="       @type format: C{str}\n"
+       u_prog+="      assigns new values to symbols in the definition of the symbol.\n"
-    u_prog+="       @return: a piece of program code which can be used to evaluate the expression assuming the values for the arguments are available.\n"
+       u_prog+="      The method replaces the L{Symbol} u by argvals[u] in the expression defining this object.\n"
-    u_prog+="       @rtype: C{str}\n"
+       u_prog+="\n"
-    u_prog+="       @raises NotImplementedError: if no implementation for the given format is available\n"
+       u_prog+="      @param argvals: new values assigned to symbols\n"
-    u_prog+="       \"\"\"\n"
+       u_prog+="      @type argvals: C{dict} with keywords of type L{Symbol}.\n"
-    u_prog+="       if format==\"escript\":\n"
+       u_prog+="      @return: result of the substitution process. Operations are executed as much as possible.\n"
-    u_prog+="          return %s(%%s)%argstrs[0]\"\n"%f[0]
+       u_prog+="      @rtype: L{escript.Symbol}, C{float}, L{escript.Data}, L{numarray.NumArray} depending on the degree of substitution\n"
-    u_prog+="       else:\n"
+       u_prog+="      @raise TypeError: if a value for a L{Symbol} cannot be substituted.\n"
-    u_prog+="          raise NotImplementedError,\"%s does not provide program code for format %%s.\"%format\n"%f[0]
+       u_prog+="      \"\"\"\n"
+       u_prog+="      if argvals.has_key(self):\n"
-    u_prog+="   def diff(self,arg):\n"
+       u_prog+="         arg=argvals[self]\n"
-    u_prog+="      \"\"\"\n"
+       u_prog+="         if self.isAppropriateValue(arg):\n"
-    u_prog+="      returns the derivative of the symbol with respect to a symbol\n"
+       u_prog+="            return arg\n"
-    u_prog+="      @param arg: argument for derivation\n"
+       u_prog+="         else:\n"
-    u_prog+="      @type arg: L{Symbol}.\n"
+       u_prog+="            raise TypeError,\"%s: new value is not appropriate.\"%str(self)\n"
-    u_prog+="      @raises NotImplementedError: derivative not available.\n"
+       u_prog+="      else:\n"
-    u_prog+="      \"\"\"\n"
+       u_prog+="         arg=self.getSubstitutedArguments(argvals)[0]\n"
-    u_prog+="      if arg==self: \n"
+       u_prog+="         return %s(arg)\n\n"%f.nickname
-    u_prog+="         return identity(self.getShape())\n"
+       if not f.diff==None:
-    u_prog+="      else:\n"
+          u_prog+="   def diff(self,arg):\n"
-    u_prog+="        darg=self.getDifferentiatedArguments(arg)[0]\n"
+          u_prog+="      \"\"\"\n"
-    u_prog+="        raise NotImplementedError,\"%s: derivative is not available.\"\n"%f[0]
+          u_prog+="      differential of this object\n"
-    u_prog+="        # dself=?\n"
+          u_prog+="\n"
-    u_prog+="        return dself.matchShape(darg)*darg\n"
+          u_prog+="      @param arg: the derivative is calculated with respect to arg\n"
+          u_prog+="      @type arg: L{escript.Symbol}\n"
+          u_prog+="      @return: derivative with respect to C{arg}\n"
+          u_prog+="      @rtype: typically L{Symbol} but other types such as C{float}, L{escript.Data}, L{numarray.NumArray}  are possible.\n"
+          u_prog+="      \"\"\"\n"
+          u_prog+="      if arg==self:\n"
+          u_prog+="         return identity(self.getShape())\n"
+          u_prog+="      else:\n"
+          u_prog+="         myarg=self.getArgument()[0]\n"
+          u_prog+="         val=matchShape(%s,self.getDifferentiatedArguments(arg)[0])\n"%f.diff.replace("%a1%","myarg")
+          u_prog+="         return val[0]*val[1]\n\n"
+    for case in case_set:
+      for sh in shape_set:
+        if not case=="float" or len(sh)==0:
+          text=""
+          text+="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+          tname="def test_%s_%s_rank%s"%(f.nickname,case,len(sh))
+          text+="   %s(self):\n"%tname
+          a=makeArray(sh,f.rng)
+          a1=makeArray(sh,f.rng)
+          r1=makeResult(a1,f.test_expr)
+          r=makeResult(a,f.test_expr)
+          text+=mkText(case,"arg",a,a1)
+          text+="      res=%s(arg)\n"%f.nickname
+          if case=="Symbol":
+              text+=mkText("array","s",a,a1)
+              text+="      sub=res.substitute({arg:s})\n"
+              text+=mkText("array","ref",r,r1)
+              res="sub"
+          else:
+              text+=mkText(case,"ref",r,r1)
+              res="res"
+          text+=mkTypeAndShapeTest(case,sh,"res")
+          text+="      self.failUnless(Lsup(%s-ref)<=self.RES_TOL*Lsup(ref),\"wrong result\")\n"%res
+          if case == "taggedData":
+            t_prog_with_tags+=text
+          else:
+            t_prog+=text
+ #=========== END OF GOOD CODE +++++++++++++++++++++++++++
+/0
-    for args in ["float","array","constData","taggedData","expandedData","Symbol"]:
+ def X():
-      for sh in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
+          if args=="float":
-        if not args=="float" or len(sh)==0:
+            a=makeArray(sh,f[RANGE])
-          t_prog+="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+            r=makeResult(a,f)
-          tname="def test_%s_%s_rank%s"%(f[0],args,len(sh))
+            t_prog+="      arg=%s\n"%a[0]
-          t_prog+="   %s(self):\n"%tname
+            t_prog+="      ref=%s\n"%r[0]
-          if args in ["float","array" ]:
+            t_prog+="      res=%s(%a1%)\n"%f.nickname
-            a=makeArray(sh,f[1])
+            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
+            t_prog+="      self.failUnless(Lsup(res-ref)<=self.tol*Lsup(ref),\"wrong result\")\n"
+          elif args == "array":
+            a=makeArray(sh,f[RANGE])
             r=makeResult(a,f)
             if len(sh)==0:
-               t_prog+="      arg=%s\n"%a
+               t_prog+="      arg=numarray.array(%s)\n"%a[0]
-               t_prog+="      ref=%s\n"%r
+               t_prog+="      ref=numarray.array(%s)\n"%r[0]
             else:
                t_prog+="      arg=numarray.array(%s)\n"%a.tolist()
                t_prog+="      ref=numarray.array(%s)\n"%r.tolist()
-            t_prog+="      res=%s(arg)\n"%f[0]
+            t_prog+="      res=%s(%a1%)\n"%f.nickname
-            if args=="float":
+            t_prog+="      self.failUnlessEqual(res.shape,%s,\"wrong shape of result.\")\n"%str(sh)
-               t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
+            t_prog+="      self.failUnless(Lsup(res-ref)<=self.tol*Lsup(ref),\"wrong result\")\n"
-            else:
-               t_prog+="      self.failUnlessEqual(res.shape,%s,\"wrong shape of result.\")\n"%str(sh)
-            t_prog+="      self.failUnless(Lsup(res-ref)<=self.tol*Lsup(ref),\"wrong result\")\n"
           elif args== "constData":
-            a=makeArray(sh,f[1])
+            a=makeArray(sh,f[RANGE])
             r=makeResult(a,f)
             if len(sh)==0:
                t_prog+="      arg=Data(%s,self.functionspace)\n"%(a)
-Line 570 
 for f in func:
+Line 1286 
 for f in func:
             else:
                t_prog+="      arg=Data(numarray.array(%s),self.functionspace)\n"%(a.tolist())
                t_prog+="      ref=numarray.array(%s)\n"%r.tolist()
-            t_prog+="      res=%s(arg)\n"%f[0]
+            t_prog+="      res=%s(%a1%)\n"%f.nickname
             t_prog+="      self.failUnlessEqual(res.getShape(),%s,\"wrong shape of result.\")\n"%str(sh)
             t_prog+="      self.failUnless(Lsup(res-ref)<=self.tol*Lsup(ref),\"wrong result\")\n"
           elif args in [ "taggedData","expandedData"]:
-            a=makeArray(sh,f[1])
+            a=makeArray(sh,f[RANGE])
             r=makeResult(a,f)
-            a1=makeArray(sh,f[1])
+            a1=makeArray(sh,f[RANGE])
             r1=makeResult(a1,f)
             if len(sh)==0:
                if args=="expandedData":
-Line 596 
 for f in func:
+Line 1312 
 for f in func:
                   t_prog+="      ref=Data(numarray.array(%s),self.functionspace)\n"%(r.tolist())
                t_prog+="      arg.setTaggedValue(1,%s)\n"%a1.tolist()
                t_prog+="      ref.setTaggedValue(1,%s)\n"%r1.tolist()
-            t_prog+="      res=%s(arg)\n"%f[0]
+            t_prog+="      res=%s(%a1%)\n"%f.nickname
             t_prog+="      self.failUnlessEqual(res.getShape(),%s,\"wrong shape of result.\")\n"%str(sh)
             t_prog+="      self.failUnless(Lsup(res-ref)<=self.tol*Lsup(ref),\"wrong result\")\n"
           elif args=="Symbol":
             t_prog+="      arg=Symbol(shape=%s)\n"%str(sh)
-            t_prog+="      v=%s(arg)\n"%f[0]
+            t_prog+="      v=%s(%a1%)\n"%f.nickname
             t_prog+="      self.failUnlessRaises(ValueError,v.substitute,Symbol(shape=(1,1)),\"illegal shape of substitute not identified.\")\n"
-            a=makeArray(sh,f[1])
+            a=makeArray(sh,f[RANGE])
             r=makeResult(a,f)
             if len(sh)==0:
                t_prog+="      res=v.substitute({arg : %s})\n"%a
-Line 649 
 for f in func:
+Line 1365 
 for f in func:
                 t_prog+="      # test derivative with shape %s as argument\n"%str(sh_in)
                 trafo=makeArray(sh+sh_in,[0,1.])
-                a_in=makeArray(sh_in,f[1])
+                a_in=makeArray(sh_in,f[RANGE])
                 t_prog+="      arg_in=Symbol(shape=%s)\n"%str(sh_in)
                 t_prog+="      arg2=Symbol(shape=%s)\n"%str(sh)
-Line 871 
 for f in func:
+Line 1587 
 for f in func:
                             if len(sh_in)==0:
                                ref_diff=(makeResult(trafo[j0,j1,j2,j3]*a_in+finc,f)-makeResult(trafo[j0,j1,j2,j3]*a_in,f))/finc
                                t_prog+="      self.failUnlessAlmostEqual(dvdin[%s,%s,%s,%s],%s,self.places,\"%s-derivative: wrong derivative of %s\")\n"%(j0,j1,j2,j3,ref_diff,str(sh_in),str((j0,j1,j2,j3)))
- # print u_prog
+ #
+ #==================
+ cases=["Scalar","Vector","Tensor", "Tensor3","Tensor4"]
+ for case in range(len(cases)):
+   for d in [ None , "d", 1, 2 , 3]:
+          if not d==None or cases[case]=="Scalar":
+             t_prog+="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+             tname="test_Symbol_%s_d%s"%(cases[case],d)
+             t_prog+="   def %s(self):\n"%tname
+             if d=="d":
+                t_prog+="      s=%sSymbol(dim=self.functionspace)\n"%(cases[case])
+                t_prog+="      d=self.functionspace.getDim()\n"
+                sh="("
+                for i in range(case):
+                  if i==0:
+                   sh+=d
+                  else:
+                   sh+=","+d
+                sh+=")"
+             else:
+                t_prog+="      s=%sSymbol(dim=%s)\n"%(cases[case],d)
+                sh=()
+                for i in range(case): sh=sh+(d,)
+             t_prog+="      self.failUnlessEqual(s.getRank(),%s,\"wrong rank.\")\n"%case
+             t_prog+="      self.failUnlessEqual(s.getShape(),%s,\"wrong shape.\")\n"%str(sh)
+             t_prog+="      self.failUnlessEqual(s.getDim(),%s,\"wrong spatial dimension.\")\n"%d
+             t_prog+="      self.failUnlessEqual(s.getArgument(),[],\"wrong arguments.\")\n"
+ print t_prog
+/0
+ for sh in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
+   for d in [ None , "domain", 1, 2 , 3]:
+     for args in [ [], ["s2"], [1,-1.] ]:
+          t_prog+="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+          tname="def test_Symbol_rank%s_d%s_nargs%s"%(len(sh),d,len(args))
+          t_prog+="   %s(self):\n"%tname
+          t_prog+="      s2=ScalarSymbol()\n"
+          if args==["s2"]:
+             a="[s2]"
+          else:
+             a=str(args)
+          if d=="domain":
+             t_prog+="      s=Symbol(shape=%s,dim=self.functionspace.getDim(),args=%s)\n"%(str(sh),a)
+             d2="self.functionspace.getDim()"
+          else:
+             t_prog+="      s=Symbol(shape=%s,dim=%s,args=%s)\n"%(sh,d,a)
+             d2=str(d)
+          t_prog+="      self.failUnlessEqual(s.getRank(),%s,\"wrong rank.\")\n"%len(sh)
+          t_prog+="      self.failUnlessEqual(s.getShape(),%s,\"wrong shape.\")\n"%str(sh)
+          t_prog+="      self.failUnlessEqual(s.getDim(),%s,\"wrong spatial dimension.\")\n"%d2
+          t_prog+="      self.failUnlessEqual(s.getArgument(),%s,\"wrong arguments.\")\n\n"%a
+          t_prog+="      ss=s.substitute({s:numarray.zeros(%s)})\n"%str(sh)
+          t_prog+="      self.failUnless(isinstance(ss,numarray.NumArray),\"value after substitution is not numarray.\")\n"
+          t_prog+="      self.failUnlessEqual(ss.shape,%s,\"value after substitution has not expected shape\")\n"%str(sh)
+          t_prog+="      try:\n        s.substitute({s:numarray.zeros((5,))})\n        fail(\"illegal substition was successful\")\n"
+          t_prog+="      except TypeError:\n        pass\n\n"
+          ###
+          for sh2 in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
+              if len(sh+sh2)<5:
+                  t_prog+="      dsdarg=s.diff(Symbol(shape=%s))\n"%str(sh2)
+                  if  len(sh+sh2)==0:
+                     t_prog+="      self.failUnless(isinstance(dsdarg,float),\"ds/ds() has wrong type.\")\n"
+                  else:
+                     t_prog+="      self.failUnless(isinstance(dsdarg,numarray.NumArray),\"ds/ds%s has wrong type.\")\n"%str(sh2)
+                     t_prog+="      self.failUnlessEqual(dsdarg.shape,%s,\"ds/ds%s has wrong shape.\")\n"%(str(sh+sh2),str(sh2))
+                  t_prog+="      self.failIf(Lsup(dsdarg)>0.,\"ds/ds%s has wrong value.\")\n"%str(sh2)
+          if len(sh)<3:
+             t_prog+="\n      dsds=s.diff(s)\n"
+             if  len(sh)==0:
+                t_prog+="      self.failUnless(isinstance(dsds,float),\"ds/ds has wrong type.\")\n"
+                t_prog+="      self.failUnlessEqual(dsds,1.,\"ds/ds has wrong value.\")\n"
+             else:
+                t_prog+="      self.failUnless(isinstance(dsds,numarray.NumArray),\"ds/ds has wrong type.\")\n"
+                t_prog+="      self.failUnlessEqual(dsds.shape,%s,\"ds/ds has wrong shape.\")\n"%str(sh+sh)
+                if len(sh)==1:
+                    for i0 in range(sh[0]):
+                          for i2 in range(sh[0]):
+                                if i0==i2:
+                                     v=1.
+                                else:
+                                     v=0.
+                                t_prog+="      self.failUnlessEqual(dsds[%s,%s],%s,\"ds/ds has wrong value at (%s,%s).\")\n"%(i0,i2,v,i0,i2)
+                else:
+                    for i0 in range(sh[0]):
+                       for i1 in range(sh[1]):
+                          for i2 in range(sh[0]):
+                             for i3 in range(sh[1]):
+                                if i0==i2 and i1==i3:
+                                     v=1.
+                                else:
+                                     v=0.
+                                t_prog+="      self.failUnlessEqual(dsds[%s,%s,%s,%s],%s,\"ds/ds has wrong value at (%s,%s,%s,%s).\")\n"%(i0,i1,i2,i3,v,i0,i1,i2,i3)
+          ###
+          t_prog+="\n"
+          for i in range(len(args)):
+              t_prog+="      self.failUnlessEqual(s.getArgument(%s),%s,\"wrong argument %s.\")\n"%(i,str(args[i]),i)
+          t_prog+="      sa=s.getSubstitutedArguments({s2:-10})\n"
+          t_prog+="      self.failUnlessEqual(len(sa),%s,\"wrong number of substituted arguments\")\n"%len(args)
+          if args==["s2"]:
+                 t_prog+="      self.failUnlessEqual(sa[0],-10,\"wrongly substituted argument 0.\")\n"
+          else:
+              for i in range(len(args)):
+                 t_prog+="      self.failUnlessEqual(sa[%s],%s,\"wrongly substituted argument %s.\")\n"%(i,str(args[i]),i)
+          t_prog+="\n"
+          for arg in ["10.", "10", "SymbolMatch", "SymbolMisMatch", \
+                                        "DataMatch","DataMisMatch", "NumArrayMatch", "NumArrayMisMatch"]:
+              if arg in ["10.", "10"]:
+                 a=str(arg)
+                 if len(sh)==0:
+                    t_prog+="      self.failUnless(s.isAppropriateValue(%s),\"%s is appropriate substitute\")\n"%(a,arg)
+                 else:
+                    t_prog+="      self.failIf(s.isAppropriateValue(%s),\" %s is not appropriate substitute\")\n"%(a,arg)
+              elif arg in ["SymbolMatch", "SymbolMisMatch"]:
+                   if arg=="SymbolMatch":
+                    t_prog+="      self.failUnless(s.isAppropriateValue(Symbol(shape=%s,dim=%s)),\"Symbol is appropriate substitute\")\n"%(str(sh),d)
+                   else:
+                    if isinstance(d,int):
+                       t_prog+="      self.failIf(s.isAppropriateValue(Symbol(shape=%s,dim=%s)),\"Symbol is not appropriate substitute (dim)\")\n"%(str(sh),d+1)
+                    else:
+                       t_prog+="      self.failIf(s.isAppropriateValue(Symbol(shape=%s)),\"Symbol is not appropriate substitute (shape)\")\n"%((5,))
+              elif arg in ["DataMatch","DataMisMatch"]:
+                   if arg=="DataMatch" and d=="domain":
+                    t_prog+="      self.failUnless(s.isAppropriateValue(escript.Data(0.,%s,self.functionspace)),\"Data is appropriate substitute\")\n"%str(sh)
+                   elif arg=="DataMisMatch":
+                       t_prog+="      self.failIf(s.isAppropriateValue(escript.Data(0.,%s,self.functionspace)),\"Data is not appropriate substitute (shape)\")\n"%(str((5,)))
+              else:
+                   if arg=="NumArrayMatch":
+                    t_prog+="      self.failUnless(s.isAppropriateValue(numarray.zeros(%s)),\"NumArray is appropriate substitute\")\n"%str(sh)
+                   else:
+                       t_prog+="      self.failIf(s.isAppropriateValue(numarray.zeros(%s)),\"NumArray is not appropriate substitute (shape)\")\n"%(str((5,)))
  print t_prog
+/0
+ for case in ["Lsup", "sup", "inf"]:
+    for args in ["float","array","constData","taggedData","expandedData"]:
+      for sh in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
+        if not args=="float" or len(sh)==0:
+          t_prog+="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+          tname="def test_%s_%s_rank%s"%(case,args,len(sh))
+          t_prog+="   %s(self):\n"%tname
+          if args in ["float","array" ]:
+            a=makeArray(sh,[-1,1])
+            r=makeResult2(a,case)
+            if len(sh)==0:
+               t_prog+="      arg=%s\n"%a
+            else:
+               t_prog+="      arg=numarray.array(%s)\n"%a.tolist()
+            t_prog+="      ref=%s\n"%r
+            t_prog+="      res=%s(%a1%)\n"%case
+            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
+            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
+          elif args== "constData":
+            a=makeArray(sh,[-1,1])
+            r=makeResult2(a,case)
+            if len(sh)==0:
+               t_prog+="      arg=Data(%s,self.functionspace)\n"%(a)
+            else:
+               t_prog+="      arg=Data(numarray.array(%s),self.functionspace)\n"%(a.tolist())
+            t_prog+="      ref=%s\n"%r
+            t_prog+="      res=%s(%a1%)\n"%case
+            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
+            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
+          elif args in [ "taggedData","expandedData"]:
+            a=makeArray(sh,[-1,1])
+            r=makeResult2(a,case)
+            a1=makeArray(sh,[-1,1])
+            r1=makeResult2(a1,case)
+            if case in ["Lsup","sup"]:
+                r=max(r,r1)
+            else:
+                r=min(r,r1)
+            if len(sh)==0:
+               if args=="expandedData":
+                  t_prog+="      arg=Data(%s,self.functionspace,True)\n"%(a)
+               else:
+                  t_prog+="      arg=Data(%s,self.functionspace)\n"%(a)
+               t_prog+="      arg.setTaggedValue(1,%s)\n"%a
+            else:
+               if args=="expandedData":
+                  t_prog+="      arg=Data(numarray.array(%s),self.functionspace,True)\n"%(a.tolist())
+               else:
+                  t_prog+="      arg=Data(numarray.array(%s),self.functionspace)\n"%(a.tolist())
+               t_prog+="      arg.setTaggedValue(1,%s)\n"%a1.tolist()
+            t_prog+="      res=%s(%a1%)\n"%case
+            t_prog+="      ref=%s\n"%r
+            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
+            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
+ print t_prog
+/0
+ for case in ["Lsup", "sup", "inf"]:
+    for args in ["float","array","constData","taggedData","expandedData"]:
+      for sh in [ (),(2,), (4,5), (6,2,2),(3,2,3,4)]:
+        if not args=="float" or len(sh)==0:
+          t_prog+="   #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n"
+          tname="def test_%s_%s_rank%s"%(case,args,len(sh))
+          t_prog+="   %s(self):\n"%tname
+          if args in ["float","array" ]:
+            a=makeArray(sh,[-1,1])
+            r=makeResult2(a,case)
+            if len(sh)==0:
+               t_prog+="      arg=%s\n"%a
+            else:
+               t_prog+="      arg=numarray.array(%s)\n"%a.tolist()
+            t_prog+="      ref=%s\n"%r
+            t_prog+="      res=%s(%a1%)\n"%case
+            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
+            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
+          elif args== "constData":
+            a=makeArray(sh,[-1,1])
+            r=makeResult2(a,case)
+            if len(sh)==0:
+               t_prog+="      arg=Data(%s,self.functionspace)\n"%(a)
+            else:
+               t_prog+="      arg=Data(numarray.array(%s),self.functionspace)\n"%(a.tolist())
+            t_prog+="      ref=%s\n"%r
+            t_prog+="      res=%s(%a1%)\n"%case
+            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
+            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
+          elif args in [ "taggedData","expandedData"]:
+            a=makeArray(sh,[-1,1])
+            r=makeResult2(a,case)
+            a1=makeArray(sh,[-1,1])
+            r1=makeResult2(a1,case)
+            if case in ["Lsup","sup"]:
+                r=max(r,r1)
+            else:
+                r=min(r,r1)
+            if len(sh)==0:
+               if args=="expandedData":
+                  t_prog+="      arg=Data(%s,self.functionspace,True)\n"%(a)
+               else:
+                  t_prog+="      arg=Data(%s,self.functionspace)\n"%(a)
+               t_prog+="      arg.setTaggedValue(1,%s)\n"%a
+            else:
+               if args=="expandedData":
+                  t_prog+="      arg=Data(numarray.array(%s),self.functionspace,True)\n"%(a.tolist())
+               else:
+                  t_prog+="      arg=Data(numarray.array(%s),self.functionspace)\n"%(a.tolist())
+               t_prog+="      arg.setTaggedValue(1,%s)\n"%a1.tolist()
+            t_prog+="      res=%s(%a1%)\n"%case
+            t_prog+="      ref=%s\n"%r
+            t_prog+="      self.failUnless(isinstance(res,float),\"wrong type of result.\")\n"
+            t_prog+="      self.failUnless(abs(res-ref)<=self.tol*abs(ref),\"wrong result\")\n"
+ print t_prog
+/0

 Legend:



Removed from v.154
 


changed lines


 
Added in v.291
 Legend:



Removed from v.154
 


changed lines


 
Added in v.291
-Removed from v.154
+Added in v.291

	ViewVC Help
Powered by ViewVC 1.1.26