/[escript]/branches/intelc_win32/escript/test/python/test_util_spatial_functions.py
ViewVC logotype

Diff of /branches/intelc_win32/escript/test/python/test_util_spatial_functions.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 440 by gross, Fri Jan 20 02:15:48 2006 UTC revision 614 by elspeth, Wed Mar 22 01:37:07 2006 UTC
# Line 7  it is assumed that the domain is the usi Line 7  it is assumed that the domain is the usi
7  not all these test will run for all domains. check the doc string for the assumptions of a particular test  not all these test will run for all domains. check the doc string for the assumptions of a particular test
8    
9  @var __author__: name of author  @var __author__: name of author
10  @var __licence__: licence agreement  @var __license__: licence agreement
11  @var __url__: url entry point on documentation  @var __url__: url entry point on documentation
12  @var __version__: version  @var __version__: version
13  @var __date__: date of the version  @var __date__: date of the version
14  """  """
15  __author__="Lutz Gross, l.gross@uq.edu.au"  __author__="Lutz Gross, l.gross@uq.edu.au"
16  __licence__="contact: esys@access.uq.edu.au"  __copyright__="""  Copyright (c) 2006 by ACcESS MNRF
17                        http://www.access.edu.au
18                    Primary Business: Queensland, Australia"""
19    __license__="""Licensed under the Open Software License version 3.0
20                 http://www.opensource.org/licenses/osl-3.0.php"""
21  __url__="http://www.iservo.edu.au/esys/escript"  __url__="http://www.iservo.edu.au/esys/escript"
22  __version__="$Revision$"  __version__="$Revision$"
23  __date__="$Date$"  __date__="$Date$"
# Line 71076  class Test_Util_SpatialFunctions(unittes Line 71080  class Test_Util_SpatialFunctions(unittes
71080        self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong functionspace of result.")        self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong functionspace of result.")
71081        self.failUnlessEqual(res.getShape(),(4, 5, 3, 2),"wrong shape of result.")        self.failUnlessEqual(res.getShape(),(4, 5, 3, 2),"wrong shape of result.")
71082        self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")        self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71083       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71084       def test_div_onFunction_fromData_ContinuousFunction(self):
71085          """
71086          tests divergence of Data on the Function
71087    
71088          assumptions: ContinuousFunction(self.domain) exists
71089                       self.domain supports div on Function
71090          """
71091          o=self.order
71092          dim=self.domain.getDim()
71093          w_ref=Function(self.domain)
71094          x_ref=w_ref.getX()
71095          w=ContinuousFunction(self.domain)
71096          x=w.getX()
71097          arg=Vector(0,w)
71098          if dim==2:
71099            arg[0]=(-0.627139584179)*x[0]**o+(0.0871027334774)*x[0]+(-0.540784323698)*x[1]**o+(0.951143032871)*x[1]
71100            arg[1]=(-0.119239347115)*x[0]**o+(0.277154010744)*x[0]+(-0.0745557686973)*x[1]**o+(-0.15832879535)*x[1]
71101            ref=o*(-0.627139584179)*x_ref[0]**(o-1)+o*(-0.0745557686973)*x_ref[1]**(o-1)+(-0.0712260618722)
71102          else:
71103            arg[0]=(0.687070465546)*x[0]**o+(0.789237250884)*x[0]+(-0.00415360035876)*x[1]**o+(-0.809802614239)*x[1]+(0.418087966616)*x[2]**o+(0.730203229934)*x[2]
71104            arg[1]=(-0.0962217374268)*x[0]**o+(-0.180692492986)*x[0]+(-0.59921793179)*x[1]**o+(-0.799342788982)*x[1]+(0.421364766686)*x[2]**o+(-0.586211831795)*x[2]
71105            arg[2]=(0.774915504102)*x[0]**o+(-0.968436517935)*x[0]+(0.325821385033)*x[1]**o+(-0.159885723341)*x[1]+(0.411134413872)*x[2]**o+(0.083388357951)*x[2]
71106            ref=o*(0.687070465546)*x_ref[0]**(o-1)+o*(-0.59921793179)*x_ref[1]**(o-1)+o*(0.411134413872)*x_ref[2]**(o-1)+(0.0732828198535)
71107          res=div(arg,where=w_ref)
71108          self.failUnless(isinstance(res,Data),"wrong type of result.")
71109          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71110          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71111          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71112       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71113       def test_div_onFunction_fromData_Solution(self):
71114          """
71115          tests divergence of Data on the Function
71116    
71117          assumptions: Solution(self.domain) exists
71118                       self.domain supports div on Function
71119          """
71120          o=self.order
71121          dim=self.domain.getDim()
71122          w_ref=Function(self.domain)
71123          x_ref=w_ref.getX()
71124          w=Solution(self.domain)
71125          x=w.getX()
71126          arg=Vector(0,w)
71127          if dim==2:
71128            arg[0]=(-0.037254966228)*x[0]**o+(-0.175442318226)*x[0]+(-0.723089592066)*x[1]**o+(-0.487393332634)*x[1]
71129            arg[1]=(0.617589532887)*x[0]**o+(0.392126578405)*x[0]+(0.612110931251)*x[1]**o+(-0.932236829843)*x[1]
71130            ref=o*(-0.037254966228)*x_ref[0]**(o-1)+o*(0.612110931251)*x_ref[1]**(o-1)+(-1.10767914807)
71131          else:
71132            arg[0]=(-0.855344637098)*x[0]**o+(0.152992485241)*x[0]+(0.519809077415)*x[1]**o+(-0.0514985311411)*x[1]+(-0.473095642241)*x[2]**o+(-0.743711945025)*x[2]
71133            arg[1]=(0.629819444749)*x[0]**o+(-0.649277860811)*x[0]+(-0.382231371814)*x[1]**o+(-0.354475847319)*x[1]+(0.523961319618)*x[2]**o+(-0.0301027430993)*x[2]
71134            arg[2]=(0.489214433445)*x[0]**o+(-0.340824606014)*x[0]+(-0.78445257629)*x[1]**o+(-0.821498813523)*x[1]+(-0.147119976738)*x[2]**o+(0.464427291378)*x[2]
71135            ref=o*(-0.855344637098)*x_ref[0]**(o-1)+o*(-0.382231371814)*x_ref[1]**(o-1)+o*(-0.147119976738)*x_ref[2]**(o-1)+(0.2629439293)
71136          res=div(arg,where=w_ref)
71137          self.failUnless(isinstance(res,Data),"wrong type of result.")
71138          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71139          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71140          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71141       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71142       def test_div_onFunction_fromData_ReducedSolution(self):
71143          """
71144          tests divergence of Data on the Function
71145    
71146          assumptions: ReducedSolution(self.domain) exists
71147                       self.domain supports div on Function
71148          """
71149          o=1
71150          dim=self.domain.getDim()
71151          w_ref=Function(self.domain)
71152          x_ref=w_ref.getX()
71153          w=ReducedSolution(self.domain)
71154          x=w.getX()
71155          arg=Vector(0,w)
71156          if dim==2:
71157            arg[0]=(0.983549953155)*x[0]+(0.741104834322)*x[1]
71158            arg[1]=(0.548447952865)*x[0]+(-0.817326874507)*x[1]
71159            ref=(0.166223078648)
71160          else:
71161            arg[0]=(1.39002615085)*x[0]+(0.609245504565)*x[1]+(-1.06625041498)*x[2]
71162            arg[1]=(-1.13329921103)*x[0]+(0.160224729695)*x[1]+(0.408632198066)*x[2]
71163            arg[2]=(0.124694320475)*x[0]+(-1.53975404419)*x[1]+(1.00224340458)*x[2]
71164            ref=(2.55249428513)
71165          res=div(arg,where=w_ref)
71166          self.failUnless(isinstance(res,Data),"wrong type of result.")
71167          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71168          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71169          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71170       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71171       def test_div_onFunction_fromSymbol_ContinuousFunction(self):
71172          """
71173          tests divergence of Symbol on the Function
71174    
71175          assumptions: ContinuousFunction(self.domain) exists
71176                       self.domain supports div on Function
71177          """
71178          o=self.order
71179          dim=self.domain.getDim()
71180          w_ref=Function(self.domain)
71181          x_ref=w_ref.getX()
71182          w=ContinuousFunction(self.domain)
71183          x=w.getX()
71184          arg=Symbol(shape=(dim,),dim=dim)
71185          s=Vector(0,w)
71186          if dim==2:
71187            s[0]=(0.056440576841)*x[0]**o+(0.246232077047)*x[0]+(0.855071175271)*x[1]**o+(0.501469853761)*x[1]
71188            s[1]=(0.138795877959)*x[0]**o+(-0.272898431539)*x[0]+(0.446848353852)*x[1]**o+(0.590328561048)*x[1]
71189            ref=o*(0.056440576841)*x_ref[0]**(o-1)+o*(0.446848353852)*x_ref[1]**(o-1)+(0.836560638095)
71190          else:
71191            s[0]=(-0.50629608129)*x[0]**o+(-0.741872423345)*x[0]+(-0.386081173959)*x[1]**o+(0.318875107198)*x[1]+(-0.385714540576)*x[2]**o+(-0.628522049303)*x[2]
71192            s[1]=(-0.174000956733)*x[0]**o+(-0.883773784269)*x[0]+(-0.811120942906)*x[1]**o+(-0.16019437105)*x[1]+(-0.385051346205)*x[2]**o+(0.988540730072)*x[2]
71193            s[2]=(0.354661225031)*x[0]**o+(0.900659468106)*x[0]+(0.589271296273)*x[1]**o+(0.339143175651)*x[1]+(-0.50750318566)*x[2]**o+(0.934057146824)*x[2]
71194            ref=o*(-0.50629608129)*x_ref[0]**(o-1)+o*(-0.811120942906)*x_ref[1]**(o-1)+o*(-0.50750318566)*x_ref[2]**(o-1)+(0.0319903524287)
71195          res=div(arg,where=w_ref)
71196          sub=res.substitute({arg:s})
71197          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71198          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71199          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71200          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71201       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71202       def test_div_onFunction_fromSymbol_Solution(self):
71203          """
71204          tests divergence of Symbol on the Function
71205    
71206          assumptions: Solution(self.domain) exists
71207                       self.domain supports div on Function
71208          """
71209          o=self.order
71210          dim=self.domain.getDim()
71211          w_ref=Function(self.domain)
71212          x_ref=w_ref.getX()
71213          w=Solution(self.domain)
71214          x=w.getX()
71215          arg=Symbol(shape=(dim,),dim=dim)
71216          s=Vector(0,w)
71217          if dim==2:
71218            s[0]=(-0.170850365394)*x[0]**o+(0.150036471084)*x[0]+(0.0923309607854)*x[1]**o+(-0.296802366309)*x[1]
71219            s[1]=(0.61420032995)*x[0]**o+(-0.430079619352)*x[0]+(0.0912728436628)*x[1]**o+(0.817677896693)*x[1]
71220            ref=o*(-0.170850365394)*x_ref[0]**(o-1)+o*(0.0912728436628)*x_ref[1]**(o-1)+(0.967714367777)
71221          else:
71222            s[0]=(-0.740025332388)*x[0]**o+(0.628542391186)*x[0]+(0.201133646437)*x[1]**o+(0.518904232415)*x[1]+(0.745948286476)*x[2]**o+(0.6146222318)*x[2]
71223            s[1]=(-0.646212542688)*x[0]**o+(-0.687137148869)*x[0]+(-0.162072841283)*x[1]**o+(0.627944920212)*x[1]+(-0.713818605572)*x[2]**o+(0.246460903592)*x[2]
71224            s[2]=(-0.736234793544)*x[0]**o+(-0.382762645761)*x[0]+(-0.837579788578)*x[1]**o+(-0.913690456246)*x[1]+(0.364622848764)*x[2]**o+(0.241650777953)*x[2]
71225            ref=o*(-0.740025332388)*x_ref[0]**(o-1)+o*(-0.162072841283)*x_ref[1]**(o-1)+o*(0.364622848764)*x_ref[2]**(o-1)+(1.49813808935)
71226          res=div(arg,where=w_ref)
71227          sub=res.substitute({arg:s})
71228          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71229          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71230          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71231          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71232       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71233       def test_div_onFunction_fromSymbol_ReducedSolution(self):
71234          """
71235          tests divergence of Symbol on the Function
71236    
71237          assumptions: ReducedSolution(self.domain) exists
71238                       self.domain supports div on Function
71239          """
71240          o=1
71241          dim=self.domain.getDim()
71242          w_ref=Function(self.domain)
71243          x_ref=w_ref.getX()
71244          w=ReducedSolution(self.domain)
71245          x=w.getX()
71246          arg=Symbol(shape=(dim,),dim=dim)
71247          s=Vector(0,w)
71248          if dim==2:
71249            s[0]=(0.0131350820952)*x[0]+(-1.82221871934)*x[1]
71250            s[1]=(-1.89777545856)*x[0]+(0.191135975577)*x[1]
71251            ref=(0.204271057672)
71252          else:
71253            s[0]=(-1.30169999796)*x[0]+(-0.550711448862)*x[1]+(0.241706428593)*x[2]
71254            s[1]=(0.843465810567)*x[0]+(-1.42460661253)*x[1]+(1.72435488277)*x[2]
71255            s[2]=(0.290030514202)*x[0]+(1.75177720442)*x[1]+(0.568532008682)*x[2]
71256            ref=(-2.15777460181)
71257          res=div(arg,where=w_ref)
71258          sub=res.substitute({arg:s})
71259          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71260          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71261          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71262          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71263       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71264       def test_div_onFunctionOnBoundary_fromData_ContinuousFunction(self):
71265          """
71266          tests divergence of Data on the FunctionOnBoundary
71267    
71268          assumptions: ContinuousFunction(self.domain) exists
71269                       self.domain supports div on FunctionOnBoundary
71270          """
71271          o=self.order
71272          dim=self.domain.getDim()
71273          w_ref=FunctionOnBoundary(self.domain)
71274          x_ref=w_ref.getX()
71275          w=ContinuousFunction(self.domain)
71276          x=w.getX()
71277          arg=Vector(0,w)
71278          if dim==2:
71279            arg[0]=(-0.39999188185)*x[0]**o+(-0.0985302665504)*x[0]+(0.103912148113)*x[1]**o+(-0.440893151166)*x[1]
71280            arg[1]=(-0.550867128413)*x[0]**o+(-0.141593933069)*x[0]+(0.70592012062)*x[1]**o+(-0.836308099686)*x[1]
71281            ref=o*(-0.39999188185)*x_ref[0]**(o-1)+o*(0.70592012062)*x_ref[1]**(o-1)+(-0.934838366236)
71282          else:
71283            arg[0]=(-0.00405079499937)*x[0]**o+(-0.282117848793)*x[0]+(0.979898720034)*x[1]**o+(-0.418106638625)*x[1]+(-0.443550810851)*x[2]**o+(-0.114976349698)*x[2]
71284            arg[1]=(0.194746221496)*x[0]**o+(0.324772666848)*x[0]+(0.887813387362)*x[1]**o+(-0.9362867149)*x[1]+(-0.837328978457)*x[2]**o+(0.666079514358)*x[2]
71285            arg[2]=(0.974797445328)*x[0]**o+(0.00365347225195)*x[0]+(-0.285413216102)*x[1]**o+(-0.253930177142)*x[1]+(0.306713249275)*x[2]**o+(-0.651133960743)*x[2]
71286            ref=o*(-0.00405079499937)*x_ref[0]**(o-1)+o*(0.887813387362)*x_ref[1]**(o-1)+o*(0.306713249275)*x_ref[2]**(o-1)+(-1.86953852444)
71287          res=div(arg,where=w_ref)
71288          self.failUnless(isinstance(res,Data),"wrong type of result.")
71289          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71290          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71291          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71292       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71293       def test_div_onFunctionOnBoundary_fromData_Solution(self):
71294          """
71295          tests divergence of Data on the FunctionOnBoundary
71296    
71297          assumptions: Solution(self.domain) exists
71298                       self.domain supports div on FunctionOnBoundary
71299          """
71300          o=self.order
71301          dim=self.domain.getDim()
71302          w_ref=FunctionOnBoundary(self.domain)
71303          x_ref=w_ref.getX()
71304          w=Solution(self.domain)
71305          x=w.getX()
71306          arg=Vector(0,w)
71307          if dim==2:
71308            arg[0]=(-0.756094856241)*x[0]**o+(-0.185186427186)*x[0]+(0.15709960228)*x[1]**o+(-0.408372399703)*x[1]
71309            arg[1]=(-0.680793761252)*x[0]**o+(0.815275471992)*x[0]+(-0.0564602888317)*x[1]**o+(0.542507598499)*x[1]
71310            ref=o*(-0.756094856241)*x_ref[0]**(o-1)+o*(-0.0564602888317)*x_ref[1]**(o-1)+(0.357321171313)
71311          else:
71312            arg[0]=(-0.934829971573)*x[0]**o+(-0.202157515712)*x[0]+(0.972095997183)*x[1]**o+(0.430890291958)*x[1]+(0.973333736054)*x[2]**o+(0.563067835398)*x[2]
71313            arg[1]=(-0.676905980848)*x[0]**o+(0.721377714968)*x[0]+(-0.594993636371)*x[1]**o+(0.678979489168)*x[1]+(-0.491382641255)*x[2]**o+(-0.237396572727)*x[2]
71314            arg[2]=(-0.429697616397)*x[0]**o+(-0.8280062193)*x[0]+(0.549112225165)*x[1]**o+(0.73490904828)*x[1]+(0.543450722632)*x[2]**o+(-0.910092410543)*x[2]
71315            ref=o*(-0.934829971573)*x_ref[0]**(o-1)+o*(-0.594993636371)*x_ref[1]**(o-1)+o*(0.543450722632)*x_ref[2]**(o-1)+(-0.433270437087)
71316          res=div(arg,where=w_ref)
71317          self.failUnless(isinstance(res,Data),"wrong type of result.")
71318          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71319          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71320          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71321       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71322       def test_div_onFunctionOnBoundary_fromData_ReducedSolution(self):
71323          """
71324          tests divergence of Data on the FunctionOnBoundary
71325    
71326          assumptions: ReducedSolution(self.domain) exists
71327                       self.domain supports div on FunctionOnBoundary
71328          """
71329          o=1
71330          dim=self.domain.getDim()
71331          w_ref=FunctionOnBoundary(self.domain)
71332          x_ref=w_ref.getX()
71333          w=ReducedSolution(self.domain)
71334          x=w.getX()
71335          arg=Vector(0,w)
71336          if dim==2:
71337            arg[0]=(-0.701055390328)*x[0]+(-0.873109677704)*x[1]
71338            arg[1]=(-0.459521943793)*x[0]+(-1.63064815751)*x[1]
71339            ref=(-2.33170354784)
71340          else:
71341            arg[0]=(-0.408202035271)*x[0]+(-0.114769362644)*x[1]+(1.5510990077)*x[2]
71342            arg[1]=(0.17481433607)*x[0]+(-0.466969145604)*x[1]+(1.25289823435)*x[2]
71343            arg[2]=(-0.215477376297)*x[0]+(0.437173510517)*x[1]+(1.00334359062)*x[2]
71344            ref=(0.128172409746)
71345          res=div(arg,where=w_ref)
71346          self.failUnless(isinstance(res,Data),"wrong type of result.")
71347          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71348          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71349          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71350       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71351       def test_div_onFunctionOnBoundary_fromSymbol_ContinuousFunction(self):
71352          """
71353          tests divergence of Symbol on the FunctionOnBoundary
71354    
71355          assumptions: ContinuousFunction(self.domain) exists
71356                       self.domain supports div on FunctionOnBoundary
71357          """
71358          o=self.order
71359          dim=self.domain.getDim()
71360          w_ref=FunctionOnBoundary(self.domain)
71361          x_ref=w_ref.getX()
71362          w=ContinuousFunction(self.domain)
71363          x=w.getX()
71364          arg=Symbol(shape=(dim,),dim=dim)
71365          s=Vector(0,w)
71366          if dim==2:
71367            s[0]=(0.600081772347)*x[0]**o+(-0.45657364476)*x[0]+(0.100558790895)*x[1]**o+(-0.055643420941)*x[1]
71368            s[1]=(-0.568472071712)*x[0]**o+(-0.683739238637)*x[0]+(-0.14866031141)*x[1]**o+(-0.17686218803)*x[1]
71369            ref=o*(0.600081772347)*x_ref[0]**(o-1)+o*(-0.14866031141)*x_ref[1]**(o-1)+(-0.63343583279)
71370          else:
71371            s[0]=(-0.822374031685)*x[0]**o+(-0.587511521237)*x[0]+(0.963639060657)*x[1]**o+(-0.190070692051)*x[1]+(0.558162506917)*x[2]**o+(-0.460808186343)*x[2]
71372            s[1]=(-0.798572575819)*x[0]**o+(-0.101266909891)*x[0]+(-0.516195739148)*x[1]**o+(0.617726153299)*x[1]+(-0.34240818464)*x[2]**o+(0.335550364849)*x[2]
71373            s[2]=(-0.213593757489)*x[0]**o+(-0.366203371298)*x[0]+(0.531651196423)*x[1]**o+(0.199631639651)*x[1]+(0.775999930783)*x[2]**o+(-0.3541802777)*x[2]
71374            ref=o*(-0.822374031685)*x_ref[0]**(o-1)+o*(-0.516195739148)*x_ref[1]**(o-1)+o*(0.775999930783)*x_ref[2]**(o-1)+(-0.323965645638)
71375          res=div(arg,where=w_ref)
71376          sub=res.substitute({arg:s})
71377          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71378          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71379          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71380          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71381       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71382       def test_div_onFunctionOnBoundary_fromSymbol_Solution(self):
71383          """
71384          tests divergence of Symbol on the FunctionOnBoundary
71385    
71386          assumptions: Solution(self.domain) exists
71387                       self.domain supports div on FunctionOnBoundary
71388          """
71389          o=self.order
71390          dim=self.domain.getDim()
71391          w_ref=FunctionOnBoundary(self.domain)
71392          x_ref=w_ref.getX()
71393          w=Solution(self.domain)
71394          x=w.getX()
71395          arg=Symbol(shape=(dim,),dim=dim)
71396          s=Vector(0,w)
71397          if dim==2:
71398            s[0]=(0.737547486132)*x[0]**o+(-0.8688345451)*x[0]+(0.750434018309)*x[1]**o+(0.140443192943)*x[1]
71399            s[1]=(-0.581930862436)*x[0]**o+(-0.0165116457364)*x[0]+(-0.575385479046)*x[1]**o+(0.840871277956)*x[1]
71400            ref=o*(0.737547486132)*x_ref[0]**(o-1)+o*(-0.575385479046)*x_ref[1]**(o-1)+(-0.0279632671436)
71401          else:
71402            s[0]=(0.270325198436)*x[0]**o+(-0.47191239181)*x[0]+(-0.999528728847)*x[1]**o+(-0.103752839996)*x[1]+(-0.76928188931)*x[2]**o+(0.595426116602)*x[2]
71403            s[1]=(0.269434059222)*x[0]**o+(0.387014929786)*x[0]+(-0.0817482722299)*x[1]**o+(-0.36264415709)*x[1]+(-0.693828731298)*x[2]**o+(-0.82629322569)*x[2]
71404            s[2]=(0.171309519816)*x[0]**o+(-0.696536709305)*x[0]+(-0.835027772202)*x[1]**o+(-0.916627860891)*x[1]+(0.35239086527)*x[2]**o+(-0.921910360255)*x[2]
71405            ref=o*(0.270325198436)*x_ref[0]**(o-1)+o*(-0.0817482722299)*x_ref[1]**(o-1)+o*(0.35239086527)*x_ref[2]**(o-1)+(-1.75646690915)
71406          res=div(arg,where=w_ref)
71407          sub=res.substitute({arg:s})
71408          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71409          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71410          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71411          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71412       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71413       def test_div_onFunctionOnBoundary_fromSymbol_ReducedSolution(self):
71414          """
71415          tests divergence of Symbol on the FunctionOnBoundary
71416    
71417          assumptions: ReducedSolution(self.domain) exists
71418                       self.domain supports div on FunctionOnBoundary
71419          """
71420          o=1
71421          dim=self.domain.getDim()
71422          w_ref=FunctionOnBoundary(self.domain)
71423          x_ref=w_ref.getX()
71424          w=ReducedSolution(self.domain)
71425          x=w.getX()
71426          arg=Symbol(shape=(dim,),dim=dim)
71427          s=Vector(0,w)
71428          if dim==2:
71429            s[0]=(-0.759081801873)*x[0]+(1.19486066363)*x[1]
71430            s[1]=(0.124293887621)*x[0]+(0.239495671437)*x[1]
71431            ref=(-0.519586130436)
71432          else:
71433            s[0]=(0.114143993825)*x[0]+(1.00937429349)*x[1]+(-0.402505788806)*x[2]
71434            s[1]=(1.3389839478)*x[0]+(-1.18006174569)*x[1]+(-0.7113433796)*x[2]
71435            s[2]=(-0.082639774749)*x[0]+(-0.349220712526)*x[1]+(0.477197377967)*x[2]
71436            ref=(-0.588720373901)
71437          res=div(arg,where=w_ref)
71438          sub=res.substitute({arg:s})
71439          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71440          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71441          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71442          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71443       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71444       def test_div_onFunctionOnContactZero_fromData_ContinuousFunction(self):
71445          """
71446          tests divergence of Data on the FunctionOnContactZero
71447    
71448          assumptions: ContinuousFunction(self.domain) exists
71449                       self.domain supports div on FunctionOnContactZero
71450          """
71451          o=self.order
71452          dim=self.domain.getDim()
71453          w_ref=FunctionOnContactZero(self.domain)
71454          x_ref=w_ref.getX()
71455          w=ContinuousFunction(self.domain)
71456          x=w.getX()
71457          arg=Vector(0,w)
71458          if dim==2:
71459            arg[0]=(-0.168949755871)*x[0]**o+(-0.850028843808)*x[0]+(-0.120402543124)*x[1]**o+(-0.962848557803)*x[1]
71460            arg[1]=(-0.654809749448)*x[0]**o+(-0.86782287971)*x[0]+(0.063297622975)*x[1]**o+(0.400298481087)*x[1]
71461            ref=o*(-0.168949755871)*x_ref[0]**(o-1)+o*(0.063297622975)*x_ref[1]**(o-1)+(-0.449730362722)
71462          else:
71463            arg[0]=(-0.171176882625)*x[0]**o+(-0.983025148621)*x[0]+(-0.287555867477)*x[1]**o+(-0.689164237089)*x[1]+(0.700322207054)*x[2]**o+(0.224056812199)*x[2]
71464            arg[1]=(-0.112978574269)*x[0]**o+(-0.858210458939)*x[0]+(-0.9204250284)*x[1]**o+(0.123297295575)*x[1]+(-0.824406652345)*x[2]**o+(-0.514156554116)*x[2]
71465            arg[2]=(0.51215310895)*x[0]**o+(-0.484568237326)*x[0]+(0.324174170946)*x[1]**o+(0.00636990564332)*x[1]+(0.640205070676)*x[2]**o+(0.642111592847)*x[2]
71466            ref=o*(-0.171176882625)*x_ref[0]**(o-1)+o*(-0.9204250284)*x_ref[1]**(o-1)+o*(0.640205070676)*x_ref[2]**(o-1)+(-0.217616260198)
71467          res=div(arg,where=w_ref)
71468          self.failUnless(isinstance(res,Data),"wrong type of result.")
71469          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71470          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71471          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71472       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71473       def test_div_onFunctionOnContactZero_fromData_Solution(self):
71474          """
71475          tests divergence of Data on the FunctionOnContactZero
71476    
71477          assumptions: Solution(self.domain) exists
71478                       self.domain supports div on FunctionOnContactZero
71479          """
71480          o=self.order
71481          dim=self.domain.getDim()
71482          w_ref=FunctionOnContactZero(self.domain)
71483          x_ref=w_ref.getX()
71484          w=Solution(self.domain)
71485          x=w.getX()
71486          arg=Vector(0,w)
71487          if dim==2:
71488            arg[0]=(-0.878817592363)*x[0]**o+(-0.670917442592)*x[0]+(0.497874113437)*x[1]**o+(-0.923717382234)*x[1]
71489            arg[1]=(-0.26042852826)*x[0]**o+(0.0668495878627)*x[0]+(-0.24188250168)*x[1]**o+(-0.189346966858)*x[1]
71490            ref=o*(-0.878817592363)*x_ref[0]**(o-1)+o*(-0.24188250168)*x_ref[1]**(o-1)+(-0.86026440945)
71491          else:
71492            arg[0]=(-0.853829042745)*x[0]**o+(0.708253823804)*x[0]+(-0.420888906754)*x[1]**o+(0.94422817266)*x[1]+(-0.0454733411462)*x[2]**o+(-0.588636328569)*x[2]
71493            arg[1]=(0.502105411994)*x[0]**o+(0.618635348918)*x[0]+(-0.459898919811)*x[1]**o+(0.0206615239957)*x[1]+(-0.479378221929)*x[2]**o+(-0.0383028811998)*x[2]
71494            arg[2]=(-0.624273042239)*x[0]**o+(0.11218158851)*x[0]+(0.300065081794)*x[1]**o+(-0.823140829548)*x[1]+(-0.537442909756)*x[2]**o+(-0.537901446348)*x[2]
71495            ref=o*(-0.853829042745)*x_ref[0]**(o-1)+o*(-0.459898919811)*x_ref[1]**(o-1)+o*(-0.537442909756)*x_ref[2]**(o-1)+(0.191013901452)
71496          res=div(arg,where=w_ref)
71497          self.failUnless(isinstance(res,Data),"wrong type of result.")
71498          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71499          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71500          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71501       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71502       def test_div_onFunctionOnContactZero_fromData_ReducedSolution(self):
71503          """
71504          tests divergence of Data on the FunctionOnContactZero
71505    
71506          assumptions: ReducedSolution(self.domain) exists
71507                       self.domain supports div on FunctionOnContactZero
71508          """
71509          o=1
71510          dim=self.domain.getDim()
71511          w_ref=FunctionOnContactZero(self.domain)
71512          x_ref=w_ref.getX()
71513          w=ReducedSolution(self.domain)
71514          x=w.getX()
71515          arg=Vector(0,w)
71516          if dim==2:
71517            arg[0]=(1.40908912517)*x[0]+(0.980544777047)*x[1]
71518            arg[1]=(1.54735707911)*x[0]+(0.136617363775)*x[1]
71519            ref=(1.54570648895)
71520          else:
71521            arg[0]=(0.542899657951)*x[0]+(0.445471953165)*x[1]+(0.832668361385)*x[2]
71522            arg[1]=(-0.658976315278)*x[0]+(0.467903824571)*x[1]+(-1.00818943414)*x[2]
71523            arg[2]=(-1.10271841197)*x[0]+(1.48792855886)*x[1]+(-0.560275626738)*x[2]
71524            ref=(0.450527855784)
71525          res=div(arg,where=w_ref)
71526          self.failUnless(isinstance(res,Data),"wrong type of result.")
71527          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71528          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71529          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71530       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71531       def test_div_onFunctionOnContactZero_fromSymbol_ContinuousFunction(self):
71532          """
71533          tests divergence of Symbol on the FunctionOnContactZero
71534    
71535          assumptions: ContinuousFunction(self.domain) exists
71536                       self.domain supports div on FunctionOnContactZero
71537          """
71538          o=self.order
71539          dim=self.domain.getDim()
71540          w_ref=FunctionOnContactZero(self.domain)
71541          x_ref=w_ref.getX()
71542          w=ContinuousFunction(self.domain)
71543          x=w.getX()
71544          arg=Symbol(shape=(dim,),dim=dim)
71545          s=Vector(0,w)
71546          if dim==2:
71547            s[0]=(0.161146122811)*x[0]**o+(-0.167192157833)*x[0]+(-0.375618887584)*x[1]**o+(0.0878245139474)*x[1]
71548            s[1]=(-0.537393073871)*x[0]**o+(0.120284625555)*x[0]+(-0.732878618183)*x[1]**o+(0.950964015707)*x[1]
71549            ref=o*(0.161146122811)*x_ref[0]**(o-1)+o*(-0.732878618183)*x_ref[1]**(o-1)+(0.783771857874)
71550          else:
71551            s[0]=(0.663467704633)*x[0]**o+(0.192717069721)*x[0]+(-0.348590092108)*x[1]**o+(-0.00702534646765)*x[1]+(0.359300718583)*x[2]**o+(0.325682691269)*x[2]
71552            s[1]=(0.127384376464)*x[0]**o+(-0.974260164601)*x[0]+(0.623191833228)*x[1]**o+(0.927154841547)*x[1]+(0.66921644471)*x[2]**o+(0.730046317457)*x[2]
71553            s[2]=(0.477753719763)*x[0]**o+(0.303349068035)*x[0]+(0.297684454456)*x[1]**o+(-0.23387142141)*x[1]+(-0.160162179877)*x[2]**o+(0.321427279218)*x[2]
71554            ref=o*(0.663467704633)*x_ref[0]**(o-1)+o*(0.623191833228)*x_ref[1]**(o-1)+o*(-0.160162179877)*x_ref[2]**(o-1)+(1.44129919049)
71555          res=div(arg,where=w_ref)
71556          sub=res.substitute({arg:s})
71557          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71558          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71559          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71560          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71561       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71562       def test_div_onFunctionOnContactZero_fromSymbol_Solution(self):
71563          """
71564          tests divergence of Symbol on the FunctionOnContactZero
71565    
71566          assumptions: Solution(self.domain) exists
71567                       self.domain supports div on FunctionOnContactZero
71568          """
71569          o=self.order
71570          dim=self.domain.getDim()
71571          w_ref=FunctionOnContactZero(self.domain)
71572          x_ref=w_ref.getX()
71573          w=Solution(self.domain)
71574          x=w.getX()
71575          arg=Symbol(shape=(dim,),dim=dim)
71576          s=Vector(0,w)
71577          if dim==2:
71578            s[0]=(-0.714164520534)*x[0]**o+(0.82104115064)*x[0]+(-0.101329353755)*x[1]**o+(0.211581405872)*x[1]
71579            s[1]=(0.154441871043)*x[0]**o+(-0.545965134865)*x[0]+(0.232672960523)*x[1]**o+(0.613108805891)*x[1]
71580            ref=o*(-0.714164520534)*x_ref[0]**(o-1)+o*(0.232672960523)*x_ref[1]**(o-1)+(1.43414995653)
71581          else:
71582            s[0]=(0.668585271141)*x[0]**o+(0.367611537166)*x[0]+(0.241825965301)*x[1]**o+(-0.111380450261)*x[1]+(-0.928428911379)*x[2]**o+(-0.282714026941)*x[2]
71583            s[1]=(-0.733274659976)*x[0]**o+(0.827799978056)*x[0]+(0.957107141065)*x[1]**o+(0.654786636056)*x[1]+(-0.327647026546)*x[2]**o+(-0.263782117053)*x[2]
71584            s[2]=(-0.770358571743)*x[0]**o+(-0.793594113842)*x[0]+(-0.870794666744)*x[1]**o+(-0.760800400466)*x[1]+(0.987607632645)*x[2]**o+(0.960902635484)*x[2]
71585            ref=o*(0.668585271141)*x_ref[0]**(o-1)+o*(0.957107141065)*x_ref[1]**(o-1)+o*(0.987607632645)*x_ref[2]**(o-1)+(1.98330080871)
71586          res=div(arg,where=w_ref)
71587          sub=res.substitute({arg:s})
71588          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71589          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71590          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71591          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71592       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71593       def test_div_onFunctionOnContactZero_fromSymbol_ReducedSolution(self):
71594          """
71595          tests divergence of Symbol on the FunctionOnContactZero
71596    
71597          assumptions: ReducedSolution(self.domain) exists
71598                       self.domain supports div on FunctionOnContactZero
71599          """
71600          o=1
71601          dim=self.domain.getDim()
71602          w_ref=FunctionOnContactZero(self.domain)
71603          x_ref=w_ref.getX()
71604          w=ReducedSolution(self.domain)
71605          x=w.getX()
71606          arg=Symbol(shape=(dim,),dim=dim)
71607          s=Vector(0,w)
71608          if dim==2:
71609            s[0]=(0.445276807175)*x[0]+(-0.878942915065)*x[1]
71610            s[1]=(-0.0238953550121)*x[0]+(0.361680637262)*x[1]
71611            ref=(0.806957444436)
71612          else:
71613            s[0]=(0.0467419526691)*x[0]+(-0.00176696769735)*x[1]+(1.42280058205)*x[2]
71614            s[1]=(0.184131344951)*x[0]+(0.64372416222)*x[1]+(-1.33372814614)*x[2]
71615            s[2]=(0.284337855687)*x[0]+(-0.185747325055)*x[1]+(0.328830085951)*x[2]
71616            ref=(1.01929620084)
71617          res=div(arg,where=w_ref)
71618          sub=res.substitute({arg:s})
71619          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71620          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71621          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71622          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71623       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71624       def test_div_onFunctionOnContactOne_fromData_ContinuousFunction(self):
71625          """
71626          tests divergence of Data on the FunctionOnContactOne
71627    
71628          assumptions: ContinuousFunction(self.domain) exists
71629                       self.domain supports div on FunctionOnContactOne
71630          """
71631          o=self.order
71632          dim=self.domain.getDim()
71633          w_ref=FunctionOnContactOne(self.domain)
71634          x_ref=w_ref.getX()
71635          w=ContinuousFunction(self.domain)
71636          x=w.getX()
71637          arg=Vector(0,w)
71638          if dim==2:
71639            arg[0]=(-0.506403770066)*x[0]**o+(0.32584268281)*x[0]+(-0.83529844868)*x[1]**o+(0.83697332673)*x[1]
71640            arg[1]=(-0.85254932286)*x[0]**o+(0.751060747065)*x[0]+(-0.672601723159)*x[1]**o+(0.33751172176)*x[1]
71641            ref=o*(-0.506403770066)*x_ref[0]**(o-1)+o*(-0.672601723159)*x_ref[1]**(o-1)+(0.66335440457)
71642          else:
71643            arg[0]=(-0.437811901761)*x[0]**o+(-0.135276240019)*x[0]+(0.683969739116)*x[1]**o+(-0.207547375093)*x[1]+(0.028594861031)*x[2]**o+(0.721966907461)*x[2]
71644            arg[1]=(0.315283027578)*x[0]**o+(0.724158692434)*x[0]+(-0.746372201791)*x[1]**o+(-0.370798791131)*x[1]+(-0.677893413238)*x[2]**o+(0.645317237187)*x[2]
71645            arg[2]=(0.0795681320657)*x[0]**o+(-0.165210743397)*x[0]+(0.866175461075)*x[1]**o+(0.10183311172)*x[1]+(-0.642389179022)*x[2]**o+(-0.917391184653)*x[2]
71646            ref=o*(-0.437811901761)*x_ref[0]**(o-1)+o*(-0.746372201791)*x_ref[1]**(o-1)+o*(-0.642389179022)*x_ref[2]**(o-1)+(-1.4234662158)
71647          res=div(arg,where=w_ref)
71648          self.failUnless(isinstance(res,Data),"wrong type of result.")
71649          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71650          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71651          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71652       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71653       def test_div_onFunctionOnContactOne_fromData_Solution(self):
71654          """
71655          tests divergence of Data on the FunctionOnContactOne
71656    
71657          assumptions: Solution(self.domain) exists
71658                       self.domain supports div on FunctionOnContactOne
71659          """
71660          o=self.order
71661          dim=self.domain.getDim()
71662          w_ref=FunctionOnContactOne(self.domain)
71663          x_ref=w_ref.getX()
71664          w=Solution(self.domain)
71665          x=w.getX()
71666          arg=Vector(0,w)
71667          if dim==2:
71668            arg[0]=(0.46385553428)*x[0]**o+(-0.91930502543)*x[0]+(0.316745110613)*x[1]**o+(-0.0996899204895)*x[1]
71669            arg[1]=(-0.473415736992)*x[0]**o+(0.514718374433)*x[0]+(-0.473429315265)*x[1]**o+(-0.194316615233)*x[1]
71670            ref=o*(0.46385553428)*x_ref[0]**(o-1)+o*(-0.473429315265)*x_ref[1]**(o-1)+(-1.11362164066)
71671          else:
71672            arg[0]=(0.740236725813)*x[0]**o+(0.887898498849)*x[0]+(-0.44803045798)*x[1]**o+(0.160930903094)*x[1]+(-0.530527194219)*x[2]**o+(0.0622347651074)*x[2]
71673            arg[1]=(0.36748785661)*x[0]**o+(-0.618052241987)*x[0]+(-0.57186325537)*x[1]**o+(-0.180576934525)*x[1]+(-0.381568503551)*x[2]**o+(0.0356882174068)*x[2]
71674            arg[2]=(0.070144257808)*x[0]**o+(0.823052625211)*x[0]+(-0.426522615959)*x[1]**o+(-0.294700653199)*x[1]+(0.209922433427)*x[2]**o+(-0.532056800218)*x[2]
71675            ref=o*(0.740236725813)*x_ref[0]**(o-1)+o*(-0.57186325537)*x_ref[1]**(o-1)+o*(0.209922433427)*x_ref[2]**(o-1)+(0.175264764106)
71676          res=div(arg,where=w_ref)
71677          self.failUnless(isinstance(res,Data),"wrong type of result.")
71678          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71679          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71680          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71681       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71682       def test_div_onFunctionOnContactOne_fromData_ReducedSolution(self):
71683          """
71684          tests divergence of Data on the FunctionOnContactOne
71685    
71686          assumptions: ReducedSolution(self.domain) exists
71687                       self.domain supports div on FunctionOnContactOne
71688          """
71689          o=1
71690          dim=self.domain.getDim()
71691          w_ref=FunctionOnContactOne(self.domain)
71692          x_ref=w_ref.getX()
71693          w=ReducedSolution(self.domain)
71694          x=w.getX()
71695          arg=Vector(0,w)
71696          if dim==2:
71697            arg[0]=(0.0337229572599)*x[0]+(0.820391566535)*x[1]
71698            arg[1]=(0.640567267185)*x[0]+(1.03537999206)*x[1]
71699            ref=(1.06910294932)
71700          else:
71701            arg[0]=(-0.0797501374913)*x[0]+(-0.798826730006)*x[1]+(-0.590979881432)*x[2]
71702            arg[1]=(-0.414547879032)*x[0]+(0.845538994985)*x[1]+(-1.21203164133)*x[2]
71703            arg[2]=(-0.438232052406)*x[0]+(-0.35977163998)*x[1]+(-1.01489636413)*x[2]
71704            ref=(-0.249107506635)
71705          res=div(arg,where=w_ref)
71706          self.failUnless(isinstance(res,Data),"wrong type of result.")
71707          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71708          self.failUnlessEqual(res.getFunctionSpace(),w_ref,"wrong function space of result.")
71709          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71710       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71711       def test_div_onFunctionOnContactOne_fromSymbol_ContinuousFunction(self):
71712          """
71713          tests divergence of Symbol on the FunctionOnContactOne
71714    
71715          assumptions: ContinuousFunction(self.domain) exists
71716                       self.domain supports div on FunctionOnContactOne
71717          """
71718          o=self.order
71719          dim=self.domain.getDim()
71720          w_ref=FunctionOnContactOne(self.domain)
71721          x_ref=w_ref.getX()
71722          w=ContinuousFunction(self.domain)
71723          x=w.getX()
71724          arg=Symbol(shape=(dim,),dim=dim)
71725          s=Vector(0,w)
71726          if dim==2:
71727            s[0]=(-0.0898941553957)*x[0]**o+(-0.856300995796)*x[0]+(0.348298533454)*x[1]**o+(0.0351975574428)*x[1]
71728            s[1]=(-0.930316249846)*x[0]**o+(-0.0295682442002)*x[0]+(-0.648381042093)*x[1]**o+(0.0737127687654)*x[1]
71729            ref=o*(-0.0898941553957)*x_ref[0]**(o-1)+o*(-0.648381042093)*x_ref[1]**(o-1)+(-0.782588227031)
71730          else:
71731            s[0]=(-0.163987987624)*x[0]**o+(-0.511857517274)*x[0]+(0.741666372996)*x[1]**o+(0.496640177195)*x[1]+(0.460061066559)*x[2]**o+(-0.558420509462)*x[2]
71732            s[1]=(0.71525289068)*x[0]**o+(0.886545582)*x[0]+(-0.904766629428)*x[1]**o+(0.146361771148)*x[1]+(0.570424059304)*x[2]**o+(0.305997230748)*x[2]
71733            s[2]=(0.615370647779)*x[0]**o+(0.471712532771)*x[0]+(0.570468738833)*x[1]**o+(-0.728014206718)*x[1]+(-0.38659264723)*x[2]**o+(0.717051171147)*x[2]
71734            ref=o*(-0.163987987624)*x_ref[0]**(o-1)+o*(-0.904766629428)*x_ref[1]**(o-1)+o*(-0.38659264723)*x_ref[2]**(o-1)+(0.351555425021)
71735          res=div(arg,where=w_ref)
71736          sub=res.substitute({arg:s})
71737          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71738          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71739          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71740          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71741       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71742       def test_div_onFunctionOnContactOne_fromSymbol_Solution(self):
71743          """
71744          tests divergence of Symbol on the FunctionOnContactOne
71745    
71746          assumptions: Solution(self.domain) exists
71747                       self.domain supports div on FunctionOnContactOne
71748          """
71749          o=self.order
71750          dim=self.domain.getDim()
71751          w_ref=FunctionOnContactOne(self.domain)
71752          x_ref=w_ref.getX()
71753          w=Solution(self.domain)
71754          x=w.getX()
71755          arg=Symbol(shape=(dim,),dim=dim)
71756          s=Vector(0,w)
71757          if dim==2:
71758            s[0]=(0.194773312667)*x[0]**o+(-0.265468977683)*x[0]+(-0.0352177899992)*x[1]**o+(0.463717858721)*x[1]
71759            s[1]=(0.139203691371)*x[0]**o+(-0.799672510649)*x[0]+(-0.367277227148)*x[1]**o+(0.111274990466)*x[1]
71760            ref=o*(0.194773312667)*x_ref[0]**(o-1)+o*(-0.367277227148)*x_ref[1]**(o-1)+(-0.154193987217)
71761          else:
71762            s[0]=(0.0505125806914)*x[0]**o+(0.149858893872)*x[0]+(-0.095881973707)*x[1]**o+(-0.850488788785)*x[1]+(-0.0110026442959)*x[2]**o+(-0.407209597266)*x[2]
71763            s[1]=(0.72998229305)*x[0]**o+(0.745287781387)*x[0]+(-0.940255747769)*x[1]**o+(0.67408292569)*x[1]+(-0.149905927735)*x[2]**o+(0.0681385797299)*x[2]
71764            s[2]=(-0.314939233587)*x[0]**o+(0.716212656447)*x[0]+(-0.78946710376)*x[1]**o+(-0.867972385662)*x[1]+(0.299407109746)*x[2]**o+(-0.601525689779)*x[2]
71765            ref=o*(0.0505125806914)*x_ref[0]**(o-1)+o*(-0.940255747769)*x_ref[1]**(o-1)+o*(0.299407109746)*x_ref[2]**(o-1)+(0.222416129783)
71766          res=div(arg,where=w_ref)
71767          sub=res.substitute({arg:s})
71768          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71769          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71770          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71771          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71772       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71773       def test_div_onFunctionOnContactOne_fromSymbol_ReducedSolution(self):
71774          """
71775          tests divergence of Symbol on the FunctionOnContactOne
71776    
71777          assumptions: ReducedSolution(self.domain) exists
71778                       self.domain supports div on FunctionOnContactOne
71779          """
71780          o=1
71781          dim=self.domain.getDim()
71782          w_ref=FunctionOnContactOne(self.domain)
71783          x_ref=w_ref.getX()
71784          w=ReducedSolution(self.domain)
71785          x=w.getX()
71786          arg=Symbol(shape=(dim,),dim=dim)
71787          s=Vector(0,w)
71788          if dim==2:
71789            s[0]=(-0.98773096396)*x[0]+(0.381969528266)*x[1]
71790            s[1]=(0.508967927604)*x[0]+(0.742652762961)*x[1]
71791            ref=(-0.245078200999)
71792          else:
71793            s[0]=(0.0672222632785)*x[0]+(0.303873945969)*x[1]+(-0.471524980136)*x[2]
71794            s[1]=(0.63378224019)*x[0]+(-0.865690740572)*x[1]+(-0.0997380430882)*x[2]
71795            s[2]=(0.711173440054)*x[0]+(0.845130507211)*x[1]+(-1.10616823701)*x[2]
71796            ref=(-1.9046367143)
71797          res=div(arg,where=w_ref)
71798          sub=res.substitute({arg:s})
71799          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
71800          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
71801          self.failUnlessEqual(sub.getFunctionSpace(),w_ref,"wrong function space of result.")
71802          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
71803       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71804       def test_L2_onFunction_fromData_rank0(self):
71805          """
71806          tests L2-norm of Data on the Function
71807    
71808          assumptions: self.domain supports integration on Function
71809          """
71810          dim=self.domain.getDim()
71811          w=Function(self.domain)
71812          x=w.getX()
71813          if dim==2:
71814            arg=Data(0,(),w)
71815            arg=(0.608797336225)*x[0]
71816            ref=sqrt((0.123544732198))
71817    
71818          else:
71819            arg=Data(0,(),w)
71820            arg=(0.136031275673)*x[0]
71821            ref=sqrt((0.00616816932037))
71822    
71823          res=L2(arg)
71824          self.failUnless(isinstance(res,float),"wrong type of result.")
71825          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
71826       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71827       def test_L2_onFunction_fromData_rank1(self):
71828          """
71829          tests L2-norm of Data on the Function
71830    
71831          assumptions: self.domain supports integration on Function
71832          """
71833          dim=self.domain.getDim()
71834          w=Function(self.domain)
71835          x=w.getX()
71836          if dim==2:
71837            arg=Data(0,(2,),w)
71838            arg[0]=(-0.212143919436)*x[0]
71839            arg[1]=(-0.256194155686)*x[1]
71840            ref=sqrt((0.0368801626538))
71841    
71842          else:
71843            arg=Data(0,(3,),w)
71844            arg[0]=(0.0452831341416)*x[0]
71845            arg[1]=(-0.278640180656)*x[1]
71846            arg[2]=(-0.607035001062)*x[2]
71847            ref=sqrt((0.149394135009))
71848    
71849          res=L2(arg)
71850          self.failUnless(isinstance(res,float),"wrong type of result.")
71851          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
71852       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71853       def test_L2_onFunction_fromData_rank2(self):
71854          """
71855          tests L2-norm of Data on the Function
71856    
71857          assumptions: self.domain supports integration on Function
71858          """
71859          dim=self.domain.getDim()
71860          w=Function(self.domain)
71861          x=w.getX()
71862          if dim==2:
71863            arg=Data(0,(4, 2),w)
71864            arg[0,0]=(0.239448813076)*x[0]
71865            arg[0,1]=(-0.529349708753)*x[1]
71866            arg[1,0]=(-0.381557161859)*x[0]
71867            arg[1,1]=(0.731658534249)*x[1]
71868            arg[2,0]=(-0.813679062342)*x[0]
71869            arg[2,1]=(0.528100089704)*x[1]
71870            arg[3,0]=(-0.480867528161)*x[0]
71871            arg[3,1]=(-0.167862206972)*x[1]
71872            ref=sqrt((0.739610516051))
71873    
71874          else:
71875            arg=Data(0,(4, 3),w)
71876            arg[0,0]=(0.951209543612)*x[0]
71877            arg[0,1]=(0.735178735637)*x[1]
71878            arg[0,2]=(0.13074673272)*x[2]
71879            arg[1,0]=(0.412295676715)*x[0]
71880            arg[1,1]=(-0.657695950153)*x[1]
71881            arg[1,2]=(-0.900044734695)*x[2]
71882            arg[2,0]=(0.741773926224)*x[0]
71883            arg[2,1]=(0.0521828807406)*x[1]
71884            arg[2,2]=(0.797728501985)*x[2]
71885            arg[3,0]=(-0.61235554051)*x[0]
71886            arg[3,1]=(0.456652747412)*x[1]
71887            arg[3,2]=(-0.734303857319)*x[2]
71888            ref=sqrt((1.72901661926))
71889    
71890          res=L2(arg)
71891          self.failUnless(isinstance(res,float),"wrong type of result.")
71892          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
71893       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71894       def test_L2_onFunction_fromData_rank3(self):
71895          """
71896          tests L2-norm of Data on the Function
71897    
71898          assumptions: self.domain supports integration on Function
71899          """
71900          dim=self.domain.getDim()
71901          w=Function(self.domain)
71902          x=w.getX()
71903          if dim==2:
71904            arg=Data(0,(6, 2, 2),w)
71905            arg[0,0,0]=(0.449174971953)*x[0]
71906            arg[0,0,1]=(-0.0109398763289)*x[1]
71907            arg[0,1,0]=(-0.202497187709)*x[0]
71908            arg[0,1,1]=(-0.12970879334)*x[1]
71909            arg[1,0,0]=(-0.138092481719)*x[0]
71910            arg[1,0,1]=(-0.528752200917)*x[1]
71911            arg[1,1,0]=(-0.605919441662)*x[0]
71912            arg[1,1,1]=(0.215615032334)*x[1]
71913            arg[2,0,0]=(-0.998734541972)*x[0]
71914            arg[2,0,1]=(0.725811901251)*x[1]
71915            arg[2,1,0]=(-0.966536503228)*x[0]
71916            arg[2,1,1]=(-0.528692217355)*x[1]
71917            arg[3,0,0]=(0.757633851466)*x[0]
71918            arg[3,0,1]=(-0.524660157377)*x[1]
71919            arg[3,1,0]=(0.983733431677)*x[0]
71920            arg[3,1,1]=(0.061279109546)*x[1]
71921            arg[4,0,0]=(0.85914215305)*x[0]
71922            arg[4,0,1]=(0.941714045112)*x[1]
71923            arg[4,1,0]=(0.172235529555)*x[0]
71924            arg[4,1,1]=(-0.108381454437)*x[1]
71925            arg[5,0,0]=(-0.736373697727)*x[0]
71926            arg[5,0,1]=(-0.599337929679)*x[1]
71927            arg[5,1,0]=(0.661072686392)*x[0]
71928            arg[5,1,1]=(-0.55107327409)*x[1]
71929            ref=sqrt((2.94641432714))
71930    
71931          else:
71932            arg=Data(0,(6, 2, 3),w)
71933            arg[0,0,0]=(0.69227064904)*x[0]
71934            arg[0,0,1]=(-0.968336177418)*x[1]
71935            arg[0,0,2]=(-0.634883146685)*x[2]
71936            arg[0,1,0]=(-0.12640661422)*x[0]
71937            arg[0,1,1]=(-0.637386589888)*x[1]
71938            arg[0,1,2]=(0.26060859356)*x[2]
71939            arg[1,0,0]=(-0.986864633297)*x[0]
71940            arg[1,0,1]=(-0.441589142379)*x[1]
71941            arg[1,0,2]=(-0.587865539582)*x[2]
71942            arg[1,1,0]=(0.596052465031)*x[0]
71943            arg[1,1,1]=(0.312732336652)*x[1]
71944            arg[1,1,2]=(-0.514423945092)*x[2]
71945            arg[2,0,0]=(-0.892391254794)*x[0]
71946            arg[2,0,1]=(0.377920185756)*x[1]
71947            arg[2,0,2]=(-0.120174597181)*x[2]
71948            arg[2,1,0]=(-0.469951576468)*x[0]
71949            arg[2,1,1]=(-0.788362249555)*x[1]
71950            arg[2,1,2]=(0.745625354986)*x[2]
71951            arg[3,0,0]=(0.542802498569)*x[0]
71952            arg[3,0,1]=(-0.814541028706)*x[1]
71953            arg[3,0,2]=(0.298410992196)*x[2]
71954            arg[3,1,0]=(0.981190341206)*x[0]
71955            arg[3,1,1]=(0.666421298608)*x[1]
71956            arg[3,1,2]=(-0.369751722626)*x[2]
71957            arg[4,0,0]=(-0.75379530597)*x[0]
71958            arg[4,0,1]=(0.283357267139)*x[1]
71959            arg[4,0,2]=(0.247787072861)*x[2]
71960            arg[4,1,0]=(0.301766692533)*x[0]
71961            arg[4,1,1]=(0.828183439224)*x[1]
71962            arg[4,1,2]=(-0.580824060547)*x[2]
71963            arg[5,0,0]=(0.637345610764)*x[0]
71964            arg[5,0,1]=(-0.234409115997)*x[1]
71965            arg[5,0,2]=(-0.192639300316)*x[2]
71966            arg[5,1,0]=(-0.62609237162)*x[0]
71967            arg[5,1,1]=(0.463404958552)*x[1]
71968            arg[5,1,2]=(-0.547814448738)*x[2]
71969            ref=sqrt((4.2381131862))
71970    
71971          res=L2(arg)
71972          self.failUnless(isinstance(res,float),"wrong type of result.")
71973          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
71974       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
71975       def test_L2_onFunction_fromData_rank4(self):
71976          """
71977          tests L2-norm of Data on the Function
71978    
71979          assumptions: self.domain supports integration on Function
71980          """
71981          dim=self.domain.getDim()
71982          w=Function(self.domain)
71983          x=w.getX()
71984          if dim==2:
71985            arg=Data(0,(4, 5, 3, 2),w)
71986            arg[0,0,0,0]=(-0.232618585183)*x[0]
71987            arg[0,0,0,1]=(0.39796117869)*x[1]
71988            arg[0,0,1,0]=(-0.997336958262)*x[0]
71989            arg[0,0,1,1]=(-0.351780915076)*x[1]
71990            arg[0,0,2,0]=(-0.876764070136)*x[0]
71991            arg[0,0,2,1]=(0.808730805817)*x[1]
71992            arg[0,1,0,0]=(-0.197154744966)*x[0]
71993            arg[0,1,0,1]=(0.416246096086)*x[1]
71994            arg[0,1,1,0]=(0.708038457121)*x[0]
71995            arg[0,1,1,1]=(-0.00954021503188)*x[1]
71996            arg[0,1,2,0]=(-0.62630809425)*x[0]
71997            arg[0,1,2,1]=(0.430228727912)*x[1]
71998            arg[0,2,0,0]=(0.0306704747648)*x[0]
71999            arg[0,2,0,1]=(-0.913877199453)*x[1]
72000            arg[0,2,1,0]=(-0.697612800829)*x[0]
72001            arg[0,2,1,1]=(-0.17996376822)*x[1]
72002            arg[0,2,2,0]=(-0.304509578871)*x[0]
72003            arg[0,2,2,1]=(-0.610556755811)*x[1]
72004            arg[0,3,0,0]=(-0.452355972234)*x[0]
72005            arg[0,3,0,1]=(-0.368921242518)*x[1]
72006            arg[0,3,1,0]=(-0.478275554932)*x[0]
72007            arg[0,3,1,1]=(0.257178549127)*x[1]
72008            arg[0,3,2,0]=(0.530736487177)*x[0]
72009            arg[0,3,2,1]=(-0.567126272463)*x[1]
72010            arg[0,4,0,0]=(0.801519165938)*x[0]
72011            arg[0,4,0,1]=(-0.509816703951)*x[1]
72012            arg[0,4,1,0]=(-0.255412646934)*x[0]
72013            arg[0,4,1,1]=(0.437540101896)*x[1]
72014            arg[0,4,2,0]=(-0.815574969538)*x[0]
72015            arg[0,4,2,1]=(-0.94691547137)*x[1]
72016            arg[1,0,0,0]=(-0.732550722593)*x[0]
72017            arg[1,0,0,1]=(0.515752381704)*x[1]
72018            arg[1,0,1,0]=(-0.343590210899)*x[0]
72019            arg[1,0,1,1]=(-0.0601907964915)*x[1]
72020            arg[1,0,2,0]=(0.0199916154421)*x[0]
72021            arg[1,0,2,1]=(-0.136927227821)*x[1]
72022            arg[1,1,0,0]=(0.397994441702)*x[0]
72023            arg[1,1,0,1]=(0.953873148948)*x[1]
72024            arg[1,1,1,0]=(0.419416235967)*x[0]
72025            arg[1,1,1,1]=(0.700998577193)*x[1]
72026            arg[1,1,2,0]=(-0.497358799271)*x[0]
72027            arg[1,1,2,1]=(0.0851768858379)*x[1]
72028            arg[1,2,0,0]=(0.0936678875202)*x[0]
72029            arg[1,2,0,1]=(0.869883786896)*x[1]
72030            arg[1,2,1,0]=(0.582700123485)*x[0]
72031            arg[1,2,1,1]=(-0.433381106794)*x[1]
72032            arg[1,2,2,0]=(-0.527031777974)*x[0]
72033            arg[1,2,2,1]=(0.105105137652)*x[1]
72034            arg[1,3,0,0]=(-0.716750829134)*x[0]
72035            arg[1,3,0,1]=(0.774519209008)*x[1]
72036            arg[1,3,1,0]=(-0.568743372716)*x[0]
72037            arg[1,3,1,1]=(0.794732483944)*x[1]
72038            arg[1,3,2,0]=(0.246606002015)*x[0]
72039            arg[1,3,2,1]=(-0.988869494994)*x[1]
72040            arg[1,4,0,0]=(0.482379298083)*x[0]
72041            arg[1,4,0,1]=(-0.386268387903)*x[1]
72042            arg[1,4,1,0]=(0.137184889675)*x[0]
72043            arg[1,4,1,1]=(-0.140520035321)*x[1]
72044            arg[1,4,2,0]=(0.822755050415)*x[0]
72045            arg[1,4,2,1]=(-0.815562139522)*x[1]
72046            arg[2,0,0,0]=(-0.462891511962)*x[0]
72047            arg[2,0,0,1]=(-0.122643411631)*x[1]
72048            arg[2,0,1,0]=(-0.520861119962)*x[0]
72049            arg[2,0,1,1]=(-0.881189618018)*x[1]
72050            arg[2,0,2,0]=(-0.776157842774)*x[0]
72051            arg[2,0,2,1]=(-0.12354053207)*x[1]
72052            arg[2,1,0,0]=(0.395495230826)*x[0]
72053            arg[2,1,0,1]=(-0.388106659423)*x[1]
72054            arg[2,1,1,0]=(0.354250242834)*x[0]
72055            arg[2,1,1,1]=(-0.666514210192)*x[1]
72056            arg[2,1,2,0]=(0.951294655083)*x[0]
72057            arg[2,1,2,1]=(0.074024416386)*x[1]
72058            arg[2,2,0,0]=(0.335448485459)*x[0]
72059            arg[2,2,0,1]=(-0.40988282528)*x[1]
72060            arg[2,2,1,0]=(-0.805725968875)*x[0]
72061            arg[2,2,1,1]=(-0.949883082118)*x[1]
72062            arg[2,2,2,0]=(0.531549210683)*x[0]
72063            arg[2,2,2,1]=(-0.398401016682)*x[1]
72064            arg[2,3,0,0]=(-0.953963433205)*x[0]
72065            arg[2,3,0,1]=(0.643431126406)*x[1]
72066            arg[2,3,1,0]=(-0.167611998738)*x[0]
72067            arg[2,3,1,1]=(0.226130056552)*x[1]
72068            arg[2,3,2,0]=(0.0752687641131)*x[0]
72069            arg[2,3,2,1]=(-0.115742756362)*x[1]
72070            arg[2,4,0,0]=(0.579694491028)*x[0]
72071            arg[2,4,0,1]=(-0.112005738299)*x[1]
72072            arg[2,4,1,0]=(0.657291764224)*x[0]
72073            arg[2,4,1,1]=(0.62671154177)*x[1]
72074            arg[2,4,2,0]=(0.103695027944)*x[0]
72075            arg[2,4,2,1]=(0.462828491544)*x[1]
72076            arg[3,0,0,0]=(0.697692979998)*x[0]
72077            arg[3,0,0,1]=(-0.123481859619)*x[1]
72078            arg[3,0,1,0]=(-0.749745629459)*x[0]
72079            arg[3,0,1,1]=(-0.541969524069)*x[1]
72080            arg[3,0,2,0]=(0.819484470759)*x[0]
72081            arg[3,0,2,1]=(-0.860592326469)*x[1]
72082            arg[3,1,0,0]=(-0.716566084771)*x[0]
72083            arg[3,1,0,1]=(-0.949235434827)*x[1]
72084            arg[3,1,1,0]=(-0.826699498174)*x[0]
72085            arg[3,1,1,1]=(-0.138511521583)*x[1]
72086            arg[3,1,2,0]=(-0.951682890904)*x[0]
72087            arg[3,1,2,1]=(0.413293316925)*x[1]
72088            arg[3,2,0,0]=(0.909516836775)*x[0]
72089            arg[3,2,0,1]=(-0.919989721277)*x[1]
72090            arg[3,2,1,0]=(0.0994860369337)*x[0]
72091            arg[3,2,1,1]=(-0.933647246623)*x[1]
72092            arg[3,2,2,0]=(-0.759215183015)*x[0]
72093            arg[3,2,2,1]=(0.0975793309286)*x[1]
72094            arg[3,3,0,0]=(-0.130256739381)*x[0]
72095            arg[3,3,0,1]=(-0.582280862311)*x[1]
72096            arg[3,3,1,0]=(0.206970526192)*x[0]
72097            arg[3,3,1,1]=(-0.8678322258)*x[1]
72098            arg[3,3,2,0]=(0.133004501279)*x[0]
72099            arg[3,3,2,1]=(0.802921710935)*x[1]
72100            arg[3,4,0,0]=(-0.255737792764)*x[0]
72101            arg[3,4,0,1]=(-0.34168114937)*x[1]
72102            arg[3,4,1,0]=(-0.859309090399)*x[0]
72103            arg[3,4,1,1]=(0.245043986435)*x[1]
72104            arg[3,4,2,0]=(0.893062018695)*x[0]
72105            arg[3,4,2,1]=(0.709422742588)*x[1]
72106            ref=sqrt((13.7289280362))
72107    
72108          else:
72109            arg=Data(0,(4, 5, 3, 3),w)
72110            arg[0,0,0,0]=(0.0312828390439)*x[0]
72111            arg[0,0,0,1]=(-0.524970416212)*x[1]
72112            arg[0,0,0,2]=(0.561865217554)*x[2]
72113            arg[0,0,1,0]=(0.692457187384)*x[0]
72114            arg[0,0,1,1]=(0.946967182157)*x[1]
72115            arg[0,0,1,2]=(-0.863842279464)*x[2]
72116            arg[0,0,2,0]=(0.993922921598)*x[0]
72117            arg[0,0,2,1]=(0.322812768679)*x[1]
72118            arg[0,0,2,2]=(0.901876132204)*x[2]
72119            arg[0,1,0,0]=(0.967569979365)*x[0]
72120            arg[0,1,0,1]=(0.840979131355)*x[1]
72121            arg[0,1,0,2]=(0.0494811460856)*x[2]
72122            arg[0,1,1,0]=(0.315178456102)*x[0]
72123            arg[0,1,1,1]=(0.449848313024)*x[1]
72124            arg[0,1,1,2]=(0.765887852886)*x[2]
72125            arg[0,1,2,0]=(0.975541574352)*x[0]
72126            arg[0,1,2,1]=(-0.797851290751)*x[1]
72127            arg[0,1,2,2]=(0.628918775319)*x[2]
72128            arg[0,2,0,0]=(0.685635794312)*x[0]
72129            arg[0,2,0,1]=(0.10341799962)*x[1]
72130            arg[0,2,0,2]=(-0.964822756043)*x[2]
72131            arg[0,2,1,0]=(-0.56160368212)*x[0]
72132            arg[0,2,1,1]=(0.676344298102)*x[1]
72133            arg[0,2,1,2]=(-0.713924121843)*x[2]
72134            arg[0,2,2,0]=(-0.276655136263)*x[0]
72135            arg[0,2,2,1]=(0.336046973788)*x[1]
72136            arg[0,2,2,2]=(-0.68789392396)*x[2]
72137            arg[0,3,0,0]=(0.0172861311571)*x[0]
72138            arg[0,3,0,1]=(-0.301075956456)*x[1]
72139            arg[0,3,0,2]=(0.779442985415)*x[2]
72140            arg[0,3,1,0]=(-0.517629576558)*x[0]
72141            arg[0,3,1,1]=(0.584779586639)*x[1]
72142            arg[0,3,1,2]=(-0.53266435436)*x[2]
72143            arg[0,3,2,0]=(0.841533567102)*x[0]
72144            arg[0,3,2,1]=(0.0458746415489)*x[1]
72145            arg[0,3,2,2]=(0.921237870758)*x[2]
72146            arg[0,4,0,0]=(0.0548343238805)*x[0]
72147            arg[0,4,0,1]=(0.687022707412)*x[1]
72148            arg[0,4,0,2]=(-0.319803609795)*x[2]
72149            arg[0,4,1,0]=(0.409763007811)*x[0]
72150            arg[0,4,1,1]=(0.165501957435)*x[1]
72151            arg[0,4,1,2]=(0.116001692781)*x[2]
72152            arg[0,4,2,0]=(-0.515571394238)*x[0]
72153            arg[0,4,2,1]=(0.209467945147)*x[1]
72154            arg[0,4,2,2]=(-0.344827191247)*x[2]
72155            arg[1,0,0,0]=(0.57193838014)*x[0]
72156            arg[1,0,0,1]=(-0.0880683799076)*x[1]
72157            arg[1,0,0,2]=(0.956899617441)*x[2]
72158            arg[1,0,1,0]=(-0.783689636357)*x[0]
72159            arg[1,0,1,1]=(-0.25177506885)*x[1]
72160            arg[1,0,1,2]=(-0.97074584634)*x[2]
72161            arg[1,0,2,0]=(0.432543519806)*x[0]
72162            arg[1,0,2,1]=(0.481003021954)*x[1]
72163            arg[1,0,2,2]=(-0.0630751518268)*x[2]
72164            arg[1,1,0,0]=(-0.65152446796)*x[0]
72165            arg[1,1,0,1]=(-0.0323685084425)*x[1]
72166            arg[1,1,0,2]=(-0.508674033909)*x[2]
72167            arg[1,1,1,0]=(-0.533367818916)*x[0]
72168            arg[1,1,1,1]=(0.310738340288)*x[1]
72169            arg[1,1,1,2]=(0.694612234326)*x[2]
72170            arg[1,1,2,0]=(-0.622052473032)*x[0]
72171            arg[1,1,2,1]=(0.0498443793671)*x[1]
72172            arg[1,1,2,2]=(0.61023707512)*x[2]
72173            arg[1,2,0,0]=(0.0730267406859)*x[0]
72174            arg[1,2,0,1]=(0.146909334607)*x[1]
72175            arg[1,2,0,2]=(-0.641860284448)*x[2]
72176            arg[1,2,1,0]=(0.917976589737)*x[0]
72177            arg[1,2,1,1]=(0.50219672122)*x[1]
72178            arg[1,2,1,2]=(0.634559579812)*x[2]
72179            arg[1,2,2,0]=(0.0578772734534)*x[0]
72180            arg[1,2,2,1]=(0.288730973517)*x[1]
72181            arg[1,2,2,2]=(-0.0525978796154)*x[2]
72182            arg[1,3,0,0]=(-0.926152433388)*x[0]
72183            arg[1,3,0,1]=(0.0616647680855)*x[1]
72184            arg[1,3,0,2]=(-0.875889217846)*x[2]
72185            arg[1,3,1,0]=(-0.638931542845)*x[0]
72186            arg[1,3,1,1]=(0.708848122964)*x[1]
72187            arg[1,3,1,2]=(0.119066979792)*x[2]
72188            arg[1,3,2,0]=(0.853716218591)*x[0]
72189            arg[1,3,2,1]=(-0.92754322201)*x[1]
72190            arg[1,3,2,2]=(-0.671530626265)*x[2]
72191            arg[1,4,0,0]=(0.337424536231)*x[0]
72192            arg[1,4,0,1]=(0.335704451719)*x[1]
72193            arg[1,4,0,2]=(-0.484565969466)*x[2]
72194            arg[1,4,1,0]=(-0.855476192012)*x[0]
72195            arg[1,4,1,1]=(0.405674615553)*x[1]
72196            arg[1,4,1,2]=(0.728310771323)*x[2]
72197            arg[1,4,2,0]=(0.363651308265)*x[0]
72198            arg[1,4,2,1]=(0.174460594531)*x[1]
72199            arg[1,4,2,2]=(-0.0418244838617)*x[2]
72200            arg[2,0,0,0]=(-0.531341992511)*x[0]
72201            arg[2,0,0,1]=(0.584996796272)*x[1]
72202            arg[2,0,0,2]=(-0.752430968716)*x[2]
72203            arg[2,0,1,0]=(-0.341989849747)*x[0]
72204            arg[2,0,1,1]=(0.153572646953)*x[1]
72205            arg[2,0,1,2]=(-0.197130051737)*x[2]
72206            arg[2,0,2,0]=(-0.338082424082)*x[0]
72207            arg[2,0,2,1]=(0.000173657394772)*x[1]
72208            arg[2,0,2,2]=(0.365272907692)*x[2]
72209            arg[2,1,0,0]=(0.904304126564)*x[0]
72210            arg[2,1,0,1]=(0.161252368484)*x[1]
72211            arg[2,1,0,2]=(0.246854092422)*x[2]
72212            arg[2,1,1,0]=(-0.299880647529)*x[0]
72213            arg[2,1,1,1]=(-0.566917528608)*x[1]
72214            arg[2,1,1,2]=(0.243183337285)*x[2]
72215            arg[2,1,2,0]=(0.437406011474)*x[0]
72216            arg[2,1,2,1]=(0.727447394053)*x[1]
72217            arg[2,1,2,2]=(0.380752950664)*x[2]
72218            arg[2,2,0,0]=(0.172292846911)*x[0]
72219            arg[2,2,0,1]=(0.334201791643)*x[1]
72220            arg[2,2,0,2]=(0.739989926962)*x[2]
72221            arg[2,2,1,0]=(-0.0669843715042)*x[0]
72222            arg[2,2,1,1]=(-0.540497281635)*x[1]
72223            arg[2,2,1,2]=(-0.744217027088)*x[2]
72224            arg[2,2,2,0]=(-0.287295952259)*x[0]
72225            arg[2,2,2,1]=(-0.512411849183)*x[1]
72226            arg[2,2,2,2]=(0.953107417666)*x[2]
72227            arg[2,3,0,0]=(0.998168116695)*x[0]
72228            arg[2,3,0,1]=(0.960065646359)*x[1]
72229            arg[2,3,0,2]=(0.110048258832)*x[2]
72230            arg[2,3,1,0]=(-0.477271134724)*x[0]
72231            arg[2,3,1,1]=(0.707182612251)*x[1]
72232            arg[2,3,1,2]=(0.285500891755)*x[2]
72233            arg[2,3,2,0]=(-0.863497506661)*x[0]
72234            arg[2,3,2,1]=(-0.293917669879)*x[1]
72235            arg[2,3,2,2]=(-0.403384244295)*x[2]
72236            arg[2,4,0,0]=(0.848455277702)*x[0]
72237            arg[2,4,0,1]=(-0.530101455578)*x[1]
72238            arg[2,4,0,2]=(0.33887313048)*x[2]
72239            arg[2,4,1,0]=(-0.195313538124)*x[0]
72240            arg[2,4,1,1]=(-0.62754572008)*x[1]
72241            arg[2,4,1,2]=(-0.385132960582)*x[2]
72242            arg[2,4,2,0]=(0.240048012886)*x[0]
72243            arg[2,4,2,1]=(0.900766252969)*x[1]
72244            arg[2,4,2,2]=(0.669620533505)*x[2]
72245            arg[3,0,0,0]=(0.375766827301)*x[0]
72246            arg[3,0,0,1]=(0.705484960308)*x[1]
72247            arg[3,0,0,2]=(0.440931516034)*x[2]
72248            arg[3,0,1,0]=(-0.44724403177)*x[0]
72249            arg[3,0,1,1]=(-0.31558249626)*x[1]
72250            arg[3,0,1,2]=(-0.00419436365172)*x[2]
72251            arg[3,0,2,0]=(0.750599752032)*x[0]
72252            arg[3,0,2,1]=(0.367649951795)*x[1]
72253            arg[3,0,2,2]=(0.0488013073654)*x[2]
72254            arg[3,1,0,0]=(-0.992890068274)*x[0]
72255            arg[3,1,0,1]=(0.671447745511)*x[1]
72256            arg[3,1,0,2]=(0.85613331404)*x[2]
72257            arg[3,1,1,0]=(-0.46064764242)*x[0]
72258            arg[3,1,1,1]=(0.48138877715)*x[1]
72259            arg[3,1,1,2]=(0.396741761803)*x[2]
72260            arg[3,1,2,0]=(-0.879391967543)*x[0]
72261            arg[3,1,2,1]=(-0.44039462138)*x[1]
72262            arg[3,1,2,2]=(0.0330511573872)*x[2]
72263            arg[3,2,0,0]=(-0.367413701648)*x[0]
72264            arg[3,2,0,1]=(0.0359818324891)*x[1]
72265            arg[3,2,0,2]=(-0.307532667032)*x[2]
72266            arg[3,2,1,0]=(0.334663597166)*x[0]
72267            arg[3,2,1,1]=(0.541941978066)*x[1]
72268            arg[3,2,1,2]=(-0.609184079318)*x[2]
72269            arg[3,2,2,0]=(0.359349239826)*x[0]
72270            arg[3,2,2,1]=(0.0419272305685)*x[1]
72271            arg[3,2,2,2]=(0.557189794296)*x[2]
72272            arg[3,3,0,0]=(-0.85864165554)*x[0]
72273            arg[3,3,0,1]=(-0.185411404213)*x[1]
72274            arg[3,3,0,2]=(0.254294865253)*x[2]
72275            arg[3,3,1,0]=(0.870362177541)*x[0]
72276            arg[3,3,1,1]=(-0.439688612864)*x[1]
72277            arg[3,3,1,2]=(0.26006729357)*x[2]
72278            arg[3,3,2,0]=(-0.0724034754175)*x[0]
72279            arg[3,3,2,1]=(0.444871564246)*x[1]
72280            arg[3,3,2,2]=(0.485634530531)*x[2]
72281            arg[3,4,0,0]=(-0.744756961758)*x[0]
72282            arg[3,4,0,1]=(0.429761406102)*x[1]
72283            arg[3,4,0,2]=(-0.584963735834)*x[2]
72284            arg[3,4,1,0]=(0.684578379159)*x[0]
72285            arg[3,4,1,1]=(0.949460132601)*x[1]
72286            arg[3,4,1,2]=(-0.592179909559)*x[2]
72287            arg[3,4,2,0]=(0.707154437797)*x[0]
72288            arg[3,4,2,1]=(0.619200407063)*x[1]
72289            arg[3,4,2,2]=(-0.338547165)*x[2]
72290            ref=sqrt((19.2170638478))
72291    
72292          res=L2(arg)
72293          self.failUnless(isinstance(res,float),"wrong type of result.")
72294          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
72295       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72296       def test_L2_onFunction_fromSymbol_rank0(self):
72297          """
72298          tests L2-norm of Symbol on the Function
72299    
72300          assumptions: self.domain supports integration on Function
72301          """
72302          dim=self.domain.getDim()
72303          w=Function(self.domain)
72304          x=w.getX()
72305          if dim==2:
72306            arg=Symbol(shape=(),dim=dim)
72307            s=Data(0,(),w)
72308            s=(-0.292546362165)*x[0]
72309            ref=sqrt((0.0285277913387))
72310    
72311          else:
72312            arg=Symbol(shape=(),dim=dim)
72313            s=Data(0,(),w)
72314            s=(0.751025585654)*x[0]
72315            ref=sqrt((0.188013143436))
72316    
72317          res=L2(arg)
72318          sub=res.substitute({arg:s})
72319          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
72320          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
72321          self.failUnlessAlmostEqual(sub,ref,int(-log10(self.RES_TOL)),"wrong result")
72322       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72323       def test_L2_onFunction_fromSymbol_rank1(self):
72324          """
72325          tests L2-norm of Symbol on the Function
72326    
72327          assumptions: self.domain supports integration on Function
72328          """
72329          dim=self.domain.getDim()
72330          w=Function(self.domain)
72331          x=w.getX()
72332          if dim==2:
72333            arg=Symbol(shape=(2,),dim=dim)
72334            s=Data(0,(2,),w)
72335            s[0]=(-0.1759467192)*x[0]
72336            s[1]=(0.37884376337)*x[1]
72337            ref=sqrt((0.0581599483473))
72338    
72339          else:
72340            arg=Symbol(shape=(3,),dim=dim)
72341            s=Data(0,(3,),w)
72342            s[0]=(-0.879259245697)*x[0]
72343            s[1]=(0.528911893259)*x[1]
72344            s[2]=(-0.751304571514)*x[2]
72345            ref=sqrt((0.539101057051))
72346    
72347          res=L2(arg)
72348          sub=res.substitute({arg:s})
72349          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
72350          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
72351          self.failUnlessAlmostEqual(sub,ref,int(-log10(self.RES_TOL)),"wrong result")
72352       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72353       def test_L2_onFunction_fromSymbol_rank2(self):
72354          """
72355          tests L2-norm of Symbol on the Function
72356    
72357          assumptions: self.domain supports integration on Function
72358          """
72359          dim=self.domain.getDim()
72360          w=Function(self.domain)
72361          x=w.getX()
72362          if dim==2:
72363            arg=Symbol(shape=(4, 2),dim=dim)
72364            s=Data(0,(4, 2),w)
72365            s[0,0]=(0.792724994628)*x[0]
72366            s[0,1]=(-0.662113166656)*x[1]
72367            s[1,0]=(-0.548842538341)*x[0]
72368            s[1,1]=(-0.555018478507)*x[1]
72369            s[2,0]=(0.42962640812)*x[0]
72370            s[2,1]=(-0.582731787726)*x[1]
72371            s[3,0]=(0.603890261621)*x[0]
72372            s[3,1]=(0.802141268835)*x[1]
72373            ref=sqrt((1.06944988539))
72374    
72375          else:
72376            arg=Symbol(shape=(4, 3),dim=dim)
72377            s=Data(0,(4, 3),w)
72378            s[0,0]=(-0.432893320336)*x[0]
72379            s[0,1]=(0.277328929482)*x[1]
72380            s[0,2]=(0.950129871073)*x[2]
72381            s[1,0]=(0.675116050333)*x[0]
72382            s[1,1]=(-0.234274111148)*x[1]
72383            s[1,2]=(-0.477441654222)*x[2]
72384            s[2,0]=(0.603834062829)*x[0]
72385            s[2,1]=(-0.606015016913)*x[1]
72386            s[2,2]=(0.637487308345)*x[2]
72387            s[3,0]=(-0.288536804159)*x[0]
72388            s[3,1]=(-0.442827019286)*x[1]
72389            s[3,2]=(-0.0978007221136)*x[2]
72390            ref=sqrt((1.11094846322))
72391    
72392          res=L2(arg)
72393          sub=res.substitute({arg:s})
72394          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
72395          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
72396          self.failUnlessAlmostEqual(sub,ref,int(-log10(self.RES_TOL)),"wrong result")
72397       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72398       def test_L2_onFunction_fromSymbol_rank3(self):
72399          """
72400          tests L2-norm of Symbol on the Function
72401    
72402          assumptions: self.domain supports integration on Function
72403          """
72404          dim=self.domain.getDim()
72405          w=Function(self.domain)
72406          x=w.getX()
72407          if dim==2:
72408            arg=Symbol(shape=(6, 2, 2),dim=dim)
72409            s=Data(0,(6, 2, 2),w)
72410            s[0,0,0]=(0.845216886022)*x[0]
72411            s[0,0,1]=(0.0597182977987)*x[1]
72412            s[0,1,0]=(0.146117477376)*x[0]
72413            s[0,1,1]=(0.918064672934)*x[1]
72414            s[1,0,0]=(-0.629068350604)*x[0]
72415            s[1,0,1]=(-0.116285587839)*x[1]
72416            s[1,1,0]=(0.678041887149)*x[0]
72417            s[1,1,1]=(-0.756045170867)*x[1]
72418            s[2,0,0]=(0.66884645591)*x[0]
72419            s[2,0,1]=(0.527297857958)*x[1]
72420            s[2,1,0]=(-0.453462310421)*x[0]
72421            s[2,1,1]=(-0.801421668573)*x[1]
72422            s[3,0,0]=(-0.418575000488)*x[0]
72423            s[3,0,1]=(0.977995539022)*x[1]
72424            s[3,1,0]=(0.863549457649)*x[0]
72425            s[3,1,1]=(0.975604004421)*x[1]
72426            s[4,0,0]=(0.642351898331)*x[0]
72427            s[4,0,1]=(-0.63624912796)*x[1]
72428            s[4,1,0]=(0.561260478169)*x[0]
72429            s[4,1,1]=(-0.942077895874)*x[1]
72430            s[5,0,0]=(0.0142173692077)*x[0]
72431            s[5,0,1]=(0.106312727314)*x[1]
72432            s[5,1,0]=(0.110676503653)*x[0]
72433            s[5,1,1]=(-0.534921324957)*x[1]
72434            ref=sqrt((3.25169916884))
72435    
72436          else:
72437            arg=Symbol(shape=(6, 2, 3),dim=dim)
72438            s=Data(0,(6, 2, 3),w)
72439            s[0,0,0]=(-0.351762958436)*x[0]
72440            s[0,0,1]=(0.797778461739)*x[1]
72441            s[0,0,2]=(-0.216759353067)*x[2]
72442            s[0,1,0]=(0.913252336442)*x[0]
72443            s[0,1,1]=(0.988076789445)*x[1]
72444            s[0,1,2]=(-0.901479800398)*x[2]
72445            s[1,0,0]=(0.179074582506)*x[0]
72446            s[1,0,1]=(-0.0198494753788)*x[1]
72447            s[1,0,2]=(0.453475519845)*x[2]
72448            s[1,1,0]=(0.0703079255814)*x[0]
72449            s[1,1,1]=(0.132531352932)*x[1]
72450            s[1,1,2]=(0.746319860866)*x[2]
72451            s[2,0,0]=(0.414228087724)*x[0]
72452            s[2,0,1]=(0.466702867918)*x[1]
72453            s[2,0,2]=(0.0868129987291)*x[2]
72454            s[2,1,0]=(0.903287212799)*x[0]
72455            s[2,1,1]=(0.912709008679)*x[1]
72456            s[2,1,2]=(-0.0365579422157)*x[2]
72457            s[3,0,0]=(0.0164686487169)*x[0]
72458            s[3,0,1]=(-0.914613841493)*x[1]
72459            s[3,0,2]=(-0.0822005463079)*x[2]
72460            s[3,1,0]=(-0.315907377871)*x[0]
72461            s[3,1,1]=(-0.102105289546)*x[1]
72462            s[3,1,2]=(-0.0353732873141)*x[2]
72463            s[4,0,0]=(0.0323628908944)*x[0]
72464            s[4,0,1]=(-0.954360115684)*x[1]
72465            s[4,0,2]=(0.923756483241)*x[2]
72466            s[4,1,0]=(0.980063248251)*x[0]
72467            s[4,1,1]=(0.0664804433015)*x[1]
72468            s[4,1,2]=(-0.765454557157)*x[2]
72469            s[5,0,0]=(-0.806747348451)*x[0]
72470            s[5,0,1]=(-0.423078051628)*x[1]
72471            s[5,0,2]=(0.765544317002)*x[2]
72472            s[5,1,0]=(0.00826992946354)*x[0]
72473            s[5,1,1]=(-0.117741801904)*x[1]
72474            s[5,1,2]=(-0.975554426921)*x[2]
72475            ref=sqrt((4.31586522476))
72476    
72477          res=L2(arg)
72478          sub=res.substitute({arg:s})
72479          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
72480          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
72481          self.failUnlessAlmostEqual(sub,ref,int(-log10(self.RES_TOL)),"wrong result")
72482       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72483       def test_L2_onFunction_fromSymbol_rank4(self):
72484          """
72485          tests L2-norm of Symbol on the Function
72486    
72487          assumptions: self.domain supports integration on Function
72488          """
72489          dim=self.domain.getDim()
72490          w=Function(self.domain)
72491          x=w.getX()
72492          if dim==2:
72493            arg=Symbol(shape=(4, 5, 3, 2),dim=dim)
72494            s=Data(0,(4, 5, 3, 2),w)
72495            s[0,0,0,0]=(0.392249504065)*x[0]
72496            s[0,0,0,1]=(-0.0829499082807)*x[1]
72497            s[0,0,1,0]=(0.075391736082)*x[0]
72498            s[0,0,1,1]=(-0.267274680434)*x[1]
72499            s[0,0,2,0]=(0.758405394297)*x[0]
72500            s[0,0,2,1]=(0.966859664545)*x[1]
72501            s[0,1,0,0]=(-0.665158005166)*x[0]
72502            s[0,1,0,1]=(-0.861735224083)*x[1]
72503            s[0,1,1,0]=(0.889852595371)*x[0]
72504            s[0,1,1,1]=(-0.456217187733)*x[1]
72505            s[0,1,2,0]=(-0.444839601276)*x[0]
72506            s[0,1,2,1]=(-0.646347424003)*x[1]
72507            s[0,2,0,0]=(0.016728267633)*x[0]
72508            s[0,2,0,1]=(0.598805251354)*x[1]
72509            s[0,2,1,0]=(-0.0850259337934)*x[0]
72510            s[0,2,1,1]=(-0.958442577173)*x[1]
72511            s[0,2,2,0]=(-0.316155802878)*x[0]
72512            s[0,2,2,1]=(0.882575663199)*x[1]
72513            s[0,3,0,0]=(-0.350482054568)*x[0]
72514            s[0,3,0,1]=(-0.0018770186166)*x[1]
72515            s[0,3,1,0]=(0.434158350351)*x[0]
72516            s[0,3,1,1]=(0.510916541891)*x[1]
72517            s[0,3,2,0]=(0.415800847408)*x[0]
72518            s[0,3,2,1]=(0.0045200661478)*x[1]
72519            s[0,4,0,0]=(0.719981048541)*x[0]
72520            s[0,4,0,1]=(-0.394991607605)*x[1]
72521            s[0,4,1,0]=(0.225637020507)*x[0]
72522            s[0,4,1,1]=(-0.942644070947)*x[1]
72523            s[0,4,2,0]=(0.914486047699)*x[0]
72524            s[0,4,2,1]=(-0.0605237231206)*x[1]
72525            s[1,0,0,0]=(0.49162536785)*x[0]
72526            s[1,0,0,1]=(-0.616492901013)*x[1]
72527            s[1,0,1,0]=(-0.1288077626)*x[0]
72528            s[1,0,1,1]=(-0.345407781206)*x[1]
72529            s[1,0,2,0]=(-0.0725937970644)*x[0]
72530            s[1,0,2,1]=(0.40531578317)*x[1]
72531            s[1,1,0,0]=(0.598712741491)*x[0]
72532            s[1,1,0,1]=(-0.93879902651)*x[1]
72533            s[1,1,1,0]=(-0.0264475169249)*x[0]
72534            s[1,1,1,1]=(0.249909294638)*x[1]
72535            s[1,1,2,0]=(0.0027245979433)*x[0]
72536            s[1,1,2,1]=(-0.373044612275)*x[1]
72537            s[1,2,0,0]=(-0.281778393525)*x[0]
72538            s[1,2,0,1]=(0.627994360637)*x[1]
72539            s[1,2,1,0]=(0.589488628124)*x[0]
72540            s[1,2,1,1]=(-0.758174695207)*x[1]
72541            s[1,2,2,0]=(-0.406965936453)*x[0]
72542            s[1,2,2,1]=(-0.69002957721)*x[1]
72543            s[1,3,0,0]=(-0.199124201524)*x[0]
72544            s[1,3,0,1]=(0.869253645966)*x[1]
72545            s[1,3,1,0]=(-0.452605020068)*x[0]
72546            s[1,3,1,1]=(-0.970641886846)*x[1]
72547            s[1,3,2,0]=(0.175601171946)*x[0]
72548            s[1,3,2,1]=(0.672851105536)*x[1]
72549            s[1,4,0,0]=(0.58320491243)*x[0]
72550            s[1,4,0,1]=(-0.259858520694)*x[1]
72551            s[1,4,1,0]=(-0.808152456276)*x[0]
72552            s[1,4,1,1]=(-0.061862146349)*x[1]
72553            s[1,4,2,0]=(-0.285657379415)*x[0]
72554            s[1,4,2,1]=(0.0400598209814)*x[1]
72555            s[2,0,0,0]=(-0.982895080214)*x[0]
72556            s[2,0,0,1]=(-0.221420258961)*x[1]
72557            s[2,0,1,0]=(0.241664738784)*x[0]
72558            s[2,0,1,1]=(0.360336298851)*x[1]
72559            s[2,0,2,0]=(-0.1930995368)*x[0]
72560            s[2,0,2,1]=(0.165323422951)*x[1]
72561            s[2,1,0,0]=(-0.580617143448)*x[0]
72562            s[2,1,0,1]=(-0.445386310829)*x[1]
72563            s[2,1,1,0]=(-0.679424485212)*x[0]
72564            s[2,1,1,1]=(0.999216345845)*x[1]
72565            s[2,1,2,0]=(-0.00488871164474)*x[0]
72566            s[2,1,2,1]=(0.94248053909)*x[1]
72567            s[2,2,0,0]=(0.241836822065)*x[0]
72568            s[2,2,0,1]=(-0.323265890223)*x[1]
72569            s[2,2,1,0]=(0.282530883606)*x[0]
72570            s[2,2,1,1]=(0.499481122286)*x[1]
72571            s[2,2,2,0]=(0.502100738495)*x[0]
72572            s[2,2,2,1]=(-0.714419126623)*x[1]
72573            s[2,3,0,0]=(0.427736585056)*x[0]
72574            s[2,3,0,1]=(0.846933115255)*x[1]
72575            s[2,3,1,0]=(0.293400967424)*x[0]
72576            s[2,3,1,1]=(0.258925376632)*x[1]
72577            s[2,3,2,0]=(-0.748167607341)*x[0]
72578            s[2,3,2,1]=(0.354090561451)*x[1]
72579            s[2,4,0,0]=(0.432737336014)*x[0]
72580            s[2,4,0,1]=(0.856383164324)*x[1]
72581            s[2,4,1,0]=(-0.0596776788823)*x[0]
72582            s[2,4,1,1]=(-0.299291531668)*x[1]
72583            s[2,4,2,0]=(0.0332610005043)*x[0]
72584            s[2,4,2,1]=(-0.784223449976)*x[1]
72585            s[3,0,0,0]=(0.856346607718)*x[0]
72586            s[3,0,0,1]=(-0.711038642485)*x[1]
72587            s[3,0,1,0]=(-0.722899969631)*x[0]
72588            s[3,0,1,1]=(-0.976358349372)*x[1]
72589            s[3,0,2,0]=(-0.566657009276)*x[0]
72590            s[3,0,2,1]=(-0.88977921418)*x[1]
72591            s[3,1,0,0]=(0.690995364783)*x[0]
72592            s[3,1,0,1]=(0.0178260768232)*x[1]
72593            s[3,1,1,0]=(0.210672134956)*x[0]
72594            s[3,1,1,1]=(-0.271769743548)*x[1]
72595            s[3,1,2,0]=(-0.119905539717)*x[0]
72596            s[3,1,2,1]=(0.408792239219)*x[1]
72597            s[3,2,0,0]=(0.134901834799)*x[0]
72598            s[3,2,0,1]=(0.0969235330927)*x[1]
72599            s[3,2,1,0]=(-0.418267686354)*x[0]
72600            s[3,2,1,1]=(-0.599174142878)*x[1]
72601            s[3,2,2,0]=(-0.409148104875)*x[0]
72602            s[3,2,2,1]=(0.504760142275)*x[1]
72603            s[3,3,0,0]=(-0.174999245323)*x[0]
72604            s[3,3,0,1]=(-0.994094684291)*x[1]
72605            s[3,3,1,0]=(0.470460754362)*x[0]
72606            s[3,3,1,1]=(-0.867881666651)*x[1]
72607            s[3,3,2,0]=(0.691171063635)*x[0]
72608            s[3,3,2,1]=(-0.644952618882)*x[1]
72609            s[3,4,0,0]=(0.883581127272)*x[0]
72610            s[3,4,0,1]=(-0.534009409512)*x[1]
72611            s[3,4,1,0]=(0.324806602648)*x[0]
72612            s[3,4,1,1]=(0.606235157996)*x[1]
72613            s[3,4,2,0]=(-0.0136704045984)*x[0]
72614            s[3,4,2,1]=(0.36671612245)*x[1]
72615            ref=sqrt((12.2721641113))
72616    
72617          else:
72618            arg=Symbol(shape=(4, 5, 3, 3),dim=dim)
72619            s=Data(0,(4, 5, 3, 3),w)
72620            s[0,0,0,0]=(-0.0241692471764)*x[0]
72621            s[0,0,0,1]=(0.816194825296)*x[1]
72622            s[0,0,0,2]=(-0.0193776462565)*x[2]
72623            s[0,0,1,0]=(0.885158780616)*x[0]
72624            s[0,0,1,1]=(0.750445408795)*x[1]
72625            s[0,0,1,2]=(-0.242904502332)*x[2]
72626            s[0,0,2,0]=(-0.101306101076)*x[0]
72627            s[0,0,2,1]=(0.254549514037)*x[1]
72628            s[0,0,2,2]=(-0.301743139759)*x[2]
72629            s[0,1,0,0]=(0.960790978081)*x[0]
72630            s[0,1,0,1]=(-0.873861925572)*x[1]
72631            s[0,1,0,2]=(-0.266926259205)*x[2]
72632            s[0,1,1,0]=(-0.533605756527)*x[0]
72633            s[0,1,1,1]=(-0.196348553154)*x[1]
72634            s[0,1,1,2]=(0.462438110297)*x[2]
72635            s[0,1,2,0]=(0.766114991742)*x[0]
72636            s[0,1,2,1]=(-0.282544763069)*x[1]
72637            s[0,1,2,2]=(-0.918562937205)*x[2]
72638            s[0,2,0,0]=(-0.723736937045)*x[0]
72639            s[0,2,0,1]=(-0.0271772220034)*x[1]
72640            s[0,2,0,2]=(-0.67448574094)*x[2]
72641            s[0,2,1,0]=(-0.0465782041976)*x[0]
72642            s[0,2,1,1]=(-0.701475255709)*x[1]
72643            s[0,2,1,2]=(-0.54745824908)*x[2]
72644            s[0,2,2,0]=(0.823427037717)*x[0]
72645            s[0,2,2,1]=(0.873366807256)*x[1]
72646            s[0,2,2,2]=(0.902453041345)*x[2]
72647            s[0,3,0,0]=(-0.383388300734)*x[0]
72648            s[0,3,0,1]=(-0.457344890379)*x[1]
72649            s[0,3,0,2]=(0.449736739028)*x[2]
72650            s[0,3,1,0]=(-0.994113075606)*x[0]
72651            s[0,3,1,1]=(0.0265853285952)*x[1]
72652            s[0,3,1,2]=(-0.738089523761)*x[2]
72653            s[0,3,2,0]=(0.663756875286)*x[0]
72654            s[0,3,2,1]=(0.597615440207)*x[1]
72655            s[0,3,2,2]=(0.246105261445)*x[2]
72656            s[0,4,0,0]=(0.397226701305)*x[0]
72657            s[0,4,0,1]=(0.0967432951001)*x[1]
72658            s[0,4,0,2]=(0.619665795097)*x[2]
72659            s[0,4,1,0]=(0.155541932506)*x[0]
72660            s[0,4,1,1]=(-0.114961356145)*x[1]
72661            s[0,4,1,2]=(-0.491668824315)*x[2]
72662            s[0,4,2,0]=(-0.726549525506)*x[0]
72663            s[0,4,2,1]=(-0.876194753259)*x[1]
72664            s[0,4,2,2]=(-0.506364111318)*x[2]
72665            s[1,0,0,0]=(-0.380662783497)*x[0]
72666            s[1,0,0,1]=(-0.57927422387)*x[1]
72667            s[1,0,0,2]=(-0.282039117242)*x[2]
72668            s[1,0,1,0]=(-0.873334149601)*x[0]
72669            s[1,0,1,1]=(-0.0145182664909)*x[1]
72670            s[1,0,1,2]=(0.903533313452)*x[2]
72671            s[1,0,2,0]=(0.123617284156)*x[0]
72672            s[1,0,2,1]=(0.716639379262)*x[1]
72673            s[1,0,2,2]=(-0.940470701414)*x[2]
72674            s[1,1,0,0]=(-0.831075410065)*x[0]
72675            s[1,1,0,1]=(0.808724910022)*x[1]
72676            s[1,1,0,2]=(0.218369441977)*x[2]
72677            s[1,1,1,0]=(0.690977533444)*x[0]
72678            s[1,1,1,1]=(-0.379327957709)*x[1]
72679            s[1,1,1,2]=(0.0964273177138)*x[2]
72680            s[1,1,2,0]=(-0.244790745268)*x[0]
72681            s[1,1,2,1]=(-0.208570215865)*x[1]
72682            s[1,1,2,2]=(0.280320965835)*x[2]
72683            s[1,2,0,0]=(-0.571572336783)*x[0]
72684            s[1,2,0,1]=(-0.512302129833)*x[1]
72685            s[1,2,0,2]=(0.458134267946)*x[2]
72686            s[1,2,1,0]=(-0.909450574449)*x[0]
72687            s[1,2,1,1]=(-0.54240194702)*x[1]
72688            s[1,2,1,2]=(0.015279542779)*x[2]
72689            s[1,2,2,0]=(-0.450829963713)*x[0]
72690            s[1,2,2,1]=(0.265958897553)*x[1]
72691            s[1,2,2,2]=(0.0115876819282)*x[2]
72692            s[1,3,0,0]=(-0.493820517172)*x[0]
72693            s[1,3,0,1]=(0.924501975039)*x[1]
72694            s[1,3,0,2]=(0.976144734904)*x[2]
72695            s[1,3,1,0]=(-0.0369162848651)*x[0]
72696            s[1,3,1,1]=(-0.282951956468)*x[1]
72697            s[1,3,1,2]=(0.46799488403)*x[2]
72698            s[1,3,2,0]=(0.859289726723)*x[0]
72699            s[1,3,2,1]=(0.460555626035)*x[1]
72700            s[1,3,2,2]=(0.515796525158)*x[2]
72701            s[1,4,0,0]=(0.707364903535)*x[0]
72702            s[1,4,0,1]=(0.749724556391)*x[1]
72703            s[1,4,0,2]=(-0.278863489815)*x[2]
72704            s[1,4,1,0]=(0.972950918189)*x[0]
72705            s[1,4,1,1]=(0.844177970875)*x[1]
72706            s[1,4,1,2]=(0.0763619420058)*x[2]
72707            s[1,4,2,0]=(-0.0852939975129)*x[0]
72708            s[1,4,2,1]=(0.583399144502)*x[1]
72709            s[1,4,2,2]=(0.848661907972)*x[2]
72710            s[2,0,0,0]=(-0.777408601463)*x[0]
72711            s[2,0,0,1]=(-0.855232334446)*x[1]
72712            s[2,0,0,2]=(-0.742431398498)*x[2]
72713            s[2,0,1,0]=(-0.96680966892)*x[0]
72714            s[2,0,1,1]=(-0.33301062934)*x[1]
72715            s[2,0,1,2]=(-0.675842472611)*x[2]
72716            s[2,0,2,0]=(-0.0163730639481)*x[0]
72717            s[2,0,2,1]=(-0.0854274064817)*x[1]
72718            s[2,0,2,2]=(-0.93094914338)*x[2]
72719            s[2,1,0,0]=(0.881651879025)*x[0]
72720            s[2,1,0,1]=(0.782286554309)*x[1]
72721            s[2,1,0,2]=(0.71813995101)*x[2]
72722            s[2,1,1,0]=(-0.0790321088042)*x[0]
72723            s[2,1,1,1]=(-0.181510921696)*x[1]
72724            s[2,1,1,2]=(0.822016852235)*x[2]
72725            s[2,1,2,0]=(0.634313542034)*x[0]
72726            s[2,1,2,1]=(0.797139044679)*x[1]
72727            s[2,1,2,2]=(0.400542618196)*x[2]
72728            s[2,2,0,0]=(-0.823507870125)*x[0]
72729            s[2,2,0,1]=(0.981256538471)*x[1]
72730            s[2,2,0,2]=(0.158779409645)*x[2]
72731            s[2,2,1,0]=(-0.0788962261172)*x[0]
72732            s[2,2,1,1]=(-0.295903805518)*x[1]
72733            s[2,2,1,2]=(0.338095367799)*x[2]
72734            s[2,2,2,0]=(0.259914616014)*x[0]
72735            s[2,2,2,1]=(-0.935338026316)*x[1]
72736            s[2,2,2,2]=(0.752104609965)*x[2]
72737            s[2,3,0,0]=(0.770409830614)*x[0]
72738            s[2,3,0,1]=(0.827165793631)*x[1]
72739            s[2,3,0,2]=(-0.570252686313)*x[2]
72740            s[2,3,1,0]=(-0.645381957261)*x[0]
72741            s[2,3,1,1]=(-0.547153600936)*x[1]
72742            s[2,3,1,2]=(-0.424301255985)*x[2]
72743            s[2,3,2,0]=(0.938907909024)*x[0]
72744            s[2,3,2,1]=(-0.165860294169)*x[1]
72745            s[2,3,2,2]=(-0.507668918028)*x[2]
72746            s[2,4,0,0]=(0.504198965293)*x[0]
72747            s[2,4,0,1]=(-0.668203518046)*x[1]
72748            s[2,4,0,2]=(0.229406581915)*x[2]
72749            s[2,4,1,0]=(0.454298324734)*x[0]
72750            s[2,4,1,1]=(0.631911737372)*x[1]
72751            s[2,4,1,2]=(-0.849242047895)*x[2]
72752            s[2,4,2,0]=(0.0187819832254)*x[0]
72753            s[2,4,2,1]=(-0.0257470291285)*x[1]
72754            s[2,4,2,2]=(-0.968820620099)*x[2]
72755            s[3,0,0,0]=(0.55579863211)*x[0]
72756            s[3,0,0,1]=(0.830363451819)*x[1]
72757            s[3,0,0,2]=(0.37501906831)*x[2]
72758            s[3,0,1,0]=(-0.609478442879)*x[0]
72759            s[3,0,1,1]=(0.895531311344)*x[1]
72760            s[3,0,1,2]=(0.457055008762)*x[2]
72761            s[3,0,2,0]=(-0.589517607648)*x[0]
72762            s[3,0,2,1]=(-0.840365410994)*x[1]
72763            s[3,0,2,2]=(-0.804004197791)*x[2]
72764            s[3,1,0,0]=(0.231479229381)*x[0]
72765            s[3,1,0,1]=(0.851135131086)*x[1]
72766            s[3,1,0,2]=(-0.558112154058)*x[2]
72767            s[3,1,1,0]=(-0.365328057806)*x[0]
72768            s[3,1,1,1]=(0.665370944345)*x[1]
72769            s[3,1,1,2]=(0.815245254888)*x[2]
72770            s[3,1,2,0]=(-0.622675567594)*x[0]
72771            s[3,1,2,1]=(0.15478575296)*x[1]
72772            s[3,1,2,2]=(-0.919833514628)*x[2]
72773            s[3,2,0,0]=(0.893976278733)*x[0]
72774            s[3,2,0,1]=(-0.881412936262)*x[1]
72775            s[3,2,0,2]=(-0.940014543462)*x[2]
72776            s[3,2,1,0]=(0.310442650776)*x[0]
72777            s[3,2,1,1]=(0.895222325851)*x[1]
72778            s[3,2,1,2]=(0.308995631858)*x[2]
72779            s[3,2,2,0]=(0.0373558936063)*x[0]
72780            s[3,2,2,1]=(-0.0592368839463)*x[1]
72781            s[3,2,2,2]=(0.793681649539)*x[2]
72782            s[3,3,0,0]=(-0.542535013221)*x[0]
72783            s[3,3,0,1]=(0.730645327078)*x[1]
72784            s[3,3,0,2]=(-0.776045858279)*x[2]
72785            s[3,3,1,0]=(-0.657528555613)*x[0]
72786            s[3,3,1,1]=(-0.282142368825)*x[1]
72787            s[3,3,1,2]=(-0.692363751497)*x[2]
72788            s[3,3,2,0]=(-0.168946040457)*x[0]
72789            s[3,3,2,1]=(-0.318493817076)*x[1]
72790            s[3,3,2,2]=(0.535922920691)*x[2]
72791            s[3,4,0,0]=(0.414492782118)*x[0]
72792            s[3,4,0,1]=(0.295207630842)*x[1]
72793            s[3,4,0,2]=(0.453596918765)*x[2]
72794            s[3,4,1,0]=(-0.083655892279)*x[0]
72795            s[3,4,1,1]=(-0.962961908465)*x[1]
72796            s[3,4,1,2]=(0.138455397004)*x[2]
72797            s[3,4,2,0]=(-0.383498097386)*x[0]
72798            s[3,4,2,1]=(0.650869920691)*x[1]
72799            s[3,4,2,2]=(-0.998836301837)*x[2]
72800            ref=sqrt((22.2241672931))
72801    
72802          res=L2(arg)
72803          sub=res.substitute({arg:s})
72804          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
72805          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
72806          self.failUnlessAlmostEqual(sub,ref,int(-log10(self.RES_TOL)),"wrong result")
72807       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72808       def test_L2_onFunctionOnBoundary_fromData_rank0(self):
72809          """
72810          tests L2-norm of Data on the FunctionOnBoundary
72811    
72812          assumptions: self.domain supports integration on FunctionOnBoundary
72813          """
72814          dim=self.domain.getDim()
72815          w=FunctionOnBoundary(self.domain)
72816          x=w.getX()
72817          if dim==2:
72818            arg=Data(0,(),w)
72819            arg=(-0.245574919477)*x[0]
72820            ref=sqrt((0.0603070410759)*(2.*dim+1.)/3.)
72821    
72822          else:
72823            arg=Data(0,(),w)
72824            arg=(0.757324521515)*x[0]
72825            ref=sqrt((0.573540430888)*(2.*dim+1.)/3.)
72826    
72827          res=L2(arg)
72828          self.failUnless(isinstance(res,float),"wrong type of result.")
72829          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
72830       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72831       def test_L2_onFunctionOnBoundary_fromData_rank1(self):
72832          """
72833          tests L2-norm of Data on the FunctionOnBoundary
72834    
72835          assumptions: self.domain supports integration on FunctionOnBoundary
72836          """
72837          dim=self.domain.getDim()
72838          w=FunctionOnBoundary(self.domain)
72839          x=w.getX()
72840          if dim==2:
72841            arg=Data(0,(2,),w)
72842            arg[0]=(0.723421565407)*x[0]
72843            arg[1]=(-0.460477393103)*x[1]
72844            ref=sqrt((0.735378190855)*(2.*dim+1.)/3.)
72845    
72846          else:
72847            arg=Data(0,(3,),w)
72848            arg[0]=(-0.88528497163)*x[0]
72849            arg[1]=(-0.65510214636)*x[1]
72850            arg[2]=(0.399538866363)*x[2]
72851            ref=sqrt((1.37251960889)*(2.*dim+1.)/3.)
72852    
72853          res=L2(arg)
72854          self.failUnless(isinstance(res,float),"wrong type of result.")
72855          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
72856       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72857       def test_L2_onFunctionOnBoundary_fromData_rank2(self):
72858          """
72859          tests L2-norm of Data on the FunctionOnBoundary
72860    
72861          assumptions: self.domain supports integration on FunctionOnBoundary
72862          """
72863          dim=self.domain.getDim()
72864          w=FunctionOnBoundary(self.domain)
72865          x=w.getX()
72866          if dim==2:
72867            arg=Data(0,(4, 2),w)
72868            arg[0,0]=(0.955620993904)*x[0]
72869            arg[0,1]=(-0.0987865813703)*x[1]
72870            arg[1,0]=(0.0288267231531)*x[0]
72871            arg[1,1]=(0.655440599879)*x[1]
72872            arg[2,0]=(0.685627284533)*x[0]
72873            arg[2,1]=(-0.989832824892)*x[1]
72874            arg[3,0]=(0.292184093194)*x[0]
72875            arg[3,1]=(0.149553857773)*x[1]
72876            ref=sqrt((2.91099532781)*(2.*dim+1.)/3.)
72877    
72878          else:
72879            arg=Data(0,(4, 3),w)
72880            arg[0,0]=(-0.325908541533)*x[0]
72881            arg[0,1]=(-0.992480479749)*x[1]
72882            arg[0,2]=(0.660360271799)*x[2]
72883            arg[1,0]=(0.173485908581)*x[0]
72884            arg[1,1]=(-0.328755199781)*x[1]
72885            arg[1,2]=(-0.943354674948)*x[2]
72886            arg[2,0]=(0.680713222646)*x[0]
72887            arg[2,1]=(-0.765971835693)*x[1]
72888            arg[2,2]=(0.0413284847528)*x[2]
72889            arg[3,0]=(0.990074004708)*x[0]
72890            arg[3,1]=(0.941801786766)*x[1]
72891            arg[3,2]=(0.886926192201)*x[2]
72892            ref=sqrt((6.26107155228)*(2.*dim+1.)/3.)
72893    
72894          res=L2(arg)
72895          self.failUnless(isinstance(res,float),"wrong type of result.")
72896          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
72897       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72898       def test_L2_onFunctionOnBoundary_fromData_rank3(self):
72899          """
72900          tests L2-norm of Data on the FunctionOnBoundary
72901    
72902          assumptions: self.domain supports integration on FunctionOnBoundary
72903          """
72904          dim=self.domain.getDim()
72905          w=FunctionOnBoundary(self.domain)
72906          x=w.getX()
72907          if dim==2:
72908            arg=Data(0,(6, 2, 2),w)
72909            arg[0,0,0]=(-0.0781611551598)*x[0]
72910            arg[0,0,1]=(0.291016249575)*x[1]
72911            arg[0,1,0]=(-0.107555233086)*x[0]
72912            arg[0,1,1]=(-0.559067108546)*x[1]
72913            arg[1,0,0]=(-0.0818406701266)*x[0]
72914            arg[1,0,1]=(-0.594866806483)*x[1]
72915            arg[1,1,0]=(-0.725814803863)*x[0]
72916            arg[1,1,1]=(0.59128101992)*x[1]
72917            arg[2,0,0]=(-0.15381555291)*x[0]
72918            arg[2,0,1]=(-0.679882948503)*x[1]
72919            arg[2,1,0]=(-0.58437193917)*x[0]
72920            arg[2,1,1]=(0.136304615849)*x[1]
72921            arg[3,0,0]=(0.0671365410096)*x[0]
72922            arg[3,0,1]=(-0.645687212187)*x[1]
72923            arg[3,1,0]=(-0.642492412392)*x[0]
72924            arg[3,1,1]=(-0.125760054735)*x[1]
72925            arg[4,0,0]=(0.731110824794)*x[0]
72926            arg[4,0,1]=(0.491668422979)*x[1]
72927            arg[4,1,0]=(-0.775841478292)*x[0]
72928            arg[4,1,1]=(0.728265567974)*x[1]
72929            arg[5,0,0]=(0.84511832373)*x[0]
72930            arg[5,0,1]=(-0.513796801068)*x[1]
72931            arg[5,1,0]=(0.113072243554)*x[0]
72932            arg[5,1,1]=(0.246630838744)*x[1]
72933            ref=sqrt((6.30829536252)*(2.*dim+1.)/3.)
72934    
72935          else:
72936            arg=Data(0,(6, 2, 3),w)
72937            arg[0,0,0]=(0.369748116859)*x[0]
72938            arg[0,0,1]=(-0.758056560031)*x[1]
72939            arg[0,0,2]=(-0.873984709951)*x[2]
72940            arg[0,1,0]=(0.311680165784)*x[0]
72941            arg[0,1,1]=(0.374400673651)*x[1]
72942            arg[0,1,2]=(0.712484217076)*x[2]
72943            arg[1,0,0]=(0.829379714484)*x[0]
72944            arg[1,0,1]=(-0.0551589596149)*x[1]
72945            arg[1,0,2]=(0.965672208426)*x[2]
72946            arg[1,1,0]=(-0.205044281547)*x[0]
72947            arg[1,1,1]=(0.238197452756)*x[1]
72948            arg[1,1,2]=(-0.33456139292)*x[2]
72949            arg[2,0,0]=(0.649928288926)*x[0]
72950            arg[2,0,1]=(-0.661384953389)*x[1]
72951            arg[2,0,2]=(-0.253241222975)*x[2]
72952            arg[2,1,0]=(-0.491716575992)*x[0]
72953            arg[2,1,1]=(-0.970872527468)*x[1]
72954            arg[2,1,2]=(0.222410198921)*x[2]
72955            arg[3,0,0]=(0.205752630262)*x[0]
72956            arg[3,0,1]=(0.864804362697)*x[1]
72957            arg[3,0,2]=(-0.417975564033)*x[2]
72958            arg[3,1,0]=(0.586425694033)*x[0]
72959            arg[3,1,1]=(0.952661122184)*x[1]
72960            arg[3,1,2]=(0.608680080453)*x[2]
72961            arg[4,0,0]=(0.625968903369)*x[0]
72962            arg[4,0,1]=(-0.573909405003)*x[1]
72963            arg[4,0,2]=(-0.762256394595)*x[2]
72964            arg[4,1,0]=(0.0710742394418)*x[0]
72965            arg[4,1,1]=(0.583378040574)*x[1]
72966            arg[4,1,2]=(0.719032893115)*x[2]
72967            arg[5,0,0]=(0.032173368884)*x[0]
72968            arg[5,0,1]=(-0.434042549492)*x[1]
72969            arg[5,0,2]=(0.363504765447)*x[2]
72970            arg[5,1,0]=(0.598817469198)*x[0]
72971            arg[5,1,1]=(-0.163967008775)*x[1]
72972            arg[5,1,2]=(0.546778730604)*x[2]
72973            ref=sqrt((11.9696343123)*(2.*dim+1.)/3.)
72974    
72975          res=L2(arg)
72976          self.failUnless(isinstance(res,float),"wrong type of result.")
72977          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
72978       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
72979       def test_L2_onFunctionOnBoundary_fromData_rank4(self):
72980          """
72981          tests L2-norm of Data on the FunctionOnBoundary
72982    
72983          assumptions: self.domain supports integration on FunctionOnBoundary
72984          """
72985          dim=self.domain.getDim()
72986          w=FunctionOnBoundary(self.domain)
72987          x=w.getX()
72988          if dim==2:
72989            arg=Data(0,(4, 5, 3, 2),w)
72990            arg[0,0,0,0]=(-0.273446520069)*x[0]
72991            arg[0,0,0,1]=(-0.913305910831)*x[1]
72992            arg[0,0,1,0]=(0.0745566747537)*x[0]
72993            arg[0,0,1,1]=(0.98803601919)*x[1]
72994            arg[0,0,2,0]=(-0.244120818875)*x[0]
72995            arg[0,0,2,1]=(0.247509644998)*x[1]
72996            arg[0,1,0,0]=(-0.548756417777)*x[0]
72997            arg[0,1,0,1]=(-0.354587911923)*x[1]
72998            arg[0,1,1,0]=(0.104268198867)*x[0]
72999            arg[0,1,1,1]=(-0.541700877072)*x[1]
73000            arg[0,1,2,0]=(-0.25900060689)*x[0]
73001            arg[0,1,2,1]=(-0.859660175231)*x[1]
73002            arg[0,2,0,0]=(0.195235560321)*x[0]
73003            arg[0,2,0,1]=(0.175518738589)*x[1]
73004            arg[0,2,1,0]=(-0.0638854232272)*x[0]
73005            arg[0,2,1,1]=(-0.586161016541)*x[1]
73006            arg[0,2,2,0]=(0.580258892247)*x[0]
73007            arg[0,2,2,1]=(-0.931927145435)*x[1]
73008            arg[0,3,0,0]=(-0.408209600298)*x[0]
73009            arg[0,3,0,1]=(-0.0344882667014)*x[1]
73010            arg[0,3,1,0]=(-0.131763534163)*x[0]
73011            arg[0,3,1,1]=(-0.787653739965)*x[1]
73012            arg[0,3,2,0]=(0.0910808104711)*x[0]
73013            arg[0,3,2,1]=(-0.280409023611)*x[1]
73014            arg[0,4,0,0]=(0.97745754012)*x[0]
73015            arg[0,4,0,1]=(-0.59829020936)*x[1]
73016            arg[0,4,1,0]=(0.890520260543)*x[0]
73017            arg[0,4,1,1]=(-0.600760090231)*x[1]
73018            arg[0,4,2,0]=(-0.897992297974)*x[0]
73019            arg[0,4,2,1]=(-0.841169898923)*x[1]
73020            arg[1,0,0,0]=(-0.249868816409)*x[0]
73021            arg[1,0,0,1]=(0.620375082228)*x[1]
73022            arg[1,0,1,0]=(-0.660480789306)*x[0]
73023            arg[1,0,1,1]=(-0.73638571806)*x[1]
73024            arg[1,0,2,0]=(0.339987316643)*x[0]
73025            arg[1,0,2,1]=(0.541112529894)*x[1]
73026            arg[1,1,0,0]=(-0.468808186705)*x[0]
73027            arg[1,1,0,1]=(-0.32919679792)*x[1]
73028            arg[1,1,1,0]=(0.917292803419)*x[0]
73029            arg[1,1,1,1]=(-0.834265058005)*x[1]
73030            arg[1,1,2,0]=(-0.247536849264)*x[0]
73031            arg[1,1,2,1]=(-0.197503469238)*x[1]
73032            arg[1,2,0,0]=(0.897591919909)*x[0]
73033            arg[1,2,0,1]=(-0.807446231234)*x[1]
73034            arg[1,2,1,0]=(-0.369878499382)*x[0]
73035            arg[1,2,1,1]=(0.985678692179)*x[1]
73036            arg[1,2,2,0]=(-0.709976427525)*x[0]
73037            arg[1,2,2,1]=(-0.368744647016)*x[1]
73038            arg[1,3,0,0]=(0.299630726462)*x[0]
73039            arg[1,3,0,1]=(-0.445295757899)*x[1]
73040            arg[1,3,1,0]=(-0.922386577254)*x[0]
73041            arg[1,3,1,1]=(0.234794853697)*x[1]
73042            arg[1,3,2,0]=(0.953377720197)*x[0]
73043            arg[1,3,2,1]=(0.409778183998)*x[1]
73044            arg[1,4,0,0]=(0.271967945488)*x[0]
73045            arg[1,4,0,1]=(-0.578629001202)*x[1]
73046            arg[1,4,1,0]=(0.210755226769)*x[0]
73047            arg[1,4,1,1]=(-0.0902751419945)*x[1]
73048            arg[1,4,2,0]=(0.70033387381)*x[0]
73049            arg[1,4,2,1]=(0.305733565661)*x[1]
73050            arg[2,0,0,0]=(-0.662483167298)*x[0]
73051            arg[2,0,0,1]=(0.585252048652)*x[1]
73052            arg[2,0,1,0]=(-0.398813785959)*x[0]
73053            arg[2,0,1,1]=(-0.797438697186)*x[1]
73054            arg[2,0,2,0]=(-0.508308971009)*x[0]
73055            arg[2,0,2,1]=(0.302249407524)*x[1]
73056            arg[2,1,0,0]=(0.208644491879)*x[0]
73057            arg[2,1,0,1]=(-0.604749055374)*x[1]
73058            arg[2,1,1,0]=(0.641654284594)*x[0]
73059            arg[2,1,1,1]=(0.456898593356)*x[1]
73060            arg[2,1,2,0]=(-0.398043867778)*x[0]
73061            arg[2,1,2,1]=(-0.0712344657587)*x[1]
73062            arg[2,2,0,0]=(0.0967860954865)*x[0]
73063            arg[2,2,0,1]=(0.520449905952)*x[1]
73064            arg[2,2,1,0]=(0.770198029595)*x[0]
73065            arg[2,2,1,1]=(-0.594004671621)*x[1]
73066            arg[2,2,2,0]=(-0.744571452885)*x[0]
73067            arg[2,2,2,1]=(0.544447367825)*x[1]
73068            arg[2,3,0,0]=(-0.137087966968)*x[0]
73069            arg[2,3,0,1]=(0.120672667497)*x[1]
73070            arg[2,3,1,0]=(0.204800088057)*x[0]
73071            arg[2,3,1,1]=(0.626526346076)*x[1]
73072            arg[2,3,2,0]=(-0.696480393227)*x[0]
73073            arg[2,3,2,1]=(0.188533741996)*x[1]
73074            arg[2,4,0,0]=(-0.403523821067)*x[0]
73075            arg[2,4,0,1]=(-0.428048989483)*x[1]
73076            arg[2,4,1,0]=(-0.244186366584)*x[0]
73077            arg[2,4,1,1]=(0.00866444909003)*x[1]
73078            arg[2,4,2,0]=(-0.445991308853)*x[0]
73079            arg[2,4,2,1]=(-0.899951068935)*x[1]
73080            arg[3,0,0,0]=(0.609340085418)*x[0]
73081            arg[3,0,0,1]=(0.878750391425)*x[1]
73082            arg[3,0,1,0]=(0.258064654464)*x[0]
73083            arg[3,0,1,1]=(-0.482402612985)*x[1]
73084            arg[3,0,2,0]=(0.943732283389)*x[0]
73085            arg[3,0,2,1]=(0.65514211843)*x[1]
73086            arg[3,1,0,0]=(-0.894551979619)*x[0]
73087            arg[3,1,0,1]=(0.220116541042)*x[1]
73088            arg[3,1,1,0]=(0.386887699577)*x[0]
73089            arg[3,1,1,1]=(-0.422560075108)*x[1]
73090            arg[3,1,2,0]=(0.00387273783493)*x[0]
73091            arg[3,1,2,1]=(0.465673505613)*x[1]
73092            arg[3,2,0,0]=(0.987383428982)*x[0]
73093            arg[3,2,0,1]=(0.376320055964)*x[1]
73094            arg[3,2,1,0]=(-0.463778689128)*x[0]
73095            arg[3,2,1,1]=(0.179816566227)*x[1]
73096            arg[3,2,2,0]=(0.961522856801)*x[0]
73097            arg[3,2,2,1]=(-0.257779627946)*x[1]
73098            arg[3,3,0,0]=(0.748886531458)*x[0]
73099            arg[3,3,0,1]=(-0.257342282566)*x[1]
73100            arg[3,3,1,0]=(0.377494024401)*x[0]
73101            arg[3,3,1,1]=(-0.334588346017)*x[1]
73102            arg[3,3,2,0]=(0.502495149189)*x[0]
73103            arg[3,3,2,1]=(0.534612429702)*x[1]
73104            arg[3,4,0,0]=(-0.308551337355)*x[0]
73105            arg[3,4,0,1]=(-0.471825826745)*x[1]
73106            arg[3,4,1,0]=(-0.262606531584)*x[0]
73107            arg[3,4,1,1]=(0.766089616367)*x[1]
73108            arg[3,4,2,0]=(-0.136526755642)*x[0]
73109            arg[3,4,2,1]=(0.675111459363)*x[1]
73110            ref=sqrt((37.3453550914)*(2.*dim+1.)/3.)
73111    
73112          else:
73113            arg=Data(0,(4, 5, 3, 3),w)
73114            arg[0,0,0,0]=(0.532946231146)*x[0]
73115            arg[0,0,0,1]=(0.269364089513)*x[1]
73116            arg[0,0,0,2]=(-0.207412457081)*x[2]
73117            arg[0,0,1,0]=(-0.843104704858)*x[0]
73118            arg[0,0,1,1]=(0.0416216508473)*x[1]
73119            arg[0,0,1,2]=(-0.836074693662)*x[2]
73120            arg[0,0,2,0]=(0.943609268731)*x[0]
73121            arg[0,0,2,1]=(0.0154543737816)*x[1]
73122            arg[0,0,2,2]=(0.0726268788381)*x[2]
73123            arg[0,1,0,0]=(0.108422740078)*x[0]
73124            arg[0,1,0,1]=(-0.296667916638)*x[1]
73125            arg[0,1,0,2]=(-0.769732600535)*x[2]
73126            arg[0,1,1,0]=(-0.428575493834)*x[0]
73127            arg[0,1,1,1]=(0.421245456722)*x[1]
73128            arg[0,1,1,2]=(-0.588277652277)*x[2]
73129            arg[0,1,2,0]=(0.145294576795)*x[0]
73130            arg[0,1,2,1]=(0.323206623794)*x[1]
73131            arg[0,1,2,2]=(0.788115602892)*x[2]
73132            arg[0,2,0,0]=(-0.227877282292)*x[0]
73133            arg[0,2,0,1]=(-0.630647460719)*x[1]
73134            arg[0,2,0,2]=(0.58754882135)*x[2]
73135            arg[0,2,1,0]=(0.347191113403)*x[0]
73136            arg[0,2,1,1]=(0.464093634725)*x[1]
73137            arg[0,2,1,2]=(-0.0412800774497)*x[2]
73138            arg[0,2,2,0]=(0.223364317185)*x[0]
73139            arg[0,2,2,1]=(0.257201130157)*x[1]
73140            arg[0,2,2,2]=(0.063203467463)*x[2]
73141            arg[0,3,0,0]=(-0.723240451643)*x[0]
73142            arg[0,3,0,1]=(-0.862468295097)*x[1]
73143            arg[0,3,0,2]=(-0.149283247587)*x[2]
73144            arg[0,3,1,0]=(0.15680097839)*x[0]
73145            arg[0,3,1,1]=(0.421563637547)*x[1]
73146            arg[0,3,1,2]=(0.111549188549)*x[2]
73147            arg[0,3,2,0]=(-0.272783329363)*x[0]
73148            arg[0,3,2,1]=(-0.420352789853)*x[1]
73149            arg[0,3,2,2]=(0.570865117722)*x[2]
73150            arg[0,4,0,0]=(-0.321910078414)*x[0]
73151            arg[0,4,0,1]=(0.988695599439)*x[1]
73152            arg[0,4,0,2]=(0.920200893398)*x[2]
73153            arg[0,4,1,0]=(0.0260910072651)*x[0]
73154            arg[0,4,1,1]=(0.460012578184)*x[1]
73155            arg[0,4,1,2]=(0.848099524112)*x[2]
73156            arg[0,4,2,0]=(0.242157803251)*x[0]
73157            arg[0,4,2,1]=(0.394528777004)*x[1]
73158            arg[0,4,2,2]=(0.562996837311)*x[2]
73159            arg[1,0,0,0]=(0.459886225958)*x[0]
73160            arg[1,0,0,1]=(-0.721868942003)*x[1]
73161            arg[1,0,0,2]=(0.432203082994)*x[2]
73162            arg[1,0,1,0]=(0.409831045482)*x[0]
73163            arg[1,0,1,1]=(-0.481677513473)*x[1]
73164            arg[1,0,1,2]=(0.439387853437)*x[2]
73165            arg[1,0,2,0]=(0.261583198434)*x[0]
73166            arg[1,0,2,1]=(0.290993423577)*x[1]
73167            arg[1,0,2,2]=(0.477993114134)*x[2]
73168            arg[1,1,0,0]=(0.586344598248)*x[0]
73169            arg[1,1,0,1]=(-0.105390792831)*x[1]
73170            arg[1,1,0,2]=(0.335990751314)*x[2]
73171            arg[1,1,1,0]=(-0.191500562856)*x[0]
73172            arg[1,1,1,1]=(0.244514598216)*x[1]
73173            arg[1,1,1,2]=(-0.804402720669)*x[2]
73174            arg[1,1,2,0]=(-0.455225710648)*x[0]
73175            arg[1,1,2,1]=(-0.505052700585)*x[1]
73176            arg[1,1,2,2]=(-0.0240295199362)*x[2]
73177            arg[1,2,0,0]=(-0.718487964893)*x[0]
73178            arg[1,2,0,1]=(-0.0899522570462)*x[1]
73179            arg[1,2,0,2]=(-0.293353754696)*x[2]
73180            arg[1,2,1,0]=(-0.180013826342)*x[0]
73181            arg[1,2,1,1]=(0.793689231922)*x[1]
73182            arg[1,2,1,2]=(0.673066555571)*x[2]
73183            arg[1,2,2,0]=(0.705362155032)*x[0]
73184            arg[1,2,2,1]=(0.54476742883)*x[1]
73185            arg[1,2,2,2]=(-0.331195064878)*x[2]
73186            arg[1,3,0,0]=(-0.360927441647)*x[0]
73187            arg[1,3,0,1]=(0.230772030282)*x[1]
73188            arg[1,3,0,2]=(0.912342489431)*x[2]
73189            arg[1,3,1,0]=(-0.817510690014)*x[0]
73190            arg[1,3,1,1]=(0.397583721353)*x[1]
73191            arg[1,3,1,2]=(-0.982551067917)*x[2]
73192            arg[1,3,2,0]=(0.86380240427)*x[0]
73193            arg[1,3,2,1]=(-0.415018976841)*x[1]
73194            arg[1,3,2,2]=(0.271582572267)*x[2]
73195            arg[1,4,0,0]=(0.252845347406)*x[0]
73196            arg[1,4,0,1]=(0.687786802906)*x[1]
73197            arg[1,4,0,2]=(0.465501171342)*x[2]
73198            arg[1,4,1,0]=(-0.613703721675)*x[0]
73199            arg[1,4,1,1]=(-0.110297640533)*x[1]
73200            arg[1,4,1,2]=(-0.836768056501)*x[2]
73201            arg[1,4,2,0]=(-0.0400898232224)*x[0]
73202            arg[1,4,2,1]=(0.0358172759009)*x[1]
73203            arg[1,4,2,2]=(-0.335751455408)*x[2]
73204            arg[2,0,0,0]=(-0.309992915015)*x[0]
73205            arg[2,0,0,1]=(-0.721404217867)*x[1]
73206            arg[2,0,0,2]=(-0.548000635629)*x[2]
73207            arg[2,0,1,0]=(0.651175831531)*x[0]
73208            arg[2,0,1,1]=(0.158960783491)*x[1]
73209            arg[2,0,1,2]=(-0.310676926155)*x[2]
73210            arg[2,0,2,0]=(-0.122289734411)*x[0]
73211            arg[2,0,2,1]=(-0.252405938421)*x[1]
73212            arg[2,0,2,2]=(-0.938280244213)*x[2]
73213            arg[2,1,0,0]=(0.559495801686)*x[0]
73214            arg[2,1,0,1]=(-0.547182622716)*x[1]
73215            arg[2,1,0,2]=(0.397441517898)*x[2]
73216            arg[2,1,1,0]=(-0.406112472071)*x[0]
73217            arg[2,1,1,1]=(0.355063810677)*x[1]
73218            arg[2,1,1,2]=(0.760400203215)*x[2]
73219            arg[2,1,2,0]=(0.992201320481)*x[0]
73220            arg[2,1,2,1]=(0.0580660882576)*x[1]
73221            arg[2,1,2,2]=(-0.643170879939)*x[2]
73222            arg[2,2,0,0]=(-0.280644461832)*x[0]
73223            arg[2,2,0,1]=(-0.0467430285531)*x[1]
73224            arg[2,2,0,2]=(0.314050593255)*x[2]
73225            arg[2,2,1,0]=(-0.230032618609)*x[0]
73226            arg[2,2,1,1]=(0.0996058698273)*x[1]
73227            arg[2,2,1,2]=(-0.0270266073208)*x[2]
73228            arg[2,2,2,0]=(0.767914132956)*x[0]
73229            arg[2,2,2,1]=(0.496930363612)*x[1]
73230            arg[2,2,2,2]=(-0.599525033616)*x[2]
73231            arg[2,3,0,0]=(-0.326433376073)*x[0]
73232            arg[2,3,0,1]=(-0.0366374501025)*x[1]
73233            arg[2,3,0,2]=(0.22555705749)*x[2]
73234            arg[2,3,1,0]=(-0.162548813895)*x[0]
73235            arg[2,3,1,1]=(-0.110074212194)*x[1]
73236            arg[2,3,1,2]=(-0.143600895553)*x[2]
73237            arg[2,3,2,0]=(0.771148880174)*x[0]
73238            arg[2,3,2,1]=(0.112528116552)*x[1]
73239            arg[2,3,2,2]=(-0.955735294341)*x[2]
73240            arg[2,4,0,0]=(-0.968392951034)*x[0]
73241            arg[2,4,0,1]=(-0.36901708507)*x[1]
73242            arg[2,4,0,2]=(0.283692515492)*x[2]
73243            arg[2,4,1,0]=(0.997238032837)*x[0]
73244            arg[2,4,1,1]=(-0.625794124653)*x[1]
73245            arg[2,4,1,2]=(0.533386027556)*x[2]
73246            arg[2,4,2,0]=(0.977311695557)*x[0]
73247            arg[2,4,2,1]=(0.693009976689)*x[1]
73248            arg[2,4,2,2]=(0.711179347652)*x[2]
73249            arg[3,0,0,0]=(-0.155585788931)*x[0]
73250            arg[3,0,0,1]=(0.0228078851234)*x[1]
73251            arg[3,0,0,2]=(0.510104938032)*x[2]
73252            arg[3,0,1,0]=(0.74865995369)*x[0]
73253            arg[3,0,1,1]=(0.672153736284)*x[1]
73254            arg[3,0,1,2]=(0.588012355098)*x[2]
73255            arg[3,0,2,0]=(-0.924508475715)*x[0]
73256            arg[3,0,2,1]=(-0.392784674758)*x[1]
73257            arg[3,0,2,2]=(-0.36371454642)*x[2]
73258            arg[3,1,0,0]=(-0.709783490337)*x[0]
73259            arg[3,1,0,1]=(0.844136172222)*x[1]
73260            arg[3,1,0,2]=(0.621011730043)*x[2]
73261            arg[3,1,1,0]=(0.428807337181)*x[0]
73262            arg[3,1,1,1]=(0.126300214574)*x[1]
73263            arg[3,1,1,2]=(0.795972806221)*x[2]
73264            arg[3,1,2,0]=(-0.252334324004)*x[0]
73265            arg[3,1,2,1]=(-0.722829467938)*x[1]
73266            arg[3,1,2,2]=(-0.551540062366)*x[2]
73267            arg[3,2,0,0]=(-0.134668475963)*x[0]
73268            arg[3,2,0,1]=(-0.598747540536)*x[1]
73269            arg[3,2,0,2]=(0.426422436624)*x[2]
73270            arg[3,2,1,0]=(-0.363050323762)*x[0]
73271            arg[3,2,1,1]=(0.980891457977)*x[1]
73272            arg[3,2,1,2]=(0.162831912555)*x[2]
73273            arg[3,2,2,0]=(-0.126505493475)*x[0]
73274            arg[3,2,2,1]=(-0.578567864811)*x[1]
73275            arg[3,2,2,2]=(-0.509843129095)*x[2]
73276            arg[3,3,0,0]=(-0.446171262265)*x[0]
73277            arg[3,3,0,1]=(-0.715175197494)*x[1]
73278            arg[3,3,0,2]=(-0.881016888806)*x[2]
73279            arg[3,3,1,0]=(-0.942020866327)*x[0]
73280            arg[3,3,1,1]=(0.156434646828)*x[1]
73281            arg[3,3,1,2]=(0.523624761583)*x[2]
73282            arg[3,3,2,0]=(-0.683550923926)*x[0]
73283            arg[3,3,2,1]=(0.857075218033)*x[1]
73284            arg[3,3,2,2]=(0.297672594023)*x[2]
73285            arg[3,4,0,0]=(0.74317121113)*x[0]
73286            arg[3,4,0,1]=(0.076464540756)*x[1]
73287            arg[3,4,0,2]=(0.781965468281)*x[2]
73288            arg[3,4,1,0]=(0.417750169098)*x[0]
73289            arg[3,4,1,1]=(0.82275428729)*x[1]
73290            arg[3,4,1,2]=(0.919072321093)*x[2]
73291            arg[3,4,2,0]=(-0.0246706472217)*x[0]
73292            arg[3,4,2,1]=(0.179863245513)*x[1]
73293            arg[3,4,2,2]=(0.539115287766)*x[2]
73294            ref=sqrt((52.492676775)*(2.*dim+1.)/3.)
73295    
73296          res=L2(arg)
73297          self.failUnless(isinstance(res,float),"wrong type of result.")
73298          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
73299       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
73300       def test_L2_onFunctionOnBoundary_fromSymbol_rank0(self):
73301          """
73302          tests L2-norm of Symbol on the FunctionOnBoundary
73303    
73304          assumptions: self.domain supports integration on FunctionOnBoundary
73305          """
73306          dim=self.domain.getDim()
73307          w=FunctionOnBoundary(self.domain)
73308          x=w.getX()
73309          if dim==2:
73310            arg=Symbol(shape=(),dim=dim)
73311            s=Data(0,(),w)
73312            s=(0.0248400067683)*x[0]
73313            ref=sqrt((0.000617025936249)*(2.*dim+1.)/3.)
73314    
73315          else:
73316            arg=Symbol(shape=(),dim=dim)
73317            s=Data(0,(),w)
73318            s=(-0.48069197083)*x[0]
73319            ref=sqrt((0.23106477082)*(2.*dim+1.)/3.)
73320    
73321          res=L2(arg)
73322          sub=res.substitute({arg:s})
73323          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
73324          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
73325          self.failUnlessAlmostEqual(sub,ref,int(-log10(self.RES_TOL)),"wrong result")
73326       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
73327       def test_L2_onFunctionOnBoundary_fromSymbol_rank1(self):
73328          """
73329          tests L2-norm of Symbol on the FunctionOnBoundary
73330    
73331          assumptions: self.domain supports integration on FunctionOnBoundary
73332          """
73333          dim=self.domain.getDim()
73334          w=FunctionOnBoundary(self.domain)
73335          x=w.getX()
73336          if dim==2:
73337            arg=Symbol(shape=(2,),dim=dim)
73338            s=Data(0,(2,),w)
73339            s[0]=(0.541099842991)*x[0]
73340            s[1]=(0.123212139947)*x[1]
73341            ref=sqrt((0.307970271515)*(2.*dim+1.)/3.)
73342    
73343          else:
73344            arg=Symbol(shape=(3,),dim=dim)
73345            s=Data(0,(3,),w)
73346            s[0]=(-0.74011573744)*x[0]
73347            s[1]=(0.63543826621)*x[1]
73348            s[2]=(-0.210366750156)*x[2]
73349            ref=sqrt((0.995807264541)*(2.*dim+1.)/3.)
73350    
73351          res=L2(arg)
73352          sub=res.substitute({arg:s})
73353          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
73354          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
73355          self.failUnlessAlmostEqual(sub,ref,int(-log10(self.RES_TOL)),"wrong result")
73356       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
73357       def test_L2_onFunctionOnBoundary_fromSymbol_rank2(self):
73358          """
73359          tests L2-norm of Symbol on the FunctionOnBoundary
73360    
73361          assumptions: self.domain supports integration on FunctionOnBoundary
73362          """
73363          dim=self.domain.getDim()
73364          w=FunctionOnBoundary(self.domain)
73365          x=w.getX()
73366          if dim==2:
73367            arg=Symbol(shape=(4, 2),dim=dim)
73368            s=Data(0,(4, 2),w)
73369            s[0,0]=(-0.324596599761)*x[0]
73370            s[0,1]=(0.456181444086)*x[1]
73371            s[1,0]=(-0.85366968746)*x[0]
73372            s[1,1]=(-0.984222055109)*x[1]
73373            s[2,0]=(0.302615209563)*x[0]
73374            s[2,1]=(-0.259853865003)*x[1]
73375            s[3,0]=(-0.2851901062)*x[0]
73376            s[3,1]=(0.790097073483)*x[1]
73377            ref=sqrt((2.87559622997)*(2.*dim+1.)/3.)
73378    
73379          else:
73380            arg=Symbol(shape=(4, 3),dim=dim)
73381            s=Data(0,(4, 3),w)
73382            s[0,0]=(0.806171559469)*x[0]
73383            s[0,1]=(0.734186538041)*x[1]
73384            s[0,2]=(0.376885565623)*x[2]
73385            s[1,0]=(-0.168339360861)*x[0]
73386            s[1,1]=(-0.184538096909)*x[1]
73387            s[1,2]=(-0.649204637511)*x[2]
73388            s[2,0]=(0.0187762580033)*x[0]
73389            s[2,1]=(-0.851287373276)*x[1]
73390            s[2,2]=(0.84351620048)*x[2]
73391            s[3,0]=(0.759367087847)*x[0]
73392            s[3,1]=(-0.418326808815)*x[1]
73393            s[3,2]=(0.207925273666)*x[2]
73394            ref=sqrt((4.04627522925)*(2.*dim+1.)/3.)
73395    
73396          res=L2(arg)
73397          sub=res.substitute({arg:s})
73398          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
73399          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
73400          self.failUnlessAlmostEqual(sub,ref,int(-log10(self.RES_TOL)),"wrong result")
73401       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
73402       def test_L2_onFunctionOnBoundary_fromSymbol_rank3(self):
73403          """
73404          tests L2-norm of Symbol on the FunctionOnBoundary
73405    
73406          assumptions: self.domain supports integration on FunctionOnBoundary
73407          """
73408          dim=self.domain.getDim()
73409          w=FunctionOnBoundary(self.domain)
73410          x=w.getX()
73411          if dim==2:
73412            arg=Symbol(shape=(6, 2, 2),dim=dim)
73413            s=Data(0,(6, 2, 2),w)
73414            s[0,0,0]=(0.656602395169)*x[0]
73415            s[0,0,1]=(-0.153988287938)*x[1]
73416            s[0,1,0]=(-0.911070962892)*x[0]
73417            s[0,1,1]=(0.734617382897)*x[1]
73418            s[1,0,0]=(0.708777892683)*x[0]
73419            s[1,0,1]=(0.407403464363)*x[1]
73420            s[1,1,0]=(-0.73004005055)*x[0]
73421            s[1,1,1]=(0.108502620047)*x[1]
73422            s[2,0,0]=(0.584913648885)*x[0]
73423            s[2,0,1]=(0.655698697233)*x[1]
73424            s[2,1,0]=(0.504301542359)*x[0]
73425            s[2,1,1]=(-0.637819233396)*x[1]
73426            s[3,0,0]=(0.395391847846)*x[0]
73427            s[3,0,1]=(-0.136070177387)*x[1]
73428            s[3,1,0]=(0.77444662439)*x[0]
73429            s[3,1,1]=(0.245316754174)*x[1]
73430            s[4,0,0]=(0.542716832119)*x[0]
73431            s[4,0,1]=(0.0202895164815)*x[1]
73432            s[4,1,0]=(0.922586929777)*x[0]
73433            s[4,1,1]=(-0.948487993154)*x[1]
73434            s[5,0,0]=(0.629779082528)*x[0]
73435            s[5,0,1]=(-0.90719864412)*x[1]
73436            s[5,1,0]=(-0.29521666306)*x[0]
73437            s[5,1,1]=(-0.431748113769)*x[1]
73438            ref=sqrt((8.84456266856)*(2.*dim+1.)/3.)
73439    
73440          else:
73441            arg=Symbol(shape=(6, 2, 3),dim=dim)
73442            s=Data(0,(6, 2, 3),w)
73443            s[0,0,0]=(0.529698924744)*x[0]
73444            s[0,0,1]=(0.779440018368)*x[1]
73445            s[0,0,2]=(-0.447704804318)*x[2]
73446            s[0,1,0]=(0.375433500828)*x[0]
73447            s[0,1,1]=(-0.567989496415)*x[1]
73448            s[0,1,2]=(-0.47133957857)*x[2]
73449            s[1,0,0]=(0.379156720923)*x[0]
73450            s[1,0,1]=(-0.629670565361)*x[1]
73451            s[1,0,2]=(0.814298387366)*x[2]
73452            s[1,1,0]=(-0.482876103672)*x[0]
73453            s[1,1,1]=(-0.592362629566)*x[1]
73454            s[1,1,2]=(0.368859438611)*x[2]
73455            s[2,0,0]=(0.145060478226)*x[0]
73456            s[2,0,1]=(-0.582989521856)*x[1]
73457            s[2,0,2]=(-0.977335802848)*x[2]
73458            s[2,1,0]=(-0.471820598698)*x[0]
73459            s[2,1,1]=(-0.680071585031)*x[1]
73460            s[2,1,2]=(-0.686102402643)*x[2]
73461            s[3,0,0]=(-0.647535125154)*x[0]
73462            s[3,0,1]=(-0.739392553517)*x[1]
73463            s[3,0,2]=(-0.0852792216585)*x[2]
73464            s[3,1,0]=(-0.0197635627728)*x[0]
73465            s[3,1,1]=(-0.811782244587)*x[1]
73466            s[3,1,2]=(0.842974983966)*x[2]
73467            s[4,0,0]=(-0.765665515246)*x[0]
73468            s[4,0,1]=(-0.379368211948)*x[1]
73469            s[4,0,2]=(-0.864157207524)*x[2]
73470            s[4,1,0]=(-0.393989909405)*x[0]
73471            s[4,1,1]=(0.482309706914)*x[1]
73472            s[4,1,2]=(-0.80068507467)*x[2]
73473            s[5,0,0]=(-0.686334218925)*x[0]
73474            s[5,0,1]=(-0.414623392196)*x[1]
73475            s[5,0,2]=(-0.689227675292)*x[2]
73476            s[5,1,0]=(0.347067831012)*x[0]
73477            s[5,1,1]=(0.675600902408)*x[1]
73478            s[5,1,2]=(-0.763467841004)*x[2]
73479            ref=sqrt((13.2965907789)*(2.*dim+1.)/3.)
73480    
73481          res=L2(arg)
73482          sub=res.substitute({arg:s})
73483          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
73484          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
73485          self.failUnlessAlmostEqual(sub,ref,int(-log10(self.RES_TOL)),"wrong result")
73486       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
73487       def test_L2_onFunctionOnBoundary_fromSymbol_rank4(self):
73488          """
73489          tests L2-norm of Symbol on the FunctionOnBoundary
73490    
73491          assumptions: self.domain supports integration on FunctionOnBoundary
73492          """
73493          dim=self.domain.getDim()
73494          w=FunctionOnBoundary(self.domain)
73495          x=w.getX()
73496          if dim==2:
73497            arg=Symbol(shape=(4, 5, 3, 2),dim=dim)
73498            s=Data(0,(4, 5, 3, 2),w)
73499            s[0,0,0,0]=(0.478851101914)*x[0]
73500            s[0,0,0,1]=(-0.669115623243)*x[1]
73501            s[0,0,1,0]=(0.169431656457)*x[0]
73502            s[0,0,1,1]=(-0.154130248518)*x[1]
73503            s[0,0,2,0]=(0.590784906322)*x[0]
73504            s[0,0,2,1]=(-0.843193872964)*x[1]
73505            s[0,1,0,0]=(0.040548638805)*x[0]
73506            s[0,1,0,1]=(0.0223688163494)*x[1]
73507            s[0,1,1,0]=(0.591094685655)*x[0]
73508            s[0,1,1,1]=(0.692105812582)*x[1]
73509            s[0,1,2,0]=(-0.326832256739)*x[0]
73510            s[0,1,2,1]=(0.824824822029)*x[1]
73511            s[0,2,0,0]=(-0.352757110519)*x[0]
73512            s[0,2,0,1]=(-0.898616847036)*x[1]
73513            s[0,2,1,0]=(0.972018635849)*x[0]
73514            s[0,2,1,1]=(0.64223146835)*x[1]
73515            s[0,2,2,0]=(0.599638014876)*x[0]
73516            s[0,2,2,1]=(0.665927987689)*x[1]
73517            s[0,3,0,0]=(-0.757282087611)*x[0]
73518            s[0,3,0,1]=(-0.541306038159)*x[1]
73519            s[0,3,1,0]=(0.443494146532)*x[0]
73520            s[0,3,1,1]=(-0.125404019651)*x[1]
73521            s[0,3,2,0]=(0.234422087306)*x[0]
73522            s[0,3,2,1]=(0.443982420301)*x[1]
73523            s[0,4,0,0]=(0.46454740036)*x[0]
73524            s[0,4,0,1]=(-0.479031824057)*x[1]
73525            s[0,4,1,0]=(-0.304056971991)*x[0]
73526            s[0,4,1,1]=(-0.763293280009)*x[1]
73527            s[0,4,2,0]=(-0.142796685199)*x[0]
73528            s[0,4,2,1]=(0.301022025426)*x[1]
73529            s[1,0,0,0]=(-0.843399285738)*x[0]
73530            s[1,0,0,1]=(0.639837980509)*x[1]
73531            s[1,0,1,0]=(-0.649024291296)*x[0]
73532            s[1,0,1,1]=(0.645960995308)*x[1]
73533            s[1,0,2,0]=(0.0862852468825)*x[0]
73534            s[1,0,2,1]=(-0.399237566917)*x[1]
73535            s[1,1,0,0]=(0.959425187971)*x[0]
73536            s[1,1,0,1]=(0.65407910284)*x[1]
73537            s[1,1,1,0]=(0.873927579655)*x[0]
73538            s[1,1,1,1]=(0.399448652787)*x[1]
73539            s[1,1,2,0]=(-0.363863298937)*x[0]
73540            s[1,1,2,1]=(0.555310285452)*x[1]
73541            s[1,2,0,0]=(0.962712099815)*x[0]
73542            s[1,2,0,1]=(0.141495259052)*x[1]
73543            s[1,2,1,0]=(-0.819117296209)*x[0]
73544            s[1,2,1,1]=(-0.752934712352)*x[1]
73545            s[1,2,2,0]=(0.065886700262)*x[0]
73546            s[1,2,2,1]=(-0.530225381274)*x[1]
73547            s[1,3,0,0]=(0.830686848377)*x[0]
73548            s[1,3,0,1]=(0.139854694845)*x[1]
73549            s[1,3,1,0]=(0.869755726605)*x[0]
73550            s[1,3,1,1]=(0.145889500911)*x[1]
73551            s[1,3,2,0]=(-0.690283765486)*x[0]
73552            s[1,3,2,1]=(-0.790245562042)*x[1]
73553            s[1,4,0,0]=(0.704042980492)*x[0]
73554            s[1,4,0,1]=(-0.692268480039)*x[1]
73555            s[1,4,1,0]=(-0.708898941564)*x[0]
73556            s[1,4,1,1]=(-0.675824414677)*x[1]
73557            s[1,4,2,0]=(0.320394083261)*x[0]
73558            s[1,4,2,1]=(0.173795411968)*x[1]
73559            s[2,0,0,0]=(0.707844986267)*x[0]
73560            s[2,0,0,1]=(0.991847131293)*x[1]
73561            s[2,0,1,0]=(0.470933752596)*x[0]
73562            s[2,0,1,1]=(0.847427404272)*x[1]
73563            s[2,0,2,0]=(0.383056136263)*x[0]
73564            s[2,0,2,1]=(-0.717411302782)*x[1]
73565            s[2,1,0,0]=(0.118326527818)*x[0]
73566            s[2,1,0,1]=(0.0957434761651)*x[1]
73567            s[2,1,1,0]=(-0.420654904504)*x[0]
73568            s[2,1,1,1]=(0.31903393188)*x[1]
73569            s[2,1,2,0]=(0.0597937431476)*x[0]
73570            s[2,1,2,1]=(0.965201628622)*x[1]
73571            s[2,2,0,0]=(0.884709108482)*x[0]
73572            s[2,2,0,1]=(-0.541160500366)*x[1]
73573            s[2,2,1,0]=(-0.180788996448)*x[0]
73574            s[2,2,1,1]=(-0.44537512426)*x[1]
73575            s[2,2,2,0]=(-0.291513668432)*x[0]
73576            s[2,2,2,1]=(0.349090737561)*x[1]
73577            s[2,3,0,0]=(0.0994765186043)*x[0]
73578            s[2,3,0,1]=(-0.317258869646)*x[1]
73579            s[2,3,1,0]=(0.661005398598)*x[0]
73580            s[2,3,1,1]=(-0.914254206568)*x[1]
73581            s[2,3,2,0]=(-0.374142249366)*x[0]
73582            s[2,3,2,1]=(-0.587651938713)*x[1]
73583            s[2,4,0,0]=(-0.0990354726919)*x[0]
73584            s[2,4,0,1]=(-0.104596309056)*x[1]
73585            s[2,4,1,0]=(0.183201845594)*x[0]
73586            s[2,4,1,1]=(-0.265185815743)*x[1]
73587            s[2,4,2,0]=(0.804060169933)*x[0]
73588            s[2,4,2,1]=(-0.0798336799535)*x[1]
73589            s[3,0,0,0]=(-0.470265711106)*x[0]
73590            s[3,0,0,1]=(0.123030821016)*x[1]
73591            s[3,0,1,0]=(0.971878570072)*x[0]
73592            s[3,0,1,1]=(0.557374437558)*x[1]
73593            s[3,0,2,0]=(0.771881325143)*x[0]
73594            s[3,0,2,1]=(-0.181917882935)*x[1]
73595            s[3,1,0,0]=(-0.30330086877)*x[0]
73596            s[3,1,0,1]=(0.785561830696)*x[1]
73597            s[3,1,1,0]=(0.0783160883668)*x[0]
73598            s[3,1,1,1]=(-0.192122642565)*x[1]
73599            s[3,1,2,0]=(-0.294486881116)*x[0]
73600            s[3,1,2,1]=(0.533158403133)*x[1]
73601            s[3,2,0,0]=(-0.413737404117)*x[0]
73602            s[3,2,0,1]=(0.622363162902)*x[1]
73603            s[3,2,1,0]=(0.241741847782)*x[0]
73604            s[3,2,1,1]=(-0.0541594558102)*x[1]
73605            s[3,2,2,0]=(0.157759963106)*x[0]
73606            s[3,2,2,1]=(-0.833376953416)*x[1]
73607            s[3,3,0,0]=(-0.671630074873)*x[0]
73608            s[3,3,0,1]=(-0.10840086864)*x[1]
73609            s[3,3,1,0]=(-0.995501368513)*x[0]
73610            s[3,3,1,1]=(-0.153147007921)*x[1]
73611            s[3,3,2,0]=(-0.504815129335)*x[0]
73612            s[3,3,2,1]=(-0.489511115245)*x[1]
73613            s[3,4,0,0]=(0.206555206064)*x[0]
73614            s[3,4,0,1]=(-0.294058867178)*x[1]
73615            s[3,4,1,0]=(-0.571176824119)*x[0]
73616            s[3,4,1,1]=(0.353847783519)*x[1]
73617            s[3,4,2,0]=(-0.441012644459)*x[0]
73618            s[3,4,2,1]=(0.198182379551)*x[1]
73619            ref=sqrt((36.8775562848)*(2.*dim+1.)/3.)
73620    
73621          else:
73622            arg=Symbol(shape=(4, 5, 3, 3),dim=dim)
73623            s=Data(0,(4, 5, 3, 3),w)
73624            s[0,0,0,0]=(-0.391342187918)*x[0]
73625            s[0,0,0,1]=(-0.807670030995)*x[1]
73626            s[0,0,0,2]=(-0.730776810158)*x[2]
73627            s[0,0,1,0]=(-0.640249702579)*x[0]
73628            s[0,0,1,1]=(-0.0944608864404)*x[1]
73629            s[0,0,1,2]=(0.852922834544)*x[2]
73630            s[0,0,2,0]=(0.0996848239317)*x[0]
73631            s[0,0,2,1]=(-0.323310001677)*x[1]
73632            s[0,0,2,2]=(-0.311089889753)*x[2]
73633            s[0,1,0,0]=(-0.294816251058)*x[0]
73634            s[0,1,0,1]=(0.939389998027)*x[1]
73635            s[0,1,0,2]=(0.900617063513)*x[2]
73636            s[0,1,1,0]=(-0.961986583089)*x[0]
73637            s[0,1,1,1]=(0.629473020335)*x[1]
73638            s[0,1,1,2]=(-0.215446848397)*x[2]
73639            s[0,1,2,0]=(-0.256062202737)*x[0]
73640            s[0,1,2,1]=(0.497231616486)*x[1]
73641            s[0,1,2,2]=(-0.813869122359)*x[2]
73642            s[0,2,0,0]=(0.352147663827)*x[0]
73643            s[0,2,0,1]=(0.553022457414)*x[1]
73644            s[0,2,0,2]=(-0.340077213113)*x[2]
73645            s[0,2,1,0]=(0.654397833915)*x[0]
73646            s[0,2,1,1]=(-0.34308640744)*x[1]
73647            s[0,2,1,2]=(-0.689126280824)*x[2]
73648            s[0,2,2,0]=(0.428183196531)*x[0]
73649            s[0,2,2,1]=(-0.322384435092)*x[1]
73650            s[0,2,2,2]=(0.636495513573)*x[2]
73651            s[0,3,0,0]=(0.214083660816)*x[0]
73652            s[0,3,0,1]=(0.312445001293)*x[1]
73653            s[0,3,0,2]=(-0.939086993471)*x[2]
73654            s[0,3,1,0]=(-0.0668860159236)*x[0]
73655            s[0,3,1,1]=(0.591012248354)*x[1]
73656            s[0,3,1,2]=(0.696149816619)*x[2]
73657            s[0,3,2,0]=(0.917050906357)*x[0]
73658            s[0,3,2,1]=(-0.695398022945)*x[1]
73659            s[0,3,2,2]=(0.578841930671)*x[2]
73660            s[0,4,0,0]=(-0.321769393495)*x[0]
73661            s[0,4,0,1]=(-0.761161601481)*x[1]
73662            s[0,4,0,2]=(0.000116192661055)*x[2]
73663            s[0,4,1,0]=(0.347135267821)*x[0]
73664            s[0,4,1,1]=(-0.0105215354141)*x[1]
73665            s[0,4,1,2]=(0.582827998159)*x[2]
73666            s[0,4,2,0]=(0.765317199582)*x[0]
73667            s[0,4,2,1]=(0.546093510978)*x[1]
73668            s[0,4,2,2]=(-0.753832119978)*x[2]
73669            s[1,0,0,0]=(-0.163230444043)*x[0]
73670            s[1,0,0,1]=(0.415060470539)*x[1]
73671            s[1,0,0,2]=(0.638843786094)*x[2]
73672            s[1,0,1,0]=(-0.320730240187)*x[0]
73673            s[1,0,1,1]=(-0.369428894975)*x[1]
73674            s[1,0,1,2]=(-0.944414569234)*x[2]
73675            s[1,0,2,0]=(0.580606041923)*x[0]
73676            s[1,0,2,1]=(-0.351082080131)*x[1]
73677            s[1,0,2,2]=(-0.170588782574)*x[2]
73678            s[1,1,0,0]=(0.323136286071)*x[0]
73679            s[1,1,0,1]=(0.397263600918)*x[1]
73680            s[1,1,0,2]=(-0.687508659585)*x[2]
73681            s[1,1,1,0]=(-0.997412227958)*x[0]
73682            s[1,1,1,1]=(0.968968702091)*x[1]
73683            s[1,1,1,2]=(-0.223523055076)*x[2]
73684            s[1,1,2,0]=(-0.495473193251)*x[0]
73685            s[1,1,2,1]=(-0.00758436986969)*x[1]
73686            s[1,1,2,2]=(0.0770020818673)*x[2]
73687            s[1,2,0,0]=(-0.522152049391)*x[0]
73688            s[1,2,0,1]=(0.820143671384)*x[1]
73689            s[1,2,0,2]=(0.672347144349)*x[2]
73690            s[1,2,1,0]=(-0.868655459375)*x[0]
73691            s[1,2,1,1]=(-0.698503510192)*x[1]
73692            s[1,2,1,2]=(0.16866148235)*x[2]
73693            s[1,2,2,0]=(0.291645089215)*x[0]
73694            s[1,2,2,1]=(0.375705968271)*x[1]
73695            s[1,2,2,2]=(0.047575084848)*x[2]
73696            s[1,3,0,0]=(-0.856292393733)*x[0]
73697            s[1,3,0,1]=(0.741997693375)*x[1]
73698            s[1,3,0,2]=(0.922057641142)*x[2]
73699            s[1,3,1,0]=(-0.0246230217779)*x[0]
73700            s[1,3,1,1]=(0.233511225618)*x[1]
73701            s[1,3,1,2]=(-0.128732881848)*x[2]
73702            s[1,3,2,0]=(0.437273172814)*x[0]
73703            s[1,3,2,1]=(-0.24673804436)*x[1]
73704            s[1,3,2,2]=(0.834689693971)*x[2]
73705            s[1,4,0,0]=(0.0567731436429)*x[0]
73706            s[1,4,0,1]=(-0.523439015055)*x[1]
73707            s[1,4,0,2]=(-0.175105109157)*x[2]
73708            s[1,4,1,0]=(-0.783819538589)*x[0]
73709            s[1,4,1,1]=(0.722409822905)*x[1]
73710            s[1,4,1,2]=(-0.99480794117)*x[2]
73711            s[1,4,2,0]=(-0.0948610680733)*x[0]
73712            s[1,4,2,1]=(-0.0934034446625)*x[1]
73713            s[1,4,2,2]=(0.993222484498)*x[2]
73714            s[2,0,0,0]=(-0.739506857296)*x[0]
73715            s[2,0,0,1]=(-0.402129626454)*x[1]
73716            s[2,0,0,2]=(-0.131164073645)*x[2]
73717            s[2,0,1,0]=(-0.185068425131)*x[0]
73718            s[2,0,1,1]=(-0.888669413054)*x[1]
73719            s[2,0,1,2]=(0.149638740783)*x[2]
73720            s[2,0,2,0]=(-0.977520384)*x[0]
73721            s[2,0,2,1]=(0.495784511707)*x[1]
73722            s[2,0,2,2]=(0.140779930302)*x[2]
73723            s[2,1,0,0]=(-0.668882409761)*x[0]
73724            s[2,1,0,1]=(0.87881226199)*x[1]
73725            s[2,1,0,2]=(0.596921491285)*x[2]
73726            s[2,1,1,0]=(0.327990184264)*x[0]
73727            s[2,1,1,1]=(-0.842310366654)*x[1]
73728            s[2,1,1,2]=(-0.104630179971)*x[2]
73729            s[2,1,2,0]=(-0.997782736966)*x[0]
73730            s[2,1,2,1]=(0.362490263673)*x[1]
73731            s[2,1,2,2]=(-0.919527812431)*x[2]
73732            s[2,2,0,0]=(-0.694141113242)*x[0]
73733            s[2,2,0,1]=(-0.189176840568)*x[1]
73734            s[2,2,0,2]=(-0.305307574884)*x[2]
73735            s[2,2,1,0]=(0.97520770841)*x[0]
73736            s[2,2,1,1]=(0.709672831962)*x[1]
73737            s[2,2,1,2]=(-0.056408975067)*x[2]
73738            s[2,2,2,0]=(-0.491153842737)*x[0]
73739            s[2,2,2,1]=(-0.487533744248)*x[1]
73740            s[2,2,2,2]=(-0.16258274458)*x[2]
73741            s[2,3,0,0]=(0.69721543109)*x[0]
73742            s[2,3,0,1]=(-0.927116706183)*x[1]
73743            s[2,3,0,2]=(-0.277453826622)*x[2]
73744            s[2,3,1,0]=(-0.530246149296)*x[0]
73745            s[2,3,1,1]=(0.971840533777)*x[1]
73746            s[2,3,1,2]=(-0.472599623799)*x[2]
73747            s[2,3,2,0]=(0.772149184332)*x[0]
73748            s[2,3,2,1]=(-0.644107019603)*x[1]
73749            s[2,3,2,2]=(-0.537937585926)*x[2]
73750            s[2,4,0,0]=(-0.786226779015)*x[0]
73751            s[2,4,0,1]=(-0.132798607299)*x[1]
73752            s[2,4,0,2]=(-0.954772620074)*x[2]
73753            s[2,4,1,0]=(-0.378657907627)*x[0]
73754            s[2,4,1,1]=(0.896332243914)*x[1]
73755            s[2,4,1,2]=(-0.980811837061)*x[2]
73756            s[2,4,2,0]=(-0.033610987457)*x[0]
73757            s[2,4,2,1]=(0.301124520167)*x[1]
73758            s[2,4,2,2]=(0.505461084966)*x[2]
73759            s[3,0,0,0]=(0.92844681553)*x[0]
73760            s[3,0,0,1]=(-0.833141539681)*x[1]
73761            s[3,0,0,2]=(-0.219378232103)*x[2]
73762            s[3,0,1,0]=(-0.342722442206)*x[0]
73763            s[3,0,1,1]=(0.662705183551)*x[1]
73764            s[3,0,1,2]=(0.544702876622)*x[2]
73765            s[3,0,2,0]=(-0.984992104327)*x[0]
73766            s[3,0,2,1]=(-0.118846731)*x[1]
73767            s[3,0,2,2]=(-0.850203016683)*x[2]
73768            s[3,1,0,0]=(0.797626533525)*x[0]
73769            s[3,1,0,1]=(-0.415519060262)*x[1]
73770            s[3,1,0,2]=(-0.629491781709)*x[2]
73771            s[3,1,1,0]=(0.223213637134)*x[0]
73772            s[3,1,1,1]=(0.824993414773)*x[1]
73773            s[3,1,1,2]=(0.141523286845)*x[2]
73774            s[3,1,2,0]=(-0.66436462404)*x[0]
73775            s[3,1,2,1]=(-0.854989422144)*x[1]
73776            s[3,1,2,2]=(-0.0354537218933)*x[2]
73777            s[3,2,0,0]=(-0.0988394772118)*x[0]
73778            s[3,2,0,1]=(0.125214003041)*x[1]
73779            s[3,2,0,2]=(-0.701121659493)*x[2]
73780            s[3,2,1,0]=(-0.603538097381)*x[0]
73781            s[3,2,1,1]=(-0.659139390328)*x[1]
73782            s[3,2,1,2]=(-0.849986094805)*x[2]
73783            s[3,2,2,0]=(-0.545364489526)*x[0]
73784            s[3,2,2,1]=(-0.90842178441)*x[1]
73785            s[3,2,2,2]=(-0.650251007613)*x[2]
73786            s[3,3,0,0]=(0.943460211337)*x[0]
73787            s[3,3,0,1]=(-0.707864979205)*x[1]
73788            s[3,3,0,2]=(0.9885932761)*x[2]
73789            s[3,3,1,0]=(0.127650934393)*x[0]
73790            s[3,3,1,1]=(-0.495451047906)*x[1]
73791            s[3,3,1,2]=(0.641823757246)*x[2]
73792            s[3,3,2,0]=(-0.33331510031)*x[0]
73793            s[3,3,2,1]=(0.922346384165)*x[1]
73794            s[3,3,2,2]=(-0.987453834808)*x[2]
73795            s[3,4,0,0]=(-0.376485044284)*x[0]
73796            s[3,4,0,1]=(0.693296795267)*x[1]
73797            s[3,4,0,2]=(-0.31498404544)*x[2]
73798            s[3,4,1,0]=(0.512477956635)*x[0]
73799            s[3,4,1,1]=(-0.333819138285)*x[1]
73800            s[3,4,1,2]=(0.560322373773)*x[2]
73801            s[3,4,2,0]=(0.889090668029)*x[0]
73802            s[3,4,2,1]=(0.981814634684)*x[1]
73803            s[3,4,2,2]=(-0.41272129735)*x[2]
73804            ref=sqrt((66.7960236856)*(2.*dim+1.)/3.)
73805    
73806          res=L2(arg)
73807          sub=res.substitute({arg:s})
73808          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
73809          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
73810          self.failUnlessAlmostEqual(sub,ref,int(-log10(self.RES_TOL)),"wrong result")
73811       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
73812       def test_L2_onFunctionOnContactZero_fromData_rank0(self):
73813          """
73814          tests L2-norm of Data on the FunctionOnContactZero
73815    
73816          assumptions: self.domain supports integration on FunctionOnContactZero
73817          """
73818          dim=self.domain.getDim()
73819          w=FunctionOnContactZero(self.domain)
73820          x=w.getX()
73821          if dim==2:
73822            arg=Data(0,(),w)
73823            arg=(-0.908822474879)*x[0]
73824            ref=sqrt((0.0)+(0.206489572711))
73825    
73826          else:
73827            arg=Data(0,(),w)
73828            arg=(-0.893168521371)*x[0]
73829            ref=sqrt((0.0)+(0.199437501892))
73830    
73831          res=L2(arg)
73832          self.failUnless(isinstance(res,float),"wrong type of result.")
73833          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
73834       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
73835       def test_L2_onFunctionOnContactZero_fromData_rank1(self):
73836          """
73837          tests L2-norm of Data on the FunctionOnContactZero
73838    
73839          assumptions: self.domain supports integration on FunctionOnContactZero
73840          """
73841          dim=self.domain.getDim()
73842          w=FunctionOnContactZero(self.domain)
73843          x=w.getX()
73844          if dim==2:
73845            arg=Data(0,(2,),w)
73846            arg[0]=(-0.30839170903)*x[0]
73847            arg[1]=(0.108352504587)*x[1]
73848            ref=sqrt((0.00391342175007)+(0.0237763615497))
73849    
73850          else:
73851            arg=Data(0,(3,),w)
73852            arg[0]=(-0.260572084359)*x[0]
73853            arg[1]=(0.250696802346)*x[1]
73854            arg[2]=(-0.498857619202)*x[2]
73855            ref=sqrt((0.103902603647)+(0.0169744527868))
73856    
73857          res=L2(arg)
73858          self.failUnless(isinstance(res,float),"wrong type of result.")
73859          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
73860       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
73861       def test_L2_onFunctionOnContactZero_fromData_rank2(self):
73862          """
73863          tests L2-norm of Data on the FunctionOnContactZero
73864    
73865          assumptions: self.domain supports integration on FunctionOnContactZero
73866          """
73867          dim=self.domain.getDim()
73868          w=FunctionOnContactZero(self.domain)
73869          x=w.getX()
73870          if dim==2:
73871            arg=Data(0,(4, 2),w)
73872            arg[0,0]=(0.0107777943992)*x[0]
73873            arg[0,1]=(0.0188929341636)*x[1]
73874            arg[1,0]=(-0.00268267834861)*x[0]
73875            arg[1,1]=(-0.656039971477)*x[1]
73876            arg[2,0]=(-0.997645982047)*x[0]
73877            arg[2,1]=(0.993049748017)*x[1]
73878            arg[3,0]=(0.938636169945)*x[0]
73879            arg[3,1]=(-0.609892243528)*x[1]
73880            ref=sqrt((0.596287245963)+(0.46911468066))
73881    
73882          else:
73883            arg=Data(0,(4, 3),w)
73884            arg[0,0]=(0.128987155564)*x[0]
73885            arg[0,1]=(-0.582660210551)*x[1]
73886            arg[0,2]=(-0.605040149822)*x[2]
73887            arg[1,0]=(0.494540007291)*x[0]
73888            arg[1,1]=(0.563900397935)*x[1]
73889            arg[1,2]=(-0.806214220737)*x[2]
73890            arg[2,0]=(0.878027993704)*x[0]
73891            arg[2,1]=(0.597165310427)*x[1]
73892            arg[2,2]=(-0.444798130742)*x[2]
73893            arg[3,0]=(0.982067213342)*x[0]
73894            arg[3,1]=(-0.160013302763)*x[1]
73895            arg[3,2]=(-0.490830124654)*x[2]
73896            ref=sqrt((0.831500595262)+(0.49914916859))
73897    
73898          res=L2(arg)
73899          self.failUnless(isinstance(res,float),"wrong type of result.")
73900          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
73901       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
73902       def test_L2_onFunctionOnContactZero_fromData_rank3(self):
73903          """
73904          tests L2-norm of Data on the FunctionOnContactZero
73905    
73906          assumptions: self.domain supports integration on FunctionOnContactZero
73907          """
73908          dim=self.domain.getDim()
73909          w=FunctionOnContactZero(self.domain)
73910          x=w.getX()
73911          if dim==2:
73912            arg=Data(0,(6, 2, 2),w)
73913            arg[0,0,0]=(0.83264345248)*x[0]
73914            arg[0,0,1]=(-0.29697614845)*x[1]
73915            arg[0,1,0]=(-0.903150797089)*x[0]
73916            arg[0,1,1]=(-0.569048463149)*x[1]
73917            arg[1,0,0]=(0.317087339385)*x[0]
73918            arg[1,0,1]=(0.0120740865344)*x[1]
73919            arg[1,1,0]=(-0.221145803457)*x[0]
73920            arg[1,1,1]=(-0.15362409313)*x[1]
73921            arg[2,0,0]=(0.459428065932)*x[0]
73922            arg[2,0,1]=(-0.495488213623)*x[1]
73923            arg[2,1,0]=(0.919114285084)*x[0]
73924            arg[2,1,1]=(0.54511942052)*x[1]
73925            arg[3,0,0]=(0.442207797529)*x[0]
73926            arg[3,0,1]=(0.958341188449)*x[1]
73927            arg[3,1,0]=(-0.0915205976682)*x[0]
73928            arg[3,1,1]=(-0.410964460336)*x[1]
73929            arg[4,0,0]=(-0.243030095673)*x[0]
73930            arg[4,0,1]=(-0.413661756935)*x[1]
73931            arg[4,1,0]=(-0.0973014277464)*x[0]
73932            arg[4,1,1]=(0.204130676874)*x[1]
73933            arg[5,0,0]=(0.38083750131)*x[0]
73934            arg[5,0,1]=(0.286331574579)*x[1]
73935            arg[5,1,0]=(0.583320730408)*x[0]
73936            arg[5,1,1]=(-0.0899419806181)*x[1]
73937            ref=sqrt((0.789530406063)+(0.868006693351))
73938    
73939          else:
73940            arg=Data(0,(6, 2, 3),w)
73941            arg[0,0,0]=(-0.98411764268)*x[0]
73942            arg[0,0,1]=(-0.180549567137)*x[1]
73943            arg[0,0,2]=(0.357923974709)*x[2]
73944            arg[0,1,0]=(0.67691778218)*x[0]
73945            arg[0,1,1]=(-0.643267669153)*x[1]
73946            arg[0,1,2]=(0.452374328301)*x[2]
73947            arg[1,0,0]=(0.494303694439)*x[0]
73948            arg[1,0,1]=(0.00767629822214)*x[1]
73949            arg[1,0,2]=(0.232436713422)*x[2]
73950            arg[1,1,0]=(-0.698568975983)*x[0]
73951            arg[1,1,1]=(-0.08483720353)*x[1]
73952            arg[1,1,2]=(-0.723935799719)*x[2]
73953            arg[2,0,0]=(0.931313239646)*x[0]
73954            arg[2,0,1]=(-0.0988070442341)*x[1]
73955            arg[2,0,2]=(-0.166201798278)*x[2]
73956            arg[2,1,0]=(-0.733172171406)*x[0]
73957            arg[2,1,1]=(0.24542706584)*x[1]
73958            arg[2,1,2]=(0.49170717592)*x[2]
73959            arg[3,0,0]=(-0.718346096869)*x[0]
73960            arg[3,0,1]=(0.297442410539)*x[1]
73961            arg[3,0,2]=(0.0277708718174)*x[2]
73962            arg[3,1,0]=(0.735100702194)*x[0]
73963            arg[3,1,1]=(-0.808007526296)*x[1]
73964            arg[3,1,2]=(-0.423023238313)*x[2]
73965            arg[4,0,0]=(0.383188529876)*x[0]
73966            arg[4,0,1]=(-0.190101601814)*x[1]
73967            arg[4,0,2]=(-0.404380990215)*x[2]
73968            arg[4,1,0]=(-0.31098204217)*x[0]
73969            arg[4,1,1]=(-0.715247945432)*x[1]
73970            arg[4,1,2]=(0.435774772982)*x[2]
73971            arg[5,0,0]=(-0.0662056096206)*x[0]
73972            arg[5,0,1]=(0.746710247367)*x[1]
73973            arg[5,0,2]=(0.753267249301)*x[2]
73974            arg[5,1,0]=(0.258102962518)*x[0]
73975            arg[5,1,1]=(-0.0270028483187)*x[1]
73976            arg[5,1,2]=(-0.971060107954)*x[2]
73977            ref=sqrt((1.86493016409)+(1.23371587938))
73978    
73979          res=L2(arg)
73980          self.failUnless(isinstance(res,float),"wrong type of result.")
73981          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
73982       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
73983       def test_L2_onFunctionOnContactZero_fromData_rank4(self):
73984          """
73985          tests L2-norm of Data on the FunctionOnContactZero
73986    
73987          assumptions: self.domain supports integration on FunctionOnContactZero
73988          """
73989          dim=self.domain.getDim()
73990          w=FunctionOnContactZero(self.domain)
73991          x=w.getX()
73992          if dim==2:
73993            arg=Data(0,(4, 5, 3, 2),w)
73994            arg[0,0,0,0]=(-0.144741217139)*x[0]
73995            arg[0,0,0,1]=(-0.188187241012)*x[1]
73996            arg[0,0,1,0]=(0.056339373733)*x[0]
73997            arg[0,0,1,1]=(0.222177130759)*x[1]
73998            arg[0,0,2,0]=(-0.437240978497)*x[0]
73999            arg[0,0,2,1]=(-0.479213082014)*x[1]
74000            arg[0,1,0,0]=(0.343204141181)*x[0]
74001            arg[0,1,0,1]=(0.099683148208)*x[1]
74002            arg[0,1,1,0]=(0.167657906331)*x[0]
74003            arg[0,1,1,1]=(0.371064917656)*x[1]
74004            arg[0,1,2,0]=(-0.175796118619)*x[0]
74005            arg[0,1,2,1]=(-0.523477567832)*x[1]
74006            arg[0,2,0,0]=(0.188832282277)*x[0]
74007            arg[0,2,0,1]=(0.948618356423)*x[1]
74008            arg[0,2,1,0]=(-0.3835066594)*x[0]
74009            arg[0,2,1,1]=(0.872875257641)*x[1]
74010            arg[0,2,2,0]=(-0.98414676194)*x[0]
74011            arg[0,2,2,1]=(0.59170993756)*x[1]
74012            arg[0,3,0,0]=(0.875820385471)*x[0]
74013            arg[0,3,0,1]=(-0.209139794169)*x[1]
74014            arg[0,3,1,0]=(0.783312979835)*x[0]
74015            arg[0,3,1,1]=(-0.440048708153)*x[1]
74016            arg[0,3,2,0]=(-0.906741480158)*x[0]
74017            arg[0,3,2,1]=(0.63834196559)*x[1]
74018            arg[0,4,0,0]=(0.0142616166715)*x[0]
74019            arg[0,4,0,1]=(-0.0745581409622)*x[1]
74020            arg[0,4,1,0]=(-0.779966728505)*x[0]
74021            arg[0,4,1,1]=(0.734744791584)*x[1]
74022            arg[0,4,2,0]=(0.0407627699446)*x[0]
74023            arg[0,4,2,1]=(-0.629666423098)*x[1]
74024            arg[1,0,0,0]=(-0.782291768803)*x[0]
74025            arg[1,0,0,1]=(-0.197799867335)*x[1]
74026            arg[1,0,1,0]=(-0.487323212409)*x[0]
74027            arg[1,0,1,1]=(-0.789940409633)*x[1]
74028            arg[1,0,2,0]=(-0.523871448728)*x[0]
74029            arg[1,0,2,1]=(-0.622272488658)*x[1]
74030            arg[1,1,0,0]=(0.370095832941)*x[0]
74031            arg[1,1,0,1]=(-0.0683624906905)*x[1]
74032            arg[1,1,1,0]=(-0.180583695959)*x[0]
74033            arg[1,1,1,1]=(-0.0529097308814)*x[1]
74034            arg[1,1,2,0]=(0.440088045764)*x[0]
74035            arg[1,1,2,1]=(-0.207665675854)*x[1]
74036            arg[1,2,0,0]=(-0.360120735448)*x[0]
74037            arg[1,2,0,1]=(0.877797020694)*x[1]
74038            arg[1,2,1,0]=(0.655192721419)*x[0]
74039            arg[1,2,1,1]=(0.978781227463)*x[1]
74040            arg[1,2,2,0]=(-0.205886258554)*x[0]
74041            arg[1,2,2,1]=(-0.0050396100363)*x[1]
74042            arg[1,3,0,0]=(-0.484332943177)*x[0]
74043            arg[1,3,0,1]=(0.964697361018)*x[1]
74044            arg[1,3,1,0]=(0.0815652906824)*x[0]
74045            arg[1,3,1,1]=(-0.531163025802)*x[1]
74046            arg[1,3,2,0]=(-0.229615479833)*x[0]
74047            arg[1,3,2,1]=(0.139971291609)*x[1]
74048            arg[1,4,0,0]=(0.960839193726)*x[0]
74049            arg[1,4,0,1]=(-0.9744930023)*x[1]
74050            arg[1,4,1,0]=(-0.0919000363634)*x[0]
74051            arg[1,4,1,1]=(0.483909186003)*x[1]
74052            arg[1,4,2,0]=(0.248597552464)*x[0]
74053            arg[1,4,2,1]=(0.965872402486)*x[1]
74054            arg[2,0,0,0]=(-0.935049188033)*x[0]
74055            arg[2,0,0,1]=(-0.823239964421)*x[1]
74056            arg[2,0,1,0]=(0.30901193713)*x[0]
74057            arg[2,0,1,1]=(-0.0538396976182)*x[1]
74058            arg[2,0,2,0]=(-0.449416473099)*x[0]
74059            arg[2,0,2,1]=(-0.857785267819)*x[1]
74060            arg[2,1,0,0]=(-0.167802578334)*x[0]
74061            arg[2,1,0,1]=(-0.7016101186)*x[1]
74062            arg[2,1,1,0]=(0.995848317929)*x[0]
74063            arg[2,1,1,1]=(-0.824595018011)*x[1]
74064            arg[2,1,2,0]=(-0.826030527686)*x[0]
74065            arg[2,1,2,1]=(-0.856151725651)*x[1]
74066            arg[2,2,0,0]=(0.342047605028)*x[0]
74067            arg[2,2,0,1]=(-0.342370307931)*x[1]
74068            arg[2,2,1,0]=(-0.540693890831)*x[0]
74069            arg[2,2,1,1]=(-0.720754897785)*x[1]
74070            arg[2,2,2,0]=(-0.0941215154824)*x[0]
74071            arg[2,2,2,1]=(0.115887914141)*x[1]
74072            arg[2,3,0,0]=(-0.0920059639279)*x[0]
74073            arg[2,3,0,1]=(0.910948619784)*x[1]
74074            arg[2,3,1,0]=(-0.40846609126)*x[0]
74075            arg[2,3,1,1]=(0.542728733954)*x[1]
74076            arg[2,3,2,0]=(0.451361830368)*x[0]
74077            arg[2,3,2,1]=(0.0767538617936)*x[1]
74078            arg[2,4,0,0]=(-0.431757008766)*x[0]
74079            arg[2,4,0,1]=(0.258988103513)*x[1]
74080            arg[2,4,1,0]=(-0.584559859464)*x[0]
74081            arg[2,4,1,1]=(-0.776827606804)*x[1]
74082            arg[2,4,2,0]=(-0.867078960637)*x[0]
74083            arg[2,4,2,1]=(-0.0972960135129)*x[1]
74084            arg[3,0,0,0]=(0.999511727022)*x[0]
74085            arg[3,0,0,1]=(-0.753218704622)*x[1]
74086            arg[3,0,1,0]=(0.506439354885)*x[0]
74087            arg[3,0,1,1]=(-0.0845853282297)*x[1]
74088            arg[3,0,2,0]=(-0.871475028801)*x[0]
74089            arg[3,0,2,1]=(-0.69261642657)*x[1]
74090            arg[3,1,0,0]=(0.549778399933)*x[0]
74091            arg[3,1,0,1]=(0.246187536149)*x[1]
74092            arg[3,1,1,0]=(-0.620454200676)*x[0]
74093            arg[3,1,1,1]=(0.372738564315)*x[1]
74094            arg[3,1,2,0]=(0.0544097075138)*x[0]
74095            arg[3,1,2,1]=(-0.0883198944676)*x[1]
74096            arg[3,2,0,0]=(-0.671057180545)*x[0]
74097            arg[3,2,0,1]=(-0.118991797907)*x[1]
74098            arg[3,2,1,0]=(-0.27196730081)*x[0]
74099            arg[3,2,1,1]=(-0.458807068968)*x[1]
74100            arg[3,2,2,0]=(-0.31485399083)*x[0]
74101            arg[3,2,2,1]=(0.487291960328)*x[1]
74102            arg[3,3,0,0]=(-0.750302723531)*x[0]
74103            arg[3,3,0,1]=(-0.486428789771)*x[1]
74104            arg[3,3,1,0]=(-0.295909324594)*x[0]
74105            arg[3,3,1,1]=(0.325702372596)*x[1]
74106            arg[3,3,2,0]=(-0.512109540631)*x[0]
74107            arg[3,3,2,1]=(0.563284721908)*x[1]
74108            arg[3,4,0,0]=(0.53579406798)*x[0]
74109            arg[3,4,0,1]=(-0.468431927975)*x[1]
74110            arg[3,4,1,0]=(0.570851401329)*x[0]
74111            arg[3,4,1,1]=(0.107791149865)*x[1]
74112            arg[3,4,2,0]=(-0.211543670157)*x[0]
74113            arg[3,4,2,1]=(0.848189550468)*x[1]
74114            ref=sqrt((6.54316712884)+(4.39564064326))
74115    
74116          else:
74117            arg=Data(0,(4, 5, 3, 3),w)
74118            arg[0,0,0,0]=(-0.392256494872)*x[0]
74119            arg[0,0,0,1]=(0.271488478841)*x[1]
74120            arg[0,0,0,2]=(-0.878268531987)*x[2]
74121            arg[0,0,1,0]=(0.106903787643)*x[0]
74122            arg[0,0,1,1]=(-0.117986434516)*x[1]
74123            arg[0,0,1,2]=(0.912673598522)*x[2]
74124            arg[0,0,2,0]=(-0.652598945824)*x[0]
74125            arg[0,0,2,1]=(-0.984195895647)*x[1]
74126            arg[0,0,2,2]=(-0.137845459589)*x[2]
74127            arg[0,1,0,0]=(0.696713200721)*x[0]
74128            arg[0,1,0,1]=(0.480337929223)*x[1]
74129            arg[0,1,0,2]=(-0.628726114325)*x[2]
74130            arg[0,1,1,0]=(-0.356503461347)*x[0]
74131            arg[0,1,1,1]=(-0.64670584045)*x[1]
74132            arg[0,1,1,2]=(-0.737787618908)*x[2]
74133            arg[0,1,2,0]=(-0.14207595302)*x[0]
74134            arg[0,1,2,1]=(-0.573485525334)*x[1]
74135            arg[0,1,2,2]=(-0.955542178481)*x[2]
74136            arg[0,2,0,0]=(0.371952883975)*x[0]
74137            arg[0,2,0,1]=(0.114016178762)*x[1]
74138            arg[0,2,0,2]=(0.552721218169)*x[2]
74139            arg[0,2,1,0]=(0.318426742113)*x[0]
74140            arg[0,2,1,1]=(0.862220239384)*x[1]
74141            arg[0,2,1,2]=(0.887376889978)*x[2]
74142            arg[0,2,2,0]=(0.203656742981)*x[0]
74143            arg[0,2,2,1]=(0.350541335144)*x[1]
74144            arg[0,2,2,2]=(-0.448401957447)*x[2]
74145            arg[0,3,0,0]=(-0.349200084042)*x[0]
74146            arg[0,3,0,1]=(-0.546012602125)*x[1]
74147            arg[0,3,0,2]=(-0.931488270979)*x[2]
74148            arg[0,3,1,0]=(0.207457831058)*x[0]
74149            arg[0,3,1,1]=(0.557715840549)*x[1]
74150            arg[0,3,1,2]=(-0.978130146744)*x[2]
74151            arg[0,3,2,0]=(-0.55088967957)*x[0]
74152            arg[0,3,2,1]=(0.0490328838057)*x[1]
74153            arg[0,3,2,2]=(0.150209929122)*x[2]
74154            arg[0,4,0,0]=(-0.484145614698)*x[0]
74155            arg[0,4,0,1]=(0.393078411279)*x[1]
74156            arg[0,4,0,2]=(0.0678631863917)*x[2]
74157            arg[0,4,1,0]=(-0.350980464628)*x[0]
74158            arg[0,4,1,1]=(-0.784203839564)*x[1]
74159            arg[0,4,1,2]=(0.636960296147)*x[2]
74160            arg[0,4,2,0]=(0.592799503581)*x[0]
74161            arg[0,4,2,1]=(-0.672104833683)*x[1]
74162            arg[0,4,2,2]=(0.0366914082467)*x[2]
74163            arg[1,0,0,0]=(-0.147168019774)*x[0]
74164            arg[1,0,0,1]=(-0.0823637938956)*x[1]
74165            arg[1,0,0,2]=(-0.852729690176)*x[2]
74166            arg[1,0,1,0]=(-0.612338430408)*x[0]
74167            arg[1,0,1,1]=(-0.85820035747)*x[1]
74168            arg[1,0,1,2]=(-0.463664966162)*x[2]
74169            arg[1,0,2,0]=(0.274600720491)*x[0]
74170            arg[1,0,2,1]=(-0.488508234093)*x[1]
74171            arg[1,0,2,2]=(-0.28251466519)*x[2]
74172            arg[1,1,0,0]=(-0.0196532462794)*x[0]
74173            arg[1,1,0,1]=(0.239352528871)*x[1]
74174            arg[1,1,0,2]=(-0.17054773873)*x[2]
74175            arg[1,1,1,0]=(-0.2396627789)*x[0]
74176            arg[1,1,1,1]=(0.868970323003)*x[1]
74177            arg[1,1,1,2]=(0.401487430312)*x[2]
74178            arg[1,1,2,0]=(-0.624411449783)*x[0]
74179            arg[1,1,2,1]=(0.0036634266684)*x[1]
74180            arg[1,1,2,2]=(0.736129120967)*x[2]
74181            arg[1,2,0,0]=(0.183756511707)*x[0]
74182            arg[1,2,0,1]=(-0.288651848639)*x[1]
74183            arg[1,2,0,2]=(-0.0672121537447)*x[2]
74184            arg[1,2,1,0]=(-0.323274725936)*x[0]
74185            arg[1,2,1,1]=(0.298001016025)*x[1]
74186            arg[1,2,1,2]=(-0.976052460675)*x[2]
74187            arg[1,2,2,0]=(0.596504441096)*x[0]
74188            arg[1,2,2,1]=(0.873776068983)*x[1]
74189            arg[1,2,2,2]=(-0.994068273196)*x[2]
74190            arg[1,3,0,0]=(-0.495387299681)*x[0]
74191            arg[1,3,0,1]=(-0.123674756551)*x[1]
74192            arg[1,3,0,2]=(0.581213818577)*x[2]
74193            arg[1,3,1,0]=(0.146405749701)*x[0]
74194            arg[1,3,1,1]=(-0.594994686675)*x[1]
74195            arg[1,3,1,2]=(-0.059093568436)*x[2]
74196            arg[1,3,2,0]=(0.651004255104)*x[0]
74197            arg[1,3,2,1]=(-0.977880706193)*x[1]
74198            arg[1,3,2,2]=(0.370344651319)*x[2]
74199            arg[1,4,0,0]=(-0.503657215247)*x[0]
74200            arg[1,4,0,1]=(-0.170885297253)*x[1]
74201            arg[1,4,0,2]=(0.533424480956)*x[2]
74202            arg[1,4,1,0]=(-0.220533193308)*x[0]
74203            arg[1,4,1,1]=(0.344537611882)*x[1]
74204            arg[1,4,1,2]=(0.861473877282)*x[2]
74205            arg[1,4,2,0]=(-0.0923010438884)*x[0]
74206            arg[1,4,2,1]=(-0.338256780498)*x[1]
74207            arg[1,4,2,2]=(0.528567959345)*x[2]
74208            arg[2,0,0,0]=(-0.0423053381485)*x[0]
74209            arg[2,0,0,1]=(0.856798579151)*x[1]
74210            arg[2,0,0,2]=(0.383258153853)*x[2]
74211            arg[2,0,1,0]=(0.350994872736)*x[0]
74212            arg[2,0,1,1]=(-0.78055158106)*x[1]
74213            arg[2,0,1,2]=(-0.770876699915)*x[2]
74214            arg[2,0,2,0]=(-0.935133287106)*x[0]
74215            arg[2,0,2,1]=(0.618238076989)*x[1]
74216            arg[2,0,2,2]=(-0.846783087949)*x[2]
74217            arg[2,1,0,0]=(-0.657394511405)*x[0]
74218            arg[2,1,0,1]=(0.576218821654)*x[1]
74219            arg[2,1,0,2]=(0.0269446356493)*x[2]
74220            arg[2,1,1,0]=(-0.310710230949)*x[0]
74221            arg[2,1,1,1]=(0.425412515598)*x[1]
74222            arg[2,1,1,2]=(-0.225225290862)*x[2]
74223            arg[2,1,2,0]=(-0.539928589495)*x[0]
74224            arg[2,1,2,1]=(-0.348082121765)*x[1]
74225            arg[2,1,2,2]=(-0.0287274646233)*x[2]
74226            arg[2,2,0,0]=(0.746132865923)*x[0]
74227            arg[2,2,0,1]=(-0.0234203693548)*x[1]
74228            arg[2,2,0,2]=(0.517411821941)*x[2]
74229            arg[2,2,1,0]=(-0.183204217349)*x[0]
74230            arg[2,2,1,1]=(0.714988861836)*x[1]
74231            arg[2,2,1,2]=(0.829083318937)*x[2]
74232            arg[2,2,2,0]=(0.458067555841)*x[0]
74233            arg[2,2,2,1]=(0.639317125869)*x[1]
74234            arg[2,2,2,2]=(0.104611520408)*x[2]
74235            arg[2,3,0,0]=(-0.420513461135)*x[0]
74236            arg[2,3,0,1]=(0.888686162754)*x[1]
74237            arg[2,3,0,2]=(0.939305777879)*x[2]
74238            arg[2,3,1,0]=(0.856795132015)*x[0]
74239            arg[2,3,1,1]=(0.817593141895)*x[1]
74240            arg[2,3,1,2]=(0.962503342535)*x[2]
74241            arg[2,3,2,0]=(-0.334586700245)*x[0]
74242            arg[2,3,2,1]=(0.182696129528)*x[1]
74243            arg[2,3,2,2]=(-0.707271571206)*x[2]
74244            arg[2,4,0,0]=(-0.594795981069)*x[0]
74245            arg[2,4,0,1]=(0.451239168073)*x[1]
74246            arg[2,4,0,2]=(0.191212211556)*x[2]
74247            arg[2,4,1,0]=(-0.503465984944)*x[0]
74248            arg[2,4,1,1]=(0.725377884208)*x[1]
74249            arg[2,4,1,2]=(-0.40719255752)*x[2]
74250            arg[2,4,2,0]=(0.268071476451)*x[0]
74251            arg[2,4,2,1]=(0.85066639942)*x[1]
74252            arg[2,4,2,2]=(-0.906021406945)*x[2]
74253            arg[3,0,0,0]=(-0.922179152122)*x[0]
74254            arg[3,0,0,1]=(-0.0903841240007)*x[1]
74255            arg[3,0,0,2]=(-0.751482803516)*x[2]
74256            arg[3,0,1,0]=(0.960697809119)*x[0]
74257            arg[3,0,1,1]=(0.638878873158)*x[1]
74258            arg[3,0,1,2]=(0.390932234724)*x[2]
74259            arg[3,0,2,0]=(-0.925078301694)*x[0]
74260            arg[3,0,2,1]=(0.793590580665)*x[1]
74261            arg[3,0,2,2]=(0.535478366911)*x[2]
74262            arg[3,1,0,0]=(-0.431951993217)*x[0]
74263            arg[3,1,0,1]=(0.211750261417)*x[1]
74264            arg[3,1,0,2]=(-0.930706580442)*x[2]
74265            arg[3,1,1,0]=(0.330979313323)*x[0]
74266            arg[3,1,1,1]=(-0.838919076081)*x[1]
74267            arg[3,1,1,2]=(0.134250050168)*x[2]
74268            arg[3,1,2,0]=(0.414922811301)*x[0]
74269            arg[3,1,2,1]=(-0.663692878121)*x[1]
74270            arg[3,1,2,2]=(0.88499278543)*x[2]
74271            arg[3,2,0,0]=(0.0884662742233)*x[0]
74272            arg[3,2,0,1]=(-0.412630722821)*x[1]
74273            arg[3,2,0,2]=(-0.730850884928)*x[2]
74274            arg[3,2,1,0]=(0.722207547366)*x[0]
74275            arg[3,2,1,1]=(-0.260067950749)*x[1]
74276            arg[3,2,1,2]=(0.426259201494)*x[2]
74277            arg[3,2,2,0]=(0.0516111795322)*x[0]
74278            arg[3,2,2,1]=(0.922853710048)*x[1]
74279            arg[3,2,2,2]=(-0.991912758116)*x[2]
74280            arg[3,3,0,0]=(0.263933965905)*x[0]
74281            arg[3,3,0,1]=(0.840541758799)*x[1]
74282            arg[3,3,0,2]=(0.417658511125)*x[2]
74283            arg[3,3,1,0]=(-0.901745614723)*x[0]
74284            arg[3,3,1,1]=(-0.623608908699)*x[1]
74285            arg[3,3,1,2]=(0.0522167208784)*x[2]
74286            arg[3,3,2,0]=(-0.549431264931)*x[0]
74287            arg[3,3,2,1]=(0.919971855457)*x[1]
74288            arg[3,3,2,2]=(0.142757773397)*x[2]
74289            arg[3,4,0,0]=(-0.258875259824)*x[0]
74290            arg[3,4,0,1]=(-0.0373872187041)*x[1]
74291            arg[3,4,0,2]=(0.445989164864)*x[2]
74292            arg[3,4,1,0]=(0.0273711397038)*x[0]
74293            arg[3,4,1,1]=(-0.85522629)*x[1]
74294            arg[3,4,1,2]=(-0.835392581226)*x[2]
74295            arg[3,4,2,0]=(0.402929450189)*x[0]
74296            arg[3,4,2,1]=(0.549623033221)*x[1]
74297            arg[3,4,2,2]=(0.237803212109)*x[2]
74298            ref=sqrt((15.1448100099)+(3.61598249819))
74299    
74300          res=L2(arg)
74301          self.failUnless(isinstance(res,float),"wrong type of result.")
74302          self.failUnlessAlmostEqual(res,ref,int(-log10(self.RES_TOL)),"wrong result")
74303       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
74304       def test_L2_onFunctionOnContactZero_fromSymbol_rank0(self):
74305          """
74306          tests L2-norm of Symbol on the FunctionOnContactZero
74307    
74308          assumptions: self.domain supports integration on FunctionOnContactZero
74309          """
74310          dim=self.domain.getDim()
74311          w=FunctionOnContactZero(self.domain)
74312          x=w.getX()
74313          if dim==2:
74314            arg=Symbol(shape=(),dim=dim)
74315            s=Data(0,(),w)
74316            s=(-0.833494674242)*x[0]
74317            ref=sqrt((0.0)+(0.173678342998))
74318    
74319          else:
74320            arg=Symbol(shape=(),dim=dim)
74321            s=Data(0,(),w)
74322            s=(-0.413475598947)*x[0]
74323            ref=sqrt((0.0)+(0.0427405177311))
74324    
74325          res=L2(arg)
74326          sub=res.substitute({arg:s})
74327          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
74328          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
74329          self.failUnlessAlmostEqual(sub,ref,int(-log10(self.RES_TOL)),"wrong result")
74330       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
74331       def test_L2_onFunctionOnContactZero_fromSymbol_rank1(self):
74332          """
74333          tests L2-norm of Symbol on the FunctionOnContactZero
74334    
74335          assumptions: self.domain supports integration on FunctionOnContactZero
74336          """
74337          dim=self.domain.getDim()
74338          w=FunctionOnContactZero(self.domain)
74339          x=w.getX()
74340          if dim==2:
74341            arg=Symbol(shape=(2,),dim=dim)
74342            s=Data(0,(2,),w)
74343            s[0]=(-0.836300232979)*x[0]
74344            s[1]=(-0.855949069442)*x[1]
74345            ref=sqrt((0.244216269826)+(0.17484951992))
74346    
74347          else:
74348            arg=Symbol(shape=(3,),dim=dim)