/[escript]/trunk/escript/test/python/test_util.py
ViewVC logotype

Diff of /trunk/escript/test/python/test_util.py

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

revision 155 by jgs, Wed Nov 9 02:02:19 2005 UTC revision 341 by gross, Mon Dec 12 05:26:10 2005 UTC
# Line 1  Line 1 
1  # $Id$  # $Id$
   
2  """  """
3  Test suite for the util.py module.  Test suite for the util.py module.
4    
5  The tests must be linked with a function space class object in the setUp method:  The tests must be linked with a function space class object in the setUp method:
6    
7    The test are grouped as
8    
9       Test_util_basic: some basic tests
10    
11       Test_util_unary_no_tagged_data: test for unary operations with no
12       Test_util_unary_tagged_data: test for unary operations
13       Test_util_unary: test for unary operations
14    
15       Test_util_reduction_no_tagged_data: test for unary operations with no
16       Test_util_reduction_tagged_data: test for unary operations
17       Test_util_reduction: test for unary operations
18    
19       Test_util_binary_no_tagged_data: test for unary operations with no
20       Test_util_binary_tagged_data: test for unary operations
21       Test_util_binary: test for unary operations
22    
23       Test_util_overloaded_operations_no_tagged_data: test for unary operations with no
24       Test_util_overloaded_operations_tagged_data: test for unary operations
25       Test_util_overloaded_operations test for unary operations
26    
27       Test_util_no_tagged_data: all test withour tagged data
28       Test_util_tagged_data: all test with tagged data only
29       Test_util: all test
30    
31    
32    to run the use:
33    
34     from esys.bruce import Brick     from esys.bruce import Brick
35     class Test_utilOnBruce(Test_util):     class Test_utilOnBruce(Test_util_no_tagged_data):
36         def setUp(self):         def setUp(self):
37             self.domain = Brick(10,10,13)             self.domain = Brick(10,10,13)
38             self.functionspace = ContinuousFunction(self.domain)             self.functionspace = ContinuousFunction(self.domain)
# Line 14  The tests must be linked with a function Line 40  The tests must be linked with a function
40     suite.addTest(unittest.makeSuite(Test_utilOnBruce))     suite.addTest(unittest.makeSuite(Test_utilOnBruce))
41     unittest.TextTestRunner(verbosity=2).run(suite)     unittest.TextTestRunner(verbosity=2).run(suite)
42    
43  For function spaces which support tagging there is the extended test case Test_util_with_tagged_Data available.  For function spaces which support tagging there is the extended test case Test_util_with_tagged_data available.
44  This test assumes that the functionspace has samples with tags equal to 1 and different from 1.  This test assumes that the functionspace has samples with tags equal to 1 and different from 1.
45    
46  @remark: at this stage thsi test will not pass as it tests for functionlity that has not been implemented yet. It also does not test the full functionalitu of util.py yet.  @note: at this stage thsi test will not pass as it tests for functionlity that has not been implemented yet. It also does not test the full functionalitu of util.py yet.
47    
48  @var __author__: name of author  @var __author__: name of author
49  @var __licence__: licence agreement  @var __licence__: licence agreement
# Line 29  This test assumes that the functionspace Line 55  This test assumes that the functionspace
55  __author__="Lutz Gross, l.gross@uq.edu.au"  __author__="Lutz Gross, l.gross@uq.edu.au"
56  __licence__="contact: esys@access.uq.edu.au"  __licence__="contact: esys@access.uq.edu.au"
57  __url__="http://www.iservo.edu.au/esys/escript"  __url__="http://www.iservo.edu.au/esys/escript"
58  __version__="$Revision$"  __version__="$Revision: 313 $"
59  __date__="$Date$"  __date__="$Date$"
60    
61  import unittest  import unittest
62  import numarray  import numarray
63  from esys.escript import *  from esys.escript import *
64    
65  class Test_util(unittest.TestCase):  class Test_util_base(unittest.TestCase):
66       """
67       basic tests on util.py
68       """
69     RES_TOL=1.e-7 # RES_TOLerance to compare results     RES_TOL=1.e-7 # RES_TOLerance to compare results
70     DIFF_TOL=1.e-7 # RES_TOLerance to derivatices     DIFF_TOL=1.e-7 # RES_TOLerance to derivatices
71  #=========================================================  #=========================================================
# Line 250  class Test_util(unittest.TestCase): Line 279  class Test_util(unittest.TestCase):
279        val=unitVector(i=0,d=self.functionspace)        val=unitVector(i=0,d=self.functionspace)
280        self.failUnless(isinstance(val,numarray.ArrayType),"wrong type of result.")        self.failUnless(isinstance(val,numarray.ArrayType),"wrong type of result.")
281        self.failUnlessEqual(val.shape,(self.functionspace.getDim(),),"wrong shape.")        self.failUnlessEqual(val.shape,(self.functionspace.getDim(),),"wrong shape.")
 #=========================================================================  
 #   global reduction operations (these functions have no symbolic version)  
 #=========================================================================  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_float_rank0(self):  
       arg=0.479077251703  
       ref=0.479077251703  
       res=Lsup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_array_rank0(self):  
       arg=0.352800421569  
       ref=0.352800421569  
       res=Lsup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_array_rank1(self):  
       arg=numarray.array([0.58364106865247445, 0.19224319360367659])  
       ref=0.583641068652  
       res=Lsup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_array_rank2(self):  
       arg=numarray.array([[0.67017748174064184, 0.27426357568545234, 0.99809374007262508, 0.0068333566694658288, -0.27942939334057559], [-0.41062296082648619, -0.036816602223561423, -0.50580074937952246, 0.93227848108675948, -0.061517050082725788], [0.36561750746233845, 0.41114839130078873, 0.52258027672142848, -0.16534372330544111, 0.20772668552253304], [0.821900382760401, -0.84255628577421948, -0.69396587198625026, -0.57918798921236458, -0.72171447032975466]])  
       ref=0.998093740073  
       res=Lsup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_array_rank3(self):  
       arg=numarray.array([[[0.058641541671277109, -0.90451294682583527], [-0.24359709498927606, -0.57748558070477163]], [[0.035804882991596898, 0.62841290637910441], [-0.28533080116748288, -0.97886508166774955]], [[0.31393622401598642, -0.43905852202615403], [-0.86251727012547685, 0.028980168735740941]], [[0.64796855283921229, -0.48583038861071492], [0.18113352051559328, -0.41145930584343637]], [[0.039393878628251944, 0.8768398562091233], [-0.17607723439655953, -0.88597401556177768]], [[-0.015710131346685419, -0.1460065558640582], [0.97739538148461858, -0.96991499683153215]]])  
       ref=0.978865081668  
       res=Lsup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_array_rank4(self):  
       arg=numarray.array([[[[-0.78982105495266985, -0.63220666806337955, 0.17512704833203396, 0.87905338838606228], [0.23198845220692799, 0.039972475068823288, 0.012169097173197807, 0.44188750570302382], [0.76550090905039703, 0.31693138180972436, 0.1053031163896907, -0.35110494947362092]], [[0.98438531435704557, 0.64830270240860366, 0.17255823042313656, -0.89376135594562944], [-0.24129437029981871, -0.142955980423916, 0.16557185988864043, 0.97182386578689162], [0.68369373227893937, -0.86170550438838256, 0.30120477894454822, 0.38702330237685523]]], [[[0.77139284396922037, 0.20032741426304668, 0.57845916425558697, -0.29867163908832151], [-0.068269410287581156, 0.5940891737261742, 0.076472990825278808, -0.099092183170674364], [-0.052727700907511776, 0.86303703635283835, -0.87561628108225542, 0.98706354430335175]], [[0.59243014649382819, 0.1550040875984271, -0.2755507051420949, -0.0013143184448647371], [0.49341486033505921, 0.47331310491746503, -0.79931467469262252, -0.90673470029976722], [-0.032268150780954796, 0.296035852616644, 0.51579882806939303, 0.46437108203184607]]], [[[-0.54940019219066349, 0.063961557315018069, 0.58950734587654585, -0.98334853918198539], [-0.3624096661573355, 0.41744569348555416, 0.30209950686844023, 0.51268273249278518], [0.18884359916930848, -0.71707023426140903, -0.30560603652072227, 0.50521867139895282]], [[0.48925658559264695, -0.22791551552340583, -0.0018172920946346593, -0.35038144063572618], [-0.92608233760416425, -0.58447575161042908, 0.6419293813902982, -0.9165521427783867], [0.32116313637555338, 0.64441081354246466, 0.57516697859586241, -0.30456483792192746]]]])  
       ref=0.987063544303  
       res=Lsup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_constData_rank0(self):  
       arg=Data(0.196366308048,self.functionspace)  
       ref=0.196366308048  
       res=Lsup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_constData_rank1(self):  
       arg=Data(numarray.array([-0.013183241788205846, 0.30081447346639489]),self.functionspace)  
       ref=0.300814473466  
       res=Lsup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_constData_rank2(self):  
       arg=Data(numarray.array([[0.5711180583492661, 0.70931947195628298, -0.66895311699347904, 0.96005746113679025, 0.73085528334644767], [-0.63904611175106618, 0.2843691804450883, 0.44023994297671054, 0.74230048057601272, 0.32582591826440876], [0.058605148358656045, 0.17856553839104938, 0.92397360311332144, -0.96449976222010503, -0.2936728605307215], [-0.54599501106213921, 0.76941479487476183, 0.071247548913826231, 0.19101147233175308, -0.1697403800152153]]),self.functionspace)  
       ref=0.96449976222  
       res=Lsup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_constData_rank3(self):  
       arg=Data(numarray.array([[[0.72501574945437675, 0.097442689963523454], [0.81136110912526904, 0.30019286779005516]], [[-0.49590270028453376, 0.89873757442194169], [-0.77574675514072333, 0.00090692035026496143]], [[0.30313499990678294, -0.22304437168798286], [0.26434595235717628, 0.56043553186944139]], [[-0.82536121216538372, 0.017266274277504934], [0.15087851023611853, 0.85422443819044291]], [[-0.85528228633213454, 0.21599153787828373], [-0.8320606477196939, 0.8359530516934528]], [[-0.32478507656272382, 0.11549647741760993], [-0.87438785398253049, 0.58454806081387956]]]),self.functionspace)  
       ref=0.898737574422  
       res=Lsup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_constData_rank4(self):  
       arg=Data(numarray.array([[[[-0.1675633776917147, 0.33827478137880718, -0.93890402023643449, 0.65020437341791437], [0.29507018847480526, 0.98622587753446878, 0.12652012726316597, -0.31134038684685694], [-0.046095794370747178, 0.52924578464459526, -0.6479404156998898, -0.50108997075395512]], [[-0.89461015899273821, -0.079360196866752331, 0.24950542226018069, 0.6689436082056277], [0.92392213781413735, 0.3873078097702356, 0.19593123983162242, -0.24092882483013001], [-0.64621424798001881, 0.9822743623774457, 0.89791841241748926, 0.61910184653693512]]], [[[-0.93993640130694156, 0.86452728798536005, 0.094496916350070848, 0.59825417382728907], [0.55042390382543216, 0.83625046124041091, -0.59865905280251042, 0.60081510989738351], [0.96300656863917622, 0.45676715577013183, 0.96765574240961594, 0.35217159943804499]], [[-0.44344990079738578, -0.62540931368504271, 0.47046830875624712, 0.56727920796684694], [0.68754074058706793, -0.20419202844112316, -0.0095491803785341389, 0.013299778291189002], [0.17824394120278897, -0.27714200037108694, -0.2616405339148673, -0.32155257707876661]]], [[[0.47113927793594357, -0.99306136743656892, 0.30468996581271934, -0.55558797016447881], [0.83216176170936151, 0.016003159554198287, 0.50607924358488665, -0.44441953149310631], [0.81919419287951278, -0.65849894919643503, 0.91897977494732008, -0.52338741357416407]], [[0.71408966944475138, -0.49347702658095161, 0.35676281330171133, 0.87268025092466872], [0.38401738326898771, -0.66323897612738114, 0.57309433517459518, 0.72101582669934583], [-0.0289954568811297, 0.55204032281174009, 0.51120867863750807, -0.67373936301915327]]]]),self.functionspace)  
       ref=0.993061367437  
       res=Lsup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
   
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_expandedData_rank0(self):  
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*0.907507663119+(1.-msk)*0.907507663119  
   
       # arg=Data(0.907507663119,self.functionspace,True)  
       # arg.setTaggedValue(1,0.907507663119)  
       res=Lsup(arg)  
       ref=0.907507663119  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_expandedData_rank1(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([0.64842023599463228, 0.7950449048151853])+(1.-msk)*numarray.array([-0.53356920308809608, -0.30392740367264159])  
   
       # arg=Data(numarray.array([0.64842023599463228, 0.7950449048151853]),self.functionspace,True)  
       # arg.setTaggedValue(1,[-0.53356920308809608, -0.30392740367264159])  
       res=Lsup(arg)  
       ref=0.795044904815  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_expandedData_rank2(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([[0.72772455370935374, -0.47120637916343311, -0.82075870555018726, -0.13186541688079845, 0.14046405940683471], [0.10791450121551649, 0.043686402172190775, 0.4587164889316806, -0.16569163575870283, 0.64477762072726041], [0.62628246294878309, -0.46538827310659792, 0.58089235621217727, -0.745300901798017, -0.1072674226756638], [0.93074707226494824, 0.17195108914746116, 0.77645205158899833, -0.55814650711894975, -0.68929261213084403]])+(1.-msk)*numarray.array([[-0.25856012658041871, -0.64132706411711782, -0.90934384682634128, 0.13076992241789931, 0.23456684296051011], [0.54052140856785269, 0.78868044275368643, 0.20419986484049479, 0.64782383948156319, 0.12883249735345115], [-0.44575026820636654, -0.86972644697707824, 0.74937006939719653, 0.64390867433141019, 0.57227950445890885], [-0.59430616226417832, -0.77932115906125854, 0.60864641730739155, 0.909083762068297, -0.5444504332265574]])  
   
       # arg=Data(numarray.array([[0.72772455370935374, -0.47120637916343311, -0.82075870555018726, -0.13186541688079845, 0.14046405940683471], [0.10791450121551649, 0.043686402172190775, 0.4587164889316806, -0.16569163575870283, 0.64477762072726041], [0.62628246294878309, -0.46538827310659792, 0.58089235621217727, -0.745300901798017, -0.1072674226756638], [0.93074707226494824, 0.17195108914746116, 0.77645205158899833, -0.55814650711894975, -0.68929261213084403]]),self.functionspace,True)  
       # arg.setTaggedValue(1,[[-0.25856012658041871, -0.64132706411711782, -0.90934384682634128, 0.13076992241789931, 0.23456684296051011], [0.54052140856785269, 0.78868044275368643, 0.20419986484049479, 0.64782383948156319, 0.12883249735345115], [-0.44575026820636654, -0.86972644697707824, 0.74937006939719653, 0.64390867433141019, 0.57227950445890885], [-0.59430616226417832, -0.77932115906125854, 0.60864641730739155, 0.909083762068297, -0.5444504332265574]])  
       res=Lsup(arg)  
       ref=0.930747072265  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_expandedData_rank3(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([[[0.31609964814729086, -0.59322042077218184], [0.62671563648606643, -0.99924882354010092]], [[-0.81285219908299133, -0.91261945476639861], [-0.66394864058744174, -0.070011911370653657]], [[-0.4798784324091383, -0.017929635369934749], [0.87935995021589952, 0.73748462709583618]], [[-0.89673095768516986, 0.44255562883781563], [-0.33009427566326166, 0.89415170271508537]], [[-0.070411620428932897, 0.34854312339042304], [-0.54088506672687542, 0.57996368816677069]], [[0.98447862226498417, 0.31010343079927294], [0.18832525314748882, 0.46594491838516161]]])+(1.-msk)*numarray.array([[[0.036725320623094637, -0.95874317021810596], [-0.66138152872168576, -0.52870418789420959]], [[0.59182952544611012, -0.31117513196914603], [0.17957160072325573, -0.93130315483187909]], [[0.33548100103066814, -0.6503677585469938], [-0.15995741665912955, -0.79138987042982367]], [[0.12353483100690976, -0.72197260504479188], [-0.35933752275788389, -0.46752695895022667]], [[0.7611306903818762, -0.88807332904594882], [0.91131651925077373, 0.81255438802194258]], [[-0.56892641899978824, 0.0010213385566093525], [0.40194539652124472, -0.006585080723547021]]])  
   
       # arg=Data(numarray.array([[[0.31609964814729086, -0.59322042077218184], [0.62671563648606643, -0.99924882354010092]], [[-0.81285219908299133, -0.91261945476639861], [-0.66394864058744174, -0.070011911370653657]], [[-0.4798784324091383, -0.017929635369934749], [0.87935995021589952, 0.73748462709583618]], [[-0.89673095768516986, 0.44255562883781563], [-0.33009427566326166, 0.89415170271508537]], [[-0.070411620428932897, 0.34854312339042304], [-0.54088506672687542, 0.57996368816677069]], [[0.98447862226498417, 0.31010343079927294], [0.18832525314748882, 0.46594491838516161]]]),self.functionspace,True)  
       # arg.setTaggedValue(1,[[[0.036725320623094637, -0.95874317021810596], [-0.66138152872168576, -0.52870418789420959]], [[0.59182952544611012, -0.31117513196914603], [0.17957160072325573, -0.93130315483187909]], [[0.33548100103066814, -0.6503677585469938], [-0.15995741665912955, -0.79138987042982367]], [[0.12353483100690976, -0.72197260504479188], [-0.35933752275788389, -0.46752695895022667]], [[0.7611306903818762, -0.88807332904594882], [0.91131651925077373, 0.81255438802194258]], [[-0.56892641899978824, 0.0010213385566093525], [0.40194539652124472, -0.006585080723547021]]])  
       res=Lsup(arg)  
       ref=0.99924882354  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_Lsup_expandedData_rank4(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([[[[0.4996033665120716, -0.074132654028136846, 0.2908837888281397, 0.79804117547820219], [0.25334186456470942, -0.10892196087517791, 0.90411872189757747, -0.21372334914190327], [0.65549677694560438, 0.97979738684954532, -0.29737844854710138, 0.93659843329597914]], [[0.22668444631484608, -0.92481913749465305, -0.9980815386745403, -0.022502768980955601], [-0.21769755240946398, 0.77216348666766876, -0.19843685166706204, 0.54270333879579558], [-0.11274856721131221, -0.29600869223659299, 0.1458222910080329, -0.83739782177046851]]], [[[0.86722932032155531, 0.39888432468517876, -0.8991679849590255, -0.088621935923834272], [-0.58464076321585412, -0.09564380294323116, 0.18232602464536307, 0.7910046931530843], [0.15923450234841652, -0.39331159996226872, 0.18298541750645669, 0.99889484861795563]], [[0.36793558813747418, -0.64593764280975363, 0.048503028175158613, -0.8304805399530264], [0.072019074767407432, -0.066883567381289311, -0.55849542620276127, -0.32521841292447484], [0.83256632210175896, -0.52124955617445723, -0.0047287521832242163, 0.84184001532121422]]], [[[-0.81375499823702158, 0.12901434959756353, -0.51500727423485215, 0.52626362435118912], [-0.47602620905811044, 0.81525173294213982, 0.023145745277130203, 0.5818744103097242], [-0.26074066195347489, 0.62737248392572886, 0.24246935026650718, 0.86155298917514145]], [[0.40180649524587109, -0.13468267908829512, -0.66576279256576543, -0.97664336021962694], [-0.81183732113700424, -0.10477655696019839, -0.90212494842448732, 0.50784279020015499], [0.29352929816605089, 0.10640245030222295, -0.16640870997460122, 0.91371366707232826]]]])+(1.-msk)*numarray.array([[[[0.6465819200939884, 0.21755363919340609, 0.73973535907059662, -0.36114669719855241], [0.16087051863228452, -0.96295075570141986, 0.93283344105282717, 0.8498346294196879], [-0.62871563035312805, 0.028501977366871101, -0.76183996578150004, -0.42396762024023338]], [[0.45139869884828876, 0.9085099092003921, 0.90516675545818392, -0.2797423591331305], [-0.012176715080714828, 0.40935600076669765, -0.010156279663344314, -0.45527372677880185], [-0.56697253731600106, -0.88076957837377901, -0.43708368779823448, -0.98115855535334329]]], [[[-0.6812131434679467, -0.75007359636996074, 0.52195871968240559, 0.74207747673309732], [0.53576769134014213, -0.19432873205999046, -0.87970756195132904, -0.36970944422105911], [0.18377651984390431, -0.30093639418244189, 0.30640551056952825, -0.95779743159891284]], [[0.3069655071293016, 0.42532244942656305, 0.27182877898608804, 0.89926151593228765], [-0.94227360921249192, 0.17309985459832045, -0.067341615594060267, -0.24017528169767255], [0.72377020653147883, -0.60287365881872312, 0.17612550848074338, -0.89499327987049915]]], [[[-0.8985020338092089, -0.27805317471704494, -0.096352572725887375, 0.26107376060313836], [-0.98264038134460852, -0.40101944215897967, 0.80787105663414827, -0.91046803072373206], [-0.11056024039811629, -0.35146855329949345, 0.62639019941990948, 0.029258586953160748]], [[0.5190564210634494, 0.25178673168519605, -0.095466912631134937, -0.66223610619416462], [0.86572944270431917, -0.0070686656495086986, -0.56404011740509774, 0.5156978630437381], [0.15106963134402651, 0.12900511640038159, 0.6022471822104567, 0.48643914768022012]]]])  
   
       # arg=Data(numarray.array([[[[0.4996033665120716, -0.074132654028136846, 0.2908837888281397, 0.79804117547820219], [0.25334186456470942, -0.10892196087517791, 0.90411872189757747, -0.21372334914190327], [0.65549677694560438, 0.97979738684954532, -0.29737844854710138, 0.93659843329597914]], [[0.22668444631484608, -0.92481913749465305, -0.9980815386745403, -0.022502768980955601], [-0.21769755240946398, 0.77216348666766876, -0.19843685166706204, 0.54270333879579558], [-0.11274856721131221, -0.29600869223659299, 0.1458222910080329, -0.83739782177046851]]], [[[0.86722932032155531, 0.39888432468517876, -0.8991679849590255, -0.088621935923834272], [-0.58464076321585412, -0.09564380294323116, 0.18232602464536307, 0.7910046931530843], [0.15923450234841652, -0.39331159996226872, 0.18298541750645669, 0.99889484861795563]], [[0.36793558813747418, -0.64593764280975363, 0.048503028175158613, -0.8304805399530264], [0.072019074767407432, -0.066883567381289311, -0.55849542620276127, -0.32521841292447484], [0.83256632210175896, -0.52124955617445723, -0.0047287521832242163, 0.84184001532121422]]], [[[-0.81375499823702158, 0.12901434959756353, -0.51500727423485215, 0.52626362435118912], [-0.47602620905811044, 0.81525173294213982, 0.023145745277130203, 0.5818744103097242], [-0.26074066195347489, 0.62737248392572886, 0.24246935026650718, 0.86155298917514145]], [[0.40180649524587109, -0.13468267908829512, -0.66576279256576543, -0.97664336021962694], [-0.81183732113700424, -0.10477655696019839, -0.90212494842448732, 0.50784279020015499], [0.29352929816605089, 0.10640245030222295, -0.16640870997460122, 0.91371366707232826]]]]),self.functionspace,True)  
       # arg.setTaggedValue(1,[[[[0.6465819200939884, 0.21755363919340609, 0.73973535907059662, -0.36114669719855241], [0.16087051863228452, -0.96295075570141986, 0.93283344105282717, 0.8498346294196879], [-0.62871563035312805, 0.028501977366871101, -0.76183996578150004, -0.42396762024023338]], [[0.45139869884828876, 0.9085099092003921, 0.90516675545818392, -0.2797423591331305], [-0.012176715080714828, 0.40935600076669765, -0.010156279663344314, -0.45527372677880185], [-0.56697253731600106, -0.88076957837377901, -0.43708368779823448, -0.98115855535334329]]], [[[-0.6812131434679467, -0.75007359636996074, 0.52195871968240559, 0.74207747673309732], [0.53576769134014213, -0.19432873205999046, -0.87970756195132904, -0.36970944422105911], [0.18377651984390431, -0.30093639418244189, 0.30640551056952825, -0.95779743159891284]], [[0.3069655071293016, 0.42532244942656305, 0.27182877898608804, 0.89926151593228765], [-0.94227360921249192, 0.17309985459832045, -0.067341615594060267, -0.24017528169767255], [0.72377020653147883, -0.60287365881872312, 0.17612550848074338, -0.89499327987049915]]], [[[-0.8985020338092089, -0.27805317471704494, -0.096352572725887375, 0.26107376060313836], [-0.98264038134460852, -0.40101944215897967, 0.80787105663414827, -0.91046803072373206], [-0.11056024039811629, -0.35146855329949345, 0.62639019941990948, 0.029258586953160748]], [[0.5190564210634494, 0.25178673168519605, -0.095466912631134937, -0.66223610619416462], [0.86572944270431917, -0.0070686656495086986, -0.56404011740509774, 0.5156978630437381], [0.15106963134402651, 0.12900511640038159, 0.6022471822104567, 0.48643914768022012]]]])  
       res=Lsup(arg)  
       ref=0.998894848618  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_float_rank0(self):  
       arg=0.870743835413  
       ref=0.870743835413  
       res=sup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_array_rank0(self):  
       arg=0.469212543992  
       ref=0.469212543992  
       res=sup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_array_rank1(self):  
       arg=numarray.array([0.8163530200305178, 0.7844191729334391])  
       ref=0.816353020031  
       res=sup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_array_rank2(self):  
       arg=numarray.array([[-0.52338785100595131, 0.72523140545134046, -0.23883623210726745, 0.29329903553233394, 0.77300897701720128], [0.56646202903477705, -0.67833617682539948, 0.71280801753916911, 0.108973189514324, -0.86675353843929437], [0.37080584846118247, 0.61817009100957776, -0.20780655998890807, 0.085315295987765438, -0.73527023026482174], [-0.97586476277122935, 0.14501540684207481, 0.57375473938632338, 0.08516777342367865, -0.22644451314946301]])  
       ref=0.773008977017  
       res=sup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_array_rank3(self):  
       arg=numarray.array([[[0.16933183602716984, -0.42964457496769226], [-0.63714228263554573, -0.28513481547494179]], [[0.72479530443714335, -0.097501515360919111], [-0.28611653510816737, -0.58370472731498535]], [[-0.18432738416022554, 0.79010596522300558], [-0.65367387441910196, 0.90861652898349976]], [[0.56004415223670123, 0.20178156913861489], [0.90730594499457595, 0.91196305151516754]], [[-0.46179421349599847, -0.54555869532019163], [0.36014998847058499, -0.70585188726413306]], [[0.49988705904335418, -0.52181171665742077], [0.14475259007357621, -0.94336078709637383]]])  
       ref=0.911963051515  
       res=sup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_array_rank4(self):  
       arg=numarray.array([[[[0.085213773984220698, -0.9837351364458633, -0.23428780807935823, -0.54350985593703971], [-0.021654619752513593, -0.58267295960777465, -0.95135334805945893, -0.82172163939108089], [0.92970460708060565, 0.12721615089598348, 0.36243089042630872, 0.50434042290503855]], [[0.20617957875725845, 0.13657289785878368, 0.7942986246389756, -0.92641374730818571], [0.30431241116181762, -0.13563881945622858, 0.37921852742514695, -0.39275408991812211], [-0.016546769015328033, 0.50932041928102878, -0.27343457607173893, -0.0076289641375255624]]], [[[0.97189015970083137, -0.71286035174080009, 0.10143028964095313, -0.41856292303563181], [-0.97563458262665792, 0.79724078659701769, -0.70932749973904685, 0.018497784992804522], [-0.86374122662275021, 0.047715471334789816, -0.95453593058418518, 0.54562170290354794]], [[0.40249406070198157, -0.54609432046574469, -0.22682900899629166, 0.98394939138178539], [0.11049172557176901, 0.42172241721325388, 0.71050000578192951, 0.35353993854713206], [0.35412886303451896, -0.98169699399727617, 0.04758881049644037, 0.96971205948237493]]], [[[0.44672925866052249, -0.51476498049696828, 0.56442823935318875, -0.39769248164928039], [-0.40340965812893304, -0.87947712857546945, 0.55927022788356706, -0.89941016574892707], [-0.43878304559423431, 0.20915357555548764, -0.76548553334601799, -0.67202522557876954]], [[-0.56749721271516318, -0.10244683680777245, 0.17727779142251943, -0.57219284260940473], [-0.17044718853145446, 0.91117482665936023, -0.30039592703806584, -0.73813808369358713], [0.63771084365736663, -0.61427668096170129, 0.34365587989446378, -0.11877233448104674]]]])  
       ref=0.983949391382  
       res=sup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_constData_rank0(self):  
       arg=Data(0.165371505685,self.functionspace)  
       ref=0.165371505685  
       res=sup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_constData_rank1(self):  
       arg=Data(numarray.array([-0.89603386749185288, -0.68712608295212729]),self.functionspace)  
       ref=-0.687126082952  
       res=sup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_constData_rank2(self):  
       arg=Data(numarray.array([[0.60272743728014655, 0.26067131689446787, -0.48488892003697837, -0.54328378217335027, -0.96627165443113894], [0.38861396631681999, -0.14210447298121753, -0.84480805358330624, -0.25397651427390566, 0.25670041011662192], [-0.062982523786134337, -0.149708363807598, -0.63332360725934489, -0.49175302564011525, -0.97647588301352473], [0.52022334705669038, -0.69717039787412727, -0.28284586409251511, 0.99642563937215467, -0.67058148736338885]]),self.functionspace)  
       ref=0.996425639372  
       res=sup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_constData_rank3(self):  
       arg=Data(numarray.array([[[-0.98552936119306023, -0.58995212270861552], [0.51743177430155907, 0.68576837981065508]], [[-0.61618414432919089, -0.12325580790677049], [0.32387395300714172, -0.95456083598524333]], [[0.89779642579517049, 0.98676270760314266], [0.71959629907181966, -0.9949078223284622]], [[-0.81547040114414271, 0.10033634427970006], [-0.21591232734408217, -0.68608679705274822]], [[0.30423138886571999, 0.34122142527426802], [-0.4344532377066066, -0.31076903154305779]], [[-0.46111628105416602, -0.18371998359850483], [0.63606993796228117, -0.10703087143670587]]]),self.functionspace)  
       ref=0.986762707603  
       res=sup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_constData_rank4(self):  
       arg=Data(numarray.array([[[[0.89488524023952776, 0.8669396968091807, -0.45769331537553315, -0.89738195395075349], [0.39077366764066168, -0.71075932241646922, -0.51096889323130612, 0.87130290122807663], [0.17079807940685177, -0.6198922248677714, -0.41261700237404653, -0.30627765803812368]], [[-0.0659839868001868, -0.54367942190111385, 0.79254440140135607, -0.28895269724305006], [0.2554732744127961, -0.0076696085190677277, 0.6846601760873452, 0.38696598742090393], [-0.77125424651939789, 0.63909999575689591, -0.87840142433528379, 0.41711809974302594]]], [[[-0.99322035791310692, 0.27097830567855352, -0.4253855401144222, 0.15768186455727529], [-0.49181115516922302, -0.36126829134959304, 0.52357599944776667, 0.91209852597809005], [0.069076441159411361, -0.18292686281510551, -0.6497679800515983, 0.022610374934600719]], [[0.28755759348156507, -0.08281906224050295, 0.76036900801429907, 0.54802231074240826], [-0.033682724326368874, -0.7414032372095134, -0.86699767465780231, 0.40592904057808044], [0.51593363738292841, -0.72087130860034332, 0.35672334112134374, -0.090721746979026463]]], [[[-0.54866684145444511, -0.96738751715836968, -0.21201752332220436, -0.099425492405464277], [-0.76528700517307313, -0.85955622688708644, -0.10492266626403257, 0.69311319310724762], [-0.33886276086664902, -0.6846128323156393, 0.05873264876508566, 0.88498228323799433]], [[-0.28404277561384639, -0.63570388064518468, -0.67775264818658387, 0.20825454125346576], [-0.84788984114351473, 0.037932422136330635, 0.021981819447397299, -0.2709264612684219], [-0.64072476278735468, 0.46126191894728197, -0.37456096950035489, 0.85599593427453957]]]]),self.functionspace)  
       ref=0.912098525978  
       res=sup(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_expandedData_rank0(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*0.842459260157+(1.-msk)*0.985691469761  
   
       # arg=Data(0.842459260157,self.functionspace,True)  
       # arg.setTaggedValue(1,0.842459260157)  
       res=sup(arg)  
       ref=0.985691469761  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_expandedData_rank1(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([0.47024430020620023, -0.40410868427962021])+(1.-msk)*numarray.array([0.34568516056640197, -0.43342673126146103])  
   
       # arg=Data(numarray.array([0.47024430020620023, -0.40410868427962021]),self.functionspace,True)  
       # arg.setTaggedValue(1,[0.34568516056640197, -0.43342673126146103])  
       res=sup(arg)  
       ref=0.470244300206  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_expandedData_rank2(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([[-0.88351146515427814, 0.87526615684362929, 0.80242059303502922, -0.6048006248682789, 0.42108402102305953], [0.11385226207304888, -0.66232044805160473, 0.69874162972474063, 0.22449470583280284, -0.19986159203927545], [0.17102700533232951, -0.9790459454968905, 0.4374092200111821, -0.4343902463997138, 0.72993175063985705], [-0.42636794385375065, -0.88420160799308434, -0.073357336228458081, -0.96071213693656698, -0.28591564459422769]])+(1.-msk)*numarray.array([[-0.66507554751323883, 0.90956185314332916, 0.39373039994051529, 0.20185922272970869, 0.56272045770025914], [-0.81603670050480082, -0.98308666677421708, 0.081972418155825233, 0.98933334281872432, -0.67280110519862579], [-0.67384516784043069, 0.19168471924963759, -0.59938113619504896, 0.22266455997006829, -0.93324865777959265], [0.93134589933544842, -0.10311385886401503, -0.2331509870020978, 0.37315747180467018, 0.73551730577813057]])  
   
       # arg=Data(numarray.array([[-0.88351146515427814, 0.87526615684362929, 0.80242059303502922, -0.6048006248682789, 0.42108402102305953], [0.11385226207304888, -0.66232044805160473, 0.69874162972474063, 0.22449470583280284, -0.19986159203927545], [0.17102700533232951, -0.9790459454968905, 0.4374092200111821, -0.4343902463997138, 0.72993175063985705], [-0.42636794385375065, -0.88420160799308434, -0.073357336228458081, -0.96071213693656698, -0.28591564459422769]]),self.functionspace,True)  
       # arg.setTaggedValue(1,[[-0.66507554751323883, 0.90956185314332916, 0.39373039994051529, 0.20185922272970869, 0.56272045770025914], [-0.81603670050480082, -0.98308666677421708, 0.081972418155825233, 0.98933334281872432, -0.67280110519862579], [-0.67384516784043069, 0.19168471924963759, -0.59938113619504896, 0.22266455997006829, -0.93324865777959265], [0.93134589933544842, -0.10311385886401503, -0.2331509870020978, 0.37315747180467018, 0.73551730577813057]])  
       res=sup(arg)  
       ref=0.989333342819  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_expandedData_rank3(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([[[-0.69867440642271283, -0.37489565319806606], [-0.66485463581725601, 0.18238313710104448]], [[-0.78388494323459157, 0.24027472943325923], [-0.4377158808146262, -0.34262284842949864]], [[-0.8539094490313166, 0.62109328106735684], [-0.20715549218162899, -0.33320905765908693]], [[-0.25702886172082651, 0.94651536183641283], [-0.2229696935051404, 0.84771132395539794]], [[0.52244706935442076, -0.89344888833386804], [0.064322796922618108, 0.36966382541443532]], [[0.55710175300577691, -0.22780561634551688], [0.89548548132750594, -0.77561238906399077]]])+(1.-msk)*numarray.array([[[-0.86933240372621312, 0.32078825553642276], [0.36873095289245739, 0.20578150283627239]], [[-0.13143164944725427, 0.89920065296927199], [0.79295913398164197, 0.78838875458878954]], [[0.068510791358111334, 0.87754319283313054], [-0.96880448620091553, -0.012058603734139028]], [[0.44680342907934811, -0.52293412412648466], [0.51117158355443149, -0.6794979840301234]], [[0.55644022070667498, 0.082838767459920026], [-0.64861425420762142, -0.20781169747814943]], [[0.52302454039265078, -0.71078210239352546], [0.67348959224612859, 0.18668184392186915]]])  
   
       # arg=Data(numarray.array([[[-0.69867440642271283, -0.37489565319806606], [-0.66485463581725601, 0.18238313710104448]], [[-0.78388494323459157, 0.24027472943325923], [-0.4377158808146262, -0.34262284842949864]], [[-0.8539094490313166, 0.62109328106735684], [-0.20715549218162899, -0.33320905765908693]], [[-0.25702886172082651, 0.94651536183641283], [-0.2229696935051404, 0.84771132395539794]], [[0.52244706935442076, -0.89344888833386804], [0.064322796922618108, 0.36966382541443532]], [[0.55710175300577691, -0.22780561634551688], [0.89548548132750594, -0.77561238906399077]]]),self.functionspace,True)  
       # arg.setTaggedValue(1,[[[-0.86933240372621312, 0.32078825553642276], [0.36873095289245739, 0.20578150283627239]], [[-0.13143164944725427, 0.89920065296927199], [0.79295913398164197, 0.78838875458878954]], [[0.068510791358111334, 0.87754319283313054], [-0.96880448620091553, -0.012058603734139028]], [[0.44680342907934811, -0.52293412412648466], [0.51117158355443149, -0.6794979840301234]], [[0.55644022070667498, 0.082838767459920026], [-0.64861425420762142, -0.20781169747814943]], [[0.52302454039265078, -0.71078210239352546], [0.67348959224612859, 0.18668184392186915]]])  
       res=sup(arg)  
       ref=0.946515361836  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sup_expandedData_rank4(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([[[[-0.97992610933200397, -0.25896245628971326, -0.70483438344031946, -0.99381143197943023], [-0.94915117581748709, -0.41900816047650036, -0.73354223723879386, 0.75059333884969881], [-0.76848095939834238, -0.75674819943701244, 0.065477641668864495, -0.42345850130975426]], [[-0.86758200423510234, -0.91179084363212071, -0.95127824910458103, 0.44686792515820439], [0.24843166983163689, -0.78829756520109728, -0.29421842880871774, 0.081312723661290498], [-0.73676127398786795, 0.91442315487631975, -0.64075473615377643, -0.68228346762450576]]], [[[-0.52913624371899504, 0.18611492696208209, 0.87647965087074042, 0.81733477764270401], [-0.45994626037000352, -0.72068350777641998, -0.67722337882139305, 0.53688427407036721], [-0.62155086776441348, -0.16407031198819877, 0.27545162813408264, 0.82180316351563087]], [[0.86221555518143278, -0.038942303505028031, 0.99073092777336114, -0.59207542384567113], [-0.42324210154238218, 0.76649013040311842, 0.86242470461616949, 0.49956796372115009], [-0.3983839684487791, 0.50100130531149967, -0.61285700166494195, -0.77581662400471862]]], [[[0.393847951204221, -0.72453857578029801, 0.97194727576353768, -0.95039782864739597], [-0.33546269250215266, 0.4831646699512071, -0.36084136685304102, -0.21835205500655297], [-0.82932637046105562, 0.70351683765540218, -0.058619290451321637, -0.2054802590132303]], [[0.94447147902776929, -0.42312399627562503, -0.11683182283655591, -0.40970199303413191], [-0.057628087834810326, -0.92418858637343759, 0.17632737701884516, -0.45930384359491305], [-0.47612419752878798, -0.96256404924809247, 0.10415265869578216, -0.63202348546194909]]]])+(1.-msk)*numarray.array([[[[-0.97434762405813102, 0.7014239623245393, 0.62448079624150288, -0.37769806924712546], [-0.85193729675303742, -0.77375392434251022, 0.36142120851055592, 0.26580596564769365], [-0.87276378893603579, 0.38973819311591718, 0.98354255063199636, -0.66795317131402343]], [[0.90231744676982428, -0.27585106370360957, -0.32108129691288001, 0.60440834831736634], [-0.045905880902579188, -0.29199624499256793, 0.025945636614535861, -0.098321374439206854], [-0.56344512008582659, -0.3766256629210043, -0.16641839175601203, -0.47355537095296341]]], [[[-0.98963277387073156, -0.84954014836916003, 0.58413699452656576, -0.90574771672091781], [-0.076165236495137068, -0.33185579541568311, 0.71508582816996036, 0.092982625872773284], [-0.59803076383019627, 0.96534061564337792, -0.86101074809006883, 0.4514321077629706]], [[0.68169942993010979, -0.46839019201575827, 0.86748862862295062, 0.077239140299438347], [-0.41039932807903745, 0.77351932859252215, -0.91858786520587499, -0.83803209999478323], [-0.66149540952220676, 0.21690925014134543, 0.49329666114093262, 0.22750525795569843]]], [[[0.49476796496001074, 0.54374663478072427, -0.64963120626875592, 0.57704965092442939], [0.74520801893525035, -0.18704889796101698, -0.73119506283113278, 0.30233417986347821], [-0.40842036405150561, -0.58450470869605797, 0.084020496164487923, -0.58538663622202569]], [[0.75611417989143481, -0.52196566347687212, 0.47144797786301607, -0.99505702762998172], [-0.0043333507755138889, -0.8740422871734248, 0.69683145050592943, -0.015830354510735223], [-0.047302931197539255, -0.033238606395723957, -0.95126827803180114, 0.88954001433619978]]]])  
   
       # arg=Data(numarray.array([[[[-0.97992610933200397, -0.25896245628971326, -0.70483438344031946, -0.99381143197943023], [-0.94915117581748709, -0.41900816047650036, -0.73354223723879386, 0.75059333884969881], [-0.76848095939834238, -0.75674819943701244, 0.065477641668864495, -0.42345850130975426]], [[-0.86758200423510234, -0.91179084363212071, -0.95127824910458103, 0.44686792515820439], [0.24843166983163689, -0.78829756520109728, -0.29421842880871774, 0.081312723661290498], [-0.73676127398786795, 0.91442315487631975, -0.64075473615377643, -0.68228346762450576]]], [[[-0.52913624371899504, 0.18611492696208209, 0.87647965087074042, 0.81733477764270401], [-0.45994626037000352, -0.72068350777641998, -0.67722337882139305, 0.53688427407036721], [-0.62155086776441348, -0.16407031198819877, 0.27545162813408264, 0.82180316351563087]], [[0.86221555518143278, -0.038942303505028031, 0.99073092777336114, -0.59207542384567113], [-0.42324210154238218, 0.76649013040311842, 0.86242470461616949, 0.49956796372115009], [-0.3983839684487791, 0.50100130531149967, -0.61285700166494195, -0.77581662400471862]]], [[[0.393847951204221, -0.72453857578029801, 0.97194727576353768, -0.95039782864739597], [-0.33546269250215266, 0.4831646699512071, -0.36084136685304102, -0.21835205500655297], [-0.82932637046105562, 0.70351683765540218, -0.058619290451321637, -0.2054802590132303]], [[0.94447147902776929, -0.42312399627562503, -0.11683182283655591, -0.40970199303413191], [-0.057628087834810326, -0.92418858637343759, 0.17632737701884516, -0.45930384359491305], [-0.47612419752878798, -0.96256404924809247, 0.10415265869578216, -0.63202348546194909]]]]),self.functionspace,True)  
       # arg.setTaggedValue(1,[[[[-0.97434762405813102, 0.7014239623245393, 0.62448079624150288, -0.37769806924712546], [-0.85193729675303742, -0.77375392434251022, 0.36142120851055592, 0.26580596564769365], [-0.87276378893603579, 0.38973819311591718, 0.98354255063199636, -0.66795317131402343]], [[0.90231744676982428, -0.27585106370360957, -0.32108129691288001, 0.60440834831736634], [-0.045905880902579188, -0.29199624499256793, 0.025945636614535861, -0.098321374439206854], [-0.56344512008582659, -0.3766256629210043, -0.16641839175601203, -0.47355537095296341]]], [[[-0.98963277387073156, -0.84954014836916003, 0.58413699452656576, -0.90574771672091781], [-0.076165236495137068, -0.33185579541568311, 0.71508582816996036, 0.092982625872773284], [-0.59803076383019627, 0.96534061564337792, -0.86101074809006883, 0.4514321077629706]], [[0.68169942993010979, -0.46839019201575827, 0.86748862862295062, 0.077239140299438347], [-0.41039932807903745, 0.77351932859252215, -0.91858786520587499, -0.83803209999478323], [-0.66149540952220676, 0.21690925014134543, 0.49329666114093262, 0.22750525795569843]]], [[[0.49476796496001074, 0.54374663478072427, -0.64963120626875592, 0.57704965092442939], [0.74520801893525035, -0.18704889796101698, -0.73119506283113278, 0.30233417986347821], [-0.40842036405150561, -0.58450470869605797, 0.084020496164487923, -0.58538663622202569]], [[0.75611417989143481, -0.52196566347687212, 0.47144797786301607, -0.99505702762998172], [-0.0043333507755138889, -0.8740422871734248, 0.69683145050592943, -0.015830354510735223], [-0.047302931197539255, -0.033238606395723957, -0.95126827803180114, 0.88954001433619978]]]])  
       res=sup(arg)  
       ref=0.990730927773  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_float_rank0(self):  
       arg=0.857535693433  
       ref=0.857535693433  
       res=inf(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_array_rank0(self):  
       arg=0.170725403135  
       ref=0.170725403135  
       res=inf(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_array_rank1(self):  
       arg=numarray.array([-0.20582799927627726, 0.0065475369467946631])  
       ref=-0.205827999276  
       res=inf(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_array_rank2(self):  
       arg=numarray.array([[-0.00088705991533410966, -0.78884753663192009, 0.51871980588812661, -0.58204851803513313, 0.14241101940826861], [0.79094574969805964, 0.79672216617995617, -0.5690477768894624, 0.51157272654417052, 0.18066938665191556], [0.32364745994353683, 0.4748425103497671, 0.66679519455306924, -0.69644515487912217, -0.37494171775165297], [-0.18679695095262239, -0.78312977298360509, 0.044885312146701661, -0.44016241609550066, -0.49756845096624081]])  
       ref=-0.788847536632  
       res=inf(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_array_rank3(self):  
       arg=numarray.array([[[-0.8081125483464171, -0.39512178653285135], [-0.88509761616456495, 0.27821695074525521]], [[-0.12065704909614361, 0.68332883926843135], [0.3403814721074454, -0.32879966956330042]], [[-0.7045229028656752, -0.1577338131736914], [-0.5966034105188045, 0.73456332700634985]], [[0.87843639147943997, 0.94490362642776882], [-0.45552277927474183, -0.9768135246661469]], [[-0.65451540143458864, -0.2796668209543185], [-0.085396852552783953, 0.83466766003117332]], [[0.43465138886082078, 0.61441480296663342], [0.92555078046558337, -0.24612584648713121]]])  
       ref=-0.976813524666  
       res=inf(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_array_rank4(self):  
       arg=numarray.array([[[[-0.05536021838962446, -0.0098764348632232046, -0.52953548051740618, 0.58523070076080819], [0.10613609818504877, 0.67324697282212087, 0.54615663777618906, -0.67572666188479613], [-0.14390410848091539, 0.54011444546397591, -0.85609073171970373, 0.077099187121419277]], [[-0.20493469025659716, 0.90647730634569368, -0.71749107354722064, -0.12332697315517271], [0.63551267588618598, -0.60802528409862266, 0.052319255834022638, -0.95394697709081688], [-0.88612629669117959, 0.32248454322667519, 0.0072741938614420132, -0.69013368898879235]]], [[[-0.10462047858216028, -0.30097012474135698, -0.050016775782701028, 0.54822125876578376], [0.84395749034726886, -0.53249513893193168, -0.88004100855031275, -0.80779542570577179], [-0.79677629667791683, 0.95096027764472169, 0.63643207567783144, 0.97757008271555401]], [[-0.65415697736192047, -0.97050764835238645, -0.84814693021942777, -0.43855897064286542], [-0.37135308255264543, 0.041120751125186095, 0.036995657114785807, -0.35706630152349828], [-0.0030591331649565401, 0.48192500000712779, 0.18102011879743984, -0.78573775232009435]]], [[[-0.31965876602783605, 0.10351748464331689, 0.067424791069963907, -0.049524027182576535], [-0.5213817364489115, 0.027521683153738818, -0.24734661576641237, 0.24321699964875232], [-0.83947613904690699, 0.77162806253216987, -0.90740945316368071, -0.3420545897410685]], [[0.91845344502663262, -0.70878381509801414, 0.90861837177726379, -0.4013061463136427], [-0.18540388033546473, 0.9254510240675875, 0.30634230347058677, -0.97817133509804033], [-0.43975591131244984, 0.30020642565479139, 0.36841633323637479, 0.3066739733421715]]]])  
       ref=-0.978171335098  
       res=inf(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_constData_rank0(self):  
       arg=Data(0.0114629834279,self.functionspace)  
       ref=0.0114629834279  
       res=inf(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_constData_rank1(self):  
       arg=Data(numarray.array([-0.13734485813185704, -0.54812466656634307]),self.functionspace)  
       ref=-0.548124666566  
       res=inf(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_constData_rank2(self):  
       arg=Data(numarray.array([[-0.89509582806410015, 0.10780316690435621, -0.93073500763754335, -0.38534759506991545, -0.6935160645644014], [-0.056672310128515813, 0.6285075027787359, 0.73632355512072167, -0.60238897825476267, 0.77403597203864094], [-0.5930215600641755, 0.72623233579382429, -0.32117191475695361, -0.081104170523293773, 0.62137628665436373], [0.2669734570396014, -0.65030905665614136, -0.53589374176691495, -0.48334830355881309, -0.89125004784938211]]),self.functionspace)  
       ref=-0.930735007638  
       res=inf(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_constData_rank3(self):  
       arg=Data(numarray.array([[[0.94493948950092999, 0.13737629155757691], [-0.81599535906086107, -0.35832278646984816]], [[-0.53692839435234041, 0.53679590218669571], [0.038856705021854232, -0.18543838436402926]], [[0.19718168292863836, -0.55405958298613656], [0.16477861536800242, 0.17787953041277582]], [[0.51547288009005165, 0.35889372726595203], [-0.033476505587150873, -0.42142418570614026]], [[0.80507204877418204, -0.79581688922832838], [-0.85909254497735588, 0.66095083521227149]], [[0.46206420953978222, 0.53654696439305005], [0.57618105395776831, -0.22241758047110038]]]),self.functionspace)  
       ref=-0.859092544977  
       res=inf(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_constData_rank4(self):  
       arg=Data(numarray.array([[[[0.50544713768476202, 0.96922321849050874, -0.81524480218696649, -0.36499730379849193], [-0.48131882706974372, 0.026812357207576465, 0.090903267401989618, -0.24742363369877829], [-0.51631372893805438, 0.30410275437953183, -0.75149566289642533, -0.19930300338453599]], [[0.82034878499482788, -0.70904661587698792, -0.27637223434426073, -0.34818734117560401], [0.11686048779802416, -0.76746266142163178, -0.75578186306174833, 0.14509316330390232], [0.1590050723141736, 0.69684384552537937, -0.58747105640080832, -0.28640840371441523]]], [[[0.14956532194045669, 0.081514192262221119, 0.32061383569406399, -0.2444346881437609], [0.79564139071785278, -0.5456680167461434, 0.24722978802719742, 0.28286130725068315], [0.10385207763921711, -0.064749181840278336, 0.21325254547672734, -0.71875644540473838]], [[0.58552496009870802, 0.35472373485671338, -0.18411162994671826, 0.71609038134967773], [-0.20966804574945064, -0.49286619989346314, 0.85116051808632553, -0.94417114370961075], [-0.40434528979823714, 0.62250343758157611, 0.64860074098639742, 0.0043146814280992096]]], [[[-0.14242849200713259, 0.42551908502898095, 0.7691157770973962, -0.37595641162856674], [0.026655444032149589, -0.82186407521644167, 0.40285091480648783, -0.53328831035315982], [-0.12887729257054481, 0.75610663428133451, 0.022049613835531723, 0.59949338706293043]], [[-0.34506254315071772, 0.019719877473602043, 0.10216765908478709, 0.022681548062032153], [0.2228614880408597, 0.26944547311401901, -0.10122095357202965, -0.51019076850180589], [-0.081439546799124463, 0.18829632566943544, 0.12366885442775377, 0.73651436499107814]]]]),self.functionspace)  
       ref=-0.94417114371  
       res=inf(arg)  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_expandedData_rank0(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*0.97331285569+(1.-msk)*0.911344578019  
   
       # arg=Data(0.97331285569,self.functionspace,True)  
       #arg.setTaggedValue(1,0.97331285569)  
       res=inf(arg)  
       ref=0.911344578019  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_expandedData_rank1(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([-0.025782649803792301, 0.15017595667012174])+(1.-msk)*numarray.array([-0.69996944983865683, 0.23286168827412723])  
   
       # arg=Data(numarray.array([-0.025782649803792301, 0.15017595667012174]),self.functionspace,True)  
       # arg.setTaggedValue(1,[-0.69996944983865683, 0.23286168827412723])  
       res=inf(arg)  
       ref=-0.699969449839  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_expandedData_rank2(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([[-0.11924617230337731, -0.69281409701569552, 0.8819805848672797, 0.67606672557817737, -0.15719846909292801], [-0.91958498979699277, 0.35156143886023572, -0.66768679685578647, -0.48673444352737993, -0.33274286155542288], [-0.011930486621410052, -0.035661622752792166, 0.8109198510155371, 0.2680383999767102, 0.38679270088753159], [-0.64107995512896321, 0.58836944145799008, -0.55856121453754959, 0.63346354980998365, -0.74990799644898765]])+(1.-msk)*numarray.array([[0.075603512293304975, 0.65374459813382813, -0.68190855977115938, 0.023184369691352069, -0.15500904033575869], [-0.28865053906142646, 0.94679590620919218, -0.53701383780009748, -0.5413294941411595, -0.1693286769782183], [-0.34870739946353968, -0.92230175409787241, -0.95867600429924127, -0.0012605712136730673, 0.33180267589091184], [-0.60152160703395885, 0.3397221706065463, 0.58860878406913142, 0.59589494790106934, -0.96157487116725071]])  
   
       # arg=Data(numarray.array([[-0.11924617230337731, -0.69281409701569552, 0.8819805848672797, 0.67606672557817737, -0.15719846909292801], [-0.91958498979699277, 0.35156143886023572, -0.66768679685578647, -0.48673444352737993, -0.33274286155542288], [-0.011930486621410052, -0.035661622752792166, 0.8109198510155371, 0.2680383999767102, 0.38679270088753159], [-0.64107995512896321, 0.58836944145799008, -0.55856121453754959, 0.63346354980998365, -0.74990799644898765]]),self.functionspace,True)  
       # arg.setTaggedValue(1,[[0.075603512293304975, 0.65374459813382813, -0.68190855977115938, 0.023184369691352069, -0.15500904033575869], [-0.28865053906142646, 0.94679590620919218, -0.53701383780009748, -0.5413294941411595, -0.1693286769782183], [-0.34870739946353968, -0.92230175409787241, -0.95867600429924127, -0.0012605712136730673, 0.33180267589091184], [-0.60152160703395885, 0.3397221706065463, 0.58860878406913142, 0.59589494790106934, -0.96157487116725071]])  
       res=inf(arg)  
       ref=-0.961574871167  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_expandedData_rank3(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([[[0.76729109013175933, 0.93446692332588199], [-0.85883010569426133, 0.94426468618035608]], [[0.93376991286356659, -0.31027020688815887], [0.68776369494826284, -0.71422083083074273]], [[0.88895851954297633, -0.0041028262794304826], [-0.56213269421968981, -0.53305350433881493]], [[0.91080353792869873, 0.87460732654624618], [-0.43411934331432445, -0.66454826732696648]], [[-0.7458989571542316, 0.0054889915153857327], [-0.43786572648758848, 0.45559010284736901]], [[0.97274627384999923, 0.28719064869132427], [-0.068944574283213989, 0.92462015394940389]]])+(1.-msk)*numarray.array([[[0.45653716082021401, -0.23702471933521396], [-0.45177153258555913, -0.41351543065221219]], [[0.24913453932538854, -0.29954039408048372], [0.47106013214852771, -0.86663080347446608]], [[-0.75781905181266151, 0.18918623668675538], [-0.66636479853389385, 0.74776214919244066]], [[-0.1199599974824086, 0.90306995612278795], [0.77248429149482201, 0.094536885699270545]], [[-0.5505821492977705, -0.42454185319972981], [-0.035064708067998662, -0.75303714911308206]], [[-0.63966405281134198, -0.5545794126646626], [-0.010523374154368881, -0.6779302443539712]]])  
   
       # arg=Data(numarray.array([[[0.76729109013175933, 0.93446692332588199], [-0.85883010569426133, 0.94426468618035608]], [[0.93376991286356659, -0.31027020688815887], [0.68776369494826284, -0.71422083083074273]], [[0.88895851954297633, -0.0041028262794304826], [-0.56213269421968981, -0.53305350433881493]], [[0.91080353792869873, 0.87460732654624618], [-0.43411934331432445, -0.66454826732696648]], [[-0.7458989571542316, 0.0054889915153857327], [-0.43786572648758848, 0.45559010284736901]], [[0.97274627384999923, 0.28719064869132427], [-0.068944574283213989, 0.92462015394940389]]]),self.functionspace,True)  
       # arg.setTaggedValue(1,[[[0.45653716082021401, -0.23702471933521396], [-0.45177153258555913, -0.41351543065221219]], [[0.24913453932538854, -0.29954039408048372], [0.47106013214852771, -0.86663080347446608]], [[-0.75781905181266151, 0.18918623668675538], [-0.66636479853389385, 0.74776214919244066]], [[-0.1199599974824086, 0.90306995612278795], [0.77248429149482201, 0.094536885699270545]], [[-0.5505821492977705, -0.42454185319972981], [-0.035064708067998662, -0.75303714911308206]], [[-0.63966405281134198, -0.5545794126646626], [-0.010523374154368881, -0.6779302443539712]]])  
       res=inf(arg)  
       ref=-0.866630803474  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_inf_expandedData_rank4(self):  
   
       msk=whereNegative(self.functionspace.getX()[0]-0.5)  
       arg=msk*numarray.array([[[[0.59301561766072242, 0.6053289847447505, 0.1720524601196014, 0.4833679091408507], [-0.09424534157102582, 0.91976800441974427, -0.11950945037648264, -0.10547294628619919], [0.045302052907340462, -0.26699801365763864, -0.59100789693502542, 0.8220898248447317]], [[-0.71764117646989489, -0.31097048109028447, -0.36880919201656037, -0.12380648590370025], [0.71171672214402615, -0.87716399369053821, 0.53673002158727501, -0.29732656272582969], [-0.71737153055394787, -0.18861795164190798, -0.55325559014387649, 0.50828072891961451]]], [[[0.7139879661021804, -0.54655602578694507, -0.62738810494945163, -0.71453639471562314], [0.25287437655577372, 0.47571671295036144, -0.86354401602062025, -0.45354287599804666], [0.44863440392806031, -0.64112646326775291, 0.91877609169151908, 0.98277738739744636]], [[-0.23627452345538003, 0.26824331838587279, -0.11255839194272887, 0.62327509528972769], [0.87773514238000572, 0.62819546928589953, 0.53463187163744053, -0.11780048176113112], [0.17743656841726674, -0.47418242507357755, 0.37012543459814751, 0.84217962384585232]]], [[[-0.51615332690558602, -0.32180746309362296, -0.86871747985681558, -0.89347967000489548], [0.79236651642797762, -0.82769899986382356, -0.27503369025221813, 0.70491420567015894], [-0.46319485284379014, -0.71191635366918904, -0.4935498645964489, 0.42096986386791024]], [[-0.95241673224815648, -0.99507534300684708, -0.76759978752396862, -0.1621109099401965], [0.011495974208982407, 0.90547796535927083, -0.79651097416963368, 0.44382172569512224], [-0.11210429012307821, 0.28303519643554576, -0.59783370185364437, 0.75478113456483809]]]])+(1.-msk)*numarray.array([[[[0.70392145790103089, -0.7532260844479588, -0.53422583924595046, 0.29798767877629717], [0.87516135156666075, -0.40276494310086908, -0.070320230959511232, 0.13669067815714553], [0.26690559342737163, -0.0067218741792103298, 0.79272133073277207, -0.90080452301155178]], [[-0.90606808543363915, 0.94927254364127123, -0.15130300474521019, -0.34632615506118936], [0.29908319964670294, -0.71717585217034374, -0.11325472101126977, 0.60911487311528911], [0.055579283773870003, -0.42895625110409941, 0.22788310989168781, 0.50000680777627848]]], [[[-0.56683598589959683, 0.05720680440798942, 0.27949696950971137, 0.028472427888231566], [-0.51619860801944828, 0.73067372155966415, 0.81910302859539108, 0.97736576074434089], [-0.68851989268805447, 0.93303896549540433, -0.21083269397032622, -0.93122611728597304]], [[-0.13573136829275501, -0.30858456571228721, 0.86534434039603658, 0.79114631697533278], [-0.32870753097283112, 0.68472493656951161, -0.071089197922887593, -0.032936485145198757], [0.40875380316397925, -0.27280027645573401, -0.27155299841136848, -0.81500786568603067]]], [[[0.080473457255322733, -0.54931257643900566, 0.19082193004877501, -0.52744293877995374], [0.44447571282767639, -0.0060974808128133606, -0.87810788913565485, -0.92670043304972327], [0.45760340069120065, -0.7504981866011311, -0.95431384972577082, 0.4644557658783679]], [[0.18449401878090566, -0.73315009595487135, -0.59404794479416467, 0.076556365298426687], [0.65441299213898763, -0.91649003079073932, -0.082437357750317686, 0.88150531806538579], [-0.45829076922310796, 0.91236619416957021, -0.91128142664652279, 0.9524897339484899]]]])  
   
       # arg=Data(numarray.array([[[[0.59301561766072242, 0.6053289847447505, 0.1720524601196014, 0.4833679091408507], [-0.09424534157102582, 0.91976800441974427, -0.11950945037648264, -0.10547294628619919], [0.045302052907340462, -0.26699801365763864, -0.59100789693502542, 0.8220898248447317]], [[-0.71764117646989489, -0.31097048109028447, -0.36880919201656037, -0.12380648590370025], [0.71171672214402615, -0.87716399369053821, 0.53673002158727501, -0.29732656272582969], [-0.71737153055394787, -0.18861795164190798, -0.55325559014387649, 0.50828072891961451]]], [[[0.7139879661021804, -0.54655602578694507, -0.62738810494945163, -0.71453639471562314], [0.25287437655577372, 0.47571671295036144, -0.86354401602062025, -0.45354287599804666], [0.44863440392806031, -0.64112646326775291, 0.91877609169151908, 0.98277738739744636]], [[-0.23627452345538003, 0.26824331838587279, -0.11255839194272887, 0.62327509528972769], [0.87773514238000572, 0.62819546928589953, 0.53463187163744053, -0.11780048176113112], [0.17743656841726674, -0.47418242507357755, 0.37012543459814751, 0.84217962384585232]]], [[[-0.51615332690558602, -0.32180746309362296, -0.86871747985681558, -0.89347967000489548], [0.79236651642797762, -0.82769899986382356, -0.27503369025221813, 0.70491420567015894], [-0.46319485284379014, -0.71191635366918904, -0.4935498645964489, 0.42096986386791024]], [[-0.95241673224815648, -0.99507534300684708, -0.76759978752396862, -0.1621109099401965], [0.011495974208982407, 0.90547796535927083, -0.79651097416963368, 0.44382172569512224], [-0.11210429012307821, 0.28303519643554576, -0.59783370185364437, 0.75478113456483809]]]]),self.functionspace,True)  
       # arg.setTaggedValue(1,[[[[0.70392145790103089, -0.7532260844479588, -0.53422583924595046, 0.29798767877629717], [0.87516135156666075, -0.40276494310086908, -0.070320230959511232, 0.13669067815714553], [0.26690559342737163, -0.0067218741792103298, 0.79272133073277207, -0.90080452301155178]], [[-0.90606808543363915, 0.94927254364127123, -0.15130300474521019, -0.34632615506118936], [0.29908319964670294, -0.71717585217034374, -0.11325472101126977, 0.60911487311528911], [0.055579283773870003, -0.42895625110409941, 0.22788310989168781, 0.50000680777627848]]], [[[-0.56683598589959683, 0.05720680440798942, 0.27949696950971137, 0.028472427888231566], [-0.51619860801944828, 0.73067372155966415, 0.81910302859539108, 0.97736576074434089], [-0.68851989268805447, 0.93303896549540433, -0.21083269397032622, -0.93122611728597304]], [[-0.13573136829275501, -0.30858456571228721, 0.86534434039603658, 0.79114631697533278], [-0.32870753097283112, 0.68472493656951161, -0.071089197922887593, -0.032936485145198757], [0.40875380316397925, -0.27280027645573401, -0.27155299841136848, -0.81500786568603067]]], [[[0.080473457255322733, -0.54931257643900566, 0.19082193004877501, -0.52744293877995374], [0.44447571282767639, -0.0060974808128133606, -0.87810788913565485, -0.92670043304972327], [0.45760340069120065, -0.7504981866011311, -0.95431384972577082, 0.4644557658783679]], [[0.18449401878090566, -0.73315009595487135, -0.59404794479416467, 0.076556365298426687], [0.65441299213898763, -0.91649003079073932, -0.082437357750317686, 0.88150531806538579], [-0.45829076922310796, 0.91236619416957021, -0.91128142664652279, 0.9524897339484899]]]])  
       res=inf(arg)  
       ref=-0.995075343007  
       self.failUnless(isinstance(res,float),"wrong type of result.")  
       self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")  
282  #=========================================================  #=========================================================
283  #  Symbols  #  Symbols
284  #=========================================================  #=========================================================
# Line 10144  class Test_util(unittest.TestCase): Line 9759  class Test_util(unittest.TestCase):
9759        self.failIf(s==DependendSymbol(shape=(3,2,3,4),dim=2,args=[1, -1.0]),"different dimension.")        self.failIf(s==DependendSymbol(shape=(3,2,3,4),dim=2,args=[1, -1.0]),"different dimension.")
9760        self.failIf(s==DependendSymbol(shape=(3,2,3,4),dim=3,args=[1, 1.0]),"different arguments not detected.")        self.failIf(s==DependendSymbol(shape=(3,2,3,4),dim=3,args=[1, 1.0]),"different arguments not detected.")
9761    
9762  class Test_util_with_tagged_Data(Test_util):  
9763    class Test_util_reduction_no_tagged_data(Test_util_base):
9764       """
9765       test for reduction operation Lsup,sup,inf. no tagged data are used
9766       """
9767       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9768       def test_Lsup_float_rank0(self):
9769          arg=0.479077251703
9770          ref=0.479077251703
9771          res=Lsup(arg)
9772          self.failUnless(isinstance(res,float),"wrong type of result.")
9773          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9774       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9775       def test_Lsup_array_rank0(self):
9776          arg=0.352800421569
9777          ref=0.352800421569
9778          res=Lsup(arg)
9779          self.failUnless(isinstance(res,float),"wrong type of result.")
9780          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9781       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9782       def test_Lsup_array_rank1(self):
9783          arg=numarray.array([0.58364106865247445, 0.19224319360367659])
9784          ref=0.583641068652
9785          res=Lsup(arg)
9786          self.failUnless(isinstance(res,float),"wrong type of result.")
9787          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9788       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9789       def test_Lsup_array_rank2(self):
9790          arg=numarray.array([[0.67017748174064184, 0.27426357568545234, 0.99809374007262508, 0.0068333566694658288, -0.27942939334057559], [-0.41062296082648619, -0.036816602223561423, -0.50580074937952246, 0.93227848108675948, -0.061517050082725788], [0.36561750746233845, 0.41114839130078873, 0.52258027672142848, -0.16534372330544111, 0.20772668552253304], [0.821900382760401, -0.84255628577421948, -0.69396587198625026, -0.57918798921236458, -0.72171447032975466]])
9791          ref=0.998093740073
9792          res=Lsup(arg)
9793          self.failUnless(isinstance(res,float),"wrong type of result.")
9794          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9795       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9796       def test_Lsup_array_rank3(self):
9797          arg=numarray.array([[[0.058641541671277109, -0.90451294682583527], [-0.24359709498927606, -0.57748558070477163]], [[0.035804882991596898, 0.62841290637910441], [-0.28533080116748288, -0.97886508166774955]], [[0.31393622401598642, -0.43905852202615403], [-0.86251727012547685, 0.028980168735740941]], [[0.64796855283921229, -0.48583038861071492], [0.18113352051559328, -0.41145930584343637]], [[0.039393878628251944, 0.8768398562091233], [-0.17607723439655953, -0.88597401556177768]], [[-0.015710131346685419, -0.1460065558640582], [0.97739538148461858, -0.96991499683153215]]])
9798          ref=0.978865081668
9799          res=Lsup(arg)
9800          self.failUnless(isinstance(res,float),"wrong type of result.")
9801          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9802       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9803       def test_Lsup_array_rank4(self):
9804          arg=numarray.array([[[[-0.78982105495266985, -0.63220666806337955, 0.17512704833203396, 0.87905338838606228], [0.23198845220692799, 0.039972475068823288, 0.012169097173197807, 0.44188750570302382], [0.76550090905039703, 0.31693138180972436, 0.1053031163896907, -0.35110494947362092]], [[0.98438531435704557, 0.64830270240860366, 0.17255823042313656, -0.89376135594562944], [-0.24129437029981871, -0.142955980423916, 0.16557185988864043, 0.97182386578689162], [0.68369373227893937, -0.86170550438838256, 0.30120477894454822, 0.38702330237685523]]], [[[0.77139284396922037, 0.20032741426304668, 0.57845916425558697, -0.29867163908832151], [-0.068269410287581156, 0.5940891737261742, 0.076472990825278808, -0.099092183170674364], [-0.052727700907511776, 0.86303703635283835, -0.87561628108225542, 0.98706354430335175]], [[0.59243014649382819, 0.1550040875984271, -0.2755507051420949, -0.0013143184448647371], [0.49341486033505921, 0.47331310491746503, -0.79931467469262252, -0.90673470029976722], [-0.032268150780954796, 0.296035852616644, 0.51579882806939303, 0.46437108203184607]]], [[[-0.54940019219066349, 0.063961557315018069, 0.58950734587654585, -0.98334853918198539], [-0.3624096661573355, 0.41744569348555416, 0.30209950686844023, 0.51268273249278518], [0.18884359916930848, -0.71707023426140903, -0.30560603652072227, 0.50521867139895282]], [[0.48925658559264695, -0.22791551552340583, -0.0018172920946346593, -0.35038144063572618], [-0.92608233760416425, -0.58447575161042908, 0.6419293813902982, -0.9165521427783867], [0.32116313637555338, 0.64441081354246466, 0.57516697859586241, -0.30456483792192746]]]])
9805          ref=0.987063544303
9806          res=Lsup(arg)
9807          self.failUnless(isinstance(res,float),"wrong type of result.")
9808          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9809       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9810       def test_Lsup_constData_rank0(self):
9811          arg=Data(0.196366308048,self.functionspace)
9812          ref=0.196366308048
9813          res=Lsup(arg)
9814          self.failUnless(isinstance(res,float),"wrong type of result.")
9815          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9816       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9817       def test_Lsup_constData_rank1(self):
9818          arg=Data(numarray.array([-0.013183241788205846, 0.30081447346639489]),self.functionspace)
9819          ref=0.300814473466
9820          res=Lsup(arg)
9821          self.failUnless(isinstance(res,float),"wrong type of result.")
9822          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9823       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9824       def test_Lsup_constData_rank2(self):
9825          arg=Data(numarray.array([[0.5711180583492661, 0.70931947195628298, -0.66895311699347904, 0.96005746113679025, 0.73085528334644767], [-0.63904611175106618, 0.2843691804450883, 0.44023994297671054, 0.74230048057601272, 0.32582591826440876], [0.058605148358656045, 0.17856553839104938, 0.92397360311332144, -0.96449976222010503, -0.2936728605307215], [-0.54599501106213921, 0.76941479487476183, 0.071247548913826231, 0.19101147233175308, -0.1697403800152153]]),self.functionspace)
9826          ref=0.96449976222
9827          res=Lsup(arg)
9828          self.failUnless(isinstance(res,float),"wrong type of result.")
9829          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9830       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9831       def test_Lsup_constData_rank3(self):
9832          arg=Data(numarray.array([[[0.72501574945437675, 0.097442689963523454], [0.81136110912526904, 0.30019286779005516]], [[-0.49590270028453376, 0.89873757442194169], [-0.77574675514072333, 0.00090692035026496143]], [[0.30313499990678294, -0.22304437168798286], [0.26434595235717628, 0.56043553186944139]], [[-0.82536121216538372, 0.017266274277504934], [0.15087851023611853, 0.85422443819044291]], [[-0.85528228633213454, 0.21599153787828373], [-0.8320606477196939, 0.8359530516934528]], [[-0.32478507656272382, 0.11549647741760993], [-0.87438785398253049, 0.58454806081387956]]]),self.functionspace)
9833          ref=0.898737574422
9834          res=Lsup(arg)
9835          self.failUnless(isinstance(res,float),"wrong type of result.")
9836          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9837       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9838       def test_Lsup_constData_rank4(self):
9839          arg=Data(numarray.array([[[[-0.1675633776917147, 0.33827478137880718, -0.93890402023643449, 0.65020437341791437], [0.29507018847480526, 0.98622587753446878, 0.12652012726316597, -0.31134038684685694], [-0.046095794370747178, 0.52924578464459526, -0.6479404156998898, -0.50108997075395512]], [[-0.89461015899273821, -0.079360196866752331, 0.24950542226018069, 0.6689436082056277], [0.92392213781413735, 0.3873078097702356, 0.19593123983162242, -0.24092882483013001], [-0.64621424798001881, 0.9822743623774457, 0.89791841241748926, 0.61910184653693512]]], [[[-0.93993640130694156, 0.86452728798536005, 0.094496916350070848, 0.59825417382728907], [0.55042390382543216, 0.83625046124041091, -0.59865905280251042, 0.60081510989738351], [0.96300656863917622, 0.45676715577013183, 0.96765574240961594, 0.35217159943804499]], [[-0.44344990079738578, -0.62540931368504271, 0.47046830875624712, 0.56727920796684694], [0.68754074058706793, -0.20419202844112316, -0.0095491803785341389, 0.013299778291189002], [0.17824394120278897, -0.27714200037108694, -0.2616405339148673, -0.32155257707876661]]], [[[0.47113927793594357, -0.99306136743656892, 0.30468996581271934, -0.55558797016447881], [0.83216176170936151, 0.016003159554198287, 0.50607924358488665, -0.44441953149310631], [0.81919419287951278, -0.65849894919643503, 0.91897977494732008, -0.52338741357416407]], [[0.71408966944475138, -0.49347702658095161, 0.35676281330171133, 0.87268025092466872], [0.38401738326898771, -0.66323897612738114, 0.57309433517459518, 0.72101582669934583], [-0.0289954568811297, 0.55204032281174009, 0.51120867863750807, -0.67373936301915327]]]]),self.functionspace)
9840          ref=0.993061367437
9841          res=Lsup(arg)
9842          self.failUnless(isinstance(res,float),"wrong type of result.")
9843          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9844    
9845       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9846       def test_Lsup_expandedData_rank0(self):
9847          msk=whereNegative(self.functionspace.getX()[0]-0.5)
9848          arg=msk*0.907507663119+(1.-msk)*0.907507663119
9849    
9850          # arg=Data(0.907507663119,self.functionspace,True)
9851          # arg.setTaggedValue(1,0.907507663119)
9852          res=Lsup(arg)
9853          ref=0.907507663119
9854          self.failUnless(isinstance(res,float),"wrong type of result.")
9855          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9856       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9857       def test_Lsup_expandedData_rank1(self):
9858    
9859          msk=whereNegative(self.functionspace.getX()[0]-0.5)
9860          arg=msk*numarray.array([0.64842023599463228, 0.7950449048151853])+(1.-msk)*numarray.array([-0.53356920308809608, -0.30392740367264159])
9861    
9862          # arg=Data(numarray.array([0.64842023599463228, 0.7950449048151853]),self.functionspace,True)
9863          # arg.setTaggedValue(1,[-0.53356920308809608, -0.30392740367264159])
9864          res=Lsup(arg)
9865          ref=0.795044904815
9866          self.failUnless(isinstance(res,float),"wrong type of result.")
9867          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9868       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9869       def test_Lsup_expandedData_rank2(self):
9870    
9871          msk=whereNegative(self.functionspace.getX()[0]-0.5)
9872          arg=msk*numarray.array([[0.72772455370935374, -0.47120637916343311, -0.82075870555018726, -0.13186541688079845, 0.14046405940683471], [0.10791450121551649, 0.043686402172190775, 0.4587164889316806, -0.16569163575870283, 0.64477762072726041], [0.62628246294878309, -0.46538827310659792, 0.58089235621217727, -0.745300901798017, -0.1072674226756638], [0.93074707226494824, 0.17195108914746116, 0.77645205158899833, -0.55814650711894975, -0.68929261213084403]])+(1.-msk)*numarray.array([[-0.25856012658041871, -0.64132706411711782, -0.90934384682634128, 0.13076992241789931, 0.23456684296051011], [0.54052140856785269, 0.78868044275368643, 0.20419986484049479, 0.64782383948156319, 0.12883249735345115], [-0.44575026820636654, -0.86972644697707824, 0.74937006939719653, 0.64390867433141019, 0.57227950445890885], [-0.59430616226417832, -0.77932115906125854, 0.60864641730739155, 0.909083762068297, -0.5444504332265574]])
9873    
9874          # arg=Data(numarray.array([[0.72772455370935374, -0.47120637916343311, -0.82075870555018726, -0.13186541688079845, 0.14046405940683471], [0.10791450121551649, 0.043686402172190775, 0.4587164889316806, -0.16569163575870283, 0.64477762072726041], [0.62628246294878309, -0.46538827310659792, 0.58089235621217727, -0.745300901798017, -0.1072674226756638], [0.93074707226494824, 0.17195108914746116, 0.77645205158899833, -0.55814650711894975, -0.68929261213084403]]),self.functionspace,True)
9875          # arg.setTaggedValue(1,[[-0.25856012658041871, -0.64132706411711782, -0.90934384682634128, 0.13076992241789931, 0.23456684296051011], [0.54052140856785269, 0.78868044275368643, 0.20419986484049479, 0.64782383948156319, 0.12883249735345115], [-0.44575026820636654, -0.86972644697707824, 0.74937006939719653, 0.64390867433141019, 0.57227950445890885], [-0.59430616226417832, -0.77932115906125854, 0.60864641730739155, 0.909083762068297, -0.5444504332265574]])
9876          res=Lsup(arg)
9877          ref=0.930747072265
9878          self.failUnless(isinstance(res,float),"wrong type of result.")
9879          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9880       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9881       def test_Lsup_expandedData_rank3(self):
9882    
9883          msk=whereNegative(self.functionspace.getX()[0]-0.5)
9884          arg=msk*numarray.array([[[0.31609964814729086, -0.59322042077218184], [0.62671563648606643, -0.99924882354010092]], [[-0.81285219908299133, -0.91261945476639861], [-0.66394864058744174, -0.070011911370653657]], [[-0.4798784324091383, -0.017929635369934749], [0.87935995021589952, 0.73748462709583618]], [[-0.89673095768516986, 0.44255562883781563], [-0.33009427566326166, 0.89415170271508537]], [[-0.070411620428932897, 0.34854312339042304], [-0.54088506672687542, 0.57996368816677069]], [[0.98447862226498417, 0.31010343079927294], [0.18832525314748882, 0.46594491838516161]]])+(1.-msk)*numarray.array([[[0.036725320623094637, -0.95874317021810596], [-0.66138152872168576, -0.52870418789420959]], [[0.59182952544611012, -0.31117513196914603], [0.17957160072325573, -0.93130315483187909]], [[0.33548100103066814, -0.6503677585469938], [-0.15995741665912955, -0.79138987042982367]], [[0.12353483100690976, -0.72197260504479188], [-0.35933752275788389, -0.46752695895022667]], [[0.7611306903818762, -0.88807332904594882], [0.91131651925077373, 0.81255438802194258]], [[-0.56892641899978824, 0.0010213385566093525], [0.40194539652124472, -0.006585080723547021]]])
9885    
9886          # arg=Data(numarray.array([[[0.31609964814729086, -0.59322042077218184], [0.62671563648606643, -0.99924882354010092]], [[-0.81285219908299133, -0.91261945476639861], [-0.66394864058744174, -0.070011911370653657]], [[-0.4798784324091383, -0.017929635369934749], [0.87935995021589952, 0.73748462709583618]], [[-0.89673095768516986, 0.44255562883781563], [-0.33009427566326166, 0.89415170271508537]], [[-0.070411620428932897, 0.34854312339042304], [-0.54088506672687542, 0.57996368816677069]], [[0.98447862226498417, 0.31010343079927294], [0.18832525314748882, 0.46594491838516161]]]),self.functionspace,True)
9887          # arg.setTaggedValue(1,[[[0.036725320623094637, -0.95874317021810596], [-0.66138152872168576, -0.52870418789420959]], [[0.59182952544611012, -0.31117513196914603], [0.17957160072325573, -0.93130315483187909]], [[0.33548100103066814, -0.6503677585469938], [-0.15995741665912955, -0.79138987042982367]], [[0.12353483100690976, -0.72197260504479188], [-0.35933752275788389, -0.46752695895022667]], [[0.7611306903818762, -0.88807332904594882], [0.91131651925077373, 0.81255438802194258]], [[-0.56892641899978824, 0.0010213385566093525], [0.40194539652124472, -0.006585080723547021]]])
9888          res=Lsup(arg)
9889          ref=0.99924882354
9890          self.failUnless(isinstance(res,float),"wrong type of result.")
9891          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9892       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9893       def test_Lsup_expandedData_rank4(self):
9894    
9895          msk=whereNegative(self.functionspace.getX()[0]-0.5)
9896          arg=msk*numarray.array([[[[0.4996033665120716, -0.074132654028136846, 0.2908837888281397, 0.79804117547820219], [0.25334186456470942, -0.10892196087517791, 0.90411872189757747, -0.21372334914190327], [0.65549677694560438, 0.97979738684954532, -0.29737844854710138, 0.93659843329597914]], [[0.22668444631484608, -0.92481913749465305, -0.9980815386745403, -0.022502768980955601], [-0.21769755240946398, 0.77216348666766876, -0.19843685166706204, 0.54270333879579558], [-0.11274856721131221, -0.29600869223659299, 0.1458222910080329, -0.83739782177046851]]], [[[0.86722932032155531, 0.39888432468517876, -0.8991679849590255, -0.088621935923834272], [-0.58464076321585412, -0.09564380294323116, 0.18232602464536307, 0.7910046931530843], [0.15923450234841652, -0.39331159996226872, 0.18298541750645669, 0.99889484861795563]], [[0.36793558813747418, -0.64593764280975363, 0.048503028175158613, -0.8304805399530264], [0.072019074767407432, -0.066883567381289311, -0.55849542620276127, -0.32521841292447484], [0.83256632210175896, -0.52124955617445723, -0.0047287521832242163, 0.84184001532121422]]], [[[-0.81375499823702158, 0.12901434959756353, -0.51500727423485215, 0.52626362435118912], [-0.47602620905811044, 0.81525173294213982, 0.023145745277130203, 0.5818744103097242], [-0.26074066195347489, 0.62737248392572886, 0.24246935026650718, 0.86155298917514145]], [[0.40180649524587109, -0.13468267908829512, -0.66576279256576543, -0.97664336021962694], [-0.81183732113700424, -0.10477655696019839, -0.90212494842448732, 0.50784279020015499], [0.29352929816605089, 0.10640245030222295, -0.16640870997460122, 0.91371366707232826]]]])+(1.-msk)*numarray.array([[[[0.6465819200939884, 0.21755363919340609, 0.73973535907059662, -0.36114669719855241], [0.16087051863228452, -0.96295075570141986, 0.93283344105282717, 0.8498346294196879], [-0.62871563035312805, 0.028501977366871101, -0.76183996578150004, -0.42396762024023338]], [[0.45139869884828876, 0.9085099092003921, 0.90516675545818392, -0.2797423591331305], [-0.012176715080714828, 0.40935600076669765, -0.010156279663344314, -0.45527372677880185], [-0.56697253731600106, -0.88076957837377901, -0.43708368779823448, -0.98115855535334329]]], [[[-0.6812131434679467, -0.75007359636996074, 0.52195871968240559, 0.74207747673309732], [0.53576769134014213, -0.19432873205999046, -0.87970756195132904, -0.36970944422105911], [0.18377651984390431, -0.30093639418244189, 0.30640551056952825, -0.95779743159891284]], [[0.3069655071293016, 0.42532244942656305, 0.27182877898608804, 0.89926151593228765], [-0.94227360921249192, 0.17309985459832045, -0.067341615594060267, -0.24017528169767255], [0.72377020653147883, -0.60287365881872312, 0.17612550848074338, -0.89499327987049915]]], [[[-0.8985020338092089, -0.27805317471704494, -0.096352572725887375, 0.26107376060313836], [-0.98264038134460852, -0.40101944215897967, 0.80787105663414827, -0.91046803072373206], [-0.11056024039811629, -0.35146855329949345, 0.62639019941990948, 0.029258586953160748]], [[0.5190564210634494, 0.25178673168519605, -0.095466912631134937, -0.66223610619416462], [0.86572944270431917, -0.0070686656495086986, -0.56404011740509774, 0.5156978630437381], [0.15106963134402651, 0.12900511640038159, 0.6022471822104567, 0.48643914768022012]]]])
9897    
9898          # arg=Data(numarray.array([[[[0.4996033665120716, -0.074132654028136846, 0.2908837888281397, 0.79804117547820219], [0.25334186456470942, -0.10892196087517791, 0.90411872189757747, -0.21372334914190327], [0.65549677694560438, 0.97979738684954532, -0.29737844854710138, 0.93659843329597914]], [[0.22668444631484608, -0.92481913749465305, -0.9980815386745403, -0.022502768980955601], [-0.21769755240946398, 0.77216348666766876, -0.19843685166706204, 0.54270333879579558], [-0.11274856721131221, -0.29600869223659299, 0.1458222910080329, -0.83739782177046851]]], [[[0.86722932032155531, 0.39888432468517876, -0.8991679849590255, -0.088621935923834272], [-0.58464076321585412, -0.09564380294323116, 0.18232602464536307, 0.7910046931530843], [0.15923450234841652, -0.39331159996226872, 0.18298541750645669, 0.99889484861795563]], [[0.36793558813747418, -0.64593764280975363, 0.048503028175158613, -0.8304805399530264], [0.072019074767407432, -0.066883567381289311, -0.55849542620276127, -0.32521841292447484], [0.83256632210175896, -0.52124955617445723, -0.0047287521832242163, 0.84184001532121422]]], [[[-0.81375499823702158, 0.12901434959756353, -0.51500727423485215, 0.52626362435118912], [-0.47602620905811044, 0.81525173294213982, 0.023145745277130203, 0.5818744103097242], [-0.26074066195347489, 0.62737248392572886, 0.24246935026650718, 0.86155298917514145]], [[0.40180649524587109, -0.13468267908829512, -0.66576279256576543, -0.97664336021962694], [-0.81183732113700424, -0.10477655696019839, -0.90212494842448732, 0.50784279020015499], [0.29352929816605089, 0.10640245030222295, -0.16640870997460122, 0.91371366707232826]]]]),self.functionspace,True)
9899          # arg.setTaggedValue(1,[[[[0.6465819200939884, 0.21755363919340609, 0.73973535907059662, -0.36114669719855241], [0.16087051863228452, -0.96295075570141986, 0.93283344105282717, 0.8498346294196879], [-0.62871563035312805, 0.028501977366871101, -0.76183996578150004, -0.42396762024023338]], [[0.45139869884828876, 0.9085099092003921, 0.90516675545818392, -0.2797423591331305], [-0.012176715080714828, 0.40935600076669765, -0.010156279663344314, -0.45527372677880185], [-0.56697253731600106, -0.88076957837377901, -0.43708368779823448, -0.98115855535334329]]], [[[-0.6812131434679467, -0.75007359636996074, 0.52195871968240559, 0.74207747673309732], [0.53576769134014213, -0.19432873205999046, -0.87970756195132904, -0.36970944422105911], [0.18377651984390431, -0.30093639418244189, 0.30640551056952825, -0.95779743159891284]], [[0.3069655071293016, 0.42532244942656305, 0.27182877898608804, 0.89926151593228765], [-0.94227360921249192, 0.17309985459832045, -0.067341615594060267, -0.24017528169767255], [0.72377020653147883, -0.60287365881872312, 0.17612550848074338, -0.89499327987049915]]], [[[-0.8985020338092089, -0.27805317471704494, -0.096352572725887375, 0.26107376060313836], [-0.98264038134460852, -0.40101944215897967, 0.80787105663414827, -0.91046803072373206], [-0.11056024039811629, -0.35146855329949345, 0.62639019941990948, 0.029258586953160748]], [[0.5190564210634494, 0.25178673168519605, -0.095466912631134937, -0.66223610619416462], [0.86572944270431917, -0.0070686656495086986, -0.56404011740509774, 0.5156978630437381], [0.15106963134402651, 0.12900511640038159, 0.6022471822104567, 0.48643914768022012]]]])
9900          res=Lsup(arg)
9901          ref=0.998894848618
9902          self.failUnless(isinstance(res,float),"wrong type of result.")
9903          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9904       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9905       def test_sup_float_rank0(self):
9906          arg=0.870743835413
9907          ref=0.870743835413
9908          res=sup(arg)
9909          self.failUnless(isinstance(res,float),"wrong type of result.")
9910          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9911       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9912       def test_sup_array_rank0(self):
9913          arg=0.469212543992
9914          ref=0.469212543992
9915          res=sup(arg)
9916          self.failUnless(isinstance(res,float),"wrong type of result.")
9917          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9918       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9919       def test_sup_array_rank1(self):
9920          arg=numarray.array([0.8163530200305178, 0.7844191729334391])
9921          ref=0.816353020031
9922          res=sup(arg)
9923          self.failUnless(isinstance(res,float),"wrong type of result.")
9924          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9925       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9926       def test_sup_array_rank2(self):
9927          arg=numarray.array([[-0.52338785100595131, 0.72523140545134046, -0.23883623210726745, 0.29329903553233394, 0.77300897701720128], [0.56646202903477705, -0.67833617682539948, 0.71280801753916911, 0.108973189514324, -0.86675353843929437], [0.37080584846118247, 0.61817009100957776, -0.20780655998890807, 0.085315295987765438, -0.73527023026482174], [-0.97586476277122935, 0.14501540684207481, 0.57375473938632338, 0.08516777342367865, -0.22644451314946301]])
9928          ref=0.773008977017
9929          res=sup(arg)
9930          self.failUnless(isinstance(res,float),"wrong type of result.")
9931          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9932       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9933       def test_sup_array_rank3(self):
9934          arg=numarray.array([[[0.16933183602716984, -0.42964457496769226], [-0.63714228263554573, -0.28513481547494179]], [[0.72479530443714335, -0.097501515360919111], [-0.28611653510816737, -0.58370472731498535]], [[-0.18432738416022554, 0.79010596522300558], [-0.65367387441910196, 0.90861652898349976]], [[0.56004415223670123, 0.20178156913861489], [0.90730594499457595, 0.91196305151516754]], [[-0.46179421349599847, -0.54555869532019163], [0.36014998847058499, -0.70585188726413306]], [[0.49988705904335418, -0.52181171665742077], [0.14475259007357621, -0.94336078709637383]]])
9935          ref=0.911963051515
9936          res=sup(arg)
9937          self.failUnless(isinstance(res,float),"wrong type of result.")
9938          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9939       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9940       def test_sup_array_rank4(self):
9941          arg=numarray.array([[[[0.085213773984220698, -0.9837351364458633, -0.23428780807935823, -0.54350985593703971], [-0.021654619752513593, -0.58267295960777465, -0.95135334805945893, -0.82172163939108089], [0.92970460708060565, 0.12721615089598348, 0.36243089042630872, 0.50434042290503855]], [[0.20617957875725845, 0.13657289785878368, 0.7942986246389756, -0.92641374730818571], [0.30431241116181762, -0.13563881945622858, 0.37921852742514695, -0.39275408991812211], [-0.016546769015328033, 0.50932041928102878, -0.27343457607173893, -0.0076289641375255624]]], [[[0.97189015970083137, -0.71286035174080009, 0.10143028964095313, -0.41856292303563181], [-0.97563458262665792, 0.79724078659701769, -0.70932749973904685, 0.018497784992804522], [-0.86374122662275021, 0.047715471334789816, -0.95453593058418518, 0.54562170290354794]], [[0.40249406070198157, -0.54609432046574469, -0.22682900899629166, 0.98394939138178539], [0.11049172557176901, 0.42172241721325388, 0.71050000578192951, 0.35353993854713206], [0.35412886303451896, -0.98169699399727617, 0.04758881049644037, 0.96971205948237493]]], [[[0.44672925866052249, -0.51476498049696828, 0.56442823935318875, -0.39769248164928039], [-0.40340965812893304, -0.87947712857546945, 0.55927022788356706, -0.89941016574892707], [-0.43878304559423431, 0.20915357555548764, -0.76548553334601799, -0.67202522557876954]], [[-0.56749721271516318, -0.10244683680777245, 0.17727779142251943, -0.57219284260940473], [-0.17044718853145446, 0.91117482665936023, -0.30039592703806584, -0.73813808369358713], [0.63771084365736663, -0.61427668096170129, 0.34365587989446378, -0.11877233448104674]]]])
9942          ref=0.983949391382
9943          res=sup(arg)
9944          self.failUnless(isinstance(res,float),"wrong type of result.")
9945          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9946       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9947       def test_sup_constData_rank0(self):
9948          arg=Data(0.165371505685,self.functionspace)
9949          ref=0.165371505685
9950          res=sup(arg)
9951          self.failUnless(isinstance(res,float),"wrong type of result.")
9952          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9953       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9954       def test_sup_constData_rank1(self):
9955          arg=Data(numarray.array([-0.89603386749185288, -0.68712608295212729]),self.functionspace)
9956          ref=-0.687126082952
9957          res=sup(arg)
9958          self.failUnless(isinstance(res,float),"wrong type of result.")
9959          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9960       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9961       def test_sup_constData_rank2(self):
9962          arg=Data(numarray.array([[0.60272743728014655, 0.26067131689446787, -0.48488892003697837, -0.54328378217335027, -0.96627165443113894], [0.38861396631681999, -0.14210447298121753, -0.84480805358330624, -0.25397651427390566, 0.25670041011662192], [-0.062982523786134337, -0.149708363807598, -0.63332360725934489, -0.49175302564011525, -0.97647588301352473], [0.52022334705669038, -0.69717039787412727, -0.28284586409251511, 0.99642563937215467, -0.67058148736338885]]),self.functionspace)
9963          ref=0.996425639372
9964          res=sup(arg)
9965          self.failUnless(isinstance(res,float),"wrong type of result.")
9966          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9967       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9968       def test_sup_constData_rank3(self):
9969          arg=Data(numarray.array([[[-0.98552936119306023, -0.58995212270861552], [0.51743177430155907, 0.68576837981065508]], [[-0.61618414432919089, -0.12325580790677049], [0.32387395300714172, -0.95456083598524333]], [[0.89779642579517049, 0.98676270760314266], [0.71959629907181966, -0.9949078223284622]], [[-0.81547040114414271, 0.10033634427970006], [-0.21591232734408217, -0.68608679705274822]], [[0.30423138886571999, 0.34122142527426802], [-0.4344532377066066, -0.31076903154305779]], [[-0.46111628105416602, -0.18371998359850483], [0.63606993796228117, -0.10703087143670587]]]),self.functionspace)
9970          ref=0.986762707603
9971          res=sup(arg)
9972          self.failUnless(isinstance(res,float),"wrong type of result.")
9973          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9974       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9975       def test_sup_constData_rank4(self):
9976          arg=Data(numarray.array([[[[0.89488524023952776, 0.8669396968091807, -0.45769331537553315, -0.89738195395075349], [0.39077366764066168, -0.71075932241646922, -0.51096889323130612, 0.87130290122807663], [0.17079807940685177, -0.6198922248677714, -0.41261700237404653, -0.30627765803812368]], [[-0.0659839868001868, -0.54367942190111385, 0.79254440140135607, -0.28895269724305006], [0.2554732744127961, -0.0076696085190677277, 0.6846601760873452, 0.38696598742090393], [-0.77125424651939789, 0.63909999575689591, -0.87840142433528379, 0.41711809974302594]]], [[[-0.99322035791310692, 0.27097830567855352, -0.4253855401144222, 0.15768186455727529], [-0.49181115516922302, -0.36126829134959304, 0.52357599944776667, 0.91209852597809005], [0.069076441159411361, -0.18292686281510551, -0.6497679800515983, 0.022610374934600719]], [[0.28755759348156507, -0.08281906224050295, 0.76036900801429907, 0.54802231074240826], [-0.033682724326368874, -0.7414032372095134, -0.86699767465780231, 0.40592904057808044], [0.51593363738292841, -0.72087130860034332, 0.35672334112134374, -0.090721746979026463]]], [[[-0.54866684145444511, -0.96738751715836968, -0.21201752332220436, -0.099425492405464277], [-0.76528700517307313, -0.85955622688708644, -0.10492266626403257, 0.69311319310724762], [-0.33886276086664902, -0.6846128323156393, 0.05873264876508566, 0.88498228323799433]], [[-0.28404277561384639, -0.63570388064518468, -0.67775264818658387, 0.20825454125346576], [-0.84788984114351473, 0.037932422136330635, 0.021981819447397299, -0.2709264612684219], [-0.64072476278735468, 0.46126191894728197, -0.37456096950035489, 0.85599593427453957]]]]),self.functionspace)
9977          ref=0.912098525978
9978          res=sup(arg)
9979          self.failUnless(isinstance(res,float),"wrong type of result.")
9980          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9981       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9982       def test_sup_expandedData_rank0(self):
9983    
9984          msk=whereNegative(self.functionspace.getX()[0]-0.5)
9985          arg=msk*0.842459260157+(1.-msk)*0.985691469761
9986    
9987          # arg=Data(0.842459260157,self.functionspace,True)
9988          # arg.setTaggedValue(1,0.842459260157)
9989          res=sup(arg)
9990          ref=0.985691469761
9991          self.failUnless(isinstance(res,float),"wrong type of result.")
9992          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
9993       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
9994       def test_sup_expandedData_rank1(self):
9995    
9996          msk=whereNegative(self.functionspace.getX()[0]-0.5)
9997          arg=msk*numarray.array([0.47024430020620023, -0.40410868427962021])+(1.-msk)*numarray.array([0.34568516056640197, -0.43342673126146103])
9998    
9999          # arg=Data(numarray.array([0.47024430020620023, -0.40410868427962021]),self.functionspace,True)
10000          # arg.setTaggedValue(1,[0.34568516056640197, -0.43342673126146103])
10001          res=sup(arg)
10002          ref=0.470244300206
10003          self.failUnless(isinstance(res,float),"wrong type of result.")
10004          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10005       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10006       def test_sup_expandedData_rank2(self):
10007    
10008          msk=whereNegative(self.functionspace.getX()[0]-0.5)
10009          arg=msk*numarray.array([[-0.88351146515427814, 0.87526615684362929, 0.80242059303502922, -0.6048006248682789, 0.42108402102305953], [0.11385226207304888, -0.66232044805160473, 0.69874162972474063, 0.22449470583280284, -0.19986159203927545], [0.17102700533232951, -0.9790459454968905, 0.4374092200111821, -0.4343902463997138, 0.72993175063985705], [-0.42636794385375065, -0.88420160799308434, -0.073357336228458081, -0.96071213693656698, -0.28591564459422769]])+(1.-msk)*numarray.array([[-0.66507554751323883, 0.90956185314332916, 0.39373039994051529, 0.20185922272970869, 0.56272045770025914], [-0.81603670050480082, -0.98308666677421708, 0.081972418155825233, 0.98933334281872432, -0.67280110519862579], [-0.67384516784043069, 0.19168471924963759, -0.59938113619504896, 0.22266455997006829, -0.93324865777959265], [0.93134589933544842, -0.10311385886401503, -0.2331509870020978, 0.37315747180467018, 0.73551730577813057]])
10010    
10011          # arg=Data(numarray.array([[-0.88351146515427814, 0.87526615684362929, 0.80242059303502922, -0.6048006248682789, 0.42108402102305953], [0.11385226207304888, -0.66232044805160473, 0.69874162972474063, 0.22449470583280284, -0.19986159203927545], [0.17102700533232951, -0.9790459454968905, 0.4374092200111821, -0.4343902463997138, 0.72993175063985705], [-0.42636794385375065, -0.88420160799308434, -0.073357336228458081, -0.96071213693656698, -0.28591564459422769]]),self.functionspace,True)
10012          # arg.setTaggedValue(1,[[-0.66507554751323883, 0.90956185314332916, 0.39373039994051529, 0.20185922272970869, 0.56272045770025914], [-0.81603670050480082, -0.98308666677421708, 0.081972418155825233, 0.98933334281872432, -0.67280110519862579], [-0.67384516784043069, 0.19168471924963759, -0.59938113619504896, 0.22266455997006829, -0.93324865777959265], [0.93134589933544842, -0.10311385886401503, -0.2331509870020978, 0.37315747180467018, 0.73551730577813057]])
10013          res=sup(arg)
10014          ref=0.989333342819
10015          self.failUnless(isinstance(res,float),"wrong type of result.")
10016          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10017       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10018       def test_sup_expandedData_rank3(self):
10019    
10020          msk=whereNegative(self.functionspace.getX()[0]-0.5)
10021          arg=msk*numarray.array([[[-0.69867440642271283, -0.37489565319806606], [-0.66485463581725601, 0.18238313710104448]], [[-0.78388494323459157, 0.24027472943325923], [-0.4377158808146262, -0.34262284842949864]], [[-0.8539094490313166, 0.62109328106735684], [-0.20715549218162899, -0.33320905765908693]], [[-0.25702886172082651, 0.94651536183641283], [-0.2229696935051404, 0.84771132395539794]], [[0.52244706935442076, -0.89344888833386804], [0.064322796922618108, 0.36966382541443532]], [[0.55710175300577691, -0.22780561634551688], [0.89548548132750594, -0.77561238906399077]]])+(1.-msk)*numarray.array([[[-0.86933240372621312, 0.32078825553642276], [0.36873095289245739, 0.20578150283627239]], [[-0.13143164944725427, 0.89920065296927199], [0.79295913398164197, 0.78838875458878954]], [[0.068510791358111334, 0.87754319283313054], [-0.96880448620091553, -0.012058603734139028]], [[0.44680342907934811, -0.52293412412648466], [0.51117158355443149, -0.6794979840301234]], [[0.55644022070667498, 0.082838767459920026], [-0.64861425420762142, -0.20781169747814943]], [[0.52302454039265078, -0.71078210239352546], [0.67348959224612859, 0.18668184392186915]]])
10022    
10023          # arg=Data(numarray.array([[[-0.69867440642271283, -0.37489565319806606], [-0.66485463581725601, 0.18238313710104448]], [[-0.78388494323459157, 0.24027472943325923], [-0.4377158808146262, -0.34262284842949864]], [[-0.8539094490313166, 0.62109328106735684], [-0.20715549218162899, -0.33320905765908693]], [[-0.25702886172082651, 0.94651536183641283], [-0.2229696935051404, 0.84771132395539794]], [[0.52244706935442076, -0.89344888833386804], [0.064322796922618108, 0.36966382541443532]], [[0.55710175300577691, -0.22780561634551688], [0.89548548132750594, -0.77561238906399077]]]),self.functionspace,True)
10024          # arg.setTaggedValue(1,[[[-0.86933240372621312, 0.32078825553642276], [0.36873095289245739, 0.20578150283627239]], [[-0.13143164944725427, 0.89920065296927199], [0.79295913398164197, 0.78838875458878954]], [[0.068510791358111334, 0.87754319283313054], [-0.96880448620091553, -0.012058603734139028]], [[0.44680342907934811, -0.52293412412648466], [0.51117158355443149, -0.6794979840301234]], [[0.55644022070667498, 0.082838767459920026], [-0.64861425420762142, -0.20781169747814943]], [[0.52302454039265078, -0.71078210239352546], [0.67348959224612859, 0.18668184392186915]]])
10025          res=sup(arg)
10026          ref=0.946515361836
10027          self.failUnless(isinstance(res,float),"wrong type of result.")
10028          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10029       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10030       def test_sup_expandedData_rank4(self):
10031    
10032          msk=whereNegative(self.functionspace.getX()[0]-0.5)
10033          arg=msk*numarray.array([[[[-0.97992610933200397, -0.25896245628971326, -0.70483438344031946, -0.99381143197943023], [-0.94915117581748709, -0.41900816047650036, -0.73354223723879386, 0.75059333884969881], [-0.76848095939834238, -0.75674819943701244, 0.065477641668864495, -0.42345850130975426]], [[-0.86758200423510234, -0.91179084363212071, -0.95127824910458103, 0.44686792515820439], [0.24843166983163689, -0.78829756520109728, -0.29421842880871774, 0.081312723661290498], [-0.73676127398786795, 0.91442315487631975, -0.64075473615377643, -0.68228346762450576]]], [[[-0.52913624371899504, 0.18611492696208209, 0.87647965087074042, 0.81733477764270401], [-0.45994626037000352, -0.72068350777641998, -0.67722337882139305, 0.53688427407036721], [-0.62155086776441348, -0.16407031198819877, 0.27545162813408264, 0.82180316351563087]], [[0.86221555518143278, -0.038942303505028031, 0.99073092777336114, -0.59207542384567113], [-0.42324210154238218, 0.76649013040311842, 0.86242470461616949, 0.49956796372115009], [-0.3983839684487791, 0.50100130531149967, -0.61285700166494195, -0.77581662400471862]]], [[[0.393847951204221, -0.72453857578029801, 0.97194727576353768, -0.95039782864739597], [-0.33546269250215266, 0.4831646699512071, -0.36084136685304102, -0.21835205500655297], [-0.82932637046105562, 0.70351683765540218, -0.058619290451321637, -0.2054802590132303]], [[0.94447147902776929, -0.42312399627562503, -0.11683182283655591, -0.40970199303413191], [-0.057628087834810326, -0.92418858637343759, 0.17632737701884516, -0.45930384359491305], [-0.47612419752878798, -0.96256404924809247, 0.10415265869578216, -0.63202348546194909]]]])+(1.-msk)*numarray.array([[[[-0.97434762405813102, 0.7014239623245393, 0.62448079624150288, -0.37769806924712546], [-0.85193729675303742, -0.77375392434251022, 0.36142120851055592, 0.26580596564769365], [-0.87276378893603579, 0.38973819311591718, 0.98354255063199636, -0.66795317131402343]], [[0.90231744676982428, -0.27585106370360957, -0.32108129691288001, 0.60440834831736634], [-0.045905880902579188, -0.29199624499256793, 0.025945636614535861, -0.098321374439206854], [-0.56344512008582659, -0.3766256629210043, -0.16641839175601203, -0.47355537095296341]]], [[[-0.98963277387073156, -0.84954014836916003, 0.58413699452656576, -0.90574771672091781], [-0.076165236495137068, -0.33185579541568311, 0.71508582816996036, 0.092982625872773284], [-0.59803076383019627, 0.96534061564337792, -0.86101074809006883, 0.4514321077629706]], [[0.68169942993010979, -0.46839019201575827, 0.86748862862295062, 0.077239140299438347], [-0.41039932807903745, 0.77351932859252215, -0.91858786520587499, -0.83803209999478323], [-0.66149540952220676, 0.21690925014134543, 0.49329666114093262, 0.22750525795569843]]], [[[0.49476796496001074, 0.54374663478072427, -0.64963120626875592, 0.57704965092442939], [0.74520801893525035, -0.18704889796101698, -0.73119506283113278, 0.30233417986347821], [-0.40842036405150561, -0.58450470869605797, 0.084020496164487923, -0.58538663622202569]], [[0.75611417989143481, -0.52196566347687212, 0.47144797786301607, -0.99505702762998172], [-0.0043333507755138889, -0.8740422871734248, 0.69683145050592943, -0.015830354510735223], [-0.047302931197539255, -0.033238606395723957, -0.95126827803180114, 0.88954001433619978]]]])
10034    
10035          # arg=Data(numarray.array([[[[-0.97992610933200397, -0.25896245628971326, -0.70483438344031946, -0.99381143197943023], [-0.94915117581748709, -0.41900816047650036, -0.73354223723879386, 0.75059333884969881], [-0.76848095939834238, -0.75674819943701244, 0.065477641668864495, -0.42345850130975426]], [[-0.86758200423510234, -0.91179084363212071, -0.95127824910458103, 0.44686792515820439], [0.24843166983163689, -0.78829756520109728, -0.29421842880871774, 0.081312723661290498], [-0.73676127398786795, 0.91442315487631975, -0.64075473615377643, -0.68228346762450576]]], [[[-0.52913624371899504, 0.18611492696208209, 0.87647965087074042, 0.81733477764270401], [-0.45994626037000352, -0.72068350777641998, -0.67722337882139305, 0.53688427407036721], [-0.62155086776441348, -0.16407031198819877, 0.27545162813408264, 0.82180316351563087]], [[0.86221555518143278, -0.038942303505028031, 0.99073092777336114, -0.59207542384567113], [-0.42324210154238218, 0.76649013040311842, 0.86242470461616949, 0.49956796372115009], [-0.3983839684487791, 0.50100130531149967, -0.61285700166494195, -0.77581662400471862]]], [[[0.393847951204221, -0.72453857578029801, 0.97194727576353768, -0.95039782864739597], [-0.33546269250215266, 0.4831646699512071, -0.36084136685304102, -0.21835205500655297], [-0.82932637046105562, 0.70351683765540218, -0.058619290451321637, -0.2054802590132303]], [[0.94447147902776929, -0.42312399627562503, -0.11683182283655591, -0.40970199303413191], [-0.057628087834810326, -0.92418858637343759, 0.17632737701884516, -0.45930384359491305], [-0.47612419752878798, -0.96256404924809247, 0.10415265869578216, -0.63202348546194909]]]]),self.functionspace,True)
10036          # arg.setTaggedValue(1,[[[[-0.97434762405813102, 0.7014239623245393, 0.62448079624150288, -0.37769806924712546], [-0.85193729675303742, -0.77375392434251022, 0.36142120851055592, 0.26580596564769365], [-0.87276378893603579, 0.38973819311591718, 0.98354255063199636, -0.66795317131402343]], [[0.90231744676982428, -0.27585106370360957, -0.32108129691288001, 0.60440834831736634], [-0.045905880902579188, -0.29199624499256793, 0.025945636614535861, -0.098321374439206854], [-0.56344512008582659, -0.3766256629210043, -0.16641839175601203, -0.47355537095296341]]], [[[-0.98963277387073156, -0.84954014836916003, 0.58413699452656576, -0.90574771672091781], [-0.076165236495137068, -0.33185579541568311, 0.71508582816996036, 0.092982625872773284], [-0.59803076383019627, 0.96534061564337792, -0.86101074809006883, 0.4514321077629706]], [[0.68169942993010979, -0.46839019201575827, 0.86748862862295062, 0.077239140299438347], [-0.41039932807903745, 0.77351932859252215, -0.91858786520587499, -0.83803209999478323], [-0.66149540952220676, 0.21690925014134543, 0.49329666114093262, 0.22750525795569843]]], [[[0.49476796496001074, 0.54374663478072427, -0.64963120626875592, 0.57704965092442939], [0.74520801893525035, -0.18704889796101698, -0.73119506283113278, 0.30233417986347821], [-0.40842036405150561, -0.58450470869605797, 0.084020496164487923, -0.58538663622202569]], [[0.75611417989143481, -0.52196566347687212, 0.47144797786301607, -0.99505702762998172], [-0.0043333507755138889, -0.8740422871734248, 0.69683145050592943, -0.015830354510735223], [-0.047302931197539255, -0.033238606395723957, -0.95126827803180114, 0.88954001433619978]]]])
10037          res=sup(arg)
10038          ref=0.990730927773
10039          self.failUnless(isinstance(res,float),"wrong type of result.")
10040          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10041       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10042       def test_inf_float_rank0(self):
10043          arg=0.857535693433
10044          ref=0.857535693433
10045          res=inf(arg)
10046          self.failUnless(isinstance(res,float),"wrong type of result.")
10047          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10048       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10049       def test_inf_array_rank0(self):
10050          arg=0.170725403135
10051          ref=0.170725403135
10052          res=inf(arg)
10053          self.failUnless(isinstance(res,float),"wrong type of result.")
10054          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10055       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10056       def test_inf_array_rank1(self):
10057          arg=numarray.array([-0.20582799927627726, 0.0065475369467946631])
10058          ref=-0.205827999276
10059          res=inf(arg)
10060          self.failUnless(isinstance(res,float),"wrong type of result.")
10061          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10062       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10063       def test_inf_array_rank2(self):
10064          arg=numarray.array([[-0.00088705991533410966, -0.78884753663192009, 0.51871980588812661, -0.58204851803513313, 0.14241101940826861], [0.79094574969805964, 0.79672216617995617, -0.5690477768894624, 0.51157272654417052, 0.18066938665191556], [0.32364745994353683, 0.4748425103497671, 0.66679519455306924, -0.69644515487912217, -0.37494171775165297], [-0.18679695095262239, -0.78312977298360509, 0.044885312146701661, -0.44016241609550066, -0.49756845096624081]])
10065          ref=-0.788847536632
10066          res=inf(arg)
10067          self.failUnless(isinstance(res,float),"wrong type of result.")
10068          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10069       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10070       def test_inf_array_rank3(self):
10071          arg=numarray.array([[[-0.8081125483464171, -0.39512178653285135], [-0.88509761616456495, 0.27821695074525521]], [[-0.12065704909614361, 0.68332883926843135], [0.3403814721074454, -0.32879966956330042]], [[-0.7045229028656752, -0.1577338131736914], [-0.5966034105188045, 0.73456332700634985]], [[0.87843639147943997, 0.94490362642776882], [-0.45552277927474183, -0.9768135246661469]], [[-0.65451540143458864, -0.2796668209543185], [-0.085396852552783953, 0.83466766003117332]], [[0.43465138886082078, 0.61441480296663342], [0.92555078046558337, -0.24612584648713121]]])
10072          ref=-0.976813524666
10073          res=inf(arg)
10074          self.failUnless(isinstance(res,float),"wrong type of result.")
10075          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10076       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10077       def test_inf_array_rank4(self):
10078          arg=numarray.array([[[[-0.05536021838962446, -0.0098764348632232046, -0.52953548051740618, 0.58523070076080819], [0.10613609818504877, 0.67324697282212087, 0.54615663777618906, -0.67572666188479613], [-0.14390410848091539, 0.54011444546397591, -0.85609073171970373, 0.077099187121419277]], [[-0.20493469025659716, 0.90647730634569368, -0.71749107354722064, -0.12332697315517271], [0.63551267588618598, -0.60802528409862266, 0.052319255834022638, -0.95394697709081688], [-0.88612629669117959, 0.32248454322667519, 0.0072741938614420132, -0.69013368898879235]]], [[[-0.10462047858216028, -0.30097012474135698, -0.050016775782701028, 0.54822125876578376], [0.84395749034726886, -0.53249513893193168, -0.88004100855031275, -0.80779542570577179], [-0.79677629667791683, 0.95096027764472169, 0.63643207567783144, 0.97757008271555401]], [[-0.65415697736192047, -0.97050764835238645, -0.84814693021942777, -0.43855897064286542], [-0.37135308255264543, 0.041120751125186095, 0.036995657114785807, -0.35706630152349828], [-0.0030591331649565401, 0.48192500000712779, 0.18102011879743984, -0.78573775232009435]]], [[[-0.31965876602783605, 0.10351748464331689, 0.067424791069963907, -0.049524027182576535], [-0.5213817364489115, 0.027521683153738818, -0.24734661576641237, 0.24321699964875232], [-0.83947613904690699, 0.77162806253216987, -0.90740945316368071, -0.3420545897410685]], [[0.91845344502663262, -0.70878381509801414, 0.90861837177726379, -0.4013061463136427], [-0.18540388033546473, 0.9254510240675875, 0.30634230347058677, -0.97817133509804033], [-0.43975591131244984, 0.30020642565479139, 0.36841633323637479, 0.3066739733421715]]]])
10079          ref=-0.978171335098
10080          res=inf(arg)
10081          self.failUnless(isinstance(res,float),"wrong type of result.")
10082          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10083       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10084       def test_inf_constData_rank0(self):
10085          arg=Data(0.0114629834279,self.functionspace)
10086          ref=0.0114629834279
10087          res=inf(arg)
10088          self.failUnless(isinstance(res,float),"wrong type of result.")
10089          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10090       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10091       def test_inf_constData_rank1(self):
10092          arg=Data(numarray.array([-0.13734485813185704, -0.54812466656634307]),self.functionspace)
10093          ref=-0.548124666566
10094          res=inf(arg)
10095          self.failUnless(isinstance(res,float),"wrong type of result.")
10096          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10097       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10098       def test_inf_constData_rank2(self):
10099          arg=Data(numarray.array([[-0.89509582806410015, 0.10780316690435621, -0.93073500763754335, -0.38534759506991545, -0.6935160645644014], [-0.056672310128515813, 0.6285075027787359, 0.73632355512072167, -0.60238897825476267, 0.77403597203864094], [-0.5930215600641755, 0.72623233579382429, -0.32117191475695361, -0.081104170523293773, 0.62137628665436373], [0.2669734570396014, -0.65030905665614136, -0.53589374176691495, -0.48334830355881309, -0.89125004784938211]]),self.functionspace)
10100          ref=-0.930735007638
10101          res=inf(arg)
10102          self.failUnless(isinstance(res,float),"wrong type of result.")
10103          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10104       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10105       def test_inf_constData_rank3(self):
10106          arg=Data(numarray.array([[[0.94493948950092999, 0.13737629155757691], [-0.81599535906086107, -0.35832278646984816]], [[-0.53692839435234041, 0.53679590218669571], [0.038856705021854232, -0.18543838436402926]], [[0.19718168292863836, -0.55405958298613656], [0.16477861536800242, 0.17787953041277582]], [[0.51547288009005165, 0.35889372726595203], [-0.033476505587150873, -0.42142418570614026]], [[0.80507204877418204, -0.79581688922832838], [-0.85909254497735588, 0.66095083521227149]], [[0.46206420953978222, 0.53654696439305005], [0.57618105395776831, -0.22241758047110038]]]),self.functionspace)
10107          ref=-0.859092544977
10108          res=inf(arg)
10109          self.failUnless(isinstance(res,float),"wrong type of result.")
10110          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10111       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10112       def test_inf_constData_rank4(self):
10113          arg=Data(numarray.array([[[[0.50544713768476202, 0.96922321849050874, -0.81524480218696649, -0.36499730379849193], [-0.48131882706974372, 0.026812357207576465, 0.090903267401989618, -0.24742363369877829], [-0.51631372893805438, 0.30410275437953183, -0.75149566289642533, -0.19930300338453599]], [[0.82034878499482788, -0.70904661587698792, -0.27637223434426073, -0.34818734117560401], [0.11686048779802416, -0.76746266142163178, -0.75578186306174833, 0.14509316330390232], [0.1590050723141736, 0.69684384552537937, -0.58747105640080832, -0.28640840371441523]]], [[[0.14956532194045669, 0.081514192262221119, 0.32061383569406399, -0.2444346881437609], [0.79564139071785278, -0.5456680167461434, 0.24722978802719742, 0.28286130725068315], [0.10385207763921711, -0.064749181840278336, 0.21325254547672734, -0.71875644540473838]], [[0.58552496009870802, 0.35472373485671338, -0.18411162994671826, 0.71609038134967773], [-0.20966804574945064, -0.49286619989346314, 0.85116051808632553, -0.94417114370961075], [-0.40434528979823714, 0.62250343758157611, 0.64860074098639742, 0.0043146814280992096]]], [[[-0.14242849200713259, 0.42551908502898095, 0.7691157770973962, -0.37595641162856674], [0.026655444032149589, -0.82186407521644167, 0.40285091480648783, -0.53328831035315982], [-0.12887729257054481, 0.75610663428133451, 0.022049613835531723, 0.59949338706293043]], [[-0.34506254315071772, 0.019719877473602043, 0.10216765908478709, 0.022681548062032153], [0.2228614880408597, 0.26944547311401901, -0.10122095357202965, -0.51019076850180589], [-0.081439546799124463, 0.18829632566943544, 0.12366885442775377, 0.73651436499107814]]]]),self.functionspace)
10114          ref=-0.94417114371
10115          res=inf(arg)
10116          self.failUnless(isinstance(res,float),"wrong type of result.")
10117          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10118       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10119       def test_inf_expandedData_rank0(self):
10120    
10121          msk=whereNegative(self.functionspace.getX()[0]-0.5)
10122          arg=msk*0.97331285569+(1.-msk)*0.911344578019
10123    
10124          # arg=Data(0.97331285569,self.functionspace,True)
10125          #arg.setTaggedValue(1,0.97331285569)
10126          res=inf(arg)
10127          ref=0.911344578019
10128          self.failUnless(isinstance(res,float),"wrong type of result.")
10129          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10130       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10131       def test_inf_expandedData_rank1(self):
10132    
10133          msk=whereNegative(self.functionspace.getX()[0]-0.5)
10134          arg=msk*numarray.array([-0.025782649803792301, 0.15017595667012174])+(1.-msk)*numarray.array([-0.69996944983865683, 0.23286168827412723])
10135    
10136          # arg=Data(numarray.array([-0.025782649803792301, 0.15017595667012174]),self.functionspace,True)
10137          # arg.setTaggedValue(1,[-0.69996944983865683, 0.23286168827412723])
10138          res=inf(arg)
10139          ref=-0.699969449839
10140          self.failUnless(isinstance(res,float),"wrong type of result.")
10141          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10142       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10143       def test_inf_expandedData_rank2(self):
10144    
10145          msk=whereNegative(self.functionspace.getX()[0]-0.5)
10146          arg=msk*numarray.array([[-0.11924617230337731, -0.69281409701569552, 0.8819805848672797, 0.67606672557817737, -0.15719846909292801], [-0.91958498979699277, 0.35156143886023572, -0.66768679685578647, -0.48673444352737993, -0.33274286155542288], [-0.011930486621410052, -0.035661622752792166, 0.8109198510155371, 0.2680383999767102, 0.38679270088753159], [-0.64107995512896321, 0.58836944145799008, -0.55856121453754959, 0.63346354980998365, -0.74990799644898765]])+(1.-msk)*numarray.array([[0.075603512293304975, 0.65374459813382813, -0.68190855977115938, 0.023184369691352069, -0.15500904033575869], [-0.28865053906142646, 0.94679590620919218, -0.53701383780009748, -0.5413294941411595, -0.1693286769782183], [-0.34870739946353968, -0.92230175409787241, -0.95867600429924127, -0.0012605712136730673, 0.33180267589091184], [-0.60152160703395885, 0.3397221706065463, 0.58860878406913142, 0.59589494790106934, -0.96157487116725071]])
10147    
10148          # arg=Data(numarray.array([[-0.11924617230337731, -0.69281409701569552, 0.8819805848672797, 0.67606672557817737, -0.15719846909292801], [-0.91958498979699277, 0.35156143886023572, -0.66768679685578647, -0.48673444352737993, -0.33274286155542288], [-0.011930486621410052, -0.035661622752792166, 0.8109198510155371, 0.2680383999767102, 0.38679270088753159], [-0.64107995512896321, 0.58836944145799008, -0.55856121453754959, 0.63346354980998365, -0.74990799644898765]]),self.functionspace,True)
10149          # arg.setTaggedValue(1,[[0.075603512293304975, 0.65374459813382813, -0.68190855977115938, 0.023184369691352069, -0.15500904033575869], [-0.28865053906142646, 0.94679590620919218, -0.53701383780009748, -0.5413294941411595, -0.1693286769782183], [-0.34870739946353968, -0.92230175409787241, -0.95867600429924127, -0.0012605712136730673, 0.33180267589091184], [-0.60152160703395885, 0.3397221706065463, 0.58860878406913142, 0.59589494790106934, -0.96157487116725071]])
10150          res=inf(arg)
10151          ref=-0.961574871167
10152          self.failUnless(isinstance(res,float),"wrong type of result.")
10153          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10154       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10155       def test_inf_expandedData_rank3(self):
10156    
10157          msk=whereNegative(self.functionspace.getX()[0]-0.5)
10158          arg=msk*numarray.array([[[0.76729109013175933, 0.93446692332588199], [-0.85883010569426133, 0.94426468618035608]], [[0.93376991286356659, -0.31027020688815887], [0.68776369494826284, -0.71422083083074273]], [[0.88895851954297633, -0.0041028262794304826], [-0.56213269421968981, -0.53305350433881493]], [[0.91080353792869873, 0.87460732654624618], [-0.43411934331432445, -0.66454826732696648]], [[-0.7458989571542316, 0.0054889915153857327], [-0.43786572648758848, 0.45559010284736901]], [[0.97274627384999923, 0.28719064869132427], [-0.068944574283213989, 0.92462015394940389]]])+(1.-msk)*numarray.array([[[0.45653716082021401, -0.23702471933521396], [-0.45177153258555913, -0.41351543065221219]], [[0.24913453932538854, -0.29954039408048372], [0.47106013214852771, -0.86663080347446608]], [[-0.75781905181266151, 0.18918623668675538], [-0.66636479853389385, 0.74776214919244066]], [[-0.1199599974824086, 0.90306995612278795], [0.77248429149482201, 0.094536885699270545]], [[-0.5505821492977705, -0.42454185319972981], [-0.035064708067998662, -0.75303714911308206]], [[-0.63966405281134198, -0.5545794126646626], [-0.010523374154368881, -0.6779302443539712]]])
10159    
10160          # arg=Data(numarray.array([[[0.76729109013175933, 0.93446692332588199], [-0.85883010569426133, 0.94426468618035608]], [[0.93376991286356659, -0.31027020688815887], [0.68776369494826284, -0.71422083083074273]], [[0.88895851954297633, -0.0041028262794304826], [-0.56213269421968981, -0.53305350433881493]], [[0.91080353792869873, 0.87460732654624618], [-0.43411934331432445, -0.66454826732696648]], [[-0.7458989571542316, 0.0054889915153857327], [-0.43786572648758848, 0.45559010284736901]], [[0.97274627384999923, 0.28719064869132427], [-0.068944574283213989, 0.92462015394940389]]]),self.functionspace,True)
10161          # arg.setTaggedValue(1,[[[0.45653716082021401, -0.23702471933521396], [-0.45177153258555913, -0.41351543065221219]], [[0.24913453932538854, -0.29954039408048372], [0.47106013214852771, -0.86663080347446608]], [[-0.75781905181266151, 0.18918623668675538], [-0.66636479853389385, 0.74776214919244066]], [[-0.1199599974824086, 0.90306995612278795], [0.77248429149482201, 0.094536885699270545]], [[-0.5505821492977705, -0.42454185319972981], [-0.035064708067998662, -0.75303714911308206]], [[-0.63966405281134198, -0.5545794126646626], [-0.010523374154368881, -0.6779302443539712]]])
10162          res=inf(arg)
10163          ref=-0.866630803474
10164          self.failUnless(isinstance(res,float),"wrong type of result.")
10165          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10166       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10167       def test_inf_expandedData_rank4(self):
10168    
10169          msk=whereNegative(self.functionspace.getX()[0]-0.5)
10170          arg=msk*numarray.array([[[[0.59301561766072242, 0.6053289847447505, 0.1720524601196014, 0.4833679091408507], [-0.09424534157102582, 0.91976800441974427, -0.11950945037648264, -0.10547294628619919], [0.045302052907340462, -0.26699801365763864, -0.59100789693502542, 0.8220898248447317]], [[-0.71764117646989489, -0.31097048109028447, -0.36880919201656037, -0.12380648590370025], [0.71171672214402615, -0.87716399369053821, 0.53673002158727501, -0.29732656272582969], [-0.71737153055394787, -0.18861795164190798, -0.55325559014387649, 0.50828072891961451]]], [[[0.7139879661021804, -0.54655602578694507, -0.62738810494945163, -0.71453639471562314], [0.25287437655577372, 0.47571671295036144, -0.86354401602062025, -0.45354287599804666], [0.44863440392806031, -0.64112646326775291, 0.91877609169151908, 0.98277738739744636]], [[-0.23627452345538003, 0.26824331838587279, -0.11255839194272887, 0.62327509528972769], [0.87773514238000572, 0.62819546928589953, 0.53463187163744053, -0.11780048176113112], [0.17743656841726674, -0.47418242507357755, 0.37012543459814751, 0.84217962384585232]]], [[[-0.51615332690558602, -0.32180746309362296, -0.86871747985681558, -0.89347967000489548], [0.79236651642797762, -0.82769899986382356, -0.27503369025221813, 0.70491420567015894], [-0.46319485284379014, -0.71191635366918904, -0.4935498645964489, 0.42096986386791024]], [[-0.95241673224815648, -0.99507534300684708, -0.76759978752396862, -0.1621109099401965], [0.011495974208982407, 0.90547796535927083, -0.79651097416963368, 0.44382172569512224], [-0.11210429012307821, 0.28303519643554576, -0.59783370185364437, 0.75478113456483809]]]])+(1.-msk)*numarray.array([[[[0.70392145790103089, -0.7532260844479588, -0.53422583924595046, 0.29798767877629717], [0.87516135156666075, -0.40276494310086908, -0.070320230959511232, 0.13669067815714553], [0.26690559342737163, -0.0067218741792103298, 0.79272133073277207, -0.90080452301155178]], [[-0.90606808543363915, 0.94927254364127123, -0.15130300474521019, -0.34632615506118936], [0.29908319964670294, -0.71717585217034374, -0.11325472101126977, 0.60911487311528911], [0.055579283773870003, -0.42895625110409941, 0.22788310989168781, 0.50000680777627848]]], [[[-0.56683598589959683, 0.05720680440798942, 0.27949696950971137, 0.028472427888231566], [-0.51619860801944828, 0.73067372155966415, 0.81910302859539108, 0.97736576074434089], [-0.68851989268805447, 0.93303896549540433, -0.21083269397032622, -0.93122611728597304]], [[-0.13573136829275501, -0.30858456571228721, 0.86534434039603658, 0.79114631697533278], [-0.32870753097283112, 0.68472493656951161, -0.071089197922887593, -0.032936485145198757], [0.40875380316397925, -0.27280027645573401, -0.27155299841136848, -0.81500786568603067]]], [[[0.080473457255322733, -0.54931257643900566, 0.19082193004877501, -0.52744293877995374], [0.44447571282767639, -0.0060974808128133606, -0.87810788913565485, -0.92670043304972327], [0.45760340069120065, -0.7504981866011311, -0.95431384972577082, 0.4644557658783679]], [[0.18449401878090566, -0.73315009595487135, -0.59404794479416467, 0.076556365298426687], [0.65441299213898763, -0.91649003079073932, -0.082437357750317686, 0.88150531806538579], [-0.45829076922310796, 0.91236619416957021, -0.91128142664652279, 0.9524897339484899]]]])
10171    
10172          # arg=Data(numarray.array([[[[0.59301561766072242, 0.6053289847447505, 0.1720524601196014, 0.4833679091408507], [-0.09424534157102582, 0.91976800441974427, -0.11950945037648264, -0.10547294628619919], [0.045302052907340462, -0.26699801365763864, -0.59100789693502542, 0.8220898248447317]], [[-0.71764117646989489, -0.31097048109028447, -0.36880919201656037, -0.12380648590370025], [0.71171672214402615, -0.87716399369053821, 0.53673002158727501, -0.29732656272582969], [-0.71737153055394787, -0.18861795164190798, -0.55325559014387649, 0.50828072891961451]]], [[[0.7139879661021804, -0.54655602578694507, -0.62738810494945163, -0.71453639471562314], [0.25287437655577372, 0.47571671295036144, -0.86354401602062025, -0.45354287599804666], [0.44863440392806031, -0.64112646326775291, 0.91877609169151908, 0.98277738739744636]], [[-0.23627452345538003, 0.26824331838587279, -0.11255839194272887, 0.62327509528972769], [0.87773514238000572, 0.62819546928589953, 0.53463187163744053, -0.11780048176113112], [0.17743656841726674, -0.47418242507357755, 0.37012543459814751, 0.84217962384585232]]], [[[-0.51615332690558602, -0.32180746309362296, -0.86871747985681558, -0.89347967000489548], [0.79236651642797762, -0.82769899986382356, -0.27503369025221813, 0.70491420567015894], [-0.46319485284379014, -0.71191635366918904, -0.4935498645964489, 0.42096986386791024]], [[-0.95241673224815648, -0.99507534300684708, -0.76759978752396862, -0.1621109099401965], [0.011495974208982407, 0.90547796535927083, -0.79651097416963368, 0.44382172569512224], [-0.11210429012307821, 0.28303519643554576, -0.59783370185364437, 0.75478113456483809]]]]),self.functionspace,True)
10173          # arg.setTaggedValue(1,[[[[0.70392145790103089, -0.7532260844479588, -0.53422583924595046, 0.29798767877629717], [0.87516135156666075, -0.40276494310086908, -0.070320230959511232, 0.13669067815714553], [0.26690559342737163, -0.0067218741792103298, 0.79272133073277207, -0.90080452301155178]], [[-0.90606808543363915, 0.94927254364127123, -0.15130300474521019, -0.34632615506118936], [0.29908319964670294, -0.71717585217034374, -0.11325472101126977, 0.60911487311528911], [0.055579283773870003, -0.42895625110409941, 0.22788310989168781, 0.50000680777627848]]], [[[-0.56683598589959683, 0.05720680440798942, 0.27949696950971137, 0.028472427888231566], [-0.51619860801944828, 0.73067372155966415, 0.81910302859539108, 0.97736576074434089], [-0.68851989268805447, 0.93303896549540433, -0.21083269397032622, -0.93122611728597304]], [[-0.13573136829275501, -0.30858456571228721, 0.86534434039603658, 0.79114631697533278], [-0.32870753097283112, 0.68472493656951161, -0.071089197922887593, -0.032936485145198757], [0.40875380316397925, -0.27280027645573401, -0.27155299841136848, -0.81500786568603067]]], [[[0.080473457255322733, -0.54931257643900566, 0.19082193004877501, -0.52744293877995374], [0.44447571282767639, -0.0060974808128133606, -0.87810788913565485, -0.92670043304972327], [0.45760340069120065, -0.7504981866011311, -0.95431384972577082, 0.4644557658783679]], [[0.18449401878090566, -0.73315009595487135, -0.59404794479416467, 0.076556365298426687], [0.65441299213898763, -0.91649003079073932, -0.082437357750317686, 0.88150531806538579], [-0.45829076922310796, 0.91236619416957021, -0.91128142664652279, 0.9524897339484899]]]])
10174          res=inf(arg)
10175          ref=-0.995075343007
10176          self.failUnless(isinstance(res,float),"wrong type of result.")
10177          self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10178    
10179    
10180    class Test_util_reduction_with_tagged_data(Test_util_base):
10181       """
10182       test for reduction operation Lsup,sup,inf with tagged data only
10183       """
10184     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10185     def test_Lsup_taggedData_rank0(self):     def test_Lsup_taggedData_rank0(self):
10186        arg=Data(0.860813503322,self.functionspace)        arg=Data(0.860813503322,self.functionspace)
10187        arg.setTaggedValue(1,0.860813503322)        arg.setTaggedValue(1,0.086081350332)
10188        res=Lsup(arg)        res=Lsup(arg)
10189        ref=0.860813503322        ref=0.860813503322
10190        self.failUnless(isinstance(res,float),"wrong type of result.")        self.failUnless(isinstance(res,float),"wrong type of result.")
# Line 10265  class Test_util_with_tagged_Data(Test_ut Line 10301  class Test_util_with_tagged_Data(Test_ut
10301        ref=0.997207317201        ref=0.997207317201
10302        self.failUnless(isinstance(res,float),"wrong type of result.")        self.failUnless(isinstance(res,float),"wrong type of result.")
10303        self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")        self.failUnless(abs(res-ref)<=self.RES_TOL*abs(ref),"wrong result")
10304    
10305    
10306    class Test_util_reduction(Test_util_reduction_no_tagged_data,Test_util_reduction_with_tagged_data):
10307       """
10308       test for reduction operation Lsup,sup,inf for all data types
10309       """
10310       pass
10311    
10312    class Test_util_unary_no_tagged_data(Test_util_base):
10313       """
10314       test for unary operations. No tagged data are tested.
10315       """
10316       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10317       def test_log10_float_rank0(self):
10318          arg=52.2519689858
10319          res=log10(arg)
10320          ref=1.7181026604
10321          self.failUnless(isinstance(res,float),"wrong type of result.")
10322          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10323       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10324       def test_log10_array_rank0(self):
10325          arg=numarray.array(45.1686859861)
10326          res=log10(arg)
10327          ref=numarray.array(1.65483745657)
10328          if not isinstance(res,float):
10329             self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10330             self.failUnlessEqual(res.shape,(),"wrong shape of result.")
10331          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10332       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10333       def test_log10_array_rank1(self):
10334          arg=numarray.array([13.954560287699826, 23.475641658812407])
10335          res=log10(arg)
10336          ref=numarray.array([1.1447161562933539, 1.3706174716547848])
10337          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10338          self.failUnlessEqual(res.shape,(2,),"wrong shape of result.")
10339          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10340       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10341       def test_log10_array_rank2(self):
10342          arg=numarray.array([[25.915081952650038, 58.337204652970946, 15.450038105653986, 38.930671788011558, 87.005181288770302], [3.6208586171272144, 84.49833125689257, 69.261223337588021, 54.98351177434435, 58.379918137373565], [99.26000663643724, 45.338259591938282, 53.685949933590322, 95.061307572866596, 47.187722694142664], [5.6737763969659527, 44.873622862711144, 97.056192800604094, 55.273029732289778, 85.494701869969745]])
10343          res=log10(arg)
10344          ref=numarray.array([[1.4135525865703951, 1.7659456151718125, 1.1889295548970895, 1.5902918979721861, 1.9395451162751614], [0.55881156734663273, 1.9268481322268585, 1.8404901580778943, 1.7402324746037254, 1.7662634816675511], [1.9967742998978548, 1.6564648447687793, 1.7298606420366613, 1.9780037837413516, 1.6738290185543834], [0.75387221628934742, 1.6519911336241999, 1.9870232513506001, 1.7425132706239763, 1.9319392022143682]])
10345          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10346          self.failUnlessEqual(res.shape,(4, 5),"wrong shape of result.")
10347          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10348       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10349       def test_log10_array_rank3(self):
10350          arg=numarray.array([[[61.549373713195962, 41.673709308293191], [18.017632188926811, 13.171469559653669]], [[50.290930361991521, 14.626533261319382], [15.969153538380304, 56.425345549785291]], [[90.382517465043676, 98.988183466908609], [33.988560486114899, 61.488838120931966]], [[27.205433883156655, 77.280843084053075], [42.537512400205529, 20.752110100745131]], [[2.7510631963546697, 37.227526331006125], [17.709630263115471, 77.944115343628809]], [[15.848941645935733, 77.546800032084079], [44.6765341255255, 59.885570390022544]]])
10351          res=log10(arg)
10352          ref=numarray.array([[[1.7892236381887503, 1.6198621580149473], [1.2556977170065395, 1.1196342325201316]], [[1.7014896699685444, 1.1651414030979794], [1.203281896517113, 1.7514742273848101]], [[1.9560844337638301, 1.9955833545833324], [1.5313327713445872, 1.7887962867926523]], [[1.434655656599509, 1.8880718513054029], [1.6287720887060415, 1.3170622629043851]], [[0.43950056694834205, 1.5708641794769067], [1.2482094942016551, 1.8917833322219468]], [[1.2000002663849119, 1.8895638813619857], [1.6500794744582843, 1.7773221904207173]]])
10353          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10354          self.failUnlessEqual(res.shape,(6, 2, 2),"wrong shape of result.")
10355          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10356       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10357       def test_log10_array_rank4(self):
10358          arg=numarray.array([[[[49.041458121649541, 12.453861805081642, 22.352539133207308, 35.856582214340698], [47.729104473308858, 67.27333693612141, 48.837394467178136, 9.6698413270700367], [64.583260503019162, 46.411663014624139, 85.71255093334365, 36.363958914509439]], [[80.036726405255635, 40.387280979035751, 15.276817994504155, 59.062184549366151], [59.167871518749848, 21.930421722965473, 0.23764880334288624, 24.921348290633865], [35.111521136514753, 93.225181218111516, 48.850751790389111, 51.591988234960553]]], [[[47.509673966789677, 54.481428169403792, 36.464944550283505, 90.799221097408463], [46.169280587237125, 47.324905848019064, 87.626395482722373, 98.929522440449787], [61.773097039759605, 82.412988902042329, 4.5402354395996527, 41.873043607198412]], [[36.545836359312922, 49.472492642337876, 54.796411622124296, 9.1573852487394394], [94.483164799633187, 59.013891170601127, 81.50036423642824, 4.9151253236939265], [53.788789868327207, 58.332866884869581, 96.756911476142037, 37.843173549368686]]], [[[80.58432601195986, 21.263772240505372, 63.6235430125706, 35.501558596702829], [5.6711036927454339, 74.217470766535399, 40.89063067086159, 30.690400010085241], [35.999004111325121, 20.274838444258663, 70.564641379269005, 99.740954368148309]], [[31.256278345889452, 17.526864558417355, 12.375337394164927, 31.216749887776125], [31.235942054585749, 4.4714795388662898, 16.839093071461757, 98.544202438777774], [7.1017853296580133, 80.078083678719835, 33.756128516966982, 25.658869355266614]]]])
10359          res=log10(arg)
10360          ref=numarray.array([[[[1.6905633743319768, 1.0953040422410532, 1.3493268638843343, 1.5545688910211573], [1.6787832859072254, 1.8278429703764396, 1.6887524857660539, 0.98541934778069684], [1.8101199667066123, 1.6666271302620568, 1.9330444205462154, 1.5606711584094208]], [[1.9032893171804688, 1.6062446158451591, 1.1840329045447144, 1.771309506296336], [1.7720859464227217, 1.3410469832596377, -0.62406436821075306, 1.3965715347504626], [1.5454496448138082, 1.969533236248409, 1.6888712516966586, 1.7125822648927624]]], [[[1.6767820501011672, 1.7362484835956555, 1.5618755574979692, 1.9580821230304646], [1.6643531073987192, 1.6750897586162579, 1.9426349473298661, 1.9953259126255949], [1.7907993755575464, 1.9159956651428329, 0.65707837432577154, 1.6219345294073721]], [[1.5628379052561994, 1.6943637925865513, 1.738752119365097, 0.96177148522339684], [1.9753544319382004, 1.7709542514498018, 1.9111595496665708, 0.69153459575815146], [1.7306917737033041, 1.7659133212214235, 1.98568199703713, 1.5779875494313049]]], [[[1.9062505779281724, 1.3276403118294007, 1.8036178500584357, 1.5502474199590055], [0.75366758817392854, 1.8705061500821059, 1.6116238088855386, 1.4870025489414542], [1.5562904864634381, 1.3069574023136983, 1.8485871387211481, 1.998873519435157]], [[1.4949372657476212, 1.2437042305963351, 1.0925570481249276, 1.4943876847840263], [1.4946546085032237, 0.65045124779595043, 1.2263186973378477, 1.9936310789157055], [0.85136754045869678, 1.9035136716426462, 1.5283526316700879, 1.4092375155000518]]]])
10361          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10362          self.failUnlessEqual(res.shape,(3, 2, 3, 4),"wrong shape of result.")
10363          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10364       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10365       def test_log10_constData_rank0(self):
10366          arg=Data(32.7103924665,self.functionspace)
10367          res=log10(arg)
10368          ref=Data(1.51468575492,self.functionspace)
10369          self.failUnless(isinstance(res,Data),"wrong type of result.")
10370          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
10371          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10372       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10373       def test_log10_constData_rank1(self):
10374          arg=Data(numarray.array([38.13113991980368, 3.9574358995083889]),self.functionspace)
10375          res=log10(arg)
10376          ref=Data(numarray.array([1.5812797885802696, 0.59741388911487381]),self.functionspace)
10377          self.failUnless(isinstance(res,Data),"wrong type of result.")
10378          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
10379          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10380       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10381       def test_log10_constData_rank2(self):
10382          arg=Data(numarray.array([[94.835349573618515, 17.653263208696131, 62.502954853493407, 19.234729096475913, 43.672005218091151], [15.048159867737148, 98.672070942815608, 52.576472580061754, 49.935023943546007, 26.60036022461162], [6.721528672936774, 75.440376910024227, 63.249503917897741, 63.687804000958671, 32.436637160710369], [68.994703422400121, 20.092325091226218, 54.808697863191284, 46.361425111883918, 79.716043096984109]]),self.functionspace)
10383          res=log10(arg)
10384          ref=Data(numarray.array([[1.9769702493968937, 1.2468249965531741, 1.7959005492838003, 1.28408607404631, 1.6402031331890035], [1.1774833963984679, 1.9941942433294959, 1.7207914453990389, 1.6984052624540111, 1.4248875179281264], [0.82746805560156844, 1.8776038495269229, 1.8010571235780615, 1.804056274373053, 1.5110358227817056], [1.8388157521471691, 1.3030301963730122, 1.7388494842917164, 1.6661567773501147, 1.9015457332824068]]),self.functionspace)
10385          self.failUnless(isinstance(res,Data),"wrong type of result.")
10386          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
10387          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10388       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10389       def test_log10_constData_rank3(self):
10390          arg=Data(numarray.array([[[60.505360366376287, 95.665159725837654], [45.535060469642595, 8.7120300613775825]], [[85.791369386166309, 55.438032107346338], [38.874954040860693, 0.032497264299415379]], [[56.341710995337245, 51.491208922462491], [88.530577620189433, 12.245118647390212]], [[2.7511376879554934, 34.207282964733224], [30.122953960922267, 38.812210597586919]], [[86.660286634007576, 99.90443738735307], [17.396122538609294, 56.668511719223552]], [[36.718231261528388, 50.782102049171812], [88.979825368021281, 69.352170891166125]]]),self.functionspace)
10391          res=log10(arg)
10392          ref=Data(numarray.array([[[1.7817938519155039, 1.9807538009560601], [1.658345917646564, 0.9401193653092289]], [[1.9334436000107917, 1.7438078056569788], [1.5896698885992053, -1.4881531974726712]], [[1.7508300315839129, 1.7117330884128066], [1.9470932977951618, 1.0879629975176723]], [[0.43951232634857773, 1.5341185801691359], [1.4788975580341073, 1.5889683792252702]], [[1.9378201211553368, 1.999584778416601], [1.2404524581824454, 1.7533418069486038]], [[1.5648817528162677, 1.7057106738803878], [1.9492915490656653, 1.8410600600927651]]]),self.functionspace)
10393          self.failUnless(isinstance(res,Data),"wrong type of result.")
10394          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
10395          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10396       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10397       def test_log10_constData_rank4(self):
10398          arg=Data(numarray.array([[[[7.1178859886623451, 14.637867086244679, 36.35859711294826, 37.7723554870581], [44.508345724124766, 25.973407994350175, 49.071421558624728, 42.354776612571754], [91.85968925895304, 94.407818198616539, 43.315126893833394, 75.615056315689174]], [[6.2918566984022908, 13.126791472139409, 5.4081624176919272, 67.758267396244534], [6.3749374576688131, 28.038450788587877, 57.310863148910528, 40.510465526946518], [93.706477842024938, 56.835264912992365, 40.743079267474769, 55.242148230373495]]], [[[83.448958312190257, 44.295439593214205, 2.2473909991848409, 76.158191501497342], [89.137647290369543, 55.865574608149423, 34.00060537625113, 37.86772086689443], [12.457637095864028, 82.46283305226747, 8.2656512835811657, 64.122937473337672]], [[54.25835998622415, 31.151251379554999, 71.605899030813731, 23.688427104278972], [93.960338747791468, 24.330099432103534, 39.06736609968543, 33.657862341058689], [4.584970065153624, 11.444794976152613, 92.427741892222471, 86.464234082604506]]], [[[73.237800540520212, 40.200704386760357, 61.394401252086411, 10.275754214437864], [77.622206392059113, 6.1972834106359214, 63.472374671706035, 80.460731554212771], [75.404584514400938, 93.73627374151657, 66.710853225948313, 60.813357606195645]], [[45.25139607197994, 74.577688908930867, 95.208049640850376, 14.393702972960131], [65.862630893385798, 71.877942440445722, 27.710516935466455, 70.580992209569118], [67.600547228807855, 78.088363930903228, 38.219137036754042, 28.047017615696081]]]]),self.functionspace)
10399          res=log10(arg)
10400          ref=Data(numarray.array([[[[0.85235102737513713, 1.1654777993891423, 1.5606071177331162, 1.5771740683100366], [1.6484414528258733, 1.4145289375397965, 1.6908286393162306, 1.6269023955286619], [1.9631249719620456, 1.9750079610345306, 1.636639591024321, 1.8786082799426707]], [[0.79877882269221356, 1.1181585862396579, 0.73304972584189554, 1.8309622923953988], [0.80447592841225835, 1.4477540138397433, 1.7582369493404233, 1.6075672339172933], [1.9717696143008383, 1.7546178886111818, 1.6100538488746503, 1.7422705588721348]]], [[[1.9214209197798999, 1.6463590160322708, 0.35167863717923287, 1.8817166224792843], [1.9500611670813865, 1.7471442700825282, 1.5314866496665132, 1.5782691671562759], [1.0954356752650989, 1.9162582511278587, 0.91727707904742606, 1.8070134091786803]], [[1.7344666626342538, 1.4934754974259916, 1.8549488017910998, 1.3745362248168791], [1.9729445738360003, 1.386143883806513, 1.5918141323168808, 1.527086529852433], [0.66133650454670789, 1.0586080170609664, 1.9658023428913385, 1.9368364987628319]]], [[[1.8647352932012256, 1.6042336627512135, 1.788128768271634, 1.0118137078374039], [1.8899859832929091, 0.79220135751176601, 1.8025847467388194, 1.9055839768869141], [1.8773977512912479, 1.9719076852022974, 1.8241964952763503, 1.7839989821922779]], [[1.6556319823700489, 1.872608920864252, 1.9786736686240998, 1.1581725363856989], [1.8186390746853227, 1.8565956366123635, 1.442644627555113, 1.8486877592678144], [1.8299502115849742, 1.8925863237992646, 1.5822808767428842, 1.4478866872710365]]]]),self.functionspace)
10401          self.failUnless(isinstance(res,Data),"wrong type of result.")
10402          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
10403          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10404       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10405       def test_log10_expandedData_rank0(self):
10406          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10407          arg=msk_arg*(96.1097445547)+(1.-msk_arg)*(15.7194730216)
10408          res=log10(arg)
10409          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10410          ref=msk_ref*(1.98276742296)+(1.-msk_ref)*(1.19643798269)
10411          self.failUnless(isinstance(res,Data),"wrong type of result.")
10412          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
10413          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10414       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10415       def test_log10_expandedData_rank1(self):
10416          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10417          arg=msk_arg*numarray.array([67.188570100204331, 83.852182235203458])+(1.-msk_arg)*numarray.array([12.970539131997421, 55.494059090853888])
10418          res=log10(arg)
10419          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10420          ref=msk_ref*numarray.array([1.8272953985804494, 1.9235143695106758])+(1.-msk_ref)*numarray.array([1.112958028295743, 1.7442464922729273])
10421          self.failUnless(isinstance(res,Data),"wrong type of result.")
10422          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
10423          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10424       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10425       def test_log10_expandedData_rank2(self):
10426          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10427          arg=msk_arg*numarray.array([[45.930333300115343, 70.753859497865847, 22.04664793382257, 79.15163171404815, 75.405024274312993], [93.445968445291669, 30.36616470571791, 6.5043375890994559, 31.426752793912506, 21.34925350080275], [55.608242339925667, 60.535785665483225, 34.569731451078027, 21.386089927826287, 3.9072078681127631], [19.365485690555648, 32.043862755374363, 58.335981689330417, 80.08022377912441, 29.309322772405462]])+(1.-msk_arg)*numarray.array([[25.745723389769719, 64.392268446036255, 85.501520058738976, 45.362572337757612, 97.503453294299518], [2.8517470840863286, 14.034055548650054, 33.880935693055591, 29.696281993337909, 92.433531843558612], [37.125936326201604, 37.497435106305446, 91.813274646371681, 77.728476618025766, 45.331358346905688], [71.362205298919307, 94.671089912047734, 25.688825508752888, 56.379550500341139, 4.1755783242915809]])
10428          res=log10(arg)
10429          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10430          ref=msk_ref*numarray.array([[1.6620995969501617, 1.849750134838158, 1.3433425668419521, 1.898459872288744, 1.8774002840914414], [1.9705605692811208, 1.4823899433069487, 0.81320307398795078, 1.4972995093490966, 1.3293826940612745], [1.7451391681548531, 1.7820121832883282, 1.5386960058146677, 1.3301313886858133, 0.59186651682317182], [1.2870283936579181, 1.5057448629748622, 1.7659365106572738, 1.9035252780814409, 1.4670057836514949]])+(1.-msk_ref)*numarray.array([[1.410705098912199, 1.8088337249250597, 1.9319738357486911, 1.6566976737600356, 1.9890199974431519], [0.45511100615307598, 1.1471831911912613, 1.5299553957767158, 1.47270207858137, 1.9658295475498999], [1.5696774154882256, 1.5740015622004013, 1.9629054773764056, 1.8905801561543689, 1.6563987328183856], [1.853468262533325, 1.9762173770124165, 1.4097442488078882, 1.7511216090311554, 0.62071663446741465]])
10431          self.failUnless(isinstance(res,Data),"wrong type of result.")
10432          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
10433          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10434       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10435       def test_log10_expandedData_rank3(self):
10436          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10437          arg=msk_arg*numarray.array([[[22.388258065770664, 51.715962865840815], [65.432613978623507, 8.3209401983813631]], [[88.431488726297857, 89.785784570369586], [3.2671698372353806, 14.647277245749521]], [[68.153001107883583, 19.918374467307398], [62.741803756290338, 32.019573139182008]], [[67.165624226669038, 2.8759095839159929], [73.719522685630153, 94.724688180711894]], [[48.844734513795146, 28.150257589983699], [42.654320101950383, 50.476435941718051]], [[37.462663753206783, 82.654691621504796], [52.152313992909285, 3.1027027366472075]]])+(1.-msk_arg)*numarray.array([[[1.8076283580543755, 4.753292603600527], [6.7876691754431446, 88.85524686992207]], [[20.447379893795944, 10.467051425047025], [48.020952347676165, 29.139882960928777]], [[32.353404155614214, 49.731545888765915], [50.076198518791642, 12.61911728105847]], [[50.812406051522565, 24.959142420006426], [32.119283687346766, 27.446174244224839]], [[78.480705204997335, 51.479031400667225], [80.539043834605735, 72.176036709299979]], [[65.812691581415578, 73.827132926837777], [61.203847954462837, 57.906796690274135]]])
10438          res=log10(arg)
10439          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10440          ref=msk_ref*numarray.array([[[1.3500203043046504, 1.7136246149415175], [1.8157942703490402, 0.92017240079787166]], [[1.9466069363367877, 1.953207581975233], [0.51417171098507863, 1.1657569020250118]], [[1.8334849846886128, 1.2992538928886661], [1.7975570000190917, 1.5054155379351397]], [[1.8271470553686036, 0.45877522808649995], [1.86758251461448, 1.9764631843179037]], [[1.6888177534210882, 1.4494823732334281], [1.6299630238135752, 1.7030886824981748]], [[1.573598654304283, 1.9172675099038647], [1.7172735827923957, 0.49174016874627252]]])+(1.-msk_ref)*numarray.array([[[0.25710914591980127, 0.6769945494552323], [0.83172066706037573, 1.9486830778292807]], [[1.3106376658608263, 1.0198243578793709], [1.6814307686997538, 1.4644878031125961]], [[1.5099199829403827, 1.6966319593433428], [1.6996313524512594, 1.1010289766693471]], [[1.7059697599596824, 1.397229659189178], [1.5067658512361108, 1.4384818161662032]], [[1.8947628968344679, 1.711630366878371], [1.9060064693262986, 1.8583930306392809]], [[1.8183096527670626, 1.8682160029445969], [1.7867787275843738, 1.7627295411341]]])
10441          self.failUnless(isinstance(res,Data),"wrong type of result.")
10442          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
10443          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10444       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10445       def test_log10_expandedData_rank4(self):
10446          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10447          arg=msk_arg*numarray.array([[[[51.471579704080902, 1.402847457439917, 48.558207798874633, 89.648969258612524], [86.525832839744794, 67.293178311636296, 36.293476074354814, 28.027447132690767], [10.633474820618499, 52.422445043400536, 16.892564122675008, 91.588281668647483]], [[69.006862669320284, 50.632932996111499, 20.819307520773513, 31.458894256989172], [34.054758838486975, 67.499730360187598, 74.656828581187256, 25.901320636052535], [69.566935512371245, 69.265794475105736, 49.758452930544813, 28.779752034461762]]], [[[72.22373251870431, 78.006053500246296, 31.060760583589399, 13.641516246702956], [19.276675259486392, 50.172392044390563, 63.569136215761631, 41.789254015859484], [77.72177399967164, 17.666602305012276, 46.52250820815128, 99.530462341866837]], [[77.258789628594741, 13.343315652586506, 70.821037532780295, 52.515534097664812], [78.878814482604369, 32.375661085180987, 46.503085042716158, 45.997964823991765], [12.861656668310804, 1.89832465373334, 25.450959358908168, 91.571383479978465]]], [[[1.2791555124757796, 61.193118582110273, 75.060163212570316, 55.342467763428438], [71.762210006922828, 84.536864679041486, 73.714524745683775, 11.850589611465555], [75.639151162482378, 64.29578756080727, 33.11720623917023, 37.534286641607828]], [[45.364350792710475, 93.649088149678789, 32.500785342140865, 3.4368793436320275], [19.133668646879922, 58.565788824469315, 98.054154704002983, 23.793410565976142], [77.647872455877192, 54.998750332692239, 19.370566893444124, 63.765617721508789]]]])+(1.-msk_arg)*numarray.array([[[[63.565214992977019, 60.995683199558883, 10.071281252885441, 99.995081907465718], [41.291004315699134, 3.2589259834977984, 64.44648163924586, 36.675923847946201], [53.577021195107271, 66.247159776521869, 11.509715616484302, 32.399165283870758]], [[25.855485901204684, 43.242105604769712, 13.014136372280724, 59.917489517777284], [72.87071809369273, 47.58552363917326, 25.297863133765659, 42.034501839579164], [94.309551997346077, 68.920541976900637, 1.692465072456105, 75.023262610656431]]], [[[63.471572962233353, 64.798741064964048, 43.72068323448616, 8.6997778638889542], [94.546430747727896, 88.016904759109764, 14.58256144742673, 74.45351675626388], [52.003630381495853, 38.537771628548576, 69.220538944397731, 25.695279099495448]], [[83.306032767743361, 47.257525060077683, 79.090659443546016, 86.984706241324432], [32.514084780833812, 41.274617166342345, 81.606897997605458, 40.058066677423589], [16.582991113576046, 26.477777900260783, 70.754349706548751, 36.162958070109205]]], [[[70.623876696227569, 88.724541508204311, 35.433617134818753, 24.504940423114135], [79.892676517300728, 54.161986455126332, 21.400020573937091, 45.043365143126863], [65.200095846905569, 45.852516046794086, 13.178288768375849, 66.486188034920545]], [[36.310614216780785, 59.353182927411325, 93.107604989020089, 34.366396717715467], [45.413466526703367, 0.13231504642780872, 85.586369506934446, 56.883390161446918], [34.343943871748365, 91.343033836337057, 8.5221756532344575, 80.981820970431841]]]])
10448          res=log10(arg)
10449          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10450          ref=msk_ref*numarray.array([[[[1.7115674973008292, 0.14701044936490915, 1.6862626492899628, 1.9525453006146518], [1.9371457882142409, 1.8279710408692522, 1.5598285655445743, 1.4475835420458216], [1.0266752070276506, 1.7195172730793549, 1.227695576143472, 1.9618399110892391]], [[1.8388922830736614, 1.7044330853392986, 1.318466280174116, 1.4977434536169738], [1.5321778091382223, 1.8293020379670764, 1.8730695371715311, 1.4133219081093693], [1.8424028727067936, 1.8405188199206457, 1.6968668689863722, 1.4590870477476021]]], [[[1.8586799289868094, 1.8921283065333185, 1.4922120860741765, 1.1348626445857921], [1.2850321311761868, 1.700464807165174, 1.8032463102305676, 1.6210646185787188], [1.890542704813432, 1.2471530326945834, 1.6676631211809771, 1.9979560214717456]], [[1.8879479000068351, 1.1252637599178532, 1.8501622849109463, 1.7202877867394817], [1.8969603747078481, 1.5102186451268347, 1.6674817652036087, 1.6627386167845508], [1.1092969122559071, 0.27837048800046127, 1.4057041574557758, 1.9617597756499436]]], [[[0.10692334674954952, 1.7867025866905135, 1.8754095044181454, 1.743058520763453], [1.8558958048831982, 1.9270461365869012, 1.867553069886098, 1.0737399586698149], [1.8787466464617588, 1.8081825203732931, 1.5200536926633199, 1.5744281662911923]], [[1.6567147000879612, 1.9715035530567897, 1.5118938553061785, 0.53616428590079812], [1.2817982486650861, 1.7676439971874796, 1.9914660001128803, 1.3764566986081392], [1.8901295606012043, 1.7403528216800304, 1.2871423308426, 1.8045865712170828]]]])+(1.-msk_ref)*numarray.array([[[[1.8032195202182379, 1.7852991001099465, 1.0030847243432686, 1.9999786404702637], [1.6158554462910679, 0.51307449691082996, 1.8091992126689456, 1.5643810623111436], [1.7289785637983148, 1.8211672634416693, 1.0610645931591225, 1.5105338214017157]], [[1.4125527038651586, 1.635906833067311, 1.1144153532983052, 1.7775536085729702], [1.8625530492364937, 1.6774748527239138, 1.4030838386300655, 1.6236059048612139], [1.974555681811033, 1.838348683991484, 0.22851971487795045, 1.8751959468180956]]], [[[1.8025792611996256, 1.8115665683111739, 1.6406869401634994, 0.93950816368541279], [1.9756451383018918, 1.9445660919061505, 1.1638338151190002, 1.871885216148214], [1.7160336628581898, 1.5858865988143969, 1.8402349763459562, 1.4098533393090875]], [[1.9206764528218314, 1.6744709733078493, 1.8981251966246733, 1.9394429011373768], [1.5120715338251509, 1.6156830537503111, 1.9117268699754428, 1.6026899851076344], [1.2196628680091728, 1.422881534916125, 1.8497531437791539, 1.5582639478260578]]], [[[1.8489515532379794, 1.948043763770869, 1.5494154882493205, 1.3892536509847744], [1.9025069708797608, 1.7336945842346827, 1.3304141908792402, 1.653630828745982], [1.8142482341636932, 1.6613631715274912, 1.1198590197647234, 1.8227314335250477]], [[1.5600335953381868, 1.7734440137833716, 1.9689851554161102, 1.5361339991826606], [1.6571846539810831, -0.87839076647757686, 1.9324046044051812, 1.7549854717676672], [1.5358501657051966, 1.9606754320191659, 0.93055048133642204, 1.9083875381587312]]]])
10451          self.failUnless(isinstance(res,Data),"wrong type of result.")
10452          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
10453          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10454       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10455       def test_log10_Symbol_rank0(self):
10456          arg=Symbol(shape=())
10457          res=log10(arg)
10458          s=numarray.array(3.30130672789)
10459          sub=res.substitute({arg:s})
10460          ref=numarray.array(0.518685876964)
10461          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10462          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
10463          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10464       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10465       def test_log10_Symbol_rank1(self):
10466          arg=Symbol(shape=(2,))
10467          res=log10(arg)
10468          s=numarray.array([80.781942827080286, 19.173714117161172])
10469          sub=res.substitute({arg:s})
10470          ref=numarray.array([1.9073142938566714, 1.2827062476902695])
10471          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10472          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
10473          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10474       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10475       def test_log10_Symbol_rank2(self):
10476          arg=Symbol(shape=(4, 5))
10477          res=log10(arg)
10478          s=numarray.array([[12.87178302719602, 68.894041539222059, 67.550533437690731, 65.121963561659555, 17.165986405555117], [70.260037949797564, 84.846330525471089, 33.94378182270269, 71.878916358185535, 48.565558946072912], [22.693372717603474, 21.936741520835913, 90.32217067645739, 70.411674261453342, 6.3690942522773053], [18.813716565135767, 44.357013040228409, 20.907360810094122, 4.6004533917390633, 16.782614506943588]])
10479          sub=res.substitute({arg:s})
10480          ref=numarray.array([[1.1096387104814578, 1.8381816625674801, 1.829628782938076, 1.8137274869538904, 1.2346687642535261], [1.8467083800330524, 1.9286330644851621, 1.5307602272931806, 1.8566015210912505, 1.6863283914409721], [1.3558990460740996, 1.3411721180145617, 1.9557943662672153, 1.8476446711733261, 0.80407767578801104], [1.2744745969481517, 1.6469622934775219, 1.3202992141685685, 0.66280063512227227, 1.224859619036704]])
10481          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10482          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
10483          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10484       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10485       def test_log10_Symbol_rank3(self):
10486          arg=Symbol(shape=(6, 2, 2))
10487          res=log10(arg)
10488          s=numarray.array([[[97.677455398657074, 5.2995923723645664], [59.480459383312862, 31.287029167765699]], [[71.178947786444226, 80.741319028685012], [4.6937684226740757, 82.77854206239293]], [[37.685161012781009, 98.687319373999358], [35.10949192866029, 91.569084058538095]], [[5.0027662267064468, 91.014241654301969], [58.955781232044089, 42.084452128968486]], [[42.095754738844363, 65.010819895554334], [1.5796236582104439, 21.735792752471603]], [[2.7216077761134634, 94.934790022180749], [48.226002781175161, 39.974953444592217]]])
10489          sub=res.substitute({arg:s})
10490          ref=numarray.array([[[1.9897943372521787, 0.72424246634779432], [1.7743743140339689, 1.4953643270547985]], [[1.852351563691448, 1.9070958399739759], [0.67152165892347482, 1.9179177731177302]], [[1.5761703751687193, 1.9942613524700676], [1.5454245448120962, 1.9617488700750414]], [[0.69921020929486732, 1.9591093548259275], [1.7705263986434625, 1.6241216777418199]], [[1.6242383004328855, 1.8129856432563642], [0.19855362959306125, 1.3371754844967376]], [[0.4348255371262037, 1.9774253941539486], [1.683281266856163, 1.6017879666329446]]])
10491          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10492          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
10493          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10494       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10495       def test_log10_Symbol_rank4(self):
10496          arg=Symbol(shape=(3, 2, 3, 4))
10497          res=log10(arg)
10498          s=numarray.array([[[[16.045040740457228, 44.206338348310695, 93.40651696252057, 41.363358895057978], [63.003183559801194, 42.521563748415652, 8.6993137819993134, 74.382838127848629], [45.459960205898135, 80.856347298703682, 44.432638407790726, 19.227764687502933]], [[83.760984274338924, 85.653170708807224, 70.695307663592047, 93.459124905553011], [12.593602001874332, 15.823926028904745, 56.197268657756482, 72.264399830277114], [79.814475892193883, 72.335551687072851, 38.67162462451919, 72.957787867770691]]], [[[63.261177157590048, 19.106157472979373, 12.579604590358606, 57.238626886098317], [37.258243564126879, 80.6564043172623, 17.791453176791894, 72.593744868798936], [51.784094386303515, 71.1225086541086, 52.470521860231401, 37.515182918884939]], [[60.054478935403843, 64.171538197777366, 59.343629062665904, 78.932915989720726], [71.684640978389197, 17.296300300660835, 66.710626043564787, 29.599576157916399], [82.750620535499948, 68.051253095052544, 47.140766487889351, 64.511627295078895]]], [[[63.303786699612154, 6.3288524584968009, 7.8921294047783288, 16.867328761433935], [26.792013647404634, 56.632884251794707, 15.19584760573529, 47.669107257961393], [14.796650879616557, 93.976599541985081, 83.095541055174948, 69.492537636920886]], [[13.729968603614751, 0.47465429532443348, 96.901076881373811, 53.206407481750915], [38.296922736957285, 64.554310808840825, 44.872698720823387, 44.966755775657276], [39.450963126141424, 45.816408715888691, 24.156240302619725, 88.251967910885227]]]])
10499          sub=res.substitute({arg:s})
10500          ref=numarray.array([[[[1.2053408241634207, 1.6454845433840053, 1.9703771779659067, 1.6166157982280229], [1.7993624949698093, 1.6286092275074269, 0.93948499601574675, 1.8714727451408386], [1.6576290512225109, 1.9077141181026729, 1.6477021023906282, 1.2839287985229535]], [[1.923041772090109, 1.9327434443108824, 1.8493905888543518, 1.970621710237741], [1.1001499640874481, 1.1993142440892028, 1.7497152081724321, 1.8589244001304135], [1.9020816661621307, 1.8593517980783829, 1.5873924174995711, 1.8630716574011561]]], [[[1.8011372689627134, 1.2811733528802767, 1.0996669903203637, 1.7576892067973247], [1.5712223774419329, 1.9066388571461961, 1.2502114219955252, 1.8608992007827503], [1.7141963855944065, 1.85200706679542, 1.7199153836168972, 1.574207068351656]], [[1.7785454031526147, 1.807342449495341, 1.7733741013623185, 1.8972581470832404], [1.855426114484128, 1.237953216953114, 1.8241950162932645, 1.4712854923563716], [1.9177712591744391, 1.8328361267069659, 1.673396639680764, 1.8096379970383623]]], [[[1.8014296893784714, 0.80132497129351055, 0.89719419762936958, 1.22704630985494], [1.428005355754228, 1.7530686803399524, 1.1817249295049448, 1.6782370185817173], [1.1701634269423968, 1.9730197264193245, 1.9195777199683672, 1.8419381709626483]], [[1.1376695441346099, -0.32362258467939325, 1.9863286034804823, 1.7259639361747965], [1.5831638786148206, 1.8099252488949431, 1.6519821895312212, 1.6528915555787334], [1.5960576102136967, 1.6610210443470965, 1.3830293412534942, 1.9457243984033095]]]])
10501          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10502          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
10503          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10504       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10505       def test_wherePositive_float_rank0(self):
10506          arg=-70.4202098913
10507          res=wherePositive(arg)
10508          ref=0.0
10509          self.failUnless(isinstance(res,float),"wrong type of result.")
10510          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10511       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10512       def test_wherePositive_array_rank0(self):
10513          arg=numarray.array(-15.0739210922)
10514          res=wherePositive(arg)
10515          ref=numarray.array(0.0)
10516          if not isinstance(res,float):
10517             self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10518             self.failUnlessEqual(res.shape,(),"wrong shape of result.")
10519          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10520       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10521       def test_wherePositive_array_rank1(self):
10522          arg=numarray.array([28.906077447952242, -23.10248488222922])
10523          res=wherePositive(arg)
10524          ref=numarray.array([1.0, 0.0])
10525          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10526          self.failUnlessEqual(res.shape,(2,),"wrong shape of result.")
10527          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10528       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10529       def test_wherePositive_array_rank2(self):
10530          arg=numarray.array([[67.494612236577638, 80.909854174047979, 47.70625909870725, -71.777921046997903, -98.760598538077588], [-91.46372992135052, -96.471924292992298, 2.2231997478348262, -86.769574545358523, 27.58841468272739], [41.637665565063259, 43.273086569741736, -91.492851720531291, -1.0475761142533457, 2.0960045464434245], [66.692822223370541, -81.550480374891549, -16.03214690197197, 40.933392894460582, -55.932865200691054]])
10531          res=wherePositive(arg)
10532          ref=numarray.array([[1.0, 1.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0, 1.0], [1.0, 0.0, 0.0, 1.0, 0.0]])
10533          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10534          self.failUnlessEqual(res.shape,(4, 5),"wrong shape of result.")
10535          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10536       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10537       def test_wherePositive_array_rank3(self):
10538          arg=numarray.array([[[-78.74335358357429, 61.656365045394921], [-42.157193730553708, -38.883346265013287]], [[-88.068489379591128, 78.654807861894938], [65.794256223486343, 0.30259701842065567]], [[-34.476517576931769, -70.04973714943732], [-40.160695156882142, -18.154859425407395]], [[84.416246128010471, -50.99152387283268], [62.940159515920811, -0.11087897257154111]], [[24.387079920060856, 48.804666891859824], [-84.793512049461796, -45.707677832173552]], [[-56.719649784696678, 41.392713601723557], [-61.888885999508261, -26.917437791111837]]])
10539          res=wherePositive(arg)
10540          ref=numarray.array([[[0.0, 1.0], [0.0, 0.0]], [[0.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]], [[1.0, 0.0], [1.0, 0.0]], [[1.0, 1.0], [0.0, 0.0]], [[0.0, 1.0], [0.0, 0.0]]])
10541          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10542          self.failUnlessEqual(res.shape,(6, 2, 2),"wrong shape of result.")
10543          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10544       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10545       def test_wherePositive_array_rank4(self):
10546          arg=numarray.array([[[[72.100249984910391, -57.956175146094189, -98.913296387113945, -94.28075564808627], [-20.338451587905567, 2.4621360465247619, -80.82947875967011, 14.027370399640887], [-48.035910797270517, 64.795111774229667, -82.329489801042541, 86.211936552870952]], [[37.185934763312503, 49.50849631983408, 52.839672777504035, 56.377399244546268], [-7.234268113362134, 63.462611511320603, -52.156035067909997, -43.754752300758845], [-14.612026578032641, 53.353096426791865, -30.372778094043994, 97.860579226476858]]], [[[-82.319953411897728, -2.3001105395993733, -12.470606338277989, -63.185118541205121], [-94.960301922301298, -5.6565221271575297, 84.191028153250841, -70.636345764666828], [-49.130664317092567, -63.768657233437096, -36.120318903149595, 9.5139407723962393]], [[-92.191650374208336, 20.072457509379518, 81.652491381337285, -23.646733247590561], [81.342975568236085, 8.3577532005437547, 90.97695735629847, -73.840918529210441], [55.181621714112651, 38.330720467911931, -44.40476584033042, -83.817032958509117]]], [[[51.616654622513693, -14.450479331389161, -5.8020122717656477, -12.213830658544154], [-51.343817002573424, 18.583775895090156, 30.9554845465818, -87.095470001919878], [18.943349747730863, -70.349447902193702, -88.554802232088136, -28.827441779916782]], [[93.287427705419901, -70.256526015900903, -42.22715235102428, -19.855219969615817], [83.720263265665665, 37.151450334636081, -9.298456402444728, -68.274978717591296], [-18.390940148111184, -34.890690302498555, -23.885346500749165, -41.804510053113894]]]])
10547          res=wherePositive(arg)
10548          ref=numarray.array([[[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 1.0], [0.0, 1.0, 0.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 0.0, 0.0], [0.0, 1.0, 0.0, 1.0]]], [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]], [[0.0, 1.0, 1.0, 0.0], [1.0, 1.0, 1.0, 0.0], [1.0, 1.0, 0.0, 0.0]]], [[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0]], [[1.0, 0.0, 0.0, 0.0], [1.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]]])
10549          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10550          self.failUnlessEqual(res.shape,(3, 2, 3, 4),"wrong shape of result.")
10551          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10552       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10553       def test_wherePositive_constData_rank0(self):
10554          arg=Data(-37.6753904615,self.functionspace)
10555          res=wherePositive(arg)
10556          ref=Data(0.0,self.functionspace)
10557          self.failUnless(isinstance(res,Data),"wrong type of result.")
10558          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
10559          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10560       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10561       def test_wherePositive_constData_rank1(self):
10562          arg=Data(numarray.array([5.9258449909595186, -10.188430268215654]),self.functionspace)
10563          res=wherePositive(arg)
10564          ref=Data(numarray.array([1.0, 0.0]),self.functionspace)
10565          self.failUnless(isinstance(res,Data),"wrong type of result.")
10566          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
10567          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10568       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10569       def test_wherePositive_constData_rank2(self):
10570          arg=Data(numarray.array([[-83.114314035576911, -97.085921526582439, -2.9217465777721827, -1.1787890915813506, -20.648618676160794], [71.555185206951847, -36.727722158005328, -65.518358513104715, -10.283766355353151, -88.62623357705364], [-87.443527444393794, 60.959525199376515, -36.134372946418772, 29.770497973959067, -0.56000819620498987], [-49.731344859570029, 75.300101947703638, -19.333618937761287, -76.395441717604839, -82.674517477413232]]),self.functionspace)
10571          res=wherePositive(arg)
10572          ref=Data(numarray.array([[0.0, 0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 0.0, 0.0]]),self.functionspace)
10573          self.failUnless(isinstance(res,Data),"wrong type of result.")
10574          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
10575          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10576       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10577       def test_wherePositive_constData_rank3(self):
10578          arg=Data(numarray.array([[[-40.29961143870586, -64.342711281295834], [-64.836836776535421, -41.307920796211107]], [[-61.487633921118331, -7.3019368673698182], [-81.595580375270529, -80.989974279719092]], [[13.759821229996419, -43.651255501857598], [50.571853247937838, 14.873409423642684]], [[32.599560708951344, 55.599891743152568], [-1.8584615650637915, 23.421438487813944]], [[47.743729631487469, -36.78569238955729], [-28.252743553505184, 22.915574068362659]], [[-0.67504474651151725, 28.5961011553226], [77.940744385806681, -89.35268267418266]]]),self.functionspace)
10579          res=wherePositive(arg)
10580          ref=Data(numarray.array([[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[1.0, 0.0], [1.0, 1.0]], [[1.0, 1.0], [0.0, 1.0]], [[1.0, 0.0], [0.0, 1.0]], [[0.0, 1.0], [1.0, 0.0]]]),self.functionspace)
10581          self.failUnless(isinstance(res,Data),"wrong type of result.")
10582          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
10583          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10584       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10585       def test_wherePositive_constData_rank4(self):
10586          arg=Data(numarray.array([[[[71.612692363554316, -80.902829681816598, -6.0794925791431496, 41.078313564593316], [84.057541602542102, -97.902796065627044, 76.245927278333113, -96.120505502491469], [-99.105019921573785, -34.847444130381049, 88.667555631999448, -61.769631633660339]], [[40.254500143735328, 70.315581126398541, 10.456067243123286, -17.984811825653452], [-27.229768774609923, 75.270523605621804, 51.732035936211417, 14.053481511556541], [-29.429004067130975, 13.931520718869521, -30.222269455495066, 53.099744636438828]]], [[[66.658594737374756, 26.443778675942383, 9.5217968199842886, 68.676346716535676], [-4.3009384691851125, -50.115873372077658, 40.775834478113808, 82.265077077049256], [-7.2654412117834681, 81.465859170947255, -40.570736265673958, 56.150931410619563]], [[15.146701299125894, -64.769075114245851, 77.291597540960367, -14.009811712530947], [32.952062015880443, 80.976651596673207, -12.913148087348574, 91.160708451911319], [11.314142446960517, 82.128551417863406, 9.3083839762397673, 84.293128609776659]]], [[[-18.320762412080938, -27.151169441911918, 68.650437109092991, 99.874147618429021], [68.713441258274884, 57.829825185320146, 97.052922881235219, -75.918331274766771], [35.001416215619628, -31.489897641770497, -92.684784085487038, -60.095802530301491]], [[92.145606292141849, -48.839544388877989, -81.576565094059148, -25.403820705830697], [-35.642188462105295, 93.371365566245657, 86.533657118913908, -64.737341204155797], [80.204843593716333, -55.196561402571298, -91.04571841996929, -36.30116120361]]]]),self.functionspace)
10587          res=wherePositive(arg)
10588          ref=Data(numarray.array([[[[1.0, 0.0, 0.0, 1.0], [1.0, 0.0, 1.0, 0.0], [0.0, 0.0, 1.0, 0.0]], [[1.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 1.0], [0.0, 1.0, 0.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0], [0.0, 1.0, 0.0, 1.0]], [[1.0, 0.0, 1.0, 0.0], [1.0, 1.0, 0.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[0.0, 0.0, 1.0, 1.0], [1.0, 1.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0]], [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0]]]]),self.functionspace)
10589          self.failUnless(isinstance(res,Data),"wrong type of result.")
10590          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
10591          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10592       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10593       def test_wherePositive_expandedData_rank0(self):
10594          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10595          arg=msk_arg*(60.0229181114)+(1.-msk_arg)*(-96.3764768528)
10596          res=wherePositive(arg)
10597          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10598          ref=msk_ref*(1.0)+(1.-msk_ref)*(0.0)
10599          self.failUnless(isinstance(res,Data),"wrong type of result.")
10600          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
10601          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10602       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10603       def test_wherePositive_expandedData_rank1(self):
10604          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10605          arg=msk_arg*numarray.array([-22.419211375644196, 61.516723654676611])+(1.-msk_arg)*numarray.array([-47.697327344809139, -28.757233801998126])
10606          res=wherePositive(arg)
10607          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10608          ref=msk_ref*numarray.array([0.0, 1.0])+(1.-msk_ref)*numarray.array([0.0, 0.0])
10609          self.failUnless(isinstance(res,Data),"wrong type of result.")
10610          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
10611          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10612       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10613       def test_wherePositive_expandedData_rank2(self):
10614          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10615          arg=msk_arg*numarray.array([[75.742071937578856, 0.92373368970095271, -52.139002610910602, -90.166031609404286, 5.5135768493946244], [-85.866582176624462, -5.8971094180698174, -44.235765048437599, 66.234147934377376, 17.435204749442562], [33.989217424407883, -90.944874166814358, 95.204126153994281, -48.494625981425976, -47.866621860789692], [-51.66387411792315, 23.408933865995692, -38.274649597022268, 94.35801540027137, -22.729990325215482]])+(1.-msk_arg)*numarray.array([[-77.74312490692175, 73.695397504354787, -25.165673520548154, 28.581554535703447, 16.809417381385657], [14.13939656000484, -30.054842741776127, 80.5114214445926, -91.608466400819012, 74.642682764121503], [24.373158682098676, 88.149830810457473, -87.043665488082226, -41.342480458547229, 47.83512981806436], [-23.988019538589128, -97.754385926732397, 64.136066737433026, 93.308550605904486, 50.264032149431102]])
10616          res=wherePositive(arg)
10617          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10618          ref=msk_ref*numarray.array([[1.0, 1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0, 0.0], [0.0, 1.0, 0.0, 1.0, 0.0]])+(1.-msk_ref)*numarray.array([[0.0, 1.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0, 1.0]])
10619          self.failUnless(isinstance(res,Data),"wrong type of result.")
10620          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
10621          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10622       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10623       def test_wherePositive_expandedData_rank3(self):
10624          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10625          arg=msk_arg*numarray.array([[[-77.3470085491482, 23.703501363968414], [-78.457555629030821, -30.460470615708402]], [[40.586688169139535, 85.979119968548844], [14.391931326799096, 98.012599760182638]], [[-25.877266251828445, 92.469507013732766], [28.446352130979278, -29.047890229715236]], [[85.045265454383923, -79.743098568103363], [-67.998286974132469, 51.27842688771014]], [[-26.856044632583959, -46.616707014967403], [-13.323366086721251, 5.0944903333334395]], [[86.74261544510577, -64.927377055330226], [-96.292217645844659, 73.280353362666261]]])+(1.-msk_arg)*numarray.array([[[-73.854272948424978, -62.224959421353731], [69.003679176662558, 55.120389456685018]], [[-66.302549803605586, 41.107120553488897], [35.942390589413179, -49.629959161552975]], [[87.070085680653023, -7.4957980304887002], [62.24913427711212, 70.671000810016523]], [[-62.720150429412101, -67.208518801718355], [1.0758801572739856, -7.2411545422204995]], [[-46.322912286667474, -95.449711884536555], [-41.530447460581279, 23.396402682152996]], [[61.760793037463145, 26.046559417690631], [20.210361159406972, -6.0045794744297183]]])
10626          res=wherePositive(arg)
10627          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10628          ref=msk_ref*numarray.array([[[0.0, 1.0], [0.0, 0.0]], [[1.0, 1.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 0.0]], [[1.0, 0.0], [0.0, 1.0]], [[0.0, 0.0], [0.0, 1.0]], [[1.0, 0.0], [0.0, 1.0]]])+(1.-msk_ref)*numarray.array([[[0.0, 0.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 0.0]], [[1.0, 0.0], [1.0, 1.0]], [[0.0, 0.0], [1.0, 0.0]], [[0.0, 0.0], [0.0, 1.0]], [[1.0, 1.0], [1.0, 0.0]]])
10629          self.failUnless(isinstance(res,Data),"wrong type of result.")
10630          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
10631          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10632       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10633       def test_wherePositive_expandedData_rank4(self):
10634          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10635          arg=msk_arg*numarray.array([[[[43.80370896979781, -1.8783559803067504, 68.652439234878358, -54.13722802579484], [-16.330009797654171, -4.9840146257985225, -82.461337583892941, 20.478464419172909], [2.5283355218952437, -38.317141099135156, 74.439904322815721, -32.370032619039009]], [[75.661807530547463, 14.806511977463515, 92.913122066573948, -57.392835755828209], [-24.746344559568371, 58.577607900172268, 19.638932598152707, -56.683628155430846], [-23.63916211487431, -31.732325498364517, 2.9992635782867012, -51.737397326020073]]], [[[14.055418901807641, 49.78668125052377, 68.35230222025416, 1.1913826311549229], [-92.159227348973076, 77.751907937221432, 44.535941263032896, -69.410161289906654], [27.701588449716269, 33.203546994102169, -52.284409227888084, 6.1028377961118991]], [[-5.3335556081772069, -9.4816270741597748, 21.074022334438197, -82.638909781192709], [-38.201386351163571, -60.608459482874963, -10.140896441708108, -51.937205523614985], [67.836075729072832, 27.271013305993591, 37.943674493436077, 47.122338195390938]]], [[[94.80320858794326, 78.422597672517611, -47.362034814216145, -67.005672757399992], [13.984708106797612, -80.851401714264526, -66.341143846358705, 23.096516376649774], [19.354469887332982, -32.204625876582298, -90.448693280849412, -83.438145584116057]], [[-20.430907359037946, 34.265521783285777, 36.932356914307803, 94.749144039157954], [-23.740364230369423, -24.861180581515924, -23.653628334874384, -76.457114676244316], [-49.29499131919097, 97.199643030562271, 86.725540680528979, -20.724580882040343]]]])+(1.-msk_arg)*numarray.array([[[[-1.6865270561507373, -48.38266559451008, -21.021725580733076, -13.790499838190257], [50.521044913720118, -11.838528039107359, 48.1628346881065, -89.550279456158279], [74.235807932697497, -13.100435601018347, 2.3652821326138422, 30.026883928678501]], [[-69.738936297086411, 88.100714549880394, -31.068488721700788, -75.688640201758659], [74.214023515172073, 24.090808172915288, 60.52301851018504, -87.853385795062763], [-87.508927874364957, -1.5837298917809335, -28.713029983952225, -57.250723533626036]]], [[[-65.075934563641624, 11.614682951153725, 45.215631592128346, -74.364837387252123], [50.728658050670447, -58.927486265154741, 52.743491813692458, -35.976343344650601], [79.119298474238235, 97.80256840023921, -59.11443388001851, 54.649824887730659]], [[-99.518412000665691, -42.977729536858433, 20.676967689422, -90.750676595060924], [38.4658987940185, -16.645573644802568, -78.554599571785232, -59.494115705700779], [9.3463745210543578, 1.8679075108029082, -47.098256469256448, 83.374869892965677]]], [[[-69.480204147992879, 22.097990324074402, 64.676628015428008, -57.273925044302757], [-22.854234700698981, -91.099345045115427, 13.492331841283175, 64.248512967461465], [35.277064985517995, -94.753538497730474, 4.898846453131128, 75.023190487572577]], [[-90.672626500706244, -96.193464484471392, -13.003806772626731, -36.673991242489045], [-91.46754262338321, -48.493735714203744, -52.961005505255308, -75.058035570591386], [-39.614658185133521, 43.427235596994592, -79.256978699402055, -23.592401540492915]]]])
10636          res=wherePositive(arg)
10637          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10638          ref=msk_ref*numarray.array([[[[1.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0], [1.0, 0.0, 1.0, 0.0]], [[1.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 1.0, 0.0]]], [[[1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 0.0], [1.0, 1.0, 0.0, 1.0]], [[0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0], [1.0, 0.0, 0.0, 0.0]], [[0.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0]]]])+(1.-msk_ref)*numarray.array([[[[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 1.0, 0.0], [1.0, 0.0, 1.0, 1.0]], [[0.0, 1.0, 0.0, 0.0], [1.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], [[[0.0, 1.0, 1.0, 0.0], [1.0, 0.0, 1.0, 0.0], [1.0, 1.0, 0.0, 1.0]], [[0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0], [1.0, 1.0, 0.0, 1.0]]], [[[0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 1.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]]]])
10639          self.failUnless(isinstance(res,Data),"wrong type of result.")
10640          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
10641          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10642       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10643       def test_wherePositive_Symbol_rank0(self):
10644          arg=Symbol(shape=())
10645          res=wherePositive(arg)
10646          s=numarray.array(-9.43501528753)
10647          sub=res.substitute({arg:s})
10648          ref=numarray.array(0.0)
10649          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10650          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
10651          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10652       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10653       def test_wherePositive_Symbol_rank1(self):
10654          arg=Symbol(shape=(2,))
10655          res=wherePositive(arg)
10656          s=numarray.array([-86.076223420613644, 24.887439437676818])
10657          sub=res.substitute({arg:s})
10658          ref=numarray.array([0.0, 1.0])
10659          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10660          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
10661          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10662       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10663       def test_wherePositive_Symbol_rank2(self):
10664          arg=Symbol(shape=(4, 5))
10665          res=wherePositive(arg)
10666          s=numarray.array([[-72.861467415908407, 87.445413020151335, 44.122959128487878, 37.815712663148446, 16.51575833789849], [5.5678430369583225, -31.657700395046518, -23.000608981075231, 13.175691780223559, -47.172371090875245], [46.838381836265143, -0.64336779291720347, 79.712475185814469, -69.138421706470496, -28.642558818567949], [91.568480320945753, -14.976400873356837, -16.802832112916647, 7.6223808092700409, 43.400561726126483]])
10667          sub=res.substitute({arg:s})
10668          ref=numarray.array([[0.0, 1.0, 1.0, 1.0, 1.0], [1.0, 0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0, 1.0]])
10669          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10670          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
10671          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10672       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10673       def test_wherePositive_Symbol_rank3(self):
10674          arg=Symbol(shape=(6, 2, 2))
10675          res=wherePositive(arg)
10676          s=numarray.array([[[14.254888779256163, -93.079183322703372], [-63.28205537162679, -5.1053738037226708]], [[88.548065869410834, 92.437854070248505], [67.463905803574136, -69.119627703399033]], [[-5.1587834929179337, 14.438150309231744], [-60.082589289020348, -2.8764823549122411]], [[86.474191437976202, -23.913731018025047], [-14.33516255203034, -76.872920311355045]], [[31.232916890504555, -98.898455060843588], [-63.462721420014013, -59.602078269458957]], [[54.664891148938096, -5.6099126717595595], [34.202150896807495, 28.911805516544462]]])
10677          sub=res.substitute({arg:s})
10678          ref=numarray.array([[[1.0, 0.0], [0.0, 0.0]], [[1.0, 1.0], [1.0, 0.0]], [[0.0, 1.0], [0.0, 0.0]], [[1.0, 0.0], [0.0, 0.0]], [[1.0, 0.0], [0.0, 0.0]], [[1.0, 0.0], [1.0, 1.0]]])
10679          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10680          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
10681          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10682       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10683       def test_wherePositive_Symbol_rank4(self):
10684          arg=Symbol(shape=(3, 2, 3, 4))
10685          res=wherePositive(arg)
10686          s=numarray.array([[[[-37.88958007709131, -69.422440876170157, 98.309997394312262, -99.832160786266513], [-98.549853800366634, -59.212851099858788, 70.467934907158082, 87.428704353937917], [8.80467342401829, -67.471677482415785, 23.942091174941325, 15.803088287257538]], [[-63.172322626194635, 82.538771957419357, 45.164380438773549, -94.022903002494402], [4.0962211030344662, -48.787187296107028, 45.525825517642005, 45.711734183529074], [48.265143872942929, -87.162363496761159, 16.011575553754028, -96.721599021387377]]], [[[9.4948883762552327, -18.446841364017814, 20.351663614867761, 55.318055980592845], [90.016295105535704, 18.315786000578143, 54.95564104759859, 75.816166573502358], [-71.162333511732001, -95.953386780228797, 84.570733819306724, -10.941053704889384]], [[-8.4083264964211111, 56.989366045336567, 9.1939134657073538, 22.066859941476011], [1.0651237550664661, 84.74053823059441, -90.753568574100399, 73.121172281878046], [-99.18615441543605, -28.331557285152641, -44.476057352835177, 46.421436565938251]]], [[[73.673411450959293, 72.485098252566615, -72.54930137464963, 82.784929340261613], [-12.436989146984473, 33.551428499615753, 53.425622240674727, 55.24125898657536], [-46.807406690716967, -99.733941429080986, 41.082918915124822, 43.402758860058839]], [[-30.615849276223585, 90.588710503833624, 36.934609404692054, -87.474764164742183], [-96.421287284725565, -5.6209672311981791, 89.578789522633173, 56.454146153177106], [-23.865121727890298, -53.925804298204838, -1.8102203614056123, -37.919849585870246]]]])
10687          sub=res.substitute({arg:s})
10688          ref=numarray.array([[[[0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 1.0]], [[0.0, 1.0, 1.0, 0.0], [1.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0]]], [[[1.0, 0.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 1.0, 0.0]], [[0.0, 1.0, 1.0, 1.0], [1.0, 1.0, 0.0, 1.0], [0.0, 0.0, 0.0, 1.0]]], [[[1.0, 1.0, 0.0, 1.0], [0.0, 1.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0]], [[0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]]]])
10689          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10690          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
10691          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10692       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10693       def test_whereNegative_float_rank0(self):
10694          arg=60.8682840238
10695          res=whereNegative(arg)
10696          ref=0.0
10697          self.failUnless(isinstance(res,float),"wrong type of result.")
10698          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10699       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10700       def test_whereNegative_array_rank0(self):
10701          arg=numarray.array(12.3306392667)
10702          res=whereNegative(arg)
10703          ref=numarray.array(0.0)
10704          if not isinstance(res,float):
10705             self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10706             self.failUnlessEqual(res.shape,(),"wrong shape of result.")
10707          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10708       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10709       def test_whereNegative_array_rank1(self):
10710          arg=numarray.array([-96.137063268028797, -76.658277780494259])
10711          res=whereNegative(arg)
10712          ref=numarray.array([1.0, 1.0])
10713          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10714          self.failUnlessEqual(res.shape,(2,),"wrong shape of result.")
10715          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10716       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10717       def test_whereNegative_array_rank2(self):
10718          arg=numarray.array([[34.527255357681298, 46.742030193793738, -10.068808745305603, 33.451041357426902, 52.37433370591711], [-1.1274024836940555, 2.5419221930968519, 32.984481014462432, 76.341642878243078, 36.384014089381708], [-98.496974526985866, -65.01368641484936, 50.789914135856463, -16.286375703249959, 45.813382104794698], [18.983852245009942, -39.656344508041677, -87.540891441344542, 22.257065860125209, -56.083642049697957]])
10719          res=whereNegative(arg)
10720          ref=numarray.array([[0.0, 0.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 0.0, 1.0, 0.0], [0.0, 1.0, 1.0, 0.0, 1.0]])
10721          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10722          self.failUnlessEqual(res.shape,(4, 5),"wrong shape of result.")
10723          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10724       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10725       def test_whereNegative_array_rank3(self):
10726          arg=numarray.array([[[27.452945477282029, 10.079247782917776], [73.463914059433876, 89.31763644890097]], [[-39.00630564129397, -56.727418650360839], [99.956113750577458, -63.201931425083899]], [[23.800879753842111, -71.802714984390661], [20.122988022110079, 50.095040283423629]], [[17.391754513203111, -87.274468281986955], [-69.061025469838569, -95.107053552460357]], [[-38.397282711106314, -73.428763082157076], [-24.751594707412835, 93.224119395489396]], [[-71.420548157545795, -10.204520855028434], [8.2682413993733377, 69.215290928341716]]])
10727          res=whereNegative(arg)
10728          ref=numarray.array([[[0.0, 0.0], [0.0, 0.0]], [[1.0, 1.0], [0.0, 1.0]], [[0.0, 1.0], [0.0, 0.0]], [[0.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 0.0]], [[1.0, 1.0], [0.0, 0.0]]])
10729          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10730          self.failUnlessEqual(res.shape,(6, 2, 2),"wrong shape of result.")
10731          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10732       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10733       def test_whereNegative_array_rank4(self):
10734          arg=numarray.array([[[[52.851635463931416, -42.757919744122042, -43.221594386333393, -71.627489318948307], [63.051185031362394, 88.122130054764369, 3.0294368603839104, -80.279495847366533], [22.202897744980945, -9.5679057475316398, 0.6747259697796153, -32.77109355448286]], [[7.4103317420963606, 56.685726337130205, -5.6243186818793873, 30.690249505075911], [-40.26391967567595, 56.69805771317823, 38.011050108017827, -67.152404819687916], [11.988018990285681, 15.418047294689202, -35.853437208267195, 9.7603269619072535]]], [[[62.818258893227807, -68.93898305799496, -59.052468240174804, -26.916691703402719], [-93.556184474191454, 54.562368122195096, -69.599681490131715, -79.832141645610747], [-68.174504363157169, 15.388412833294524, 92.958241545241805, 48.717089383312725]], [[80.362433523267072, 85.459156338229405, 48.410142376841151, 92.900690384172805], [-13.477883213840627, -48.877024108923784, -42.918741473403841, 30.897642075312746], [6.738002126296621, 12.415597112960256, 39.201682409893436, -18.884889673699519]]], [[[-62.408880043825611, -72.590378070784652, -82.098861995291813, -34.475953721594863], [85.281229062252805, -53.982038453937164, 31.566642378708877, 10.785407426910879], [67.392800607262615, -44.131930493424655, -79.616463869751612, 69.356492589536515]], [[20.091109964478719, -76.324154832707023, 76.477460746877824, -45.456803948000314], [77.912305288034929, -24.195046812358953, -28.192001907231074, 87.18708113620994], [31.883641084515517, 58.423371148498177, 68.91426566250999, -4.6562642110223038]]]])
10735          res=whereNegative(arg)
10736          ref=numarray.array([[[[0.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 1.0]], [[0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 0.0]]], [[[0.0, 1.0, 1.0, 1.0], [1.0, 0.0, 1.0, 1.0], [1.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0]], [[0.0, 1.0, 0.0, 1.0], [0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]]])
10737          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10738          self.failUnlessEqual(res.shape,(3, 2, 3, 4),"wrong shape of result.")
10739          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10740       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10741       def test_whereNegative_constData_rank0(self):
10742          arg=Data(71.0461471154,self.functionspace)
10743          res=whereNegative(arg)
10744          ref=Data(0.0,self.functionspace)
10745          self.failUnless(isinstance(res,Data),"wrong type of result.")
10746          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
10747          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10748       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10749       def test_whereNegative_constData_rank1(self):
10750          arg=Data(numarray.array([-80.731119617568183, 91.086434642832756]),self.functionspace)
10751          res=whereNegative(arg)
10752          ref=Data(numarray.array([1.0, 0.0]),self.functionspace)
10753          self.failUnless(isinstance(res,Data),"wrong type of result.")
10754          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
10755          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10756       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10757       def test_whereNegative_constData_rank2(self):
10758          arg=Data(numarray.array([[-30.078161181135357, -83.774816691205274, 31.234430645356866, -88.643364099015969, -27.327692899224587], [39.87080777988453, -90.362613632345415, -88.178393380316351, 0.78766148538969105, 17.467833815617212], [-41.019873514226759, 85.969686883649359, -71.810931481288037, -64.605161148773874, 73.291192617723908], [59.382800564915414, 72.112470346114435, 64.321292886976977, 83.840884620483592, -18.887748452642555]]),self.functionspace)
10759          res=whereNegative(arg)
10760          ref=Data(numarray.array([[1.0, 1.0, 0.0, 1.0, 1.0], [0.0, 1.0, 1.0, 0.0, 0.0], [1.0, 0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 1.0]]),self.functionspace)
10761          self.failUnless(isinstance(res,Data),"wrong type of result.")
10762          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
10763          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10764       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10765       def test_whereNegative_constData_rank3(self):
10766          arg=Data(numarray.array([[[52.467962714577851, -10.755811269205751], [-49.824884301105229, -87.898834770673545]], [[-84.887027502945656, 39.276449348108372], [-0.28784075758221661, -43.719102909037424]], [[5.0483861425380212, 77.163995546260338], [-82.618948195844013, 1.7083645155553171]], [[-85.252812042880379, 47.920337911790767], [-89.706782276303997, -9.5992153716397723]], [[-53.487541003352291, -37.042887199510169], [-39.924749090729648, -97.861135144144257]], [[14.313959182168418, -64.680421169049538], [-18.772463792577526, -22.16535015919969]]]),self.functionspace)
10767          res=whereNegative(arg)
10768          ref=Data(numarray.array([[[0.0, 1.0], [1.0, 1.0]], [[1.0, 0.0], [1.0, 1.0]], [[0.0, 0.0], [1.0, 0.0]], [[1.0, 0.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 1.0]]]),self.functionspace)
10769          self.failUnless(isinstance(res,Data),"wrong type of result.")
10770          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
10771          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10772       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10773       def test_whereNegative_constData_rank4(self):
10774          arg=Data(numarray.array([[[[-56.738900482413811, -11.202980729285244, -71.631743919679849, -14.501263562534177], [43.190705972099948, 28.379497298551968, -13.569119185364585, 65.358348068303656], [-91.736472018303189, 45.571509175250782, 20.814396687393597, 53.332854517832743]], [[32.567368220643601, 3.4928426287876135, 58.278182327340858, -96.270406402097166], [30.357738302076029, -34.075847316972101, 88.565145570585258, 68.632732598053138], [-43.333644849377052, 98.698365574236476, 99.086221332142486, 79.256177564404851]]], [[[83.658967348768414, 73.87622641143912, 26.664285223308923, -24.236702163040988], [33.966505242244011, -47.630267479564296, -41.486678856495061, -68.553303600684572], [-75.108951411161826, 42.384054423970923, -48.286880035511935, -66.006863305952038]], [[-1.946984825710345, 12.753883934941655, 99.463784625818676, -86.199776629612472], [43.644149588437671, -18.088721159515316, 82.264706299718881, -66.686685578089453], [-1.6489398255121301, 17.662742039769299, -39.062788718667996, 43.366643090778211]]], [[[7.0838003526987166, 84.164965010157346, 94.39131652727707, 42.082953004169639], [-55.773938700136782, 52.435811047719028, 53.070615567554626, -64.791867065020568], [-11.109776598239193, 76.314724953648579, -47.359305606426716, 52.614937206019448]], [[18.800439656297712, 93.558627961377653, 13.541712656625251, 4.6114826390651018], [63.601298072608671, 48.408056729632989, 49.122562180543326, -0.17795085269705169], [35.457986798476099, -74.518767618135072, 11.99706514332901, 40.603347309608296]]]]),self.functionspace)
10775          res=whereNegative(arg)
10776          ref=Data(numarray.array([[[[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 1.0], [0.0, 1.0, 1.0, 1.0], [1.0, 0.0, 1.0, 1.0]], [[1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 1.0], [1.0, 0.0, 1.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0], [1.0, 0.0, 1.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 0.0]]]]),self.functionspace)
10777          self.failUnless(isinstance(res,Data),"wrong type of result.")
10778          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
10779          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10780       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10781       def test_whereNegative_expandedData_rank0(self):
10782          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10783          arg=msk_arg*(-30.5711237435)+(1.-msk_arg)*(69.0316558372)
10784          res=whereNegative(arg)
10785          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10786          ref=msk_ref*(1.0)+(1.-msk_ref)*(0.0)
10787          self.failUnless(isinstance(res,Data),"wrong type of result.")
10788          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
10789          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10790       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10791       def test_whereNegative_expandedData_rank1(self):
10792          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10793          arg=msk_arg*numarray.array([-71.631541638025368, -34.933285862461716])+(1.-msk_arg)*numarray.array([94.532432395056986, -8.4861064431438251])
10794          res=whereNegative(arg)
10795          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10796          ref=msk_ref*numarray.array([1.0, 1.0])+(1.-msk_ref)*numarray.array([0.0, 1.0])
10797          self.failUnless(isinstance(res,Data),"wrong type of result.")
10798          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
10799          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10800       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10801       def test_whereNegative_expandedData_rank2(self):
10802          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10803          arg=msk_arg*numarray.array([[-81.246161725962281, -0.80928674630524711, 64.245598914154385, 25.019488668613903, -20.02114893086133], [-16.925215481515338, -19.119399037651519, -33.929581396089105, 49.036506368260234, -19.653199853598636], [-71.356363589257569, 60.190772929399429, -80.879381891956257, -25.014458239978964, 53.593957929715629], [-99.037250890485964, 2.1499053353822575, 24.458899543815619, 17.352712366156538, 87.281727012725412]])+(1.-msk_arg)*numarray.array([[24.876343327252769, -97.810881158075432, -98.976581314248165, -58.828345137646295, -47.996308815032116], [88.870044806649133, 83.497827171390071, -49.848159713628817, -79.747992284629902, -86.622423551338159], [-44.407345444816215, -19.420350667571313, 30.593026030666437, -92.522432388627806, -27.411015715113336], [-70.620933054656803, 95.630924114745426, -6.4891593001671595, 30.067888220202349, 54.633003267596763]])
10804          res=whereNegative(arg)
10805          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10806          ref=msk_ref*numarray.array([[1.0, 1.0, 0.0, 0.0, 1.0], [1.0, 1.0, 1.0, 0.0, 1.0], [1.0, 0.0, 1.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0, 0.0]])+(1.-msk_ref)*numarray.array([[0.0, 1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0, 1.0], [1.0, 1.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0, 0.0]])
10807          self.failUnless(isinstance(res,Data),"wrong type of result.")
10808          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
10809          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10810       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10811       def test_whereNegative_expandedData_rank3(self):
10812          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10813          arg=msk_arg*numarray.array([[[-13.226116878406287, -82.199364713243199], [10.802887584692229, -65.686743331979756]], [[-53.361630863787582, 99.378467998876744], [-3.7915436947351395, -26.517844578338142]], [[93.096723454132416, -93.695818457215509], [31.554012577630004, 39.96605767563608]], [[-42.995245201378005, -29.890999774133903], [18.30723099164662, 88.621280116942501]], [[1.7197935367676394, 25.587678904490673], [48.238578489671426, -98.542525990226594]], [[-37.454079112118485, 7.2826272286010294], [76.911623094137013, 88.86281750539041]]])+(1.-msk_arg)*numarray.array([[[-76.308681189268725, 78.036351430824794], [29.442414274483752, 32.970131475820949]], [[-11.522188039672287, -29.450015896780172], [-71.490304555395142, 86.623804825605646]], [[29.9575694239212, 48.244193165489548], [12.890596118737662, -44.72251029422889]], [[87.880930152139086, 77.877282206925827], [52.458002105709056, -26.128933933435519]], [[-10.037415450512867, 62.849269823732953], [-13.341389821511029, -66.474146337225662]], [[-66.827808490764482, 55.123032168800961], [11.770865332062257, -65.792755427561076]]])
10814          res=whereNegative(arg)
10815          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10816          ref=msk_ref*numarray.array([[[1.0, 1.0], [0.0, 1.0]], [[1.0, 0.0], [1.0, 1.0]], [[0.0, 1.0], [0.0, 0.0]], [[1.0, 1.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 1.0]], [[1.0, 0.0], [0.0, 0.0]]])+(1.-msk_ref)*numarray.array([[[1.0, 0.0], [0.0, 0.0]], [[1.0, 1.0], [1.0, 0.0]], [[0.0, 0.0], [0.0, 1.0]], [[0.0, 0.0], [0.0, 1.0]], [[1.0, 0.0], [1.0, 1.0]], [[1.0, 0.0], [0.0, 1.0]]])
10817          self.failUnless(isinstance(res,Data),"wrong type of result.")
10818          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
10819          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10820       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10821       def test_whereNegative_expandedData_rank4(self):
10822          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10823          arg=msk_arg*numarray.array([[[[22.736350434258242, 83.810869845847236, 19.347903964541985, -80.166931850749208], [45.452393364563619, 50.301718349604471, 67.66905146372207, -16.354259444700304], [47.685594996358162, -15.412627032981447, -33.973100957852424, -28.421171446812849]], [[28.765923294757869, 81.948159836174653, -61.002964447142837, -60.377845446919643], [-11.088814072045068, 77.109491110526534, -28.820136591829765, 54.89579817587898], [88.727197576669454, -61.758232727685126, 31.11303916232518, 22.425386560120742]]], [[[-37.668698306499728, -93.367508938543509, -96.69001608717312, 46.73287429891991], [-17.086614002398235, 77.117506515236443, -89.609359206118882, -51.116796499884963], [-11.331078933065797, 82.655593610768733, -51.263800662903833, -45.417082762140161]], [[-38.448402748623288, 40.952337637478053, 8.3792678972500312, -28.811191611059755], [-46.223465500265526, -44.801884964741333, 87.075157001648392, 72.791216981596563], [-0.90078100649908777, -60.044301966082593, -24.235637315239387, 86.769389985854133]]], [[[-85.232530260963387, 8.41880287115751, -80.819791741701195, 1.6073205456352753], [43.848963529258867, -84.768973989806852, 45.149836932049368, -54.480107023795263], [-90.354256577100813, -28.667837787830337, -74.038580399961162, -44.842435509105826]], [[-13.569853286180006, -39.870360955262484, -43.80119994880998, 98.821718640347399], [-74.739576772222932, -10.481845098843181, -19.428165239121967, -64.409567816025458], [-84.960799515544096, 44.601968055026731, -53.945696380018205, -62.508824901005354]]]])+(1.-msk_arg)*numarray.array([[[[98.331226651596097, -45.908896808474253, -76.328427133254692, 9.0732880852006019], [77.537791077921838, 81.188001463478429, -77.573617910825661, -70.53070043922385], [-60.093184821750675, -51.652608941265157, 17.555344559057744, 71.905673472708713]], [[60.587001914144139, -22.25480650550962, -15.669252605643379, 81.086498408593513], [20.771698800848753, 88.031012565600975, -57.68613427820555, 33.563864544408631], [71.357793416800945, 48.697344496300332, -56.302119150659721, 85.465915125881565]]], [[[71.34331579003441, -76.222881134514139, 70.657517114902021, -51.209553238176994], [-51.01048305469795, -54.010632435840478, 40.057721463180229, 90.017288091933807], [23.78119243806394, -65.128478845325958, -69.24071358054411, -35.156183078888859]], [[24.931984536066182, 29.218423454675872, 37.291762771095193, -44.301474105023033], [-27.534021386697475, 22.357601126944559, -32.007180009349128, -78.646515703268264], [70.214506130886946, 57.390883214823788, -94.288983066193083, 68.156267247037135]]], [[[86.210144621283746, 47.931898737102983, 64.611807566463199, 97.889272082903091], [-31.445648061764658, 80.771569964243128, -36.261273157065155, 95.317389789191196], [-53.571317526281348, -14.421189259125327, 59.637908000860364, -61.238575115717154]], [[-25.60102669901228, 53.006556636924671, -69.520681581420575, -2.0132709991870286], [22.968036096731808, 5.7145633292572597, 73.063684440985469, -57.182218254882436], [77.157618409964044, -31.84995932925176, -83.282695391829435, 77.690533538106138]]]])
10824          res=whereNegative(arg)
10825          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10826          ref=msk_ref*numarray.array([[[[0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 1.0], [0.0, 1.0, 1.0, 1.0]], [[0.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 0.0]]], [[[1.0, 1.0, 1.0, 0.0], [1.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 1.0]], [[1.0, 0.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0], [1.0, 1.0, 1.0, 0.0]]], [[[1.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 0.0], [1.0, 1.0, 1.0, 1.0], [1.0, 0.0, 1.0, 1.0]]]])+(1.-msk_ref)*numarray.array([[[[0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 1.0, 1.0], [1.0, 1.0, 0.0, 0.0]], [[0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 1.0, 0.0]]], [[[0.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0], [0.0, 1.0, 1.0, 1.0]], [[0.0, 0.0, 0.0, 1.0], [1.0, 0.0, 1.0, 1.0], [0.0, 0.0, 1.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 1.0, 0.0], [1.0, 1.0, 0.0, 1.0]], [[1.0, 0.0, 1.0, 1.0], [0.0, 0.0, 0.0, 1.0], [0.0, 1.0, 1.0, 0.0]]]])
10827          self.failUnless(isinstance(res,Data),"wrong type of result.")
10828          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
10829          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10830       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10831       def test_whereNegative_Symbol_rank0(self):
10832          arg=Symbol(shape=())
10833          res=whereNegative(arg)
10834          s=numarray.array(40.4011650623)
10835          sub=res.substitute({arg:s})
10836          ref=numarray.array(0.0)
10837          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10838          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
10839          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10840       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10841       def test_whereNegative_Symbol_rank1(self):
10842          arg=Symbol(shape=(2,))
10843          res=whereNegative(arg)
10844          s=numarray.array([-71.655665065686279, 91.138272113877008])
10845          sub=res.substitute({arg:s})
10846          ref=numarray.array([1.0, 0.0])
10847          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10848          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
10849          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10850       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10851       def test_whereNegative_Symbol_rank2(self):
10852          arg=Symbol(shape=(4, 5))
10853          res=whereNegative(arg)
10854          s=numarray.array([[12.471311999599237, -79.466700443191797, -29.647474934713685, 78.725723129788037, -25.193667637213736], [-27.383589504006082, -92.789488552284837, -67.82758123957224, 48.122220899847264, 19.750545844613285], [74.799702244704122, -4.7296754832835575, -63.235693854345975, -75.80063354282521, 35.997583859070147], [-41.225516291769672, 38.466173287652197, -75.068915147413065, 11.383660545905457, 72.671825561656561]])
10855          sub=res.substitute({arg:s})
10856          ref=numarray.array([[0.0, 1.0, 1.0, 0.0, 1.0], [1.0, 1.0, 1.0, 0.0, 0.0], [0.0, 1.0, 1.0, 1.0, 0.0], [1.0, 0.0, 1.0, 0.0, 0.0]])
10857          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10858          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
10859          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10860       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10861       def test_whereNegative_Symbol_rank3(self):
10862          arg=Symbol(shape=(6, 2, 2))
10863          res=whereNegative(arg)
10864          s=numarray.array([[[86.049934039938336, -76.916545040373748], [47.912904518542064, -19.385016225256763]], [[-43.143194458809234, 22.762350582447041], [17.476826380519455, -26.433656105535647]], [[-36.204785428645977, -16.285117464727605], [-50.409162834264045, -25.095216353145005]], [[-39.400776326287087, -33.445516576117896], [37.980139505297558, -92.882287108795424]], [[-46.373275962943225, -12.838605874855318], [84.062884747590715, 98.762981126760053]], [[85.475866506225884, -56.869083412891563], [-2.8563954657025761, -33.463794722879598]]])
10865          sub=res.substitute({arg:s})
10866          ref=numarray.array([[[0.0, 1.0], [0.0, 1.0]], [[1.0, 0.0], [0.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [0.0, 1.0]], [[1.0, 1.0], [0.0, 0.0]], [[0.0, 1.0], [1.0, 1.0]]])
10867          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10868          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
10869          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10870       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10871       def test_whereNegative_Symbol_rank4(self):
10872          arg=Symbol(shape=(3, 2, 3, 4))
10873          res=whereNegative(arg)
10874          s=numarray.array([[[[-39.14990061925532, 51.949859965073983, 55.37633633636824, -82.35728979416686], [-62.823259140676726, -60.987847514454629, -87.165694611302087, -9.4983692954954506], [-59.034970257539342, -12.349309123798236, -74.849079914303317, -41.408354712867457]], [[29.9307981548464, -81.526499155207048, 46.012868740458487, 11.900092247618034], [53.654390339989675, -56.414112602954262, 32.405102833786714, 46.210686310237207], [-72.147580142442223, -22.977139544545636, 89.142946567216995, -88.831906311919909]]], [[[-1.3198711955164697, 21.369948454299475, 59.766310276379983, -53.755025619966347], [98.576470432795276, -72.025064379707928, 58.324331062695535, 49.676210952580192], [-29.552848681947296, 13.576893933997908, -54.333930944304967, -13.498886110363202]], [[9.3704956801669397, -2.2513137797195668, -52.882998377311516, -93.606100392506164], [-88.881588707277956, 83.417801198755512, 57.914520898503298, -97.689248571026454], [-74.800685017601623, -35.991007287628051, 81.330326943014711, 22.556206038634812]]], [[[9.2780054495407569, 93.824584816474839, 51.875991914097796, -42.220631714359456], [85.338622377384127, -27.149448703310824, -73.347709655591103, -23.42518563583134], [45.940803116571885, -32.381912906643123, -95.049577516480682, 63.411283490611311]], [[-30.01425279958174, 25.196938582282158, -10.252771505748854, 52.029675553268618], [-0.53388159534763702, 77.25070415513926, 49.336454387777877, -46.275901599419569], [4.3984065300076907, 91.391927269984365, 42.161201561377652, -85.358967464268986]]]])
10875          sub=res.substitute({arg:s})
10876          ref=numarray.array([[[[1.0, 0.0, 0.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[0.0, 1.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [1.0, 1.0, 0.0, 1.0]]], [[[1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 0.0], [1.0, 0.0, 1.0, 1.0]], [[0.0, 1.0, 1.0, 1.0], [1.0, 0.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 1.0], [0.0, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 0.0]], [[1.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 1.0]]]])
10877          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
10878          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
10879          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10880       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10881       def test_whereNonNegative_float_rank0(self):
10882          arg=58.4734070432
10883          res=whereNonNegative(arg)
10884          ref=1.0
10885          self.failUnless(isinstance(res,float),"wrong type of result.")
10886          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10887       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10888       def test_whereNonNegative_array_rank0(self):
10889          arg=numarray.array(-77.2396345376)
10890          res=whereNonNegative(arg)
10891          ref=numarray.array(0.0)
10892          if not isinstance(res,float):
10893             self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10894             self.failUnlessEqual(res.shape,(),"wrong shape of result.")
10895          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10896       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10897       def test_whereNonNegative_array_rank1(self):
10898          arg=numarray.array([-96.481185201309529, 55.69393817245151])
10899          res=whereNonNegative(arg)
10900          ref=numarray.array([0.0, 1.0])
10901          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10902          self.failUnlessEqual(res.shape,(2,),"wrong shape of result.")
10903          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10904       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10905       def test_whereNonNegative_array_rank2(self):
10906          arg=numarray.array([[33.751666255076515, -97.928265537757909, 14.362676388994842, 74.281280811324933, -52.516825657717888], [-20.461289856454684, -45.157730149915643, 31.896091176433487, 4.1317379123191529, -55.246764488338762], [19.700429048464358, 16.679444563048492, -38.30023330559407, -77.041761864300582, -28.043364036650644], [5.0773359198315973, 91.9368391294513, 20.710543350370259, -28.942481048294326, -16.348545481686472]])
10907          res=whereNonNegative(arg)
10908          ref=numarray.array([[1.0, 0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 1.0, 1.0, 0.0], [1.0, 1.0, 0.0, 0.0, 0.0], [1.0, 1.0, 1.0, 0.0, 0.0]])
10909          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10910          self.failUnlessEqual(res.shape,(4, 5),"wrong shape of result.")
10911          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10912       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10913       def test_whereNonNegative_array_rank3(self):
10914          arg=numarray.array([[[19.729007031849989, 28.339725664851557], [-47.773566720641256, -21.927219410096143]], [[46.094165089019498, -0.63223312390847752], [5.1418015828473358, -3.2223067899969919]], [[-93.553953569350369, 88.717633043793484], [-78.87519362229618, 32.971725631423112]], [[-90.65660301934227, 6.6283631097893192], [90.193523289250635, -40.957164498019537]], [[83.152161885821187, -70.542346994808355], [30.571013881082479, -0.80033587662163086]], [[53.966121161234639, -32.727914208209413], [5.7429993927969889, -30.72691997703258]]])
10915          res=whereNonNegative(arg)
10916          ref=numarray.array([[[1.0, 1.0], [0.0, 0.0]], [[1.0, 0.0], [1.0, 0.0]], [[0.0, 1.0], [0.0, 1.0]], [[0.0, 1.0], [1.0, 0.0]], [[1.0, 0.0], [1.0, 0.0]], [[1.0, 0.0], [1.0, 0.0]]])
10917          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10918          self.failUnlessEqual(res.shape,(6, 2, 2),"wrong shape of result.")
10919          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10920       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10921       def test_whereNonNegative_array_rank4(self):
10922          arg=numarray.array([[[[67.819303150305586, 58.094451445762473, -56.716860642067182, -31.264742194049617], [-65.095373210856522, -76.708282393809441, 32.654968187506199, 85.420496372460292], [-6.1214503461968235, -12.93519491683017, -71.316345077104828, 50.676771270018918]], [[-90.117656138807604, -30.507925648793119, 29.786316442392916, -13.581636478986141], [-56.535310447507214, 68.422294613888425, -76.869431303022864, -92.136715817023898], [-69.545808694217229, -65.561773987757903, 80.884826568492457, -16.59346797909906]]], [[[28.446041688660898, -93.575372847332545, 51.967032569599922, 16.338681282927169], [-54.098652915975663, -64.462591681548645, 27.942122982761418, 66.929439755872039], [44.711579155976636, -20.254353511943918, 5.2271920927414754, -32.665593100317622]], [[-28.264723368846106, 51.707175859789402, -70.695873526038469, 10.846862489367922], [-78.389576448699813, -61.161653853188945, 15.927215052827066, -96.297305121328208], [-89.498120859989911, -83.699171123343334, -49.945976969918114, 52.515091562529761]]], [[[98.432201063954437, 5.3470028633255424, -87.883945686853139, -82.398714780883893], [88.61112112218737, 65.282106288691892, -90.450701516842031, 11.372598817788031], [-1.2170253549431749, -11.147053059704916, -51.10796851690624, -21.568184900408241]], [[-58.41155791852222, 63.556679823020005, -33.777540011731944, -19.968219145362582], [62.331887732495801, 96.26963346060586, -47.912958914398573, 20.836893897762778], [83.530900729436809, 36.16042965799457, -99.099072331349603, -82.111303540526407]]]])
10923          res=whereNonNegative(arg)
10924          ref=numarray.array([[[[1.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 1.0], [0.0, 0.0, 0.0, 1.0]], [[0.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0]]], [[[1.0, 0.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0]], [[0.0, 1.0, 0.0, 1.0], [0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]], [[[1.0, 1.0, 0.0, 0.0], [1.0, 1.0, 0.0, 1.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 1.0, 0.0, 0.0], [1.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0]]]])
10925          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
10926          self.failUnlessEqual(res.shape,(3, 2, 3, 4),"wrong shape of result.")
10927          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10928       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10929       def test_whereNonNegative_constData_rank0(self):
10930          arg=Data(-5.63597616175,self.functionspace)
10931          res=whereNonNegative(arg)
10932          ref=Data(0.0,self.functionspace)
10933          self.failUnless(isinstance(res,Data),"wrong type of result.")
10934          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
10935          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10936       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10937       def test_whereNonNegative_constData_rank1(self):
10938          arg=Data(numarray.array([52.597537475659237, 65.281264541702825]),self.functionspace)
10939          res=whereNonNegative(arg)
10940          ref=Data(numarray.array([1.0, 1.0]),self.functionspace)
10941          self.failUnless(isinstance(res,Data),"wrong type of result.")
10942          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
10943          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10944       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10945       def test_whereNonNegative_constData_rank2(self):
10946          arg=Data(numarray.array([[23.937746997604961, 12.178098197245674, 19.416176574130617, -13.724111061677206, 73.879619373893036], [-64.162137997220782, 40.478876735342112, -58.917478343894622, -70.727192689590737, -44.735513365105881], [-84.885212174941756, -95.547022727178614, 29.595829863194666, 86.446737656525102, -84.567583366252606], [82.021223674901137, -37.06970380424206, 29.766667765490439, 36.637380378689386, 94.715161252546096]]),self.functionspace)
10947          res=whereNonNegative(arg)
10948          ref=Data(numarray.array([[1.0, 1.0, 1.0, 0.0, 1.0], [0.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 1.0, 0.0], [1.0, 0.0, 1.0, 1.0, 1.0]]),self.functionspace)
10949          self.failUnless(isinstance(res,Data),"wrong type of result.")
10950          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
10951          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10952       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10953       def test_whereNonNegative_constData_rank3(self):
10954          arg=Data(numarray.array([[[-84.874906350810292, -44.379505192158206], [28.596504409608315, 60.352404739121454]], [[17.592457984129254, 67.664065046718292], [46.795367470916034, 36.556332282490359]], [[6.2010626169601011, -33.585920455893998], [-47.715736291142342, -42.963154840594278]], [[-45.34095850737463, -26.483708610893302], [-39.974262905912994, 19.88771053468794]], [[88.691725161686577, -75.208046572141768], [-85.689747680137458, 8.2377492978098985]], [[83.787631396620867, -49.123477152480156], [36.050783089982389, 54.394056720653481]]]),self.functionspace)
10955          res=whereNonNegative(arg)
10956          ref=Data(numarray.array([[[0.0, 0.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 1.0]], [[1.0, 0.0], [0.0, 1.0]], [[1.0, 0.0], [1.0, 1.0]]]),self.functionspace)
10957          self.failUnless(isinstance(res,Data),"wrong type of result.")
10958          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
10959          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10960       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10961       def test_whereNonNegative_constData_rank4(self):
10962          arg=Data(numarray.array([[[[-84.52613988075008, -64.947347041847252, 9.4101305201296839, 35.435694420253526], [-7.120286056474697, -6.0689912937658619, 61.501160707208356, -4.1907953448503577], [54.669009036752612, -98.597999209648663, 79.057818995264938, 34.756927524520307]], [[-70.577681199984156, -52.492379254166764, 35.141902397747174, -16.226709548482205], [36.635918130607024, 42.223918562099385, -29.109256279694733, 54.62766676733915], [15.534773817682535, 87.38605319097698, 1.625572546046854, 27.706127877563389]]], [[[-25.7664484244482, 47.928621558570313, 7.3034707294236796, 78.015951593044775], [-43.166701835432143, -38.442261925682033, 30.893468557397057, 76.670511167039166], [92.706771429777774, -55.126224012943425, 67.321551454448951, 21.740500733205522]], [[-61.907644030699458, -38.306720971672583, 0.028473852938077471, -77.315845643856392], [-66.248821618301704, -68.743432146090242, -30.342588891529431, 74.988392905265613], [67.96408525986044, -30.961390473072626, -88.014243699266714, -7.3404633115983273]]], [[[82.80863756339042, -84.617444504028242, 28.915306301329991, -73.0670924857328], [-24.942282815492604, -25.503886997001899, -47.670576507576847, 67.418759772866565], [-5.4429473873534846, -9.2842979893077171, 81.764457533224487, 72.156672638590123]], [[-90.515361748774609, 49.995483389181857, 64.396138141130649, -33.448204883697159], [63.15104838581496, 45.549340467023313, -10.674194426909494, 33.4040207366196], [-29.719350476337425, 1.7739287529206678, 46.246160005609397, 56.425625128320206]]]]),self.functionspace)
10963          res=whereNonNegative(arg)
10964          ref=Data(numarray.array([[[[0.0, 0.0, 1.0, 1.0], [0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 1.0, 1.0]], [[0.0, 0.0, 1.0, 0.0], [1.0, 1.0, 0.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[0.0, 1.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 1.0]], [[0.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0], [1.0, 0.0, 0.0, 0.0]]], [[[1.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0]], [[0.0, 1.0, 1.0, 0.0], [1.0, 1.0, 0.0, 1.0], [0.0, 1.0, 1.0, 1.0]]]]),self.functionspace)
10965          self.failUnless(isinstance(res,Data),"wrong type of result.")
10966          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
10967          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10968       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10969       def test_whereNonNegative_expandedData_rank0(self):
10970          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10971          arg=msk_arg*(56.6120440687)+(1.-msk_arg)*(96.3965404442)
10972          res=whereNonNegative(arg)
10973          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10974          ref=msk_ref*(1.0)+(1.-msk_ref)*(1.0)
10975          self.failUnless(isinstance(res,Data),"wrong type of result.")
10976          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
10977          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10978       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10979       def test_whereNonNegative_expandedData_rank1(self):
10980          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10981          arg=msk_arg*numarray.array([25.636357534486805, 67.685837005139604])+(1.-msk_arg)*numarray.array([-24.15576704470746, -84.048449027253042])
10982          res=whereNonNegative(arg)
10983          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10984          ref=msk_ref*numarray.array([1.0, 1.0])+(1.-msk_ref)*numarray.array([0.0, 0.0])
10985          self.failUnless(isinstance(res,Data),"wrong type of result.")
10986          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
10987          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10988       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10989       def test_whereNonNegative_expandedData_rank2(self):
10990          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
10991          arg=msk_arg*numarray.array([[-78.072975305635964, -30.667161396580141, 61.34202507179748, -11.419584402032768, 39.71596012189525], [-25.684737576238177, 53.340398852687258, -3.7920141589733873, -35.952675355382183, -72.00887455038], [-66.687289808523516, -55.038138946819949, 87.076259533901833, -62.254642616503332, -29.28679422910929], [-72.59303136759938, 93.821103037696304, -1.9135138142220853, 29.766163398776797, 39.407165859633977]])+(1.-msk_arg)*numarray.array([[83.571115792006481, 21.888287744499536, -29.168589548635609, 34.101960445545103, 25.366974991818296], [37.116659623741299, -20.551392540396819, 9.4877933474515999, -61.562905177089135, 92.89134307705973], [-52.907637411387178, 55.499587467889029, 48.295777148962998, -48.29039188616369, -41.329781691943211], [-89.407168408621132, 48.502208126113885, 40.222625009294035, -62.616466083297404, -70.677377752043967]])
10992          res=whereNonNegative(arg)
10993          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
10994          ref=msk_ref*numarray.array([[0.0, 0.0, 1.0, 0.0, 1.0], [0.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0, 0.0], [0.0, 1.0, 0.0, 1.0, 1.0]])+(1.-msk_ref)*numarray.array([[1.0, 1.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0, 1.0], [0.0, 1.0, 1.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0, 0.0]])
10995          self.failUnless(isinstance(res,Data),"wrong type of result.")
10996          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
10997          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
10998       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
10999       def test_whereNonNegative_expandedData_rank3(self):
11000          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11001          arg=msk_arg*numarray.array([[[40.268335457118411, -86.265565082439849], [-77.060652900660841, -35.613541831532686]], [[-11.130159180791651, -50.801802035975065], [77.616966406185526, -70.955846219724322]], [[-59.237474200638005, 30.293686762130278], [8.9399890546122833, 18.022819538905438]], [[-16.735446376444173, 81.491526325502974], [-59.435886845211414, -23.576205091650152]], [[-19.93446385501656, 28.158357589195418], [-81.904756903369673, 37.850741195421818]], [[-23.170136003419174, -88.117336264200148], [-39.721430862707805, -37.158697868374823]]])+(1.-msk_arg)*numarray.array([[[-89.484033408544164, 3.6290659328079471], [55.5035691803443, 35.04365064842699]], [[-39.575786434207672, 24.075061751850129], [-51.028410946050862, -72.168381468693894]], [[8.7978652953924126, 33.743730472745966], [48.813391295251847, 57.556748922574599]], [[-50.67819357472851, 98.297612205036046], [65.754745719803822, 94.701073496612821]], [[-7.8627589244033089, -77.587700068588745], [-78.102433124642317, 80.568138398059347]], [[20.626187739191067, 72.868306997375896], [-92.253636917468327, -92.26606957875822]]])
11002          res=whereNonNegative(arg)
11003          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11004          ref=msk_ref*numarray.array([[[1.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [1.0, 0.0]], [[0.0, 1.0], [1.0, 1.0]], [[0.0, 1.0], [0.0, 0.0]], [[0.0, 1.0], [0.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]]])+(1.-msk_ref)*numarray.array([[[0.0, 1.0], [1.0, 1.0]], [[0.0, 1.0], [0.0, 0.0]], [[1.0, 1.0], [1.0, 1.0]], [[0.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 1.0]], [[1.0, 1.0], [0.0, 0.0]]])
11005          self.failUnless(isinstance(res,Data),"wrong type of result.")
11006          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11007          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11008       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11009       def test_whereNonNegative_expandedData_rank4(self):
11010          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11011          arg=msk_arg*numarray.array([[[[50.118052228953417, -88.730765495976627, -84.378037931711788, -23.415595349324121], [-67.440289645809926, 93.404419793514279, -59.787425377620963, -32.374614750659873], [72.996508166755063, 28.673559835094807, -41.279856362022961, -98.826373041981256]], [[34.161465745827087, 60.408826978493238, -55.569419121217997, 98.526543458136359], [89.581255428071103, -7.9093712080281477, 19.046497284788245, 46.656250120588084], [-89.213555622028167, -60.048706949978836, -96.023118800400738, -38.560321211470217]]], [[[30.610073607783136, -83.484858651904204, -17.939350518275972, -19.569367705996626], [-74.45115543876399, 6.2068488889173636, -6.9764471417878156, -9.6106071030669113], [-34.169979148291318, 39.422153163908035, -82.520572748630272, -97.826881500667696]], [[-43.805063575145113, 52.820087341249064, -11.425891732077531, 91.225666306308483], [-65.7372703434865, -62.123010875670246, -34.999218025158257, 82.649036492923187], [26.621421005843573, -24.208721371623469, 36.104693970302208, -26.311040499741821]]], [[[-73.614891770734744, -85.837005758293458, -53.722074500413754, 80.21071183957946], [46.723144872292266, -6.4559074348415066, 76.314206389016562, 49.12876304442392], [-24.203320133532188, 92.593031809694111, 95.529348278263171, 79.699349442454661]], [[47.068575118893051, 38.079994995473555, 49.966665821438681, 26.424916515149306], [-87.637253126554185, -12.958087998221799, -84.146782819641402, -1.3189534835551484], [-78.523734070290715, 46.584675916144505, 12.785152169211571, -39.544671827810497]]]])+(1.-msk_arg)*numarray.array([[[[-44.483784104558957, -28.006494802891964, 92.253214471020186, -15.814708339708289], [-34.727972062008462, 18.489845474296487, -8.684561294250372, -39.459862391993617], [3.2532135157034503, 97.032451670690847, -5.0819510089139328, 78.319214911261668]], [[-98.398026812312395, 59.505846535267978, 10.784341452949846, -14.250704963278665], [16.595393811048226, 4.8049629604389565, -76.61905163551242, -96.404190597114223], [11.885589053645433, -73.332964281192645, 53.445417740070354, 93.807480385985798]]], [[[66.632634303970747, 28.645399611787298, -83.987062053435622, -62.89109800936339], [-24.23393761880088, 48.42862684926024, 40.07211030469216, -81.012080582820943], [50.754863806056903, -68.507318003236549, -25.055399867857432, 62.59244861144785]], [[-11.047268692459596, -90.177853490375483, -11.20089156470867, 35.53859445005051], [59.047803703205204, 23.854271835098714, -89.220352115110501, -54.108930266124823], [-70.781715085187784, 30.727426768606961, 19.981466099151106, -26.098236640973766]]], [[[71.538263486211775, -85.096322580377006, 79.221899163626887, -59.858169598469793], [47.338661263600414, 93.057272248217714, 75.394754283706391, 58.169107710198773], [73.772225431452796, -59.557034519677707, -26.119548712323578, 31.027715412640816]], [[61.119765212242982, 42.526393080611683, 69.940051844556393, -54.370980511290881], [-75.41802697240314, -87.096596680306959, 90.532406636535342, -46.482642233552987], [-46.532222608169491, 73.733664853166999, -93.120651954554361, 42.436012745957726]]]])
11012          res=whereNonNegative(arg)
11013          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11014          ref=msk_ref*numarray.array([[[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [1.0, 1.0, 0.0, 0.0]], [[1.0, 1.0, 0.0, 1.0], [1.0, 0.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]]], [[[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]], [[0.0, 1.0, 0.0, 1.0], [0.0, 0.0, 0.0, 1.0], [1.0, 0.0, 1.0, 0.0]]], [[[0.0, 0.0, 0.0, 1.0], [1.0, 0.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0]]]])+(1.-msk_ref)*numarray.array([[[[0.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 0.0], [1.0, 1.0, 0.0, 1.0]], [[0.0, 1.0, 1.0, 0.0], [1.0, 1.0, 0.0, 0.0], [1.0, 0.0, 1.0, 1.0]]], [[[1.0, 1.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [1.0, 0.0, 0.0, 1.0]], [[0.0, 0.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0]]], [[[1.0, 0.0, 1.0, 0.0], [1.0, 1.0, 1.0, 1.0], [1.0, 0.0, 0.0, 1.0]], [[1.0, 1.0, 1.0, 0.0], [0.0, 0.0, 1.0, 0.0], [0.0, 1.0, 0.0, 1.0]]]])
11015          self.failUnless(isinstance(res,Data),"wrong type of result.")
11016          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11017          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11018       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11019       def test_whereNonNegative_Symbol_rank0(self):
11020          arg=Symbol(shape=())
11021          res=whereNonNegative(arg)
11022          s=numarray.array(-58.8398548815)
11023          sub=res.substitute({arg:s})
11024          ref=numarray.array(0.0)
11025          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11026          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11027          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11028       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11029       def test_whereNonNegative_Symbol_rank1(self):
11030          arg=Symbol(shape=(2,))
11031          res=whereNonNegative(arg)
11032          s=numarray.array([-82.978162754997925, 8.8047326469017122])
11033          sub=res.substitute({arg:s})
11034          ref=numarray.array([0.0, 1.0])
11035          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11036          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11037          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11038       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11039       def test_whereNonNegative_Symbol_rank2(self):
11040          arg=Symbol(shape=(4, 5))
11041          res=whereNonNegative(arg)
11042          s=numarray.array([[-57.114751898774863, 15.310009304133203, 43.273189593545482, 77.426458486062614, 98.035318487754211], [-76.31417820596009, 96.405957727411931, -36.79040107424283, 69.588907574896353, -90.819051620846139], [-21.384010858090917, -49.316099962453343, -55.596563560663206, -56.091061695460368, -54.243683421440721], [-3.1770490856211921, -77.802197055188955, -91.262528798034097, 16.294977226431428, -61.953476904394321]])
11043          sub=res.substitute({arg:s})
11044          ref=numarray.array([[0.0, 1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0, 0.0]])
11045          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11046          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11047          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11048       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11049       def test_whereNonNegative_Symbol_rank3(self):
11050          arg=Symbol(shape=(6, 2, 2))
11051          res=whereNonNegative(arg)
11052          s=numarray.array([[[-52.302419178666696, -36.011072121710995], [70.344129482626641, -94.887462805836108]], [[39.457090101441935, 62.182034936241706], [33.071419719406265, 19.65467224682935]], [[96.444658364252234, 41.810028968759298], [17.391731498730124, -61.25543188161371]], [[-63.301909068860418, -81.883202505287912], [-9.9686422778212318, -46.09994160257731]], [[0.79602140898114726, 50.995175121403491], [39.42271713433064, -42.96711417231338]], [[80.077410450464015, -98.147299040950202], [64.444746581110735, 51.710239923438252]]])
11053          sub=res.substitute({arg:s})
11054          ref=numarray.array([[[0.0, 0.0], [1.0, 0.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[1.0, 1.0], [1.0, 0.0]], [[1.0, 0.0], [1.0, 1.0]]])
11055          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11056          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11057          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11058       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11059       def test_whereNonNegative_Symbol_rank4(self):
11060          arg=Symbol(shape=(3, 2, 3, 4))
11061          res=whereNonNegative(arg)
11062          s=numarray.array([[[[-2.5976588468490576, 40.976618480274965, 70.916330592715354, -49.191553192076313], [-45.926997545504577, 24.639940210475771, 97.36697304102708, 17.590694675821311], [7.7336847115890208, 85.237419267281496, -44.228298807540178, 78.087061579851849]], [[-12.198656257367603, 47.317574884270329, -62.408862701830678, -80.308596525604585], [80.773698810403005, -9.4412453002422581, 23.683937597676618, 85.85784825956523], [59.265035657131932, -69.325519327240812, 8.7058140434875781, -2.6024028142058313]]], [[[86.063542738983188, -51.362725843818154, 34.405542453001004, -41.972672290063898], [55.999438377020596, 34.884322235694952, 43.380175207740791, 72.776691509642774], [34.801699371894642, -29.764898058856332, -21.123661199537452, 70.371152717243234]], [[3.6278240748509347, 70.0196680461124, 13.553508050734834, 63.606237837653055], [-96.718689436297979, 4.8092184150583961, 77.949143466573901, 4.2865181135117325], [86.218370330935954, 2.1563115590517583, 79.16881170243272, 30.950434657002916]]], [[[-21.513843712936279, 58.255206877882586, 72.514067267547603, -55.492241103847896], [50.528843425732504, 32.768659523585143, -96.564483321783712, 8.5964884268373822], [-64.457464623327951, 28.321553816132479, -80.813838907921777, -47.985766337452375]], [[72.299179846553841, 23.493342362064666, -62.700406034359645, 98.803246182773449], [58.424956553971555, 44.217263909841364, -90.54565580877221, -17.345594535777977], [-75.243832297268185, -78.534529191352576, -4.4135475705371761, -10.331784394585156]]]])
11063          sub=res.substitute({arg:s})
11064          ref=numarray.array([[[[0.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 1.0], [1.0, 1.0, 0.0, 1.0]], [[0.0, 1.0, 0.0, 0.0], [1.0, 0.0, 1.0, 1.0], [1.0, 0.0, 1.0, 0.0]]], [[[1.0, 0.0, 1.0, 0.0], [1.0, 1.0, 1.0, 1.0], [1.0, 0.0, 0.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[0.0, 1.0, 1.0, 0.0], [1.0, 1.0, 0.0, 1.0], [0.0, 1.0, 0.0, 0.0]], [[1.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]]])
11065          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11066          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11067          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11068       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11069       def test_whereNonPositive_float_rank0(self):
11070          arg=-45.8140100626
11071          res=whereNonPositive(arg)
11072          ref=1.0
11073          self.failUnless(isinstance(res,float),"wrong type of result.")
11074          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11075       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11076       def test_whereNonPositive_array_rank0(self):
11077          arg=numarray.array(-63.8959249588)
11078          res=whereNonPositive(arg)
11079          ref=numarray.array(1.0)
11080          if not isinstance(res,float):
11081             self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11082             self.failUnlessEqual(res.shape,(),"wrong shape of result.")
11083          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11084       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11085       def test_whereNonPositive_array_rank1(self):
11086          arg=numarray.array([54.415838481100479, -35.5624835416114])
11087          res=whereNonPositive(arg)
11088          ref=numarray.array([0.0, 1.0])
11089          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11090          self.failUnlessEqual(res.shape,(2,),"wrong shape of result.")
11091          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11092       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11093       def test_whereNonPositive_array_rank2(self):
11094          arg=numarray.array([[-19.977776356765318, 5.9786051244587952, -56.499280299922752, -34.772432329184056, -42.376287015366223], [-84.487175491423102, -47.807388262784926, -2.1549567968020398, 65.070219308351994, -81.156967947597551], [39.362869981047908, 82.897480274445286, -25.251661283915567, -14.554050325024775, 99.441792996707022], [-87.49041530809086, -32.750499747633071, 40.491174827110797, 68.288080492730728, 21.562840881641691]])
11095          res=whereNonPositive(arg)
11096          ref=numarray.array([[1.0, 0.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0, 0.0], [1.0, 1.0, 0.0, 0.0, 0.0]])
11097          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11098          self.failUnlessEqual(res.shape,(4, 5),"wrong shape of result.")
11099          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11100       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11101       def test_whereNonPositive_array_rank3(self):
11102          arg=numarray.array([[[-80.816933807988647, 18.410516218736745], [-84.025394562335066, 73.817364376601347]], [[61.338668393303806, -19.309105906918774], [60.531656152601499, -62.629597501263888]], [[98.405881825725487, -87.157404259910081], [-77.87716088817686, 54.080880261791691]], [[44.017293267806849, 81.605183414497702], [25.005545230944733, 43.880992994339664]], [[-9.0200660048142396, -52.950279136546015], [33.391394798474323, 77.366312324785582]], [[-12.930426357736494, 26.724479555287701], [76.853844695874045, -73.905941842749797]]])
11103          res=whereNonPositive(arg)
11104          ref=numarray.array([[[1.0, 0.0], [1.0, 0.0]], [[0.0, 1.0], [0.0, 1.0]], [[0.0, 1.0], [1.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[1.0, 1.0], [0.0, 0.0]], [[1.0, 0.0], [0.0, 1.0]]])
11105          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11106          self.failUnlessEqual(res.shape,(6, 2, 2),"wrong shape of result.")
11107          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11108       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11109       def test_whereNonPositive_array_rank4(self):
11110          arg=numarray.array([[[[84.854900822533551, -70.314859921760501, 91.167657851483199, 58.634317483028553], [-45.674981783852253, -91.344582047164224, -45.296293433418299, -11.820391409783412], [7.5520922261311085, 33.939791936902679, -30.78101779452625, 92.217815104797097]], [[16.487093948363324, 46.549440093303588, -35.737509999956288, -79.69614030357792], [28.449486617318911, -62.884436564134603, 40.844828284827628, 10.366425813044785], [79.665416005370531, 39.56742434170576, -27.721667918864227, -81.954150375477553]]], [[[47.951911230948269, -25.788610534552575, -16.885257596759516, 82.068516597608067], [-0.51652980482228372, -66.573004416820339, -72.185890143047729, -63.647624985740258], [93.906834018256092, -58.422363414411606, -39.708973666342608, -7.1654247643074314]], [[-82.284191996980809, 63.235007339504534, -78.292387412733092, -52.126182522828877], [16.684565256071693, 57.832220397954075, -38.766429611788354, -62.311953863196749], [-60.30897110518432, -42.386777033904146, -60.890434946023241, 78.663607764550704]]], [[[-47.287040896177388, -20.906728008055325, 48.334998443867818, 18.78306004141406], [-74.950637186434733, 84.51043393945514, 14.145744299214428, 76.234540063777558], [18.666731132635476, 83.354101505920454, 48.433353335770846, -50.240885823292778]], [[-72.060114740388656, -55.762235089994427, -35.520941042497213, 49.448425790974369], [-0.16498976632010454, 3.6711888832083588, 0.44840601553353565, -4.6970780448722991], [-94.786520432934168, 18.525824825003696, 61.101943285402172, -87.622236927860868]]]])
11111          res=whereNonPositive(arg)
11112          ref=numarray.array([[[[0.0, 1.0, 0.0, 0.0], [1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 1.0, 0.0]], [[0.0, 0.0, 1.0, 1.0], [0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 1.0]]], [[[0.0, 1.0, 1.0, 0.0], [1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0]], [[1.0, 0.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0], [1.0, 1.0, 1.0, 0.0]]], [[[1.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]], [[1.0, 1.0, 1.0, 0.0], [1.0, 0.0, 0.0, 1.0], [1.0, 0.0, 0.0, 1.0]]]])
11113          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11114          self.failUnlessEqual(res.shape,(3, 2, 3, 4),"wrong shape of result.")
11115          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11116       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11117       def test_whereNonPositive_constData_rank0(self):
11118          arg=Data(76.8341760885,self.functionspace)
11119          res=whereNonPositive(arg)
11120          ref=Data(0.0,self.functionspace)
11121          self.failUnless(isinstance(res,Data),"wrong type of result.")
11122          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11123          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11124       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11125       def test_whereNonPositive_constData_rank1(self):
11126          arg=Data(numarray.array([5.110430775637127, -8.5929188047610552]),self.functionspace)
11127          res=whereNonPositive(arg)
11128          ref=Data(numarray.array([0.0, 1.0]),self.functionspace)
11129          self.failUnless(isinstance(res,Data),"wrong type of result.")
11130          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11131          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11132       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11133       def test_whereNonPositive_constData_rank2(self):
11134          arg=Data(numarray.array([[73.186196525129645, 63.106873510282924, -37.93591985539193, -4.9728512739999076, 19.376979391439363], [4.5452345913447658, 46.103234583667671, 18.062219251009836, 99.310495136151133, 51.526446572677145], [-94.648587297912812, -79.599690191233478, 95.310895065698446, -91.742395450846828, -95.503130322854204], [54.132238583769265, -6.2958941894595881, 80.387872082718758, -56.594075571445003, -0.087162886623445957]]),self.functionspace)
11135          res=whereNonPositive(arg)
11136          ref=Data(numarray.array([[0.0, 0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [1.0, 1.0, 0.0, 1.0, 1.0], [0.0, 1.0, 0.0, 1.0, 1.0]]),self.functionspace)
11137          self.failUnless(isinstance(res,Data),"wrong type of result.")
11138          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11139          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11140       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11141       def test_whereNonPositive_constData_rank3(self):
11142          arg=Data(numarray.array([[[35.640522044117716, 35.479584214315452], [-83.66008428402651, -12.353315661361748]], [[-46.695985576916875, 56.815876089929901], [14.328557434943392, 54.490435657692615]], [[38.157071729732564, -63.060450376793042], [-56.69840568574287, 45.584077281388033]], [[96.777622099398059, -5.1796500781218384], [89.674102699704235, 41.472615569686411]], [[59.694746638725746, -37.205367017231382], [-29.955192328084593, 55.672175132947785]], [[35.375171131639576, -93.866403218358215], [23.27567992190464, -49.139452886576862]]]),self.functionspace)
11143          res=whereNonPositive(arg)
11144          ref=Data(numarray.array([[[0.0, 0.0], [1.0, 1.0]], [[1.0, 0.0], [0.0, 0.0]], [[0.0, 1.0], [1.0, 0.0]], [[0.0, 1.0], [0.0, 0.0]], [[0.0, 1.0], [1.0, 0.0]], [[0.0, 1.0], [0.0, 1.0]]]),self.functionspace)
11145          self.failUnless(isinstance(res,Data),"wrong type of result.")
11146          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11147          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11148       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11149       def test_whereNonPositive_constData_rank4(self):
11150          arg=Data(numarray.array([[[[78.120351293960368, 45.517827635106755, 13.754081165958112, 53.648332704104661], [-95.730532610383534, 64.863790698266143, -56.063132630021649, 66.592428370803646], [63.399839434838213, -73.022434587860104, -67.904116954138885, -50.280183675978037]], [[-29.930362494006559, 32.052615321911333, 72.250187735124626, 33.654605438190998], [-65.127089193367851, -32.722417502163452, 38.596924965290668, -81.264280989691599], [-26.325082622716451, 92.723726612008733, -6.9104901305947948, -56.732407303629607]]], [[[81.299873121289409, -0.60752785487785843, 81.02975074643345, 5.6594823714348053], [17.236459205051176, 2.9463513679599771, 96.07565713416264, -70.792732773851498], [87.611958793760635, 99.359964258540117, 10.130252954092242, -67.297975693155252]], [[-71.553505655481999, -90.989697336378043, -57.310147425889625, -4.7051290563562276], [45.896460083362314, 79.487272101784242, 33.393465498093576, 90.509868144157366], [-68.059017250831175, 98.172331068427752, 76.21324396944388, -18.114975003809363]]], [[[30.18165573581669, -95.406985301029422, -41.697668617320851, -88.452149593062245], [-26.45265307152971, 7.5605523928963692, 87.21992505390017, -83.416286385195633], [-25.719143977748814, 57.849131833666064, 16.280200193493343, -48.38523212914918]], [[22.977807767062089, -16.18840952303114, 99.764245118344576, -31.703462585340404], [-11.504718586929556, -24.746181326375378, 30.058139117771191, 93.910717466047032], [-79.520098835545866, 30.192855384126148, 99.121945637672439, -59.524886303278301]]]]),self.functionspace)
11151          res=whereNonPositive(arg)
11152          ref=Data(numarray.array([[[[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 1.0, 0.0], [0.0, 1.0, 1.0, 1.0]], [[1.0, 0.0, 0.0, 0.0], [1.0, 1.0, 0.0, 1.0], [1.0, 0.0, 1.0, 1.0]]], [[[0.0, 1.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0]]], [[[0.0, 1.0, 1.0, 1.0], [1.0, 0.0, 0.0, 1.0], [1.0, 0.0, 0.0, 1.0]], [[0.0, 1.0, 0.0, 1.0], [1.0, 1.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0]]]]),self.functionspace)
11153          self.failUnless(isinstance(res,Data),"wrong type of result.")
11154          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11155          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11156       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11157       def test_whereNonPositive_expandedData_rank0(self):
11158          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11159          arg=msk_arg*(-21.294938937)+(1.-msk_arg)*(-72.0328127018)
11160          res=whereNonPositive(arg)
11161          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11162          ref=msk_ref*(1.0)+(1.-msk_ref)*(1.0)
11163          self.failUnless(isinstance(res,Data),"wrong type of result.")
11164          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11165          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11166       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11167       def test_whereNonPositive_expandedData_rank1(self):
11168          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11169          arg=msk_arg*numarray.array([14.001065620474165, 51.060850237675112])+(1.-msk_arg)*numarray.array([-6.4845892236093334, 73.407748235087723])
11170          res=whereNonPositive(arg)
11171          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11172          ref=msk_ref*numarray.array([0.0, 0.0])+(1.-msk_ref)*numarray.array([1.0, 0.0])
11173          self.failUnless(isinstance(res,Data),"wrong type of result.")
11174          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11175          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11176       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11177       def test_whereNonPositive_expandedData_rank2(self):
11178          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11179          arg=msk_arg*numarray.array([[-64.52120230042874, -31.827528475750682, 10.004997743630327, 91.575189079620088, 50.375139386687209], [41.720379535781916, 63.159827023202382, 49.57432401463214, 9.3070620932102202, 60.232643522299185], [25.240200875891901, -96.938260964323163, 62.0452615917537, -42.644345796361179, -82.263178482606222], [-75.954278388926681, 14.813887736649605, 8.7669517953596028, -76.802613030476522, 4.3723418171869923]])+(1.-msk_arg)*numarray.array([[3.6464123199156973, -30.094451732015187, -38.084149034576512, 16.553157123976646, 49.784666124112704], [-66.53566180083385, -1.0279761734758068, 36.193921499854014, 27.465955037373504, 8.41610652840032], [45.914465105438126, 47.11191355094499, -78.536609881550731, -28.478652266113855, -36.443325125458003], [86.47075792022045, -8.4827911972243299, 36.645811902720908, 45.3318814313877, -93.9890221530123]])
11180          res=whereNonPositive(arg)
11181          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11182          ref=msk_ref*numarray.array([[1.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 1.0, 1.0], [1.0, 0.0, 0.0, 1.0, 0.0]])+(1.-msk_ref)*numarray.array([[0.0, 1.0, 1.0, 0.0, 0.0], [1.0, 1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 1.0, 1.0, 1.0], [0.0, 1.0, 0.0, 0.0, 1.0]])
11183          self.failUnless(isinstance(res,Data),"wrong type of result.")
11184          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11185          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11186       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11187       def test_whereNonPositive_expandedData_rank3(self):
11188          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11189          arg=msk_arg*numarray.array([[[3.4932152236425225, -36.146311025025412], [-79.511782256523205, 43.209384016358598]], [[-12.911756606412169, 84.296575347249728], [-18.796706505874795, -65.624653714469986]], [[20.077128133134423, 82.197624733378518], [-10.896782554696998, 8.3500680112954484]], [[-55.918585807034724, -71.322632870917687], [-79.500335685116255, -66.109585462512442]], [[5.3425876719804819, 59.506331837634548], [4.3592655512523493, -44.497382825601115]], [[-8.9240915992721028, 56.420248561123145], [10.275532725278708, -14.724999384740372]]])+(1.-msk_arg)*numarray.array([[[-50.654219085401195, -20.564018798701042], [-6.8157495083358981, -8.7152789021806001]], [[67.612800754357124, 20.241913145493101], [68.465229152050711, 32.266053812298566]], [[-0.88016538230590413, 41.688901064752685], [27.230966724318776, 32.520603018797004]], [[26.061980470503499, -54.87980460183941], [7.6346427424732042, 20.663565250317689]], [[-96.61073536198441, -73.190601459898843], [-61.479505152207395, -99.707856346427221]], [[-9.3807883210439371, -9.3488757322235188], [-6.7769146729327758, -73.95899955952676]]])
11190          res=whereNonPositive(arg)
11191          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11192          ref=msk_ref*numarray.array([[[0.0, 1.0], [1.0, 0.0]], [[1.0, 0.0], [1.0, 1.0]], [[0.0, 0.0], [1.0, 0.0]], [[1.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 1.0]], [[1.0, 0.0], [0.0, 1.0]]])+(1.-msk_ref)*numarray.array([[[1.0, 1.0], [1.0, 1.0]], [[0.0, 0.0], [0.0, 0.0]], [[1.0, 0.0], [0.0, 0.0]], [[0.0, 1.0], [0.0, 0.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]])
11193          self.failUnless(isinstance(res,Data),"wrong type of result.")
11194          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11195          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11196       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11197       def test_whereNonPositive_expandedData_rank4(self):
11198          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11199          arg=msk_arg*numarray.array([[[[-58.89835447211469, -6.0893328346566733, -1.0023693518593575, -61.539230319459627], [60.870457135837682, -83.305095813845867, -38.116740546736374, -64.075745680293039], [79.081243725668998, -3.1565899739248522, -69.359266580736985, -25.939574951041493]], [[44.840056891487734, 9.4190204246416016, 33.086497185256661, 45.011451755319172], [94.214589826739939, -5.702363967501924, -19.973298938018431, 76.184762328377644], [7.5290921100338721, 48.192190457350875, 80.630439347990887, -10.677496472704931]]], [[[11.221137534077187, 7.1347297082242846, 25.87988065153138, -3.7157692974099064], [-76.043759143725808, 69.02633203511769, -98.860304021235777, 53.531068740423734], [-34.89611427266945, 27.156902812036535, 72.743609137679357, 95.314597465726479]], [[78.038851407351615, 56.72377621086261, -20.725276919441342, -58.75384173399285], [-26.213835341147828, -86.937961787952219, -45.889334819778796, 31.050065322925832], [75.255475636162998, -54.929307087299996, -42.283656056524642, 68.6586886677525]]], [[[-28.16883583872432, -40.372922117108565, -30.135564687244994, 50.246251468410065], [-7.2498686947860165, 94.45851868271248, -53.581025727792642, -32.424001887898868], [85.576621269199592, 58.609425585253945, 78.085399899893304, 98.996509927055513]], [[-75.317618268425264, 11.26227410259915, -51.177413277829785, -34.929151547420361], [4.3965337305110097, 90.923268663940149, -89.483861691460845, -5.4115854061605972], [-49.940568614308049, -28.969569648394568, -95.982720688496244, 87.745557466302273]]]])+(1.-msk_arg)*numarray.array([[[[-74.771460648328443, 13.793031178508002, -41.976214738752859, -25.36331645721701], [24.01507156186311, 60.776951586528895, 8.3096968814290619, -60.613551059743067], [1.4391448885635327, -92.057454358544248, 13.907184752443811, -52.254719033883632]], [[-46.910170661904637, -33.334225663168681, -9.3791104242402952, -15.404344393378281], [69.025944878882456, -51.909070828632785, 31.053379001160948, 62.760215014236422], [-74.91014748820912, 22.358213500298248, -91.88145013095253, 35.630042926552306]]], [[[-29.279785927448572, -98.509512781683981, -3.2141945191207668, -7.8787884397738992], [61.929082763373486, -13.285831454240963, -22.609607789839885, -95.781398772215994], [11.65303310062788, -55.087961160687016, -7.340663618342063, -51.681435909557429]], [[10.223206694434708, 52.870731191118949, 94.343773117331011, 54.502331701573127], [-74.304124617034418, 37.5127280034894, 87.414312181666446, 5.5216671015867007], [-48.162344739211704, 40.109818025385323, 88.765369352144177, -3.2256322380404612]]], [[[-21.040797096187333, 38.819012415945906, -40.815118132374636, 57.1068994645087], [44.584730270097026, 63.853583439836456, 64.648203529995698, 19.794733417566988], [90.528792123051915, -65.456358000132781, 10.691310766549861, 90.084242627365683]], [[-64.643286624216984, 36.640703954145948, 82.940348145540838, -74.20215167286193], [80.641128632128385, 7.801376809332325, 8.1922136533463004, 85.312711221718672], [60.727877225987015, -96.319606263671147, 42.598308142226301, 27.966063247606769]]]])
11200          res=whereNonPositive(arg)
11201          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11202          ref=msk_ref*numarray.array([[[[1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 1.0, 0.0], [0.0, 0.0, 0.0, 1.0]]], [[[0.0, 0.0, 0.0, 1.0], [1.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 1.0, 1.0], [1.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 0.0]]], [[[1.0, 1.0, 1.0, 0.0], [1.0, 0.0, 1.0, 1.0], [0.0, 0.0, 0.0, 0.0]], [[1.0, 0.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0], [1.0, 1.0, 1.0, 0.0]]]])+(1.-msk_ref)*numarray.array([[[[1.0, 0.0, 1.0, 1.0], [0.0, 0.0, 0.0, 1.0], [0.0, 1.0, 0.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 0.0, 0.0], [1.0, 0.0, 1.0, 0.0]]], [[[1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0]], [[0.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 0.0], [1.0, 0.0, 0.0, 1.0]]], [[[1.0, 0.0, 1.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]], [[1.0, 0.0, 0.0, 1.0], [0.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]]]])
11203          self.failUnless(isinstance(res,Data),"wrong type of result.")
11204          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11205          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11206       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11207       def test_whereNonPositive_Symbol_rank0(self):
11208          arg=Symbol(shape=())
11209          res=whereNonPositive(arg)
11210          s=numarray.array(77.8916591537)
11211          sub=res.substitute({arg:s})
11212          ref=numarray.array(0.0)
11213          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11214          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11215          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11216       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11217       def test_whereNonPositive_Symbol_rank1(self):
11218          arg=Symbol(shape=(2,))
11219          res=whereNonPositive(arg)
11220          s=numarray.array([-33.289158126131952, -1.5128195409398302])
11221          sub=res.substitute({arg:s})
11222          ref=numarray.array([1.0, 1.0])
11223          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11224          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11225          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11226       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11227       def test_whereNonPositive_Symbol_rank2(self):
11228          arg=Symbol(shape=(4, 5))
11229          res=whereNonPositive(arg)
11230          s=numarray.array([[-89.675580644561265, 22.559086207037524, -61.828686826382075, 27.1544684361686, 45.542621022409065], [85.192461460403905, -53.369255198350189, -14.522490839063138, -52.745550126279504, 86.892055736152827], [59.381482694454775, -2.2128498063082986, -18.474083777512277, -32.66119377883534, -4.6884479061867381], [7.5046013827574569, -64.478468078572845, -62.300090670346989, -43.459905594571559, -37.619402963077995]])
11231          sub=res.substitute({arg:s})
11232          ref=numarray.array([[1.0, 0.0, 1.0, 0.0, 0.0], [0.0, 1.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0, 1.0]])
11233          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11234          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11235          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11236       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11237       def test_whereNonPositive_Symbol_rank3(self):
11238          arg=Symbol(shape=(6, 2, 2))
11239          res=whereNonPositive(arg)
11240          s=numarray.array([[[-95.918264910372713, 6.3129536060116038], [-76.185186646280044, 44.955820732431221]], [[-32.087973595564208, -0.31281142062647405], [98.251703861862637, 23.468120114051857]], [[-17.876631318058784, -80.339284229220681], [66.433104146541297, -2.5691119117624766]], [[-92.336473044409061, -66.47349632093993], [6.9081826899842298, -92.412591379337769]], [[69.747227993397672, -68.361187717592585], [28.906283769426977, -3.0855057313569034]], [[0.16094458858653127, -37.744731595476111], [29.326676077792968, -67.220325889081693]]])
11241          sub=res.substitute({arg:s})
11242          ref=numarray.array([[[1.0, 0.0], [1.0, 0.0]], [[1.0, 1.0], [0.0, 0.0]], [[1.0, 1.0], [0.0, 1.0]], [[1.0, 1.0], [0.0, 1.0]], [[0.0, 1.0], [0.0, 1.0]], [[0.0, 1.0], [0.0, 1.0]]])
11243          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11244          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11245          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11246       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11247       def test_whereNonPositive_Symbol_rank4(self):
11248          arg=Symbol(shape=(3, 2, 3, 4))
11249          res=whereNonPositive(arg)
11250          s=numarray.array([[[[55.498714331062388, 54.252976216091497, -98.652221242885446, -23.046325158660252], [66.57207224733591, -81.489676342610181, -32.086709889394712, -53.285321024541574], [5.2473282469308771, 13.640749356133469, -12.21713455758298, -1.1074900781016055]], [[83.821686808343998, 99.553411628762717, -33.166274509524158, -53.92140858957346], [5.6843137169410483, 91.822981464459502, -59.926027075594135, 98.170404451167997], [-19.520109690127313, -16.751066330247028, -19.60635328442504, -73.443643477418306]]], [[[-88.557271430733664, 69.650033834683228, 55.310025898430098, -1.3968640891514497], [85.622930077343767, -28.885517945359183, -38.007545637866905, 48.884082461569591], [32.287613684538513, -67.874193842556593, -46.816154148980679, 15.033159367432276]], [[15.626339801085123, -36.615019684003272, -3.5738338209469305, -82.126638691597861], [75.620428324563647, 14.684051809096403, 32.959487070219126, -47.924394139408747], [86.232984866683438, 94.002057931789693, -5.031840183352827, -99.515668678010044]]], [[[38.57106713689825, 71.66686186356219, -72.000417104598526, -63.413495181487974], [69.578042969052859, 24.326236647615815, -61.668240010633532, -56.60420332916172], [-96.104048028550366, -63.518533753250914, -81.310814350545613, 85.074793962081429]], [[-71.475740787666183, -47.442708107298046, 76.896488259930521, 7.503896955381876], [1.72079358206976, 80.217658032495223, -76.894583651034452, 84.60341852944893], [-14.477740266380309, 9.795225312137859, 39.751992668400902, -45.915851163810764]]]])
11251          sub=res.substitute({arg:s})
11252          ref=numarray.array([[[[0.0, 0.0, 1.0, 1.0], [0.0, 1.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0]], [[0.0, 0.0, 1.0, 1.0], [0.0, 0.0, 1.0, 0.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 0.0, 0.0, 1.0], [0.0, 1.0, 1.0, 0.0], [0.0, 1.0, 1.0, 0.0]], [[0.0, 1.0, 1.0, 1.0], [0.0, 0.0, 0.0, 1.0], [0.0, 0.0, 1.0, 1.0]]], [[[0.0, 0.0, 1.0, 1.0], [0.0, 0.0, 1.0, 1.0], [1.0, 1.0, 1.0, 0.0]], [[1.0, 1.0, 0.0, 0.0], [0.0, 0.0, 1.0, 0.0], [1.0, 0.0, 0.0, 1.0]]]])
11253          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11254          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11255          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11256       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11257       def test_whereZero_float_rank0(self):
11258          arg=36.9194219022
11259          res=whereZero(arg)
11260          ref=0.0
11261          self.failUnless(isinstance(res,float),"wrong type of result.")
11262          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11263       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11264       def test_whereZero_array_rank0(self):
11265          arg=numarray.array(-93.2286970236)
11266          res=whereZero(arg)
11267          ref=numarray.array(0.0)
11268          if not isinstance(res,float):
11269             self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11270             self.failUnlessEqual(res.shape,(),"wrong shape of result.")
11271          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11272       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11273       def test_whereZero_array_rank1(self):
11274          arg=numarray.array([-5.4758135185183079, -12.393482705182549])
11275          res=whereZero(arg)
11276          ref=numarray.array([0.0, 0.0])
11277          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11278          self.failUnlessEqual(res.shape,(2,),"wrong shape of result.")
11279          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11280       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11281       def test_whereZero_array_rank2(self):
11282          arg=numarray.array([[-22.216037501798056, 4.9281618608239484, 24.076323373045312, -1.5837381383595073, 89.085883212985664], [-31.966408477169978, 59.125907926918728, 22.148581815123777, -3.4787216423014513, 70.486779662550191], [-38.434264024343953, -28.545406042409468, -86.569085677953652, 29.872458065808701, 82.968130635374706], [-0.12806513945584186, 5.2584442959378919, 88.481457835654652, 52.526216268675853, -47.867118858740824]])
11283          res=whereZero(arg)
11284          ref=numarray.array([[0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0]])
11285          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11286          self.failUnlessEqual(res.shape,(4, 5),"wrong shape of result.")
11287          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11288       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11289       def test_whereZero_array_rank3(self):
11290          arg=numarray.array([[[83.566843166821798, 83.428361682287743], [-27.142097287854597, -7.7449066894637042]], [[95.740285720896139, 58.956113534039076], [50.123535284541219, 51.623550969006601]], [[95.393321001956423, 88.750537248542344], [-29.708780869260522, -90.320511258990138]], [[75.205523953075215, -81.374513795204507], [-70.55439045053609, 27.401171040594903]], [[23.344274043598048, -52.331497199756583], [77.956546937871479, 25.315698227587191]], [[-73.700561398579438, -10.261392160687222], [-0.82001847170529629, -69.219536679954956]]])
11291          res=whereZero(arg)
11292          ref=numarray.array([[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]])
11293          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11294          self.failUnlessEqual(res.shape,(6, 2, 2),"wrong shape of result.")
11295          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11296       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11297       def test_whereZero_array_rank4(self):
11298          arg=numarray.array([[[[25.646485297551976, 11.073836310281109, 54.114761331724992, -12.154046230984548], [55.324874795537227, 28.95659934737148, 94.639492916569793, 34.007912394649708], [63.557437176693213, 74.008668533501378, 64.891082638452303, 75.02732907327038]], [[0.10812203896047379, -56.42920257387194, 25.284865245539166, 56.659069500901381], [-24.816276674907726, 54.234226668365494, 30.712957393064244, 99.206875660084734], [-70.610950252661524, -95.570055459069891, -15.080615988435554, -34.468629003757911]]], [[[56.891765767496025, -18.388156109946863, -69.598390029982539, -49.746422132267121], [-55.031142846420522, -76.066644780947399, -77.183345994632262, 57.117746506564544], [-90.739836243999989, -64.407621405298698, 47.917245532062736, 40.184055666825515]], [[-50.242499172011243, -8.87012437468087, 43.485752684298006, 1.9802518704210286], [52.738617953516098, 67.416303731706478, -93.317491063936075, -10.148998504978351], [41.786805141066679, -0.75710798140093516, -0.44487284484937106, 52.422098163397976]]], [[[-56.523619961520424, -56.87408626775543, 86.257157391371067, -59.666478835501756], [-27.523677831571518, 26.978800410887743, 41.981358630995317, 60.966684046224884], [-88.336158365149743, 25.253390160451673, 24.947726326096927, -69.88210288786064]], [[28.934555939829323, 28.843750360082907, 52.298137157289517, 98.435696242381738], [-45.858063671063661, -24.386879374695596, -4.7125807697196933, 18.897314951135954], [-68.600970437531487, 46.967350537404627, 24.491641179009946, -14.113138296837874]]]])
11299          res=whereZero(arg)
11300          ref=numarray.array([[[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]]])
11301          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11302          self.failUnlessEqual(res.shape,(3, 2, 3, 4),"wrong shape of result.")
11303          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11304       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11305       def test_whereZero_constData_rank0(self):
11306          arg=Data(28.1448958043,self.functionspace)
11307          res=whereZero(arg)
11308          ref=Data(0.0,self.functionspace)
11309          self.failUnless(isinstance(res,Data),"wrong type of result.")
11310          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11311          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11312       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11313       def test_whereZero_constData_rank1(self):
11314          arg=Data(numarray.array([-82.424192879607403, -37.742931006156489]),self.functionspace)
11315          res=whereZero(arg)
11316          ref=Data(numarray.array([0.0, 0.0]),self.functionspace)
11317          self.failUnless(isinstance(res,Data),"wrong type of result.")
11318          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11319          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11320       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11321       def test_whereZero_constData_rank2(self):
11322          arg=Data(numarray.array([[88.228357156618614, -67.868123140983812, 1.512038393501669, -2.4090303677805451, -77.431662457170702], [-28.559471393034855, -15.937848887398616, -10.531725851274871, -1.7510038488192521, -44.964870198048246], [-39.261122217051955, 63.804285642486178, -92.35899221299897, 83.265740587577596, 25.680465013643357], [54.5460930839632, 60.917809009044504, -50.068271855067373, -27.753796832679427, 24.173974108605705]]),self.functionspace)
11323          res=whereZero(arg)
11324          ref=Data(numarray.array([[0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0]]),self.functionspace)
11325          self.failUnless(isinstance(res,Data),"wrong type of result.")
11326          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11327          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11328       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11329       def test_whereZero_constData_rank3(self):
11330          arg=Data(numarray.array([[[5.8006491078266436, 35.129891450052469], [72.468149481480708, 30.423431420167645]], [[-97.49296225256478, -95.545777693389056], [-19.272840387210778, -52.712492439965295]], [[-8.4318486054725099, -48.14775009081422], [15.485176866163101, 20.812291283387779]], [[59.148678501666808, 44.49011017020382], [68.060455906204766, -28.366297330479597]], [[-53.89552234182662, -56.019523425289734], [-12.787919401488608, -25.640418311378554]], [[-80.946202928069681, 98.68988212964004], [-86.271543759781096, 58.957148643203482]]]),self.functionspace)
11331          res=whereZero(arg)
11332          ref=Data(numarray.array([[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]]),self.functionspace)
11333          self.failUnless(isinstance(res,Data),"wrong type of result.")
11334          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11335          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11336       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11337       def test_whereZero_constData_rank4(self):
11338          arg=Data(numarray.array([[[[-65.177620457916689, 67.29262327490423, -7.3415276413508082, -5.2405941808933392], [-48.758858112961768, 22.839891911492273, 79.281591854134689, -31.661211799895611], [-29.378697622508909, 97.445171039982398, -3.9519401978111972, 76.511678962031851]], [[-62.423828480664746, 56.125375059826581, -75.453141434267295, -58.099034647323307], [-97.405453924636291, 50.587164071913492, -62.207039945193785, 6.9380229297484561], [-97.178170849233254, 95.128123507156232, 73.270487977455275, 43.015502805504582]]], [[[-18.640235019885793, -64.312133051653603, 94.354412363014035, 22.993281228643994], [-91.306876358518196, 43.015613220689886, 33.570404531422213, 82.971175030422302], [31.335392435326156, -34.121087575670714, 78.788049923464627, -5.6671192929215692]], [[85.897768300402873, -12.59829275357778, 43.814744997102991, 6.6323709267625048], [-43.13141600459609, -90.169076035549622, -61.538645551752701, -65.336406452922034], [25.4847655361812, 79.757518347506931, 4.4404225559480039, -90.310854126467547]]], [[[-89.942170042909737, 48.83614806552265, 27.339850059944709, 40.364684920253126], [82.979560873661626, -14.475961583560661, -62.784944309919325, -98.935571321987737], [-88.87373557335512, -85.243755112678102, -26.797719666615038, -78.779936332270836]], [[-97.025077640729592, 60.965387643532466, -96.879335350883025, -44.074960019423479], [84.871574286123774, 63.119314763292721, -64.659489888329944, 84.502657554937542], [65.086432289042222, -21.632326349787093, -4.2254524282816277, 84.264250212943978]]]]),self.functionspace)
11339          res=whereZero(arg)
11340          ref=Data(numarray.array([[[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]]]),self.functionspace)
11341          self.failUnless(isinstance(res,Data),"wrong type of result.")
11342          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11343          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11344       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11345       def test_whereZero_expandedData_rank0(self):
11346          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11347          arg=msk_arg*(32.6280408645)+(1.-msk_arg)*(95.9857415093)
11348          res=whereZero(arg)
11349          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11350          ref=msk_ref*(0.0)+(1.-msk_ref)*(0.0)
11351          self.failUnless(isinstance(res,Data),"wrong type of result.")
11352          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11353          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11354       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11355       def test_whereZero_expandedData_rank1(self):
11356          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11357          arg=msk_arg*numarray.array([78.912256081910982, 95.107329887542988])+(1.-msk_arg)*numarray.array([-93.129096936828716, -31.119112819271606])
11358          res=whereZero(arg)
11359          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11360          ref=msk_ref*numarray.array([0.0, 0.0])+(1.-msk_ref)*numarray.array([0.0, 0.0])
11361          self.failUnless(isinstance(res,Data),"wrong type of result.")
11362          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11363          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11364       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11365       def test_whereZero_expandedData_rank2(self):
11366          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11367          arg=msk_arg*numarray.array([[-4.5674063676684113, -89.281893625146708, 23.19996829396085, 18.836280966336673, 48.069098115838699], [-22.012453235487612, 49.277998375509071, 36.357927774507999, -81.584591164471846, -86.383640243979073], [-11.398848874052291, 53.725683521115826, 57.996950911680813, -19.278919654298136, -7.6330215452677663], [23.212683532644604, 47.218488529598716, 94.087207901705796, -19.986642121880791, -60.768388103484973]])+(1.-msk_arg)*numarray.array([[-91.766428267475405, -80.743485192118527, 49.721965309529139, -8.4541150165939598, 11.588341364396655], [-66.832555155876435, -41.812843111232766, -42.848862832974092, 38.718794135330427, 97.120556706875561], [-1.7661898089937438, 9.3172028698214291, 64.632791057438652, 8.7177199255444151, 97.409280590459673], [-40.687002837505325, -44.151855951781215, 81.104463998584123, 68.501916362320713, 15.603376060294408]])
11368          res=whereZero(arg)
11369          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11370          ref=msk_ref*numarray.array([[0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0]])+(1.-msk_ref)*numarray.array([[0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0]])
11371          self.failUnless(isinstance(res,Data),"wrong type of result.")
11372          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11373          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11374       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11375       def test_whereZero_expandedData_rank3(self):
11376          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11377          arg=msk_arg*numarray.array([[[-21.084709880958158, 60.058563461115341], [23.462135905224613, 4.1925110299263935]], [[-73.752445728764471, 98.917050977312613], [91.380933382588495, 96.936759674063694]], [[-42.119594542112758, -36.557259071778894], [-41.337250253991378, -23.488672516050045]], [[79.635013224815708, 34.63320785977092], [52.590069604255888, 21.512417656206551]], [[54.361795611776955, -45.247793152599435], [-90.021841110057906, 80.87660694310236]], [[68.838235188657535, 53.277307015666736], [69.927085977405824, -86.715842974659438]]])+(1.-msk_arg)*numarray.array([[[35.824777853004889, -98.41139283617531], [46.481491612419063, 73.744423180097272]], [[-62.535302751139653, 90.281500522248365], [75.01937602982872, -28.925552206472531]], [[-13.317676532324427, -65.881247444860747], [88.671022199931372, 73.998882504024408]], [[0.15025950906122887, -94.853839866383098], [46.402552203453979, -47.706832151504287]], [[-89.242628256571521, -34.33096936505919], [81.905543323362821, -16.972568236626273]], [[96.777671705474376, -54.187557400745568], [31.04774327078735, -10.538455973188675]]])
11378          res=whereZero(arg)
11379          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11380          ref=msk_ref*numarray.array([[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]])+(1.-msk_ref)*numarray.array([[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]])
11381          self.failUnless(isinstance(res,Data),"wrong type of result.")
11382          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11383          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11384       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11385       def test_whereZero_expandedData_rank4(self):
11386          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11387          arg=msk_arg*numarray.array([[[[-32.662481234741009, 40.260928889330899, 75.847123834183577, 78.64906987881929], [-63.275395114512165, -31.782530467351066, -33.223085447198656, -41.760129832198146], [-74.215302896565618, 96.846057240589488, -42.720460482944176, -81.859139209222548]], [[-80.806077534597605, -71.830510003086573, -52.675707514171592, 59.066414162745303], [-70.588014101153917, 51.148551968394855, -74.276699989547552, 73.901372979374713], [70.366974039594226, -9.8398879113183852, 36.910219459152358, 70.56418458925782]]], [[[-86.98957296102455, -81.086417993215889, -46.036348376772821, 1.9830002078387707], [-81.396274030320797, -7.4045882449412943, 6.3580886221511008, 79.040288934545032], [-14.153401419846759, 67.679531820133519, 51.592855364211687, 90.708140577398439]], [[-94.306912199804941, 98.63226780530934, -8.9357196058543309, 4.7943903912119907], [-74.373684606723373, 91.169643203671882, 16.841492324960569, 93.632465846065628], [-99.088266439789805, 45.694749451260208, -90.330018599691812, -60.130076035705656]]], [[[-7.2101696440878698, -34.214635113611934, -41.058199491627747, 16.37206535285118], [12.97372741143397, 61.291284156806938, 92.690533886945445, -90.198572175888316], [43.854839856732838, 69.937218292009533, -9.1804659284850771, -94.216640840953787]], [[68.181402600087836, 0.30694213217643096, -28.922839864406868, -23.615203338489295], [-25.458367043581916, -53.828155760722353, -87.161998896681524, 25.519257343379692], [79.178020952386134, -30.669991922330126, 69.968344114998871, -2.5714051990672857]]]])+(1.-msk_arg)*numarray.array([[[[85.208773947656681, 88.332585876380023, -44.90871447056162, -43.006236243527241], [-2.047920558204595, 89.27443100854407, -5.5594319239118448, -51.774859847771722], [-60.342290733130845, 30.737338461190973, -11.740568632642152, 92.593235560303924]], [[-16.237930188618634, 85.904441626286911, 73.575939167565167, 61.372847005304777], [-25.293050011864722, 86.444597934853704, 65.144765734125684, 24.221545914400892], [-45.788018695054447, 20.030203845344701, -38.808816142235322, 95.412752620189195]]], [[[95.355286693057337, -20.930533826082325, -53.087896571538536, 58.552873058160117], [-9.8932393167384873, -63.401775116131475, -78.43041141947036, 8.9216142837929198], [56.310803454533783, -77.378150114889451, 54.241934023962244, -24.239451277709605]], [[-81.577621003821022, -20.575488788882396, -74.748333868053194, -77.650260041846195], [-36.715889937928893, 46.713294962560639, -32.726652799822858, -86.511792039144225], [-36.63521378668375, -6.6216634903382214, -38.109037159628009, 37.802959591625665]]], [[[-89.164784930058289, -16.893154586268452, -34.0483761542868, 45.087030820992595], [56.096068746482814, -47.841426397183099, 62.786778552668522, -53.641715554093629], [68.655982343210781, -29.962711809331694, -37.999496293427541, 65.862456745659273]], [[-73.176583009461709, 49.80677997366908, 12.506512460993363, 35.473350491292592], [16.781388716717373, -8.5505718161589215, 26.19539860058407, 46.761865879346487], [41.621990096276903, -38.514318974070669, -74.226339225637702, 41.167568383147398]]]])
11388          res=whereZero(arg)
11389          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11390          ref=msk_ref*numarray.array([[[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]]])+(1.-msk_ref)*numarray.array([[[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]]])
11391          self.failUnless(isinstance(res,Data),"wrong type of result.")
11392          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11393          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11394       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11395       def test_whereZero_Symbol_rank0(self):
11396          arg=Symbol(shape=())
11397          res=whereZero(arg)
11398          s=numarray.array(81.6444913441)
11399          sub=res.substitute({arg:s})
11400          ref=numarray.array(0.0)
11401          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11402          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11403          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11404       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11405       def test_whereZero_Symbol_rank1(self):
11406          arg=Symbol(shape=(2,))
11407          res=whereZero(arg)
11408          s=numarray.array([-0.42577857552119269, -97.824884344164786])
11409          sub=res.substitute({arg:s})
11410          ref=numarray.array([0.0, 0.0])
11411          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11412          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11413          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11414       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11415       def test_whereZero_Symbol_rank2(self):
11416          arg=Symbol(shape=(4, 5))
11417          res=whereZero(arg)
11418          s=numarray.array([[39.799478427096147, 38.492638423570327, -72.762325210310081, -69.098205396529181, 38.188266474849456], [13.030277476589887, 74.277784962164588, -75.455425329956682, -0.98991194199366817, 40.241690530095951], [32.255154097894831, -99.716448230113969, -21.681673392271421, 93.069064225310001, 11.128753427692573], [7.0711563192171809, -17.15976661897767, -74.584589854898439, 51.041755486974239, -5.6722415070331778]])
11419          sub=res.substitute({arg:s})
11420          ref=numarray.array([[0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0, 0.0]])
11421          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11422          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11423          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11424       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11425       def test_whereZero_Symbol_rank3(self):
11426          arg=Symbol(shape=(6, 2, 2))
11427          res=whereZero(arg)
11428          s=numarray.array([[[-6.9578233775275038, 49.132223141003095], [-48.145023755700088, 21.587944379016761]], [[86.651677318588611, -0.57273995292416657], [-24.596335688728061, -84.06959838105297]], [[39.239654475555739, 46.913346038704105], [67.021307498603164, -3.8507829652879622]], [[-80.47774249090331, -64.49244373998269], [-13.414465155552463, -28.648148016214364]], [[-39.709711031302874, -5.31689974420064], [-57.377517901382276, 94.506624151769302]], [[11.115875644871551, 72.592213743917142], [-32.851536402053583, 78.518378718942529]]])
11429          sub=res.substitute({arg:s})
11430          ref=numarray.array([[[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]], [[0.0, 0.0], [0.0, 0.0]]])
11431          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11432          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11433          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11434       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11435       def test_whereZero_Symbol_rank4(self):
11436          arg=Symbol(shape=(3, 2, 3, 4))
11437          res=whereZero(arg)
11438          s=numarray.array([[[[-39.290159719357185, 6.4490380987615623, -32.475323811147817, 60.226470912331308], [-67.755482790982938, -39.36427904339579, 21.997707246133388, -57.33676285078031], [25.320831197285258, -76.349205569527896, -36.414788962722014, 32.291459935518731]], [[-65.904294197582345, -89.034718909868275, 23.261623493802404, -23.180947290729321], [-46.259617026665943, 99.549706170539366, 10.306727586246595, 87.039923782401161], [66.016848823361642, 28.256642649753928, 70.164371345513473, 67.371978520546691]]], [[[95.146996060217106, -97.305855490492306, -29.256335422763627, -24.209100707496575], [45.641162744683385, 63.645930271424191, -90.807337430480288, 24.138834899377557], [73.589873856883969, -56.963982942159276, -56.566510827885196, 19.815127048510604]], [[-6.0501958637814397, -64.804389079293671, -97.436129865062156, -75.007677448589078], [97.657879332162167, 76.181023957804541, 10.091188897304022, -50.857694189930648], [-21.917722344901122, -73.808061753514863, -65.869251863183962, 4.5616827304170613]]], [[[70.035781937760731, -51.832467945539221, 79.042746419994728, 38.668501922355972], [34.119830624253126, 24.299671216764267, -42.277730257287182, 92.671939181987852], [-72.79102447157895, 30.740060638932874, -74.191520466794174, -52.954497069438666]], [[24.430118839801438, -6.8193204451386151, 61.796792049679993, 64.743591095050022], [43.828951570456724, -52.733202497353915, 18.689222089808339, 53.094849161936565], [77.126411810233293, 46.773335174712628, 24.535808124902417, -51.550372123195707]]]])
11439          sub=res.substitute({arg:s})
11440          ref=numarray.array([[[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]], [[[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]], [[0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 0.0]]]])
11441          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11442          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11443          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11444       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11445       def test_whereNonZero_float_rank0(self):
11446          arg=-56.0152542247
11447          res=whereNonZero(arg)
11448          ref=1.0
11449          self.failUnless(isinstance(res,float),"wrong type of result.")
11450          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11451       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11452       def test_whereNonZero_array_rank0(self):
11453          arg=numarray.array(71.1859507003)
11454          res=whereNonZero(arg)
11455          ref=numarray.array(1.0)
11456          if not isinstance(res,float):
11457             self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11458             self.failUnlessEqual(res.shape,(),"wrong shape of result.")
11459          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11460       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11461       def test_whereNonZero_array_rank1(self):
11462          arg=numarray.array([-17.3035326538253, -86.593915731827906])
11463          res=whereNonZero(arg)
11464          ref=numarray.array([1.0, 1.0])
11465          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11466          self.failUnlessEqual(res.shape,(2,),"wrong shape of result.")
11467          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11468       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11469       def test_whereNonZero_array_rank2(self):
11470          arg=numarray.array([[41.61768486731961, 69.290611719671801, 48.401728321290705, -54.590972112334143, 11.564399558126269], [-1.8042524010560896, -92.702095284465159, 45.136484559735237, -72.362244352134866, 24.194710407260914], [-43.108695050778387, 47.647489079294672, -61.701429681233932, -36.067537829718567, 99.180966430966492], [51.707301922404213, 7.5838051866514746, -43.604821883975163, 74.85674310120524, 91.181953108853094]])
11471          res=whereNonZero(arg)
11472          ref=numarray.array([[1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0]])
11473          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11474          self.failUnlessEqual(res.shape,(4, 5),"wrong shape of result.")
11475          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11476       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11477       def test_whereNonZero_array_rank3(self):
11478          arg=numarray.array([[[21.449928615271091, -17.253570875796783], [23.691826817893485, 72.615672710486564]], [[-56.101868173239325, -50.789146263740115], [44.254260393918344, -77.113348468531143]], [[31.628186192244158, -29.567091682631514], [-25.637642791911858, 90.000932154214325]], [[-98.909566050888145, -15.524708628153604], [40.294638716411356, 19.662663209587222]], [[-8.9424053143323476, 44.033554341712147], [-28.592658918978913, 57.701429147236496]], [[5.8373347600123964, -15.938309186009377], [47.118492474253401, -17.104874895088756]]])
11479          res=whereNonZero(arg)
11480          ref=numarray.array([[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]])
11481          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11482          self.failUnlessEqual(res.shape,(6, 2, 2),"wrong shape of result.")
11483          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11484       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11485       def test_whereNonZero_array_rank4(self):
11486          arg=numarray.array([[[[36.811388311146146, -37.819440076221554, -70.946877208868955, -53.423749294710589], [-27.959990449110549, -13.19600531838357, 30.051887488086265, -62.951332747963093], [44.237322250517849, -49.199225003263706, 80.483871168859963, -89.985441118504284]], [[44.560573770678758, -54.599849870638707, -88.477359629839185, 28.797401260182085], [-77.152989636288908, 20.342246911351296, 75.740577688308235, -19.451449067952353], [55.586372931716994, 46.066327045425965, -61.412715276495746, -0.57311906305483262]]], [[[69.342920685200568, 20.761986693929686, 65.355240394684017, -43.975994488286531], [-45.602468581331699, -60.702312875128705, -52.741215221192064, -50.152173529149891], [63.871292914570887, 50.308104012520829, 13.646656015678801, -2.2486349800344954]], [[9.7609011134064332, 3.3174725979807818, 96.220499171807035, -20.264739672411267], [-26.826050737340353, 12.940873209136299, 54.903850018848289, -44.753514431245911], [-31.296365135620107, -53.852944671155981, 37.681503437560878, 50.394193944723071]]], [[[93.559245006066305, 21.615439772198215, -46.999800142512726, -99.515382399330576], [-26.590613229769033, 65.009853745193624, -38.710017866404975, -34.390372809473206], [71.657928675928162, 85.018672069146191, 72.768640349535559, 66.342192378120103]], [[39.999657304603545, -96.748350051606195, 84.903024547152626, -24.425754771404911], [14.239472718681043, 21.23525425634169, 85.086308297188765, 58.613396024449628], [58.879250368865002, 22.553655766939201, -40.509432689823655, 90.333538469165688]]]])
11487          res=whereNonZero(arg)
11488          ref=numarray.array([[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]]])
11489          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11490          self.failUnlessEqual(res.shape,(3, 2, 3, 4),"wrong shape of result.")
11491          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11492       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11493       def test_whereNonZero_constData_rank0(self):
11494          arg=Data(81.267839677,self.functionspace)
11495          res=whereNonZero(arg)
11496          ref=Data(1.0,self.functionspace)
11497          self.failUnless(isinstance(res,Data),"wrong type of result.")
11498          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11499          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11500       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11501       def test_whereNonZero_constData_rank1(self):
11502          arg=Data(numarray.array([4.3097880462597686, 38.2746982582035]),self.functionspace)
11503          res=whereNonZero(arg)
11504          ref=Data(numarray.array([1.0, 1.0]),self.functionspace)
11505          self.failUnless(isinstance(res,Data),"wrong type of result.")
11506          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11507          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11508       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11509       def test_whereNonZero_constData_rank2(self):
11510          arg=Data(numarray.array([[-57.872158775060825, 3.0665803612860714, 23.678752611770307, 27.706914354716304, -78.399825738474846], [83.27658948992422, -86.630812378705045, -94.818125169373133, 80.207597472222801, -59.996764104241066], [-48.920076163552359, -5.2793956419858716, -50.805323597125707, -2.4177320821246724, 14.787663281902354], [-91.456661324218942, -75.915552368352166, 9.029031640098097, -64.522060166953736, 45.606353207854369]]),self.functionspace)
11511          res=whereNonZero(arg)
11512          ref=Data(numarray.array([[1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0]]),self.functionspace)
11513          self.failUnless(isinstance(res,Data),"wrong type of result.")
11514          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11515          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11516       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11517       def test_whereNonZero_constData_rank3(self):
11518          arg=Data(numarray.array([[[-65.737279660632169, -69.58794855021317], [49.173019648663285, -75.324917930399081]], [[36.734465319459133, 39.356936322031572], [72.229844336186147, 27.313887429173732]], [[-46.346862025625811, -28.232476346878286], [67.290787988042212, 28.839469197769318]], [[22.138154835183599, -73.891269486450966], [44.435903802312509, 35.208760455185853]], [[17.707928227345704, -82.502312692751232], [-50.185359824329211, -75.512768380834984]], [[-11.011396097469046, 3.7914246847852837], [88.484294237998171, 27.817718891298298]]]),self.functionspace)
11519          res=whereNonZero(arg)
11520          ref=Data(numarray.array([[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]]),self.functionspace)
11521          self.failUnless(isinstance(res,Data),"wrong type of result.")
11522          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11523          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11524       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11525       def test_whereNonZero_constData_rank4(self):
11526          arg=Data(numarray.array([[[[-90.837005944640453, 58.32908469863068, -21.397220189906932, -59.882605473903048], [-60.155669460320048, 94.264197917567316, 5.2271187077156895, 7.6994454870920919], [45.007283205913836, -12.641863450474105, 14.162620707917583, 19.00968469844095]], [[80.350439667173504, 62.976498386779269, -92.277088804255243, -22.02365795339658], [-77.586036199115824, 18.456470236740913, 47.615072286184358, 54.538747153369343], [91.74150400219861, 86.412378355903371, 88.617980688509135, -46.604677919468649]]], [[[-53.574380602108441, -25.238541870158244, -73.591218463895842, -37.649627917290609], [-67.751440748047912, 75.941689285252011, -89.393524054767482, 67.428736009005092], [96.911150988908844, 12.958697435254351, -66.109426273033193, -88.3308257725689]], [[62.378724670258009, -4.8176444206246885, 81.947676307785855, -48.326765737807989], [2.7384341578773075, -51.578329102849452, -8.1888405371007593, 40.041650279869941], [1.097138779089164, -94.669191888914668, -51.813633997289308, -54.599754268322151]]], [[[83.590503053969371, -74.086642770815402, -72.770948998639255, -97.314802633614931], [-86.027885055613837, 33.553797401705197, 31.053141327356713, 67.511970696929382], [52.366010839111311, -33.722724485456567, -85.983722002837638, -86.789587160415778]], [[-70.157132541078397, -77.562471328811228, 14.699980308694634, -18.99732113106478], [12.774619589743438, -87.237747438149697, -81.789726467975441, 70.99819494952979], [-49.82446845622561, 29.476931575070466, 31.2380468420277, -80.56982756990962]]]]),self.functionspace)
11527          res=whereNonZero(arg)
11528          ref=Data(numarray.array([[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]]]),self.functionspace)
11529          self.failUnless(isinstance(res,Data),"wrong type of result.")
11530          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11531          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11532       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11533       def test_whereNonZero_expandedData_rank0(self):
11534          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11535          arg=msk_arg*(55.457381569)+(1.-msk_arg)*(-23.468996897)
11536          res=whereNonZero(arg)
11537          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11538          ref=msk_ref*(1.0)+(1.-msk_ref)*(1.0)
11539          self.failUnless(isinstance(res,Data),"wrong type of result.")
11540          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11541          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11542       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11543       def test_whereNonZero_expandedData_rank1(self):
11544          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11545          arg=msk_arg*numarray.array([75.794421272424358, 53.341174509357501])+(1.-msk_arg)*numarray.array([62.218317595110733, 28.772022216936335])
11546          res=whereNonZero(arg)
11547          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11548          ref=msk_ref*numarray.array([1.0, 1.0])+(1.-msk_ref)*numarray.array([1.0, 1.0])
11549          self.failUnless(isinstance(res,Data),"wrong type of result.")
11550          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11551          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11552       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11553       def test_whereNonZero_expandedData_rank2(self):
11554          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11555          arg=msk_arg*numarray.array([[25.693195010945445, 53.470932335076157, -68.183323445425884, -90.253837566532937, 97.906247975957115], [58.50459295308795, -44.270817918326053, 44.734053038122738, 46.132305677124208, 15.093865803964562], [42.388010237041698, -7.0981379825856266, -2.7347840708205098, -29.594785545579597, -95.196484793137472], [38.36601032797401, -31.853113575844233, 22.743621849911833, -4.9889383642481846, -51.432166195627829]])+(1.-msk_arg)*numarray.array([[-21.251861279170669, 23.87089448722665, 54.546286256972479, -50.596083351973761, 71.290931136958989], [-85.431548064496582, 20.522672789852606, -90.730704002438671, -46.757529093371275, 16.785961991598612], [22.174454395058632, 69.692756669654159, 87.615316871643131, -78.004806291849491, 3.6808126640922865], [-57.786804759801669, -87.557537170166015, 64.774622761137721, 90.823752701099721, -47.516231901181612]])
11556          res=whereNonZero(arg)
11557          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11558          ref=msk_ref*numarray.array([[1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0]])+(1.-msk_ref)*numarray.array([[1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0]])
11559          self.failUnless(isinstance(res,Data),"wrong type of result.")
11560          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11561          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11562       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11563       def test_whereNonZero_expandedData_rank3(self):
11564          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11565          arg=msk_arg*numarray.array([[[86.149242248728058, -35.02751878546529], [40.087555658614548, -77.393517988885691]], [[26.117710543523316, 71.702690330409268], [98.666028493959146, 11.651670052091717]], [[-89.606381835492499, 52.900856899025115], [-28.078601574503764, -95.119493866321875]], [[98.666959366780844, 23.275898081831897], [4.3281069846126172, -80.865475942459497]], [[-14.7551225313251, 97.396689501269265], [23.671398524796032, 21.397118290457513]], [[23.732489190132, -59.259215202504677], [-83.242145340201688, -75.536810160429368]]])+(1.-msk_arg)*numarray.array([[[-9.7478095088222148, 11.661323310074323], [4.8146279047090559, -52.254294186764461]], [[-25.036812644543332, 73.198082013951563], [-9.0171269289220106, -47.016186545303171]], [[-28.848236212560835, 22.014297849998428], [-80.472580936591527, 35.926128036359103]], [[-50.335917685172404, 10.849423531461483], [-41.037282141150008, 99.521035981305374]], [[3.7060647555777138, -50.51251638563128], [-33.000056918825209, 91.690666567142586]], [[-26.856701959084845, -3.2105214924453378], [96.598379912806394, -15.447865865744575]]])
11566          res=whereNonZero(arg)
11567          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11568          ref=msk_ref*numarray.array([[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]])+(1.-msk_ref)*numarray.array([[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]])
11569          self.failUnless(isinstance(res,Data),"wrong type of result.")
11570          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11571          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11572       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11573       def test_whereNonZero_expandedData_rank4(self):
11574          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11575          arg=msk_arg*numarray.array([[[[-13.011952221782906, 60.146594640260929, -92.58084328474439, -63.668052583858525], [-29.604118765606316, -54.921705782621324, 63.355787794763557, 32.048187979650379], [52.690986117833347, -65.333226351220446, -80.457709522487477, -98.926180293535211]], [[-7.1796814873670343, 94.388137298771483, 95.299168868419684, -54.524320427950833], [-61.062722861775207, 83.2566734157692, 19.473153243447854, -17.683274427867616], [92.214390273881946, 33.610188459781625, -81.830151098817836, 58.157655737818004]]], [[[63.469751000464782, -17.599047199042445, 78.031842669949526, -4.4970488112825819], [-66.54952900441117, 67.261106981137686, 54.23547006750232, 55.602853560488029], [45.038007193518467, -70.427944498069365, -69.825782007360743, -65.982920351293558]], [[-95.008913410852742, -39.213243291094948, 72.194277685731862, 97.046556215652714], [37.536007158729404, 44.977826357229333, -74.984923076853008, -25.784263917813036], [16.469242924065597, 55.697269253699091, -14.794604017518907, -31.753199846344259]]], [[[56.500805440617142, 35.623660964275814, -33.468639069785453, 55.151083545768927], [80.08078661666562, 86.285902320161256, 11.017641963291695, -68.900497305225002], [68.192503427277103, -86.515657932050203, 47.994984746708809, -43.370874890365265]], [[61.776516875254572, -18.579244394902929, -15.183358149836849, -74.888276150809219], [69.965669844543783, 5.4340404212045286, 28.363989733719109, 15.311329580643189], [94.76411206365961, -11.043728008539119, -15.649591146513345, 47.035633382894645]]]])+(1.-msk_arg)*numarray.array([[[[74.385412727423812, -37.538049462402647, 55.913400604665355, -70.457307068022459], [79.482613421908439, 83.515322164631527, -43.324348243704634, 14.84345334513965], [68.778457595687001, -56.301700989105122, -67.104809294858455, -93.503482897897513]], [[-23.750280106836712, 33.848737195440208, 14.997455364891138, 97.834390144064486], [-6.4280342178465446, -82.354008114682159, 1.1797643810675993, -84.817435750943289], [4.0640627650950734, 36.731149482102808, 4.4401253362509721, 50.187621844828357]]], [[[10.746049103776784, -0.50416504196932976, 6.1710864748900605, 25.710101291704632], [-8.3240472300805806, 0.40060317937977175, -4.6344318693605686, 60.779785582340679], [-45.076412053791138, -1.378387041154653, 51.553519112651571, 26.371530000106787]], [[-46.325656386879729, 38.949682993329958, -96.678227888724777, -71.397182995030661], [-39.275033452116404, -20.946676674594329, -1.9183420721467428, -16.206004000684842], [9.166499552764293, 55.367654830204089, 55.869168851337804, 31.8283590864053]]], [[[70.064271798572975, 25.227460810734044, -49.584790116912771, 6.4927871739775185], [-14.735101219279272, -32.448581566238843, 92.390606133049715, -71.298582637949863], [-39.675482065031062, 13.907314019034956, -47.48451389090782, -93.93888851018022]], [[-92.274017822855086, -10.260862968529636, 14.31392023943387, 32.589318378815591], [84.922863364253459, 71.725715754215599, 47.377427817862753, -55.639887444292157], [63.461117774674562, 89.548143331715664, 33.157691946888747, -56.134655663723642]]]])
11576          res=whereNonZero(arg)
11577          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11578          ref=msk_ref*numarray.array([[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]]])+(1.-msk_ref)*numarray.array([[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]]])
11579          self.failUnless(isinstance(res,Data),"wrong type of result.")
11580          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11581          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11582       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11583       def test_whereNonZero_Symbol_rank0(self):
11584          arg=Symbol(shape=())
11585          res=whereNonZero(arg)
11586          s=numarray.array(-63.9986107791)
11587          sub=res.substitute({arg:s})
11588          ref=numarray.array(1.0)
11589          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11590          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11591          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11592       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11593       def test_whereNonZero_Symbol_rank1(self):
11594          arg=Symbol(shape=(2,))
11595          res=whereNonZero(arg)
11596          s=numarray.array([5.5359318226973215, -86.821749912549208])
11597          sub=res.substitute({arg:s})
11598          ref=numarray.array([1.0, 1.0])
11599          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11600          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11601          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11602       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11603       def test_whereNonZero_Symbol_rank2(self):
11604          arg=Symbol(shape=(4, 5))
11605          res=whereNonZero(arg)
11606          s=numarray.array([[71.725472035318546, -58.612052886303289, 62.157756415813651, -47.063778001895315, 77.803560471030494], [92.195417194871851, 89.724837980402924, -10.413176528694962, -61.838646095919756, -37.956581923595522], [-21.02513441733258, 72.503213262682806, 16.360830438439564, 15.487516956343583, -71.733457944717614], [-35.521341182196721, 90.927740424160248, 21.718277340665054, -90.551829331778478, -79.822246461445403]])
11607          sub=res.substitute({arg:s})
11608          ref=numarray.array([[1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0, 1.0]])
11609          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11610          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11611          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11612       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11613       def test_whereNonZero_Symbol_rank3(self):
11614          arg=Symbol(shape=(6, 2, 2))
11615          res=whereNonZero(arg)
11616          s=numarray.array([[[-92.039200834931847, -62.745860821492137], [55.562355191956101, 36.13623050761575]], [[51.428582569678667, 6.7813551764689777], [34.834098385485248, -46.565103858624781]], [[-22.197926800436505, -23.75105117868452], [62.316617058759022, 39.650089801879489]], [[-17.301716595043743, -49.890756774157772], [65.113911490167396, 70.406681905728902]], [[67.970437340226084, 6.763877574674737], [-72.440603095681496, 83.905240789027999]], [[-9.4725564250577747, 6.7172370152905216], [10.657653776805361, 31.813356576401873]]])
11617          sub=res.substitute({arg:s})
11618          ref=numarray.array([[[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]], [[1.0, 1.0], [1.0, 1.0]]])
11619          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11620          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11621          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11622       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11623       def test_whereNonZero_Symbol_rank4(self):
11624          arg=Symbol(shape=(3, 2, 3, 4))
11625          res=whereNonZero(arg)
11626          s=numarray.array([[[[95.390257385358666, 45.581102621197772, -34.472614399751976, -44.187969729817155], [62.619954103462845, -62.125630494937909, 62.664289458215393, 38.69703477202745], [18.292449005125235, -68.461908914622853, 86.000739545438819, -48.949946326838379]], [[20.120065500586364, 83.296762964032268, 90.39226764899351, 37.379442794888803], [-48.543736312915108, -57.067875736841486, -1.3972280138476236, -7.7638288295607651], [-29.177967514332664, -81.460379350377593, 10.435285429910195, 57.630275899938113]]], [[[-45.71961261819397, 22.373502185500541, 37.662223848476089, -2.2940311095793504], [59.235081702607431, -21.847349361693887, 68.766451889270002, -25.664076299853662], [-65.794252273908256, -93.497162167099475, -45.937528408479956, -4.9683114364239316]], [[38.415579583735934, 51.680222508550969, 45.533224435884534, -95.377478810488256], [-67.689600658634703, 38.481196742257595, -85.39114161427824, 34.228355824940252], [58.581033737968397, -23.491787526221358, 14.698443690426117, -54.750734727094994]]], [[[-67.627258717531191, 88.697079672890254, 53.870078458562432, 51.736240026571721], [-70.95614948743227, 11.195775524020291, 31.058839065828323, -15.23262569608319], [-56.668773707515705, -39.564235352463164, 61.035865972707171, -59.669324480633094]], [[-85.916017079613511, 28.542821077324334, -41.081637035461597, 0.56732809105591286], [-69.673695812034737, -96.079626480303531, 72.015551834181167, 38.954889388681607], [-81.08586516893655, -41.644221407464485, -85.347230876678211, -19.457969474192112]]]])
11627          sub=res.substitute({arg:s})
11628          ref=numarray.array([[[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]], [[[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]], [[1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0], [1.0, 1.0, 1.0, 1.0]]]])
11629          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11630          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11631          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11632       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11633       def test_sin_float_rank0(self):
11634          arg=26.6185049196
11635          res=sin(arg)
11636          ref=0.99638690326
11637          self.failUnless(isinstance(res,float),"wrong type of result.")
11638          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11639       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11640       def test_sin_array_rank0(self):
11641          arg=numarray.array(-19.1395275546)
11642          res=sin(arg)
11643          ref=numarray.array(-0.285925042532)
11644          if not isinstance(res,float):
11645             self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11646             self.failUnlessEqual(res.shape,(),"wrong shape of result.")
11647          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11648       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11649       def test_sin_array_rank1(self):
11650          arg=numarray.array([9.7813278790190594, -15.410822535775822])
11651          res=sin(arg)
11652          ref=numarray.array([-0.34904322255989967, -0.29278743949712893])
11653          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11654          self.failUnlessEqual(res.shape,(2,),"wrong shape of result.")
11655          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11656       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11657       def test_sin_array_rank2(self):
11658          arg=numarray.array([[7.5709622007726978, -96.010110171854322, 64.464875837548789, 18.074098255478049, -79.887891912588785], [-61.137259666889591, 24.376915700677898, 1.6520396981142653, 73.282870077726415, 37.390208438590236], [-18.018770402944398, -20.185849422983694, 16.072369015111192, 52.807262209935885, 19.287397979810578], [-77.896963892166468, 49.777355373857489, 61.194119343070525, 50.551462513063115, 15.922964094659335]])
11659          res=sin(arg)
11660          ref=numarray.array([[0.9602166212011517, -0.98171332509549469, 0.99806455979119224, -0.70004296831489288, 0.9753000889147212], [0.99234692329352858, -0.68588964365820848, 0.99670157217596123, -0.85535672018082665, -0.30401412851360171], [0.73846127084748792, -0.97262998476338458, -0.3563941257877799, 0.56448804411955977, 0.42398607347515932], [-0.59948094483604641, -0.46897252800353989, -0.99776052848304986, 0.28209783791975507, -0.21334823597722449]])
11661          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11662          self.failUnlessEqual(res.shape,(4, 5),"wrong shape of result.")
11663          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11664       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11665       def test_sin_array_rank3(self):
11666          arg=numarray.array([[[-58.576474897348007, 54.809262272793802], [-92.545446097205968, 85.575190211710776]], [[38.681288743038209, -11.603575878192785], [-95.597383200249268, -13.02556705264513]], [[61.706270910680416, 85.490591964337312], [71.624027820036616, -25.863896412300605]], [[25.476947591593444, 70.435340495814557], [-30.073684565633215, 67.490356578240863]], [[4.9713423686298341, 91.911859760915974], [30.367874697055328, -84.144554970831109]], [[98.391390622536989, 31.732748787807651], [-14.934490963501432, -59.311188442325168]]])
11667          res=sin(arg)
11668          ref=numarray.array([[[-0.89737553935745262, -0.98581911829326108], [0.99136145080590388, -0.68323847477655364]], [[0.83170798407592028, 0.82079120409534756], [-0.97563646528573944, -0.44322793023104901]], [[-0.90251845539243469, -0.61909542454627942], [0.59124622666754811, -0.66773000309600883]], [[0.33744969840141792, 0.96879003389058782], [0.97399495168350392, -0.99854852911307401]], [[-0.96665851232305666, -0.72129680977545241], [-0.86645223153963946, -0.62758444363043242]], [[-0.84255979532259895, 0.31154854639750068], [-0.698623841417506, -0.37005848663264262]]])
11669          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11670          self.failUnlessEqual(res.shape,(6, 2, 2),"wrong shape of result.")
11671          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11672       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11673       def test_sin_array_rank4(self):
11674          arg=numarray.array([[[[-50.615462747878006, -66.973812639371985, -77.708206606928769, -36.431802774059221], [84.078764335768454, -86.057175975235566, -4.2507864983636097, 32.605074036304671], [-35.47698277417679, -32.850292882440925, 19.746311000390619, 96.575011359809082]], [[37.550695304429951, -85.192245059759713, -19.585580977316283, 4.9299086609782705], [70.955489529502842, 64.084022545666187, -35.537247087129771, -47.717715879912468], [3.8361995697958662, 95.532145761226531, -51.581690563318517, -23.90597768756011]]], [[[-85.885115626404513, 27.544257154700233, 57.776442658393961, -22.764439696740865], [9.7442723032797431, -47.221529831578344, -24.523464073641321, 22.843310070989517], [67.821301169614003, 19.731335445973343, -74.187754964775991, -69.863316195387767]], [[64.051377288481888, 13.397049375815271, 7.2977357293966065, -53.46018591213759], [18.669622257829204, 64.3833982650888, 43.248464847568329, 55.630477540818163], [69.55974394554579, -47.17349597543474, 13.955474294777375, 57.58228196835239]]], [[[-67.48312543703419, -79.807110080995614, 29.982433513595652, -41.775471818361368], [-36.948208936105289, -81.305101266586661, -85.068091915731998, -25.025548528744793], [-18.039651899818338, 6.4567829828828138, 78.793240634732797, 32.996039522485205]], [[-99.940020762322376, 68.326160737955007, -61.082363029407126, 54.949813891014884], [80.038229033350177, -33.552375886074117, -31.608129371983892, 64.177422432822794], [32.303265514373805, -76.156866511153297, 64.174936832666873, 11.368893661666618]]]])
11675          res=sin(arg)
11676          ref=numarray.array([[[[-0.34287929276723833, 0.84166917263443375, -0.73901678422019978, 0.95430012717376367], [0.67741096998138572, 0.943875804457038, 0.89533992846215704, 0.92805179004897842], [0.79527653438049994, -0.99070785666439132, 0.78130571381342773, 0.72728711253181411]], [[-0.1478722649927692, 0.3609099416305746, -0.67134722109833267, -0.97643572609341589], [0.96386290831076604, 0.94966646919227582, 0.83034577260054665, 0.55953618516020254], [-0.64008348060134623, 0.95925856748150318, -0.96776708303022096, 0.94140212104966459]]], [[[0.8733869978866744, 0.66692680849003383, 0.94174275492293247, 0.69849419559794712], [-0.31408653242230877, 0.097484958579927491, 0.57227483208076302, -0.75270519985308859], [-0.96186401066781391, 0.77187148397831629, 0.93578136651060684, -0.68037764724345384]], [[0.93893574912137301, 0.73838928073958066, 0.84924325972879255, 0.053085835853353053], [-0.17896430849100536, 0.99981470265224548, -0.66972046488018222, -0.79450391882013482], [0.43019210289246596, 0.04958582917574688, 0.98353924979282858, 0.85915404611622637]]], [[[0.9981329609384284, 0.95429554635975633, -0.99058870054119763, 0.80446088766755564], [0.68229912906486578, 0.36748906525527336, 0.24264389693973754, 0.10698753894470732], [0.72422099416087193, 0.17272706090204004, -0.25072034421713113, 0.99995660023908339]], [[0.55714530958135622, -0.70956285806092356, 0.98407671685665454, -0.99960641285478424], [-0.99738144842386833, -0.84423878131865737, -0.19102162937524009, 0.97474344445505001], [0.77539411931850055, -0.68793708162803491, 0.97418533082369707, -0.93112187460985318]]]])
11677          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11678          self.failUnlessEqual(res.shape,(3, 2, 3, 4),"wrong shape of result.")
11679          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11680       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11681       def test_sin_constData_rank0(self):
11682          arg=Data(35.9258166114,self.functionspace)
11683          res=sin(arg)
11684          ref=Data(-0.979567062569,self.functionspace)
11685          self.failUnless(isinstance(res,Data),"wrong type of result.")
11686          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11687          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11688       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11689       def test_sin_constData_rank1(self):
11690          arg=Data(numarray.array([11.05411721386011, 92.760749350185449]),self.functionspace)
11691          res=sin(arg)
11692          ref=Data(numarray.array([-0.99828685225980784, -0.99649367379012466]),self.functionspace)
11693          self.failUnless(isinstance(res,Data),"wrong type of result.")
11694          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11695          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11696       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11697       def test_sin_constData_rank2(self):
11698          arg=Data(numarray.array([[86.368381659051408, -41.695780796282492, -58.183479792434831, -70.875178760715073, -20.678382721502217], [17.695341117085974, 2.740439328337672, 62.183987328150124, -22.389692204658516, 25.527065283434851], [-19.879704086428717, 97.930429727602103, 16.055583599572529, -16.208182451420882, 54.913306337155262], [-69.833724282794194, 31.117621263412161, 97.441216860315848, 31.002527925222012, -33.156619640633039]]),self.functionspace)
11699          res=sin(arg)
11700          ref=Data(numarray.array([[-0.99967702286155391, 0.75462098315788761, -0.99795169465255495, -0.98212790490620516, -0.96689443052183988], [-0.91447752242728786, 0.39048036598212266, -0.60348598179363533, 0.3880765237690833, 0.38418420577157436], [-0.85737525785576585, -0.5150427020633046, -0.34066144314268004, 0.47961787867933503, -0.99791639785660491], [-0.65839615788937589, -0.2939007480209867, -0.051821376961544853, -0.40172395652639609, -0.98560222500947936]]),self.functionspace)
11701          self.failUnless(isinstance(res,Data),"wrong type of result.")
11702          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11703          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11704       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11705       def test_sin_constData_rank3(self):
11706          arg=Data(numarray.array([[[-9.383136985495085, 51.313988740117281], [-84.286741947414299, -12.349769403836447]], [[-58.98719875193035, -69.772217254427616], [25.488307874218165, 60.443485945243793]], [[80.648598553510482, 92.976864439316103], [4.2817739078012664, 91.184638461427113]], [[-76.55157819489709, -16.719487135234104], [13.038521969338817, -14.062881841606639]], [[-60.572162238841166, -8.277832942135376], [90.508007133317363, 9.9045178477461775]], [[43.319148489339796, -36.82759950317913], [23.772826290958989, 23.859083701318681]]]),self.functionspace)
11707          res=sin(arg)
11708          ref=Data(numarray.array([[[-0.041628942278232502, 0.86667902768507166], [-0.5109243145942064, 0.21491149901715179]], [[-0.64655635572868242, -0.61088574863445955], [0.34812162256726858, -0.68399529227053291]], [[-0.85874246895135953, -0.9553716024683695], [-0.90870917195229073, -0.078371058632619367]], [[-0.91412907684432942, 0.84764134621368814], [0.45480331572319638, -0.99724213056634026]], [[0.77194923151153583, -0.91151176131243561], [0.56313928014945791, -0.4615484409914466]], [[-0.6156012262898336, 0.76530325949300315], [-0.97784680058787665, -0.95617812015239778]]]),self.functionspace)
11709          self.failUnless(isinstance(res,Data),"wrong type of result.")
11710          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11711          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11712       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11713       def test_sin_constData_rank4(self):
11714          arg=Data(numarray.array([[[[-82.266761499442822, 10.258465683133593, 35.258711312343792, 83.260426498166652], [44.545759248512837, 78.847333090045225, -91.458863199213994, 88.135667192818687], [55.303615717334651, 57.343360606367497, 72.386684244462259, -77.851237894363791]], [[7.6357829095114624, 58.043761182779804, 32.459127943514119, -46.057054845382581], [-62.173352222977194, -91.055460532286546, 1.908599997174349, 50.256424878237198], [80.737361916893349, -59.097170441109384, -11.392890659087485, -17.113974908227121]]], [[[-69.94898633515831, 41.553507654384049, -2.0229189980548909, 11.130327214085185], [27.241980003875298, -92.430057302595131, -59.821389090442324, -10.836164150097432], [-97.960459786173644, 77.056043492990739, 18.592655235604354, -99.221726011137193]], [[-62.79302507786295, -60.628776679562854, -92.135333094895984, -7.7874612902526792], [-59.349180405626001, 98.544187052373076, 25.967954318471186, 26.092417193137578], [15.354438427681245, -0.13204595002771669, 57.604938537040567, -78.12077453253174]]], [[[26.134134711410127, -21.654760380881413, 91.027816009977528, -70.493423376080287], [50.18077929890714, -45.818068992158459, 17.514556104968705, -87.948924607482581], [-2.9358337467884752, 52.58088647758106, -88.281586106394585, -37.905045294843575]], [[9.2050228670356233, -53.760066650396411, -36.646477787406951, -50.989346886330431], [46.181223758729573, -56.454456456188559, 0.97893723365712049, 67.524717727099727], [76.315867619424694, -64.23482558405928, -9.4212307356945644, 94.459095295520825]]]]),self.functionspace)
11715          res=sin(arg)
11716          ref=Data(numarray.array([[[[-0.55249323661859384, -0.74041510223459006, -0.64512901510731857, 0.99996620630617827], [0.53411628907438291, -0.30269281624662714, 0.34541056811800569, 0.17023967780324173], [-0.94741280897254443, 0.71364847302087853, -0.12968690532551203, -0.63544017109361273]], [[0.97628895760467316, 0.99713590303276967, 0.86402042247071265, -0.87567650001557451], [0.61193184565404779, -0.050704669999494079, 0.94348483865887567, -0.00905745535309368], [-0.8099383976922776, -0.55892595044018734, 0.92210273022629663, 0.98645369822246709]]], [[[-0.74058999329446951, -0.65395701522909533, -0.89952178562120422, -0.99093455465566593], [0.8585084340096536, 0.96966836773299581, 0.13075320819151812, 0.98732108746426506], [0.54054731770475606, 0.99621584600900559, -0.25408417591070465, 0.9659884230955289]], [[0.038818238402855587, 0.80668212053066524, 0.85685909391293247, -0.997788337658438], [-0.33450508434738102, -0.91472013442829736, 0.74143951598281521, 0.81900568441531063], [0.34620680919904595, -0.13166255596987642, 0.87052630534488828, -0.40688535076780291]]], [[[0.84222306949426196, -0.33007987762886654, 0.078290742973310345, -0.98154597956213518], [-0.084601909290267188, -0.96509891341258691, -0.97232857103810033, 0.015669051785311802], [-0.20431011725232823, 0.73535381865796079, -0.31170965722815802, -0.20448097728983067]], [[0.21799061313810039, 0.34570643936958911, 0.86873084472110407, -0.66228504096565033], [0.8091276300491409, 0.094072003936346266, 0.82990491677663747, -0.99980940641969562], [0.79417206042993815, -0.98595060503156651, -0.0035472176358126886, 0.209746502418206]]]]),self.functionspace)
11717          self.failUnless(isinstance(res,Data),"wrong type of result.")
11718          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11719          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11720       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11721       def test_sin_expandedData_rank0(self):
11722          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11723          arg=msk_arg*(64.9800250937)+(1.-msk_arg)*(-13.9362171446)
11724          res=sin(arg)
11725          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11726          ref=msk_ref*(0.837897949793)+(1.-msk_ref)*(-0.979877440358)
11727          self.failUnless(isinstance(res,Data),"wrong type of result.")
11728          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11729          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11730       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11731       def test_sin_expandedData_rank1(self):
11732          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11733          arg=msk_arg*numarray.array([38.770149608840256, -60.012793688818753])+(1.-msk_arg)*numarray.array([-99.060327275798542, -82.301745794852508])
11734          res=sin(arg)
11735          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11736          ref=msk_ref*numarray.array([0.87769828831808394, 0.31697021887466476])+(1.-msk_ref)*numarray.array([0.99498831041282509, -0.58130924307676168])
11737          self.failUnless(isinstance(res,Data),"wrong type of result.")
11738          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11739          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11740       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11741       def test_sin_expandedData_rank2(self):
11742          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11743          arg=msk_arg*numarray.array([[1.8437603079485996, -55.085629630896008, 0.76077789325732681, 75.303888016859787, 44.134994661850783], [79.846819977879846, 55.190840097906744, 66.852695154059461, -2.7788078944115426, -33.754582563675072], [79.437692683252919, 25.719174268770573, 22.693852460282187, 73.984833469926286, 34.325902065505829], [36.438188095997873, -58.458802817368706, 35.872691199405381, -97.828193056307839, 17.582825707314015]])+(1.-msk_arg)*numarray.array([[5.857972204383401, 68.980392763644375, -31.110427811729835, 60.164069309555259, 59.562550189394926], [-79.365962953462713, -74.725764079778173, 85.216081299963463, -56.646488172185805, 46.373883249354861], [-96.708272172455125, -53.912331939216031, 50.478527343574285, -97.278578429153086, -19.251159449913018], [89.592226731549431, -48.83081996413825, 86.246650594081075, -29.89076793492336, -45.154211051500191]])
11744          res=sin(arg)
11745          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11746          ref=msk_ref*numarray.array([[0.96297607712265498, 0.99419970184494533, 0.68948508165976352, -0.094195812584939725, 0.15210480698702625], [-0.96540800347437894, -0.97740775938701152, -0.77026043446389958, -0.35487911125423122, -0.719398961710221], [-0.78200505820620614, 0.55339355773313237, -0.64628337521816626, -0.98763721556473016, 0.22955176403585492], [-0.95237243281291895, -0.94297498574434913, -0.96750562604917711, 0.42487228151059697, -0.954126976601816]])+(1.-msk_ref)*numarray.array([[-0.4125149172810601, -0.13423914232300688, 0.30076884437212431, -0.45627887875349671, 0.12736335490838124], [0.73532534193785637, 0.62291199948324294, -0.38303500671569563, -0.097664477681636913, 0.68164355585755676], [-0.62964804242596883, 0.48403219384114982, 0.21143692166914244, -0.11056730045170879, -0.39089478845779391], [0.99838526337700328, 0.9907480912937221, -0.98919334458602826, 0.99895877973110281, -0.92149562271137819]])
11747          self.failUnless(isinstance(res,Data),"wrong type of result.")
11748          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11749          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11750       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11751       def test_sin_expandedData_rank3(self):
11752          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11753          arg=msk_arg*numarray.array([[[-38.413084764990302, -51.052907554914874], [-70.505293089549951, 90.313652142673448]], [[14.910063396779577, 5.5459023128808838], [-17.734013723516611, -0.2879278829081926]], [[-22.114710637688262, 46.626248466538811], [67.532808824706478, -59.397222523445059]], [[92.618471591726234, 73.621613593824065], [88.375553175968605, 5.7283336450617099]], [[53.683923353330755, -77.160809717487297], [-34.501807709057687, -33.073637412461139]], [[27.624848265822479, 15.259019682038172], [0.55157605306179391, -71.932924310466888]]])+(1.-msk_arg)*numarray.array([[[-34.335248638101717, 68.752336646733312], [-43.346716752254302, -8.6223337031949683]], [[-35.640511588324259, 29.644108535921475], [64.496990192063578, 38.316350896738442]], [[-42.749910167259664, 9.2631745284455604], [73.587108766995641, -96.934463397218067]], [[-74.560330219656223, 2.8651995440780524], [65.274936254565944, -71.732320070952852]], [[66.378370922669262, -31.104012988746703], [38.402067771718777, 88.070193006735252]], [[-3.3040251330990884, -30.446998125502006], [53.53952042332989, 49.143306316308468]]])
11754          res=sin(arg)
11755          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11756          ref=msk_ref*numarray.array([[[-0.65484153130973721, -0.70853858647854739], [-0.98374658316761376, 0.71213510355429321]], [[0.71589133616462552, -0.67227900197685508], [0.89814931915579443, -0.28396601912126207]], [[0.1232478868102998, 0.47735428568469945], [-0.99993464136673393, -0.28886194517886638]], [[-0.99828867944095934, -0.97889500442468336], [0.3994885492462833, -0.5268172219749746]], [[-0.27332526710635363, -0.98166466097630112], [-0.055682665640661121, -0.99622530762962569]], [[0.60477683330883625, 0.43401404656957493], [0.5240302030950843, -0.31808294342294718]]])+(1.-msk_ref)*numarray.array([[[-0.22044488395248701, -0.35480148713588266], [0.59364467642489349, -0.71905687697203813]], [[0.88336425850768363, -0.97986309124469417], [0.99555320691853921, 0.57878587408359439]], [[0.94328393594361259, 0.16090095326994339], [-0.97126219531557589, -0.43938044812272531]], [[0.74323543603717557, 0.27288743671671112], [0.6430769524396025, -0.50061664432606201]], [[-0.39395000791253521, 0.30688041201024424], [0.64647568844428205, 0.10540255889338963]], [[0.16171914304468005, 0.82427947074375341], [-0.13205843112469617, -0.90104641666580576]]])
11757          self.failUnless(isinstance(res,Data),"wrong type of result.")
11758          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11759          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11760       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11761       def test_sin_expandedData_rank4(self):
11762          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11763          arg=msk_arg*numarray.array([[[[-68.525560759670157, 72.014851464858708, -96.064109131678975, 77.226473627484438], [10.661045262101496, 17.374475984434937, -70.970539568996642, -86.5663539792791], [42.328708688260292, -49.606342449617813, -41.332552022078197, 5.781826685010131]], [[32.656794594741456, -45.69741225061923, -75.977367014659336, 65.992637114312402], [-24.968933149299261, -19.170628852284295, -82.992054567050218, -69.278260336258882], [45.308496224570149, 58.254105930225364, -52.053961481820508, -99.633451029223679]]], [[[57.389652364413365, -6.4497448547971459, 67.302050277783934, -64.487213635922004], [2.7850477397074656, -37.14171412837635, -45.831747383644263, -81.22619991798237], [28.555595155095858, 6.3743955466930515, -9.7644609522321133, -2.1997743618038328]], [[35.568247785419004, -31.599877667329878, 82.028553557923146, -78.86370276205146], [-99.731804643220002, 69.776357240610565, -12.167123991837968, 33.790715856665315], [-10.562353591062944, -16.629309453963131, -77.001863431944969, 52.718875999701169]]], [[[-98.376736649980899, 29.119393841437898, 75.366820567618731, -66.514039609932439], [-88.471818477178289, 47.880968729353668, 65.085879417509886, 84.296285545557623], [-86.151465152354675, 9.1305089222339433, 3.0045836139087356, -81.15026537989543]], [[19.458035685379343, -16.79612796438164, -62.697038154714392, 82.150007929305815], [51.125444489928753, -39.220742821773079, -31.48429119581813, -40.990991828400048], [-20.250208920559061, 52.655819512739868, 26.546619397350256, -77.359673716677449]]]])+(1.-msk_arg)*numarray.array([[[[-18.615245719283436, 96.201699795366437, -82.66494125542863, 33.07492631817621], [82.443853712892633, -34.736058741884463, -95.351325060809899, 59.914700106027027], [-31.967579463417351, 45.580214173517021, -85.610494042354162, 49.498206680862722]], [[47.852867738343264, -35.372573605242792, 2.511993838319043, 94.155389339549941], [-1.38794622700091, 85.930835412964996, -85.707091771314651, -46.64999398418388], [57.879302040774746, -50.458699813236429, 25.001254046544503, -59.801937388884156]]], [[[99.915640912459565, 42.356808810363106, -15.646740182074836, 72.140752053033623], [22.725076309780334, -0.022312650774281906, -7.1186223183705266, -26.368838179359486], [66.038559283219001, -17.561521846617723, 4.9702769173480306, -59.711097000633437]], [[-78.084063698630573, -45.932568204284749, -45.100652927345664, 80.338502970189182], [50.249408685318571, 27.311139139809868, 9.9265850486579552, -56.606805234548688], [7.2672257036688848, 49.011928816065478, -54.764618596546889, 70.942797505173303]]], [[[61.689516820950246, -58.515211403448731, 53.79986661743186, -81.589305129450977], [74.672959560216214, 61.905849543205051, -27.673934374496582, -43.264203000639313], [66.074534000186645, -29.171690529749995, 62.854710104264711, 28.934380662657873]], [[72.033136619176673, 0.8371610199688746, -21.89771655702684, 35.848349672772173], [14.782846328746871, 69.671698166617858, -71.840672845829047, -65.869180747022639], [-87.952973126148649, -58.34136644843764, 58.528431489251943, -45.940658422238933]]]])
11764          res=sin(arg)
11765          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11766          ref=msk_ref*numarray.array([[[[0.55592687965297938, 0.23943081082144563, -0.97000785672325052, 0.96704147053511302], [-0.94456504679141606, -0.99542268261330857, -0.95974459076326801, 0.98514911686367079], [-0.99657468842237251, 0.61243723818846874, 0.47225521641568707, -0.48061739888675808]], [[0.94606558536471286, -0.98960410832751255, -0.54730716207657015, -0.01919021088691918], [0.16307648225519095, -0.3155848432241144, -0.96635121146850689, -0.16249817830586416], [0.97023493524697935, 0.99094947267277556, -0.97640053267971305, 0.78177909697867587]]], [[[0.74529994268538491, -0.16579049701658166, -0.97081465164637015, -0.99642657514017952], [0.3490385329297237, 0.52897960232366481, -0.96142656801469195, 0.4396501084403685], [-0.277567581500057, 0.091083824433171562, 0.33318821411150523, -0.80862917156767822]], [[-0.84721913137013771, -0.18291546159728064, 0.34021409508202199, 0.31825330538480789], [0.71677079367561358, 0.61415820889112394, 0.38872432525224898, 0.69383676427292507], [0.90761842336617005, 0.79641644551081814, -0.99946070339480197, 0.63514722255050504]]], [[[0.83457694337317756, -0.74801090758055289, -0.031397957395935407, 0.51464528088708705], [-0.4857527846740865, -0.68680120896912167, 0.77553765270553499, 0.50269724950691053], [0.97078081455322718, 0.29004038701884971, 0.13658079814321689, 0.5065197281697561]], [[0.57162074004370722, 0.88577662065266316, 0.1344069097928022, 0.45163669702654402], [0.75781779092430412, -0.99879162771218244, -0.06831141940693769, 0.1497222316080222], [-0.98556050825669073, 0.68255692976113103, 0.98771358789813224, -0.92466033167086703]]]])+(1.-msk_ref)*numarray.array([[[[0.23217209197051894, 0.92750140233150447, -0.83245973502718251, 0.99611259648561323], [0.69069140539580076, 0.17759253084678614, -0.89280995913599226, -0.22256013812798214], [-0.52409567549761338, 0.99963225645305609, 0.70858607515885852, -0.69417690883737659]], [[-0.66610766977352276, 0.72776291956861339, 0.58882054224263247, -0.092258884266531088], [-0.98332944541626977, -0.89473334399200433, 0.77333845218638109, -0.45635622904471135], [0.97129944223643883, -0.19201736907284048, -0.13110863189212127, 0.11144498092658177]]], [[[-0.57722312856525515, -0.99850476462170312, -0.061184846303749152, 0.11561981763652862], [-0.66979133087446185, -0.022310799411864708, -0.74158975309064767, -0.9445091028081305], [-0.065067556442604341, 0.96028840893223799, -0.96693079262155868, 0.020835074713991906]], [[-0.44013825745236268, -0.92885934187433605, -0.89938286674246037, -0.97414519119251186], [-0.016073079973959268, 0.82101963337083039, -0.4810106237620847, -0.058104725027164135], [0.83274117746688869, -0.95009916753271018, 0.97734765469722507, 0.9671663248687612]]], [[[-0.90960662105081236, -0.92270873486286653, -0.38276882002523788, 0.091973697724973463], [-0.6633331176425904, -0.79922431918451375, -0.56497215635127529, 0.65795064607285259], [-0.10091619527458537, 0.78168104056774534, 0.022855042267844725, -0.61315380741542369]], [[0.22163847286200966, 0.7427452080440865, -0.093296140968069, -0.96106487708897625], [0.7986911357951999, 0.5283532279670673, -0.40406659748310347, -0.10407616703187229], [0.011620912790781377, -0.97548053305667226, 0.9175319386483336, -0.92583209645347753]]]])
11767          self.failUnless(isinstance(res,Data),"wrong type of result.")
11768          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11769          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11770       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11771       def test_sin_Symbol_rank0(self):
11772          arg=Symbol(shape=())
11773          res=sin(arg)
11774          s=numarray.array(-59.3916014281)
11775          sub=res.substitute({arg:s})
11776          ref=numarray.array(-0.294238825658)
11777          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11778          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11779          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11780       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11781       def test_sin_Symbol_rank1(self):
11782          arg=Symbol(shape=(2,))
11783          res=sin(arg)
11784          s=numarray.array([-77.518180416339703, -99.902097052938913])
11785          sub=res.substitute({arg:s})
11786          ref=numarray.array([-0.85296306795174082, 0.58822958187337715])
11787          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11788          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11789          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11790       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11791       def test_sin_Symbol_rank2(self):
11792          arg=Symbol(shape=(4, 5))
11793          res=sin(arg)
11794          s=numarray.array([[-68.776025628098921, 18.583534072810437, 2.5030615885359282, -81.568488722453594, -86.093220779774867], [-67.221717338138347, 7.8150319629840936, -38.212473776124511, -35.413212843434039, -29.084029341527298], [44.463615730285483, -35.607990030177803, 7.7479366716322886, -27.403061449775464, -36.661576208361481], [38.270555455018439, 43.395245412009388, -83.395946138420143, 82.237580019924621, 14.004270430298305]])
11795          sub=res.substitute({arg:s})
11796          ref=numarray.array([[0.33255619605642595, -0.2628953097831197, 0.59601657099216188, 0.11268044966812327, 0.95516575752479826], [0.94843820301578952, 0.99924155745678056, -0.49110859112560667, 0.75502592312392947, 0.72407716039519021], [0.46294834755613434, 0.86765740613097231, 0.99438250025762476, -0.76514881632423337, 0.86115409814746968], [0.54084686431197915, -0.55390877782719994, -0.98968706359916092, 0.5279381946907461, 0.99118224805070021]])
11797          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11798          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11799          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11800       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11801       def test_sin_Symbol_rank3(self):
11802          arg=Symbol(shape=(6, 2, 2))
11803          res=sin(arg)
11804          s=numarray.array([[[-37.699048834122337, 67.487864519915888], [2.9828406413621451, -24.732359622933814]], [[-61.929665641026645, -68.476378179772155], [-32.237324902859314, -7.6070318207624581]], [[60.977769128483089, -72.382514925143823], [-46.560105241719477, 45.937821630681839]], [[83.263439432502082, -92.94384685128874], [51.849927093272044, -78.761237021574999]], [[91.585054594657009, -36.002253133666869], [53.726162646665756, 51.861195467288468]], [[-47.206562095893624, -54.234991663118073], [24.635547568924366, 10.897512608905188]]])
11805          sub=res.substitute({arg:s})
11806          ref=numarray.array([[[6.3008955140298549e-05, -0.99841120781631043], [0.15808603528894985, 0.38976979614921003]], [[0.78468476326272762, 0.5961202571458688], [-0.73209911016042217, -0.96966254162590804]], [[-0.96014169481053901, 0.1255516807235128], [-0.53438887581027339, 0.92690049281462372]], [[0.99993689802325469, 0.96460273897511306], [0.99990686327594558, 0.21961584215844765]], [[-0.46077448262053106, 0.99206465505959207], [-0.31370028629469887, 0.99968959551254188]], [[0.082578150729693003, 0.73652370204730333], [-0.47696085874176203, -0.99519580523955087]]])
11807          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11808          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11809          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11810       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11811       def test_sin_Symbol_rank4(self):
11812          arg=Symbol(shape=(3, 2, 3, 4))
11813          res=sin(arg)
11814          s=numarray.array([[[[-15.890402342693434, 0.34967079278480639, -69.644962745437795, 42.940560221661485], [-87.145936678451136, 49.455183015727584, -55.024672865086053, -33.720006009004152], [-60.374597103391658, -10.062767069904965, -26.275100187070336, 73.475919773065471]], [[-21.069235104213391, -32.962767163632307, -83.961409610894236, 56.598525324661068], [10.664148354586175, -84.175124335735191, 70.938373649792197, -50.885634199045818], [-3.7753473336700836, -64.579189053025345, 39.526279799984962, -78.118476532600027]]], [[[-87.539170348669316, 53.990171737005767, 75.031120602988295, 89.786150540127636], [15.24565797164064, 47.14487621807001, -38.076038239089939, -71.863955067032919], [54.427160884365065, -51.643922687914447, 31.69388597837235, 63.197010162156403]], [[40.095787791911192, 68.569022656716015, 83.368763637032373, -64.130086266478315], [-56.640669699135394, 28.887347050286337, 42.538464681579825, -0.81329085125044287], [78.334444852851078, 53.976051151834668, -92.677265657880042, -67.717790405619212]]], [[[94.55646393436794, -74.072328469071493, 15.628014750861269, -19.08383918357049], [0.34503678387962111, 24.723546408702205, -72.452170470947522, -66.788152868232629], [61.510016195707891, 66.878349407366471, 84.66308347515232, -15.120176750922298]], [[-31.566786151962461, 45.449410239249346, -90.349459031765548, -27.203984637101513], [-39.051741216817845, -72.264868220520867, -67.902622230428847, -59.158845980218722], [0.52167726472671916, -10.820231066135364, 71.585444977834385, -19.920876608835187]]]])
11815          sub=res.substitute({arg:s})
11816          ref=numarray.array([[[[0.18142870681923798, 0.3425885406050273, -0.50546808260791642, -0.86328219433933273], [0.73022937255072884, -0.72449360648452032, 0.99890501309408652, -0.74298095956355081], [0.63215918874375432, 0.59558130798366149, -0.90961605511692745, -0.93885469749753936]], [[-0.79675938208265107, -0.99971307596321124, -0.75888030600764067, 0.049836906821785487], [-0.94557931825783614, -0.60349520540713741, 0.96828115466442444, -0.58115865307416081], [0.5921744828383132, -0.98445730548018506, 0.96731639813302839, -0.40898344979772361]]], [[[0.41270698122918936, -0.55061151710067213, -0.35891304360076959, 0.9687241365310475], [0.44601259199410115, -0.020984873750761551, -0.36806437453098872, -0.3826620757098414], [-0.85215290965973867, -0.98155654013732874, 0.27439398566293094, 0.35709603191044931]], [[0.67791057877776606, -0.5192863947552645, 0.99321476652686747, -0.96308406338850749], [-0.091872199916891564, -0.57533459294226186, -0.99195091057653295, -0.72655228515132986], [0.20393085417395668, -0.53876969374246431, 0.99999996013162051, 0.98497824474943119]]], [[[0.30380541290205748, 0.97016130669394118, 0.079863375608460366, -0.23214588781170803], [0.33823129342514735, -0.39787075152274376, 0.19429572151212773, 0.72752470593055507], [-0.9691693331376533, -0.78636565705333028, 0.15923742302181473, -0.5545203884228973]], [[-0.15028804065876869, 0.9946297066698937, -0.68654604166089739, -0.87736813185980267], [-0.97629583471350656, 0.0082370948053343829, 0.93646621708071842, -0.50675322220049412], [0.4983350007448592, 0.98466672326147653, 0.62191520543510515, -0.87783383304733476]]]])
11817          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11818          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11819          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11820       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11821       def test_cos_float_rank0(self):
11822          arg=12.8022737001
11823          res=cos(arg)
11824          ref=0.972303667601
11825          self.failUnless(isinstance(res,float),"wrong type of result.")
11826          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11827       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11828       def test_cos_array_rank0(self):
11829          arg=numarray.array(81.9030902279)
11830          res=cos(arg)
11831          ref=numarray.array(0.975529175116)
11832          if not isinstance(res,float):
11833             self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11834             self.failUnlessEqual(res.shape,(),"wrong shape of result.")
11835          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11836       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11837       def test_cos_array_rank1(self):
11838          arg=numarray.array([-3.1659404550478598, -78.770544011004517])
11839          res=cos(arg)
11840          ref=numarray.array([-0.9997036069247125, -0.97350024454745809])
11841          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11842          self.failUnlessEqual(res.shape,(2,),"wrong shape of result.")
11843          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11844       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11845       def test_cos_array_rank2(self):
11846          arg=numarray.array([[-30.794187778759778, 0.85080886747965678, 72.306186238999288, 6.9748772974918012, 79.516672956944063], [86.786469847342659, 3.7028708915669171, 80.37984411727453, 88.481994155573062, 44.230357294268288], [-58.302217071119557, -55.178139958451936, 87.593515438312323, -24.785367985815171, 98.359589229615466], [-31.854839257078595, -9.0018909167008729, 4.7136540476817572, 16.002129052312014, -11.789662012845042]])
11847          res=cos(arg)
11848          ref=numarray.array([[0.81286694784924007, 0.65937524376097301, -0.99877239201012524, 0.77016789679198738, -0.55963036169023139], [0.38265829523948425, -0.84657543666548907, 0.26599065257267407, 0.8691082050444322, 0.96939052643352663], [-0.18173739330410366, 0.1989324917250061, 0.93193666987235591, 0.94027018029592546, -0.56512054377873722], [0.90521424329995193, -0.91190791424406981, 0.0012650669596327702, -0.95704434909532998, 0.7132244558805807]])
11849          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11850          self.failUnlessEqual(res.shape,(4, 5),"wrong shape of result.")
11851          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11852       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11853       def test_cos_array_rank3(self):
11854          arg=numarray.array([[[50.387970299672958, 29.283929509977696], [-66.772009838509376, 60.429920999281819]], [[-8.5766208394698822, -60.883217299800329], [95.242982403475651, -86.115091741382543]], [[-52.324500845707703, 25.632872154700763], [-0.58350729326133433, -24.097894724429821]], [[-56.715089150416162, 84.206037318419675], [-36.690358592980928, -19.579806089690194]], [[-13.309049137718802, -73.64720223221002], [-44.056513958126729, -89.338449548164448]], [[39.590677420492995, 71.64654237642219], [-60.51045883245412, -14.000945362814974]]])
11855          res=cos(arg)
11856          ref=numarray.array([[[0.99250773865265618, -0.53220311324739533], [-0.69773603296499365, -0.73869738226508386]], [[-0.6613665430403447, -0.36891317441110316], [0.54433278152098952, -0.27511203517551286]], [[-0.46905641157801509, 0.87751978510932405], [0.83453542849264828, 0.51065791183165576]], [[0.9861838930452187, -0.81563853576330847], [0.53291609526312445, 0.74500754948473746]], [[0.73665981590171459, -0.17925105881386577], [0.99724719663050987, 0.19567045990235213]], [[-0.31529666740670903, -0.81959722640487132], [-0.68207612410963148, 0.13580067388724723]]])
11857          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11858          self.failUnlessEqual(res.shape,(6, 2, 2),"wrong shape of result.")
11859          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11860       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11861       def test_cos_array_rank4(self):
11862          arg=numarray.array([[[[8.8585796551860625, 56.230722191967914, 32.019025852785489, -76.240723304025721], [-47.749040562512789, -98.339434837051783, 70.859766363200237, -98.311574089761322], [-52.324580920881303, 96.326373563570314, 69.773493973765369, 34.547548410615576]], [[-81.713903361911818, 96.89515505261167, 32.14011355478587, 40.833117226994347], [88.359411641871901, 99.260851582320299, 32.291978752467458, 34.648053452706648], [62.889324490972825, -83.646300835071457, 22.610216303248336, 66.616016567138644]]], [[[-17.197294613142319, -3.6842582419897667, 78.922021411276916, 35.992025233043194], [-92.506302343396186, -12.80399377292683, -18.033493882610045, 72.067566702745893], [21.035957164282863, 70.855105287036082, -8.5253976863984349, 80.750151682605122]], [[-8.8417506220947359, 61.36510079425446, -25.644929133852216, 40.188275611212987], [-25.669229350991557, -16.113815339165384, 43.92335634612391, 90.772865066514441], [26.034572422228308, -2.8711185835616675, -30.821975852409707, 99.67303892757721]]], [[[-12.673601706489663, 2.304354282387223, -44.91890224201309, -51.245125847269122], [-36.174794536889479, -6.8764825759013206, -68.713937504645145, -97.121693324391245], [-92.116548149907402, -51.150678601242895, -85.862075707093993, -26.492481960906773]], [[-9.3549875850648334, 91.091860017849058, 19.150635549346703, -59.957632280501507], [-30.353193336019046, -97.973159096626318, 12.100803192254858, 73.753754526126613], [-93.775512934495197, 2.0310829139235693, 31.781795131664779, 88.243508559195647]]]])
11863          res=cos(arg)
11864          ref=numarray.array([[[[-0.84394640242754804, 0.94987966856902739, 0.82358164777126441, 0.66559941934698164], [-0.81087490180541133, -0.58163218822498852, -0.173056013152627, -0.60406691123278633], [-0.46912712992167072, -0.48625395737776261, 0.79093818984192754, -0.99995029219615772]], [[0.99947210445754142, -0.8803402908496113, 0.74903829114045251, -0.99997121680753465], [0.92306683750653218, 0.29617262700437857, 0.64018888147855402, -0.99590457207030214], [0.99834897250432109, -0.38397319491648929, -0.81441978564223916, -0.80055781398499271]]], [[[-0.081374903851665389, -0.85633516088809258, -0.92784447233066147, -0.13586874199713481], [-0.16985343142213913, 0.97190021204609445, 0.68509513388229792, -0.98218051486600799], [-0.57745249597890147, -0.16846340013067879, -0.62209529663370222, 0.59682562466322531]], [[-0.83479976539592393, 0.10385643517733804, 0.8716743341110903, -0.7946115232954305], [0.85950897121254921, -0.91876633151615572, 0.99826349361266198, -0.94496069123950321], [0.62017450370660798, -0.96364433869084776, 0.82873619390006759, 0.65400783890141501]]], [[[0.99425625331526324, -0.66951670587906009, 0.59252620664860245, 0.55731867514789302], [0.046462287647983845, 0.82910169364382147, 0.92063173530463938, -0.96438740023068792], [-0.53155481457863152, 0.6331376906760543, -0.50701857453496257, 0.20949218767157707]], [[-0.9975656400559022, -0.99989737120426636, 0.95501688058642786, -0.96446857407183784], [0.4864859369011077, -0.83438138098161108, 0.89356697671985796, -0.073606205812436112], [0.89053945351718922, -0.44420488584319706, 0.93381336417866412, 0.96135492253562493]]]])
11865          self.failUnless(isinstance(res,numarray.NumArray),"wrong type of result.")
11866          self.failUnlessEqual(res.shape,(3, 2, 3, 4),"wrong shape of result.")
11867          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11868       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11869       def test_cos_constData_rank0(self):
11870          arg=Data(-61.9498622145,self.functionspace)
11871          res=cos(arg)
11872          ref=Data(0.635615451425,self.functionspace)
11873          self.failUnless(isinstance(res,Data),"wrong type of result.")
11874          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11875          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11876       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11877       def test_cos_constData_rank1(self):
11878          arg=Data(numarray.array([-89.363505318102554, 90.746151091366158]),self.functionspace)
11879          res=cos(arg)
11880          ref=Data(numarray.array([0.17104017933113105, -0.93588418955761465]),self.functionspace)
11881          self.failUnless(isinstance(res,Data),"wrong type of result.")
11882          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11883          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11884       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11885       def test_cos_constData_rank2(self):
11886          arg=Data(numarray.array([[-87.716817023452975, -13.508318618768172, -40.837878999841813, -94.821047816906486, 20.238625532480697], [10.664222985785372, 41.421464805806608, -59.947824248490633, -78.555304048035651, -8.6157242378561278], [12.921775769760472, -50.786928458875181, 14.281561344574072, -62.970825984819953, 69.030431174425786], [33.649169420684956, 31.961869743753539, 95.025401181456971, -69.38900568783086, 28.121974134384544]]),self.functionspace)
11887          res=cos(arg)
11888          ref=Data(numarray.array([[0.96945993825961785, 0.58821378024571513, -0.99999600828650015, 0.84013285161999507, 0.1807281241902764], [-0.32532112085362436, -0.83604574058067016, -0.96701340164638327, -0.99988006784331296, -0.69018350050446609], [0.93750558375153104, 0.8670997832638041, -0.1438931618585739, 0.9903587968098958, 0.99642294505936524], [-0.61504777690368062, 0.85463793445943459, 0.71258422387118503, 0.96270510850591873, -0.98841568900027077]]),self.functionspace)
11889          self.failUnless(isinstance(res,Data),"wrong type of result.")
11890          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11891          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11892       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11893       def test_cos_constData_rank3(self):
11894          arg=Data(numarray.array([[[-86.264864472603193, 7.0899163167813697], [62.034724520374027, -53.737765416027081]], [[21.737171707872307, -39.991208563910121], [41.050321790962244, -40.100213891371972]], [[80.79158486625019, 9.5468715078936839], [20.045951470114602, -73.62813814925822]], [[90.373079869171505, 55.136085676347903], [-60.773850688066375, -19.49023282382187]], [[-16.279695430573497, 70.631083378881186], [87.762984375593931, -70.166718723420061]], [[-44.704810449858392, 60.228705435547226], [-72.118752328137177, -48.200833401477624]]]),self.functionspace)
11895          res=cos(arg)
11896          ref=Data(numarray.array([[[-0.1285765694430033, 0.69186243246368828], [0.69876368539675648, -0.9458184296187333]], [[-0.96792086970536395, -0.6603617578658344], [-0.97811062189215869, -0.73813766065052]], [[0.62954868271257325, -0.99255583718030116], [0.36571488292688958, -0.1979726592446612]], [[-0.74309878813858687, 0.15755500107466464], [-0.46815886672734131, 0.80169133119863356]], [[-0.84096498214967286, 0.054723976242368536], [0.97974546517631589, 0.49611277631934148]], [[0.7501461251974979, -0.85850711663576951], [-0.99050978024869984, -0.47402177642967447]]]),self.functionspace)
11897          self.failUnless(isinstance(res,Data),"wrong type of result.")
11898          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11899          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11900       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11901       def test_cos_constData_rank4(self):
11902          arg=Data(numarray.array([[[[10.86769150637592, -11.766101946953086, -40.632054317141275, -44.331198232316773], [63.040749529539085, -18.188400617211855, -49.618899482969979, 16.74749768820601], [-99.222919092701332, 50.811854793623525, -98.706022950048023, -76.194952985075304]], [[-92.353764397766298, 0.88734782067865581, -6.0019342520621279, 12.072469458988607], [86.40044972063265, 93.841407292060126, 62.04309009236411, -25.676293779358559], [-53.006995335453475, 33.517916229155048, 62.667462961355739, -61.156034212813907]]], [[[-91.6272838267937, 24.711419376381642, 56.938687934439201, 85.589689401573139], [27.872798937640738, -94.922800615920181, 24.187649616642489, -82.28813915263045], [-82.429183872811905, 23.776052793476254, 49.178642418795391, 42.237566296771035]], [[-95.599653557158874, -3.2117874250670013, -4.6985177190430107, 30.009412205188966], [-94.177295806719982, -67.100440854840656, 78.043053536597739, -17.760351739077223], [-82.421230180492344, -61.760191108767785, 83.752315525263384, -43.739701552250153]]], [[[17.27288088011116, 88.675054753497733, 6.787070381501394, 69.810884667683069], [-55.219843507383715, 54.083266698745206, 86.063401087901809, -76.089326493737033], [-42.038461813845807, -49.675851649369406, -74.52809891911744, -26.645885023219407]], [[95.412577827443414, -31.818322125741673, -62.668782913250844, 51.056651157908732], [29.626229191282619, -70.916672795563258, -93.812308419630284, 50.993951822668606], [97.536350190192877, -58.491790765244666, 40.487592210008074, 58.566434870771474]]]]),self.functionspace)
11903          res=cos(arg)
11904          ref=Data(numarray.array([[[[-0.12753450014394557, 0.69651395400439842, -0.97831140708599751, 0.93974896212096948], [0.9782603634601218, 0.78928336789060305, 0.79814708436766113, -0.50662172029142771], [0.25973763620098306, 0.85441504186502082, -0.25141858195451089, 0.69904923600339386]], [[-0.31762040357237481, 0.63147074411941229, 0.96070895016005275, 0.88049016444672401], [0.0066516978615375373, 0.9185608137809258, 0.70472349851785032, 0.85587677865914791], [-0.92102992500063807, -0.50656262601085844, 0.98651834766531155, -0.10482957689473014]]], [[[-0.86727364348422242, 0.91254914364446615, 0.92490139133616656, -0.72021249801851428], [-0.92046217359465865, 0.78069382297587053, 0.58566862525374508, 0.82151681807034405], [0.73320378466216263, 0.21247577462533909, 0.46528475996332708, -0.17305883912173914]], [[0.21717784735742893, -0.99753735846015812, -0.013870816513353947, 0.16354403647281665], [0.99751704509186812, -0.42937551918191064, -0.87912995574006803, 0.46319081359752184], [0.7385891182610298, 0.47866569181287344, -0.47952224979636382, 0.97071772306861814]]], [[[-0.0058786807720651261, 0.75806165680370197, 0.87571333970615173, 0.76751147584898971], [0.23961770902092361, -0.77996177708505321, -0.324418473652555, 0.77054356811991798], [-0.36444710950988046, 0.83114602646711189, 0.64473117916407829, 0.057620599880895247]], [[0.3949359265321995, 0.92012546535486572, 0.98673349925454323, 0.70301464495912791], [-0.21715699760614957, -0.22879346324193936, 0.9066713780848985, 0.74619426288234914], [-0.98921817473160367, -0.36378367286102392, -0.93830096876607127, -0.43223588967640608]]]]),self.functionspace)
11905          self.failUnless(isinstance(res,Data),"wrong type of result.")
11906          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11907          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11908       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11909       def test_cos_expandedData_rank0(self):
11910          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11911          arg=msk_arg*(-36.0973683311)+(1.-msk_arg)*(-15.0675429856)
11912          res=cos(arg)
11913          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11914          ref=msk_ref*(-0.0309422456304)+(1.-msk_ref)*(-0.801844696357)
11915          self.failUnless(isinstance(res,Data),"wrong type of result.")
11916          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11917          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11918       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11919       def test_cos_expandedData_rank1(self):
11920          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11921          arg=msk_arg*numarray.array([13.22047315692194, 66.297986628531646])+(1.-msk_arg)*numarray.array([25.148700308715902, 90.629815998628033])
11922          res=cos(arg)
11923          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11924          ref=msk_ref*numarray.array([0.79359430314944091, -0.94779722020057866])+(1.-msk_ref)*numarray.array([0.99987265658563174, -0.88866489544992711])
11925          self.failUnless(isinstance(res,Data),"wrong type of result.")
11926          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11927          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11928       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11929       def test_cos_expandedData_rank2(self):
11930          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11931          arg=msk_arg*numarray.array([[-1.224755096301692, 97.114446084647994, 78.66934127829532, 20.492601387243852, -1.8468029073290637], [94.122385272674506, -83.420646649404915, 84.662371945918665, 96.044573177625836, -4.3173175013998133], [39.380839398982147, 49.750816368301798, -46.750527293456187, 96.2026545747689, 59.005783622713864], [-64.783479411930358, 80.977519793545952, -9.0322065293006801, 59.07665091049779, 18.567068128306488]])+(1.-msk_arg)*numarray.array([[-40.062758393821142, -77.335375405412861, 47.444663163105105, -22.075478512825967, 30.498519871683385], [-6.6058669139393373, -43.594483739360854, -79.124767745891376, 39.981887534339364, 67.873590863604875], [-35.635014978859346, -91.956973584247208, 13.377356719156637, -71.146754763345243, -24.032516390161177], [-16.058009823221269, 66.650000191064265, 33.773123019379568, -35.806618515625303, -82.89935689255681]])
11932          res=cos(arg)
11933          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11934          ref=msk_ref*numarray.array([[0.33917637019859703, -0.96244524151414412, -0.99162336600665246, -0.072186299308219973, -0.27251555769578545], [0.99214842647378776, -0.16764594205585706, -0.98712676481798567, -0.22407835776507445, -0.38487416268261437], [-0.11070385395641859, 0.87045713651526513, -0.93110614158646188, -0.37470506271731796, -0.7747499584525428], [-0.37169114559236371, 0.76233091786134399, -0.923928374612207, -0.8175749134173127, 0.96036494926789795]])+(1.-msk_ref)*numarray.array([[-0.71235650110259441, -0.35821507052086493, -0.94899186128321478, -0.99644633755360834, 0.60788137929554054], [0.94838846229715867, 0.92573816396702235, -0.83373891839854186, -0.65333356768775441, 0.32342690776752892], [-0.47353549211311979, -0.65939196193876926, 0.68878387477507896, -0.44477233883471701, 0.45339573218511048], [-0.93935674812859138, -0.77973462685642325, -0.70781494235331721, -0.31617696002534756, 0.3455721479169635]])
11935          self.failUnless(isinstance(res,Data),"wrong type of result.")
11936          self.failUnlessEqual(res.getShape(),(4, 5),"wrong shape of result.")
11937          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11938       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11939       def test_cos_expandedData_rank3(self):
11940          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11941          arg=msk_arg*numarray.array([[[55.483105445596493, -84.002238303792453], [28.575161935168694, 67.00969325541476]], [[-82.092190352486142, 70.81562364547608], [-74.349947649074409, -6.7333955028757941]], [[73.606514485922332, 40.968585169340713], [-10.786045857308508, 65.198060327659135]], [[-50.170284604471327, -55.056223512041669], [77.506098391169076, -23.282530663895102]], [[-26.756072717949436, 84.143805447203476], [1.180711606109071, -52.027593969940369]], [[-4.2616554777689117, -84.42480221013362], [15.144723947311817, 99.934532959080201]]])+(1.-msk_arg)*numarray.array([[[72.197802657304322, 30.031068553513251], [31.351829685111909, -36.235960482725837]], [[21.624265511345357, 23.64734280582843], [-89.88417079282425, 60.44136194543546]], [[10.996017730716773, 65.262227504852063], [-76.321146670174272, -52.668478887245065]], [[82.50391310015678, -20.135683721573756], [14.572063027442368, -0.6896670909694933]], [[60.842163889504008, 36.998458942261806], [-20.499215145000463, -72.797762608461667]], [[16.509505303768293, -79.949879255527264], [-6.9809554307616679, 66.810788972572908]]])
11942          res=cos(arg)
11943          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11944          ref=msk_ref*numarray.array([[[0.48401222470712563, -0.68166289343156683], [-0.95509145527759087, -0.50945283155622245]], [[0.91680908584073406, -0.12942486038880624], [0.49906571322494375, 0.90035565457820055]], [[-0.21912040288715273, -0.99183440386679222], [-0.20799866689643615, -0.71415131202097681]], [[0.99547210549862564, 0.078271930973057291], [-0.51162790055459817, -0.27579265145672299]], [[-0.05251100009257479, -0.77807789151181295], [0.38026677268852599, -0.19015024920430146]], [[-0.43562589734555279, -0.92176067291186181], [-0.84552998640555266, 0.8273450262977281]]])+(1.-msk_ref)*numarray.array([[[-0.99827011011545363, 0.18486878514750979], [0.99794650005510754, 0.10743719861113013]], [[-0.93344994710516715, 0.08529414341350125], [-0.34175167339508283, -0.73093758146911281]], [[0.00044344313796299586, -0.75756723617489508], [0.60349204112184918, -0.73941438014513183]], [[0.68038820299051661, 0.28083933369769526], [-0.42131616285948442, 0.77145788123141812]], [[-0.40674928195501753, 0.76442141404261976], [-0.078781176005662423, -0.85712634845985503]], [[-0.69559969265779853, -0.16004220706279867], [0.76627681039248841, -0.66943880063060068]]])
11945          self.failUnless(isinstance(res,Data),"wrong type of result.")
11946          self.failUnlessEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")
11947          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11948       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11949       def test_cos_expandedData_rank4(self):
11950          msk_arg=whereNegative(self.functionspace.getX()[0]-0.5)
11951          arg=msk_arg*numarray.array([[[[81.658891253874316, 30.154394472077058, -36.265578949628633, -47.079147518937468], [-71.167146036277003, -41.9186826247917, -19.117903943939993, -26.079905327428762], [65.931361328358861, 90.197906187757837, -31.423335850518441, -28.286048187927378]], [[71.871283726884485, 97.6737686461978, 73.42998495160947, -14.865232484694445], [21.661875371448701, 84.396447257210269, -22.129504015834016, 42.427494938535261], [88.771175748186749, -75.408811105169974, -69.575485813748742, 5.5990892178879648]]], [[[-2.5470387198181186, 83.040539862229934, 27.081303077340337, 51.185017387292476], [-47.666956331255705, -71.09454374103494, -12.656279276279207, 46.394025119360208], [-89.901778088496684, -17.767376720946132, -99.917741127313974, -47.717421519561462]], [[8.693865786048363, 14.971207834154555, -63.535614994602518, -44.328116514882751], [-51.286711883396954, 9.1258561937947604, 43.312231786364464, -33.34607470853696], [27.51825978940407, 73.872039558971039, 84.752128628228576, -9.0124335912783948]]], [[[-26.128227021007319, 20.639092270432016, -22.680126332913247, 25.063812028694016], [-56.615261494527402, 67.210893028966325, 87.796053191372465, -81.471710946526699], [-89.314681542332949, 65.872995175957186, 43.779448960120646, 67.866612105077394]], [[-66.870791246045002, -45.354327014974331, -65.816476857544785, 53.473037113499004], [-41.393387472045397, 41.345634736576699, 40.192586700259739, 11.936195522492625], [-83.82311215875697, 79.874611048483359, -80.758910243743685, 54.169687707747642]]]])+(1.-msk_arg)*numarray.array([[[[79.975844309170498, -48.345625034036722, 66.443940680510877, 39.323120361210499], [9.3550298748197491, 52.272469669987004, 7.7830009762651002, -50.077500193710648], [-61.587099942318744, -66.863938143271454, -51.722120138546821, -43.001183411657685]], [[74.508937209465643, -17.801821857280032, -96.972937711273246, 72.41183780379302], [29.452848452635891, 94.133920463076976, -27.938357509488185, 4.098257930496942], [21.067732757629187, -52.606997531840641, 42.818983964361422, -20.470439762486563]]], [[[41.131011535410437, 33.995686953582606, -59.091466947449334, 13.06823181504609], [-26.826785538691382, -36.157623980696727, 67.955195199568607, -26.327491349671178], [-66.437617402363486, -38.150104004241527, -10.872833925186612, -7.9714487224826769]], [[59.359911777606669, 90.541284511390501, -90.232513741603299, 79.142818011771851], [-58.547802522437806, 74.087580646014828, 95.212298086166982, 58.740940692381656], [-97.360556330976905, 13.614895311489079, -16.297445160271735, -14.876606558474577]]], [[[-0.81239837735233777, -71.100446898779367, -74.082829351107051, 33.018490125485727], [8.0131639573274924, -29.224274631812278, 65.331408901937834, -93.121364679526437], [48.094133457963153, 94.659711075768058, -56.265304671957381, -44.775197816875092]], [[78.067699088113585, -50.740947996549203, -27.505788007906219, -48.105796725511851], [27.275728631570999, -82.611405981579054, 62.772330081477833, 91.643617134438784], [-79.364280665253176, -47.031342269127421, -98.190983248186029, -34.616820364422708]]]])
11952          res=cos(arg)
11953          msk_ref=whereNegative(self.functionspace.getX()[0]-0.5)
11954          ref=msk_ref*numarray.array([[[[0.99974648641704578, 0.30435788687272552, 0.13683280344622692, -0.99899923093822218], [-0.46294192167477966, -0.47311060525720278, 0.96421021544423069, 0.58398751340702615], [-0.9991145824550095, -0.61510218317556875, 0.9999725511540013, -0.99993138830653794]], [[-0.92666794295836774, -0.9598311886992611, -0.38706137277129665, -0.66542688071327594], [-0.94627760692292984, -0.91039672543745431, -0.99044414397882241, 0.015993433168101586], [0.69197041282698768, 0.99994395380283829, 0.89585377001765809, 0.77499061055278551]]], [[[-0.82839844046690569, 0.21008847929829561, -0.36884446429894552, 0.60619010167380138], [-0.85612803895715517, -0.39742502551382042, 0.99596093819165676, -0.74526463332938697], [-0.3582450109517854, 0.46940528357073097, 0.81779695883550263, -0.82897059205453272]], [[-0.74456579079006469, -0.74065243965863614, 0.76241328374955808, 0.94079803034423892], [0.52231795226174615, -0.95565457337977633, 0.78378107414507481, -0.35166755390596066], [-0.72753505953347086, 0.044597402857294056, -0.99748955870013933, -0.91618381584706621]]], [[[0.54409536262501013, -0.21699984096121355, -0.77189630709509238, 0.99762532313598207], [0.99778345689649628, -0.32720952301781842, 0.98583053656377828, 0.97809381526902872], [0.21892156237938304, -0.99495908440040703, 0.97949675533888336, 0.31681541317886081]], [[-0.62368710091572177, 0.19746023066230201, -0.98770566197447685, -0.99782529579539758], [-0.85111909839025046, -0.87520822274754506, -0.79722147176466518, 0.80792434147142878], [-0.54039529506920203, -0.23381695647535797, 0.60383025819594616, -0.72303366513856404]]]])+(1.-msk_ref)*numarray.array([[[[-0.13436077240726316, -0.34201567621685647, -0.89134402060793727, -0.053187082842302578], [-0.9975685881864238, -0.42249008090281082, 0.07092106962798754, 0.98238330330531154], [0.32029719862810208, -0.62902930625367448, 0.11391085089048571, 0.55609724451005038]], [[0.6299663251108153, 0.49953529411945946, -0.91453698294999897, -0.98797958829090204], [-0.38229784081228507, 0.99352504718605417, -0.94408885824716904, -0.5762485691730832], [-0.60309899769845521, -0.69665105534915361, 0.39629980402135667, -0.050066573862182912]]], [[[-0.95815603193412535, -0.84628043097907402, -0.82601627167478864, 0.8766887352613707], [-0.12293619592253698, 0.029304268667122303, 0.39948329810258998, 0.36724583096741847], [-0.89419269786037481, 0.90001510332012979, -0.1224324098233948, -0.11719712955985295]], [[-0.94592931147917447, -0.84464083011827396, -0.64201466079431768, -0.82363702778858228], [-0.41535991838593167, 0.25722868355816148, 0.5698126445332351, -0.58223630038953733], [-0.99958484980840756, 0.49885021791560108, -0.83122882247753749, -0.67387398078725091]]], [[[0.68775933759123087, -0.40283501156914814, 0.25263438090145968, -0.031761920026041855], [-0.15851092074962655, -0.58173128371482041, -0.80087771324083845, 0.42989944177895328], [-0.5650985275826873, 0.91634921141350756, 0.96012059545797757, 0.70178185948911376]], [[-0.89060741634512253, 0.8890797163293207, -0.71892217832022665, -0.55543784153332254], [-0.54147542099155643, 0.59783639656790899, 0.9982290297813865, -0.85902708455056043], [-0.67895034675987809, -0.99572053270346172, -0.69555015450633373, -0.99824220054368329]]]])
11955          self.failUnless(isinstance(res,Data),"wrong type of result.")
11956          self.failUnlessEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
11957          self.failUnless(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11958       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11959       def test_cos_Symbol_rank0(self):
11960          arg=Symbol(shape=())
11961          res=cos(arg)
11962          s=numarray.array(90.5372724402)
11963          sub=res.substitute({arg:s})
11964          ref=numarray.array(-0.842486242114)
11965          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11966          self.failUnlessEqual(res.getShape(),(),"wrong shape of result.")
11967          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11968       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11969       def test_cos_Symbol_rank1(self):
11970          arg=Symbol(shape=(2,))
11971          res=cos(arg)
11972          s=numarray.array([-9.0536838172296825, 33.816188000375888])
11973          sub=res.substitute({arg:s})
11974          ref=numarray.array([-0.93193112842841397, -0.73757029996164303])
11975          self.failUnless(isinstance(res,Symbol),"wrong type of result.")
11976          self.failUnlessEqual(res.getShape(),(2,),"wrong shape of result.")
11977          self.failUnless(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
11978       #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
11979       def test_cos_Symbol_rank2(self):
11980          arg=Symbol(shape=(4, 5))
11981          res=cos(arg)
11982          s=numarray.array([[-31.546701209629163, 39.362102781082996, -15.354595714411218, 38.340687603236177, -98.010951194079894], [82.222812801466517, -86.454712307597589, 32.12633138537268, -45.272841747188863, -11.684078726050444], [31.575597388189834, -26.847774004442044, -98.273037827965055, 89.120378763437628, 97.882547727500537], [89.465688335120035, -64.006390385826847, -38.163447134657758, -4.2672402307320567, 57.401582191500665]])
11983          sub=res.substitute({arg:s})
11984          ref=numarray.array([[0.99146117203213002, -0.09206406003479313, -0.93821266187128138, 0.80115372568056786, -0.81296002706195136], [0.85698608818153499, 0.060876669858104665, 0.75809791928896697, 0.27659756615947145, 0.63538302492165299], [0.98727966912002574, -0.14373