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

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

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

revision 3974 by jfenwick, Thu Jun 14 01:01:03 2012 UTC revision 3975 by caltinay, Thu Sep 20 01:54:06 2012 UTC
# Line 1076  class Test_util_overloaded_binary_with_t Line 1076  class Test_util_overloaded_binary_with_t
1076        self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")        self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
1077        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
1078     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    def test_add_overloaded_Symbol_rank0_taggedData_rank0(self):  
       arg0=Symbol(shape=())  
       arg1=Data(-4.47375462667,self.functionspace)  
       arg1.setTaggedValue(1,-1.31941601768)  
       res=arg0+arg1  
       s0=numpy.array(1.61261179813)  
       sub=res.substitute({arg0:s0})  
       ref=Data(-2.86114282854,self.functionspace)  
       ref.setTaggedValue(1,0.293195780452)  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank0_taggedData_rank1(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([4.231368041965883, -4.4013971070790703]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([-3.6855298770013012, -1.2929884812069514]))  
       res=arg0+arg1  
       s0=numpy.array(2.84155105109)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([7.0729190930555035, -1.5598460559894498]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([-0.84397882591168072, 1.548562569882669]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank0_taggedData_rank2(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[2.2716923801159581, 2.4614277114154319, 1.0514237712774701, 2.3687515325619426, -4.1002787098015734], [-3.560468173384078, -2.5666832217262394, -1.7342384343440678, -2.284269818337247, -4.915018194315774], [3.3813280983607363, 0.63037776510500354, -2.6011819111781778, -1.5604450665180569, -2.8572305936043172], [-3.3886195588094048, 4.184842923853985, -4.016920709486449, -4.2172825457053289, -1.8762207050868671]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[-3.1342118813199313, -3.2159979934249803, -0.90983248734422695, 0.47440238296968218, 4.5810169136648184], [-1.1043399201793438, -3.7919051368111445, 4.0782893736046315, -2.8351808495937969, -1.928877721758071], [3.4854138289567054, -2.7810235375215289, -2.2992882103363934, -3.0443291947203219, -1.1356385778104428], [-4.4940728118374418, 4.9638782122972405, 1.9515441594983463, 4.1171019138732241, 3.8458241094887899]]))  
       res=arg0+arg1  
       s0=numpy.array(-2.76880283902)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[-0.49711045890033745, -0.30737512760086361, -1.7173790677388254, -0.40005130645435294, -6.8690815488178689], [-6.3292710124003735, -5.335486060742535, -4.5030412733603633, -5.0530726573535425, -7.6838210333320696], [0.6125252593444408, -2.138425073911292, -5.3699847501944733, -4.329247905534352, -5.6260334326206127], [-6.1574223978256999, 1.4160400848376895, -6.7857235485027445, -6.9860853847216244, -4.6450235441031626]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[-5.9030147203362269, -5.9848008324412758, -3.6786353263605225, -2.2944004560466134, 1.8122140746485229], [-3.8731427591956393, -6.56070797582744, 1.309486534588336, -5.6039836886100929, -4.6976805607743666], [0.71661098994040984, -5.5498263765378244, -5.0680910493526889, -5.8131320337366175, -3.9044414168267383], [-7.2628756508537373, 2.1950753732809449, -0.81725867951794928, 1.3482990748569286, 1.0770212704724944]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank0_taggedData_rank3(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[[-0.14784160783232814, -3.4496999219721394], [-1.0172727851296024, -3.8907971892421789]], [[0.38904944161453159, 3.1067797097438437], [1.308243457842245, 3.0479776412962494]], [[-2.6620127843382857, 0.13780775111537391], [3.2423288153768244, -1.5725303627159226]], [[0.31136772074727226, -4.9176534218517363], [-0.72102383872784248, 3.7479849986665634]], [[-3.12917139650007, 4.7234449598742501], [0.080406934435902855, -1.630317680103369]], [[-2.7453370329295601, -2.667315931056363], [1.9424056665979039, -2.1986275254196208]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[0.24545335590413231, -4.882085674625257], [-3.8294686349995457, -3.0357838680061189]], [[0.085951308071958721, -4.2409388804732604], [-1.0386163666377666, -2.3663644324147448]], [[-4.8080777008107445, -2.7683904356552858], [-4.0053000715390175, -2.8442899320375883]], [[-1.8650141447279744, -2.5842078097712138], [-4.5450552440926941, -3.2146903130613458]], [[-3.7463971814362074, -3.3352130581837089], [-2.9035855561500199, -3.4667682478162853]], [[4.7550450317946851, 0.54987906361700034], [3.0735337239611109, -1.3417790452642917]]]))  
       res=arg0+arg1  
       s0=numpy.array(-4.01740856828)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[-4.1652501761088621, -7.4671084902486733], [-5.0346813534061363, -7.9082057575187132]], [[-3.6283591266620023, -0.91062885853269027], [-2.7091651104342889, -0.96943092698028455]], [[-6.6794213526148196, -3.87960081716116], [-0.77507975289970954, -5.5899389309924565]], [[-3.7060408475292617, -8.9350619901282702], [-4.7384324070043764, -0.26942356960997049]], [[-7.1465799647766044, 0.70603639159771614], [-3.9370016338406311, -5.6477262483799029]], [[-6.7627456012060936, -6.6847244993328969], [-2.07500290167863, -6.2160360936961547]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[-3.7719552123724016, -8.8994942429017918], [-7.8468772032760796, -7.0531924362826528]], [[-3.9314572602045752, -8.2583474487497952], [-5.0560249349143005, -6.3837730006912787]], [[-8.8254862690872784, -6.7857990039318192], [-8.0227086398155514, -6.8616985003141222]], [[-5.8824227130045088, -6.6016163780477477], [-8.5624638123692272, -7.2320988813378797]], [[-7.7638057497127413, -7.3526216264602429], [-6.9209941244265538, -7.4841768160928197]], [[0.73763646351815115, -3.4675295046595336], [-0.94387484431542301, -5.3591876135408256]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank0_taggedData_rank4(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[[[4.5010485600778143, -2.4394428112844668, 3.0374333449696422, -4.7663889606507226], [2.0654546194828303, -4.696996623108241, 2.5289070867635042, 0.65780415177769846], [-1.7946102912417161, 4.0226702712655378, -2.6307618199832374, -1.9664117380003288]], [[1.4205257504300448, 3.0848116635609912, -4.3309901128921133, 2.5816781560021829], [1.98739592932656, 1.9496431987326268, -0.24515198425166851, -2.6865551451056047], [4.0894349368503597, -4.8776140546557354, 2.9403229977812249, 3.7789156292168506]]], [[[3.75112053814874, -2.3546149287193319, 0.91426838791839682, -1.2211121717905273], [-3.5764088419366424, 0.068153343632031849, 3.6115648933666797, 4.7950609836969029], [4.5482408153883398, 0.85647955953738997, -2.4264114798265659, 3.5297475883542599]], [[-2.6339065403404929, -1.5299846912705894, -1.6453648079685568, 3.1714320975414907], [2.7295303313999248, 1.3588936592292313, 0.70590159398216112, 0.0062376525690446272], [3.1324590592008565, -4.1144165176754788, 4.2193199599318696, -0.49386166187075276]]], [[[1.7782539261723596, -2.6772790432879914, 0.3135123883886255, 2.2809465321644531], [-1.6035391350360562, -3.2457684546816026, 2.3086657670475805, -0.088308827161065473], [-4.2186825129103198, -4.6725179452083196, -2.1800915817091671, -4.8642457652089455]], [[-2.8897872727149041, -0.86448077056544204, -2.9984279005279104, -4.112319799765574], [2.5944099555947613, -2.5402961819962866, -4.5162095208483644, -4.2957042082135253], [1.2309096976525176, 3.3672995882994154, 0.73856013466593495, -3.7303133616580144]]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[[-4.898829233273565, -4.6709148064582244, 2.8181850854931492, -3.53719102963586], [2.8280067628493732, -2.557137413646692, 3.9346010568045351, 1.0033058673338893], [-0.63126901137643365, 2.5357415480493692, 1.9090530570853179, -1.1891908866639089]], [[3.8125800552825346, -4.7743279898028739, -3.1590909808645007, 0.28978622660003772], [-3.2436602973270179, 3.9378620469676964, -0.25687330875900027, -1.2431513240632075], [-2.855073901958034, 0.68704979936070298, -0.38653513939718831, 0.55297574964115626]]], [[[0.26824834873033154, -3.8023350703654746, 2.2494477913661983, -1.8576959511561353], [4.4315401137879569, 0.86172435784696511, -3.879894824877177, -1.4482806063304543], [-0.74897037076889905, 3.6106453948298896, -1.8380526811810229, 1.3476964159836697]], [[3.3781973484724421, 0.73379836493088213, -4.6470796259180824, -1.102781952237013], [4.4452616202956854, -3.8388255181561015, 0.82164194455244122, -2.5674995073874984], [-4.4698560648563053, -1.0877234401319278, -0.39195692973236618, -4.055518011746714]]], [[[2.987000185950083, -2.119241780461242, 2.4612076998963692, -1.12969179310906], [-2.3781079170895456, -3.6251652731224415, -3.8841206078967119, 2.2955183412383224], [2.2178052354192612, -4.2075200116280449, 2.3404730427450504, 0.014812900400232643]], [[2.3282192042257774, -2.550712421353948, -4.9404509187995753, 1.2572697652949341], [-1.3456675897492087, 2.7348699950932023, 1.9239956292187728, 3.7583192048432945], [-2.3072051398261761, -0.83333567597773239, -4.0358836522292503, -4.6401150846497154]]]]))  
       res=arg0+arg1  
       s0=numpy.array(2.67446531785)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[7.1755138779316248, 0.23502250656934365, 5.7118986628234527, -2.0919236427969121], [4.7399199373366407, -2.0225313052544305, 5.2033724046173147, 3.3322694696315089], [0.87985502661209436, 6.6971355891193483, 0.043703497870573038, 0.70805357985348172]], [[4.0949910682838553, 5.7592769814148017, -1.6565247950383029, 5.2561434738559933], [4.6618612471803704, 4.6241085165864373, 2.429313333602142, -0.012089827251794194], [6.7639002547041702, -2.2031487368019249, 5.6147883156350353, 6.4533809470706611]]], [[[6.4255858560025505, 0.31985038913447861, 3.5887337057722073, 1.4533531460632831], [-0.90194352408283196, 2.7426186614858423, 6.2860302112204902, 7.4695263015507134], [7.2227061332421503, 3.5309448773912004, 0.24805383802724457, 6.2042129062080704]], [[0.040558777513317601, 1.144480626583221, 1.0291005098852537, 5.8458974153953012], [5.4039956492537353, 4.0333589770830418, 3.3803669118359716, 2.6807029704228551], [5.806924377054667, -1.4399511998216683, 6.8937852777856801, 2.1806036559830577]]], [[[4.45271924402617, -0.0028137254341809026, 2.987977706242436, 4.9554118500182636], [1.0709261828177543, -0.5713031368277921, 4.983131084901391, 2.586156490692745], [-1.5442171950565093, -1.9980526273545092, 0.49437373614464342, -2.189780447355135]], [[-0.21532195486109362, 1.8099845472883684, -0.32396258267409994, -1.4378544819117636], [5.2688752734485718, 0.13416913585752388, -1.8417442029945539, -1.6212388903597148], [3.905375015506328, 6.0417649061532259, 3.4130254525197454, -1.0558480438042039]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[-2.2243639154197545, -1.996449488604414, 5.4926504033469596, -0.86272571178204949], [5.5024720807031837, 0.11732790420711847, 6.6090663746583456, 3.6777711851876997], [2.0431963064773768, 5.2102068659031797, 4.5835183749391284, 1.4852744311899015]], [[6.4870453731363451, -2.0998626719490634, -0.48462566301069021, 2.9642515444538482], [-0.56919497947320741, 6.6123273648215068, 2.4175920090948102, 1.431313993790603], [-0.18060858410422354, 3.3615151172145135, 2.2879301784566222, 3.2274410674949667]]], [[[2.942713666584142, -1.1278697525116641, 4.9239131092200088, 0.81676936669767519], [7.1060054316417673, 3.5361896757007756, -1.2054295070233665, 1.2261847115233562], [1.9254949470849114, 6.2851107126837, 0.83641263667278754, 4.0221617338374802]], [[6.0526626663262526, 3.4082636827846926, -1.972614308064272, 1.5716833656167974], [7.1197269381494959, -1.164360200302291, 3.4961072624062517, 0.10696581046631204], [-1.7953907470024948, 1.5867418777218827, 2.2825083881214443, -1.3810526938929035]]], [[[5.6614655038038935, 0.55522353739256847, 5.1356730177501797, 1.5447735247447505], [0.29635740076426487, -0.95069995526863105, -1.2096552900429014, 4.9699836590921329], [4.8922705532730717, -1.5330546937742344, 5.0149383605988609, 2.6892782182540431]], [[5.0026845220795879, 0.12375289649986243, -2.2659856009457648, 3.9317350831487445], [1.3287977281046017, 5.4093353129470128, 4.5984609470725832, 6.432784522697105], [0.36726017802763433, 1.8411296418760781, -1.3614183343754398, -1.965649766795905]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank1_taggedData_rank0(self):  
       arg0=Symbol(shape=(2,))  
       arg1=Data(2.0170735169,self.functionspace)  
       arg1.setTaggedValue(1,3.82672695724)  
       res=arg0+arg1  
       s0=numpy.array([1.00484796599339, 0.2880505540704581])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([3.0219214828921679, 2.305124070969236]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([4.8315749232336422, 4.1147775113107103]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank1_taggedData_rank1(self):  
       arg0=Symbol(shape=(2,))  
       arg1=Data(numpy.array([3.3215394211180378, 3.5981265746593944]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([2.1778784136224694, -2.3764353271397098]))  
       res=arg0+arg1  
       s0=numpy.array([-3.4742800315482514, 3.4103551574211437])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([-0.15274061043021359, 7.0084817320805382]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([-1.296401617925782, 1.0339198302814339]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank2_taggedData_rank0(self):  
       arg0=Symbol(shape=(4, 5))  
       arg1=Data(-0.986427052024,self.functionspace)  
       arg1.setTaggedValue(1,4.5351324783)  
       res=arg0+arg1  
       s0=numpy.array([[2.0321266643272953, -2.4680764477372739, -4.3060411539602974, -2.7559649217314863, -2.4618535918318041], [-0.21747292814117358, 4.350913546702305, 3.6669815102443994, 0.71166661853854052, -3.1994657496871204], [-1.7898199030315967, 3.4336619398304347, 0.13737652216904461, 0.38886634752835114, -3.1862442896213903], [0.62247301709956915, -0.3939775549812996, 2.0325858192829029, 3.5731701337680697, 4.9760526241675151]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[1.0456996123034328, -3.4545034997611364, -5.2924682059841599, -3.7423919737553488, -3.4482806438556666], [-1.2038999801650361, 3.3644864946784425, 2.680554458220537, -0.27476043348532198, -4.1858928017109829], [-2.7762469550554592, 2.4472348878065722, -0.84905052985481788, -0.59756070449551135, -4.1726713416452528], [-0.36395403492429335, -1.3804046070051621, 1.0461587672590404, 2.5867430817442072, 3.9896255721436527]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[6.5672591426281244, 2.0670560305635552, 0.2290913243405317, 1.7791675565693428, 2.073278886469025], [4.3176595501596555, 8.8860460250031341, 8.2021139885452286, 5.2467990968393696, 1.3356667286137087], [2.7453125752692324, 7.9687944181312638, 4.6725090004698737, 4.9239988258291802, 1.3488881886794388], [5.1576054954003983, 4.1411549233195295, 6.567718297583732, 8.1083026120688988, 9.5111851024683443]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank2_taggedData_rank2(self):  
       arg0=Symbol(shape=(4, 5))  
       arg1=Data(numpy.array([[2.5408811571936649, -2.1334521210261146, -3.9652568099895591, -3.6478783147223384, 2.1114771268028516], [3.8890945494486164, -4.899040480556101, -1.7817100838503555, 2.9407131603888335, -2.974653264828401], [-3.2299050249521732, -3.6281098048078686, -1.3080359502903427, -1.6714823247179798, -0.097718975771847738], [-1.8427361410784737, -3.557728290609151, 4.3307602449437486, 4.3011295472084239, 4.4350229540676622]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[-1.2704267330867083, 1.2361295109524075, 0.9540966315759789, 3.5337541649787489, 4.8836580966415468], [4.1067090622491875, 2.6522349387018798, 2.0355272062841205, -2.2445813788586468, 0.97737671794951986], [-4.2647489562794627, -4.3976922282457078, 0.39840800126256326, -0.66341665836320907, 4.1826246163193694], [-1.305596490949962, 0.064238811217302683, -0.063396358619006499, 2.2946376763409768, 4.6337041214815038]]))  
       res=arg0+arg1  
       s0=numpy.array([[0.0061599503412477219, 4.3146936147943098, 3.5941315929470505, 0.48494973223811044, 1.0436274104272503], [-3.1651610945212227, -0.76349139958966816, 1.4367481727420301, -4.3009580966562853, -2.9779235142471872], [-2.6915250975807892, 3.3006327198118317, -1.7038120201318274, -1.672784874038312, -1.1339247805382113], [-4.3386946862197275, 3.5721729964814575, 0.76523026977124875, -4.1648368747748705, 4.2172917844542646]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[2.5470411075349126, 2.1812414937681952, -0.37112521704250856, -3.1629285824842279, 3.1551045372301019], [0.72393345492739369, -5.6625318801457691, -0.3449619111083253, -1.3602449362674518, -5.9525767790755886], [-5.9214301225329624, -0.32747708499603689, -3.0118479704221701, -3.3442671987562917, -1.2316437563100591], [-6.1814308272982013, 0.014444705872306507, 5.0959905147149973, 0.13629267243355336, 8.6523147385219268]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[-1.2642667827454606, 5.5508231257467173, 4.5482282245230294, 4.0187038972168594, 5.9272855070687971], [0.94154796772796479, 1.8887435391122116, 3.4722753790261507, -6.5455394755149321, -2.0005467962976673], [-6.9562740538602519, -1.0970595084338761, -1.3054040188692642, -2.3362015324015211, 3.0486998357811581], [-5.6442911771696895, 3.6364118076987602, 0.70183391115224225, -1.8701991984338937, 8.8509959059357683]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank3_taggedData_rank0(self):  
       arg0=Symbol(shape=(6, 2, 2))  
       arg1=Data(4.14158894912,self.functionspace)  
       arg1.setTaggedValue(1,1.06697978175)  
       res=arg0+arg1  
       s0=numpy.array([[[4.6043956675232156, -1.7939819611951213], [2.3413306572512553, 4.2737970814645436]], [[-1.4206860728526092, -4.0638596853371043], [-3.7916815480563271, 4.5662079674933835]], [[-2.7442888086115866, 4.1309855580493053], [4.2577420257990415, -1.8097107655207578]], [[-2.5054995467769015, 1.92691180848038], [1.4885858198441548, 0.67943684407550364]], [[-0.49912977294902738, 2.8970848026790819], [-1.6758640571529062, 1.138492891645301]], [[3.0874944087385323, 2.3401300556494409], [4.4331203054131514, -3.6332015417943317]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[8.7459846166406692, 2.3476069879223322], [6.4829196063687089, 8.4153860305819972]], [[2.7209028762648444, 0.077729263780349278], [0.3499074010611265, 8.7077969166108371]], [[1.3973001405058669, 8.2725745071667589], [8.3993309749164951, 2.3318781835966957]], [[1.6360894023405521, 6.0685007575978336], [5.6301747689616084, 4.8210257931929572]], [[3.6424591761684262, 7.0386737517965354], [2.4657248919645474, 5.2800818407627546]], [[7.2290833578559859, 6.4817190047668944], [8.574709254530605, 0.50838740732312182]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[5.6713754492735333, -0.72700217944480361], [3.408310439001573, 5.3407768632148613]], [[-0.35370629110229146, -2.9968799035867866], [-2.7247017663060094, 5.6331877492437012]], [[-1.6773090268612689, 5.1979653397996231], [5.3247218075493592, -0.74273098377044011]], [[-1.4385197650265837, 2.9938915902306977], [2.5555656015944725, 1.7464166258258214]], [[0.56785000880129033, 3.9640645844293996], [-0.60888427540258849, 2.2054726733956187]], [[4.15447419048885, 3.4071098373997586], [5.5001000871634691, -2.566221760044014]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank3_taggedData_rank3(self):  
       arg0=Symbol(shape=(6, 2, 2))  
       arg1=Data(numpy.array([[[-3.2205119696448303, -2.2490349733904793], [4.7309330578342728, 0.04657431344927776]], [[-0.3936253737986215, -2.2272967031536908], [-0.18189473472768825, 2.1329990369487444]], [[-2.8571323537009574, -2.3391743717247926], [-4.785564927869757, -4.197566087277985]], [[-0.51803357013187057, -4.8885075218534615], [-3.3585297223151986, 3.0552364663746783]], [[-2.0151519611983781, 3.9345436537274772], [-2.7878957958219641, -2.6195705904754907]], [[-4.6622983911161757, 3.0345762238702996], [0.95808145500662167, 2.3032005907590172]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[3.104646508941352, -1.8350669536127073], [-1.8494877036228319, 2.5165921132539548]], [[-4.3449195335208621, -1.4036674978303032], [0.58656847358649422, 3.9825780978594274]], [[-4.9368312337184133, -0.042185221712557563], [-2.4903344676247419, 3.7410025704065433]], [[-2.2093033763679437, 3.7351383406586951], [2.1672851266703494, -1.9415031622540333]], [[-4.4057143358398667, 1.3704466489896756], [0.44171097788911684, 1.3603733891149092]], [[3.7432273916816836, 4.8577379208019238], [2.294252392567973, 4.2678497661549475]]]))  
       res=arg0+arg1  
       s0=numpy.array([[[0.33409445301712548, 1.0262876775832419], [0.62203428397303817, 0.51066294504137844]], [[-4.1549113652076786, -4.2504735496647204], [-2.0019465032056152, 4.8054738870828242]], [[-4.3658355024726774, 0.2553620331523998], [-0.79889155802600875, -3.3547936760431227]], [[0.40231279215622973, 4.2664467271600302], [-1.7175380098400339, -0.81865406700567434]], [[-0.64588705255776091, 1.6059018168999337], [2.8292560276929528, 0.10018639544890462]], [[2.3376478522877395, 0.023210406810374451], [-1.2986529924243637, -4.0319968926337122]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[-2.8864175166277048, -1.2227472958072374], [5.3529673418073109, 0.5572372584906562]], [[-4.5485367390063001, -6.4777702528184111], [-2.1838412379333034, 6.9384729240315686]], [[-7.2229678561736348, -2.0838123385723928], [-5.5844564858957657, -7.5523597633211077]], [[-0.11572077797564084, -0.62206079469343134], [-5.0760677321552325, 2.2365823993690039]], [[-2.661039013756139, 5.5404454706274109], [0.041360231870988695, -2.5193841950265861]], [[-2.3246505388284362, 3.057786630680674], [-0.34057153741774204, -1.728796301874695]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[3.4387409619584774, -0.80877927602946542], [-1.2274534196497937, 3.0272550582953333]], [[-8.4998308987285398, -5.654141047495024], [-1.415378029619121, 8.7880519849422516]], [[-9.3026667361910906, 0.21317681143984224], [-3.2892260256507506, 0.38620889436342054]], [[-1.806990584211714, 8.0015850678187252], [0.44974711683031554, -2.7601572292597076]], [[-5.0516013883976276, 2.9763484658896093], [3.2709670055820697, 1.4605597845638139]], [[6.0808752439694231, 4.8809483276122982], [0.99559940014360926, 0.2358528735212353]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank4_taggedData_rank0(self):  
       arg0=Symbol(shape=(3, 2, 3, 4))  
       arg1=Data(-3.36975935987,self.functionspace)  
       arg1.setTaggedValue(1,3.58602218193)  
       res=arg0+arg1  
       s0=numpy.array([[[[-3.6605228616502314, 0.78674534918464545, 0.69312789575915001, 2.356131819716019], [0.48601839576294559, -0.8628798777934481, 2.0026054240640327, -2.8438553618805074], [2.18593941055701, 0.25091342560107233, -0.44940571292306508, -1.8489414934427248]], [[-1.6568919674937996, 1.4484497570863928, -1.2264293885684063, -4.7716825946229005], [-1.3057144095360087, -3.9748266764998927, -2.0153241631008232, 0.8906992201061259], [3.1404890626229403, -2.3225000581193034, -4.7546142656597512, 1.0875541812566327]]], [[[-4.9205226888839535, -0.34316300298918989, 0.8558352751277134, -3.4000447507892417], [-3.0159227232102994, -3.1011841180365698, -3.4973942534946834, 2.6602665320705743], [-3.576305734030345, 4.5522646489279559, -1.9313889864968314, -1.7583554713364027]], [[-2.1597288443976992, -0.87844191426882734, 1.6629079858036864, 1.6896187755779879], [4.4293625595362176, -3.3382654120448785, -2.3507247228257433, 0.26479000769794858], [-3.0180130358534916, -1.2605639144806311, -0.98298619931606979, -2.137834133062908]]], [[[-2.0419939573204591, -2.6632590751077245, 4.8052724398948197, 2.322278323818975], [-2.1060352956778869, 2.7184916976977158, 4.6875011554708408, -4.9682643309417891], [-0.28424615713109525, -3.7631316336804597, 0.1225411062888595, 2.4120376904759002]], [[2.7686219370779028, 4.8049949856048499, -1.1346120770786539, -2.9443051480041191], [4.7732765254402914, 1.6848474249715109, -3.1920023076915047, -1.5880107209289274], [-3.5864061777464897, -2.8246690408805364, -3.6011040408748474, 3.7248241863617704]]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[-7.0302822215191769, -2.5830140106843, -2.6766314641097955, -1.0136275401529264], [-2.8837409641059999, -4.2326392376623936, -1.3671539358049127, -6.2136147217494528], [-1.1838199493119355, -3.1188459342678732, -3.8191650727920106, -5.2187008533116703]], [[-5.0266513273627451, -1.9213096027825527, -4.5961887484373518, -8.1414419544918459], [-4.6754737694049542, -7.3445860363688382, -5.3850835229697687, -2.4790601397628196], [-0.22927029724600523, -5.6922594179882484, -8.1243736255286976, -2.2822051786123128]]], [[[-8.2902820487528999, -3.7129223628581354, -2.5139240847412321, -6.7698041106581872], [-6.3856820830792449, -6.4709434779055153, -6.8671536133636284, -0.7094928277983712], [-6.9460650938992909, 1.1825052890590104, -5.3011483463657765, -5.1281148312053482]], [[-5.5294882042666451, -4.2482012741377728, -1.7068513740652591, -1.6801405842909576], [1.0596031996672721, -6.7080247719138235, -5.7204840826946892, -3.1049693521709969], [-6.387772395722437, -4.6303232743495766, -4.3527455591850153, -5.5075934929318535]]], [[[-5.4117533171894046, -6.03301843497667, 1.4355130800258742, -1.0474810360499704], [-5.4757946555468324, -0.65126766217122967, 1.3177417956018953, -8.3380236908107346], [-3.6540055170000407, -7.1328909935494051, -3.247218253580086, -0.95772166939304526]], [[-0.60113742279104265, 1.4352356257359045, -4.5043714369475989, -6.3140645078730646], [1.4035171655713459, -1.6849119348974346, -6.5617616675604502, -4.9577700807978733], [-6.9561655376154352, -6.1944284007494819, -6.9708634007437933, 0.35506482649282489]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[-0.074500679717217189, 4.3727675311176597, 4.2791500776921643, 5.9421540016490333], [4.0720405776959598, 2.7231423041395661, 5.588627605997047, 0.74216682005250689], [5.7719615924900243, 3.8369356075340866, 3.1366164690099492, 1.7370806884902894]], [[1.9291302144392146, 5.034471939019407, 2.3595927933646079, -1.1856604126898862], [2.2803077723970056, -0.38880449456687849, 1.5706980188321911, 4.4767214020391402], [6.7265112445559545, 1.2635221238137109, -1.168592083726737, 4.673576363189647]]], [[[-1.3345005069509392, 3.2428591789438244, 4.4418574570607277, 0.18597743114377252], [0.57009945872271484, 0.48483806389644446, 0.088627928438330894, 6.2462887140035885], [0.0097164479026692341, 8.1382868308609702, 1.6546331954361828, 1.8276667105966116]], [[1.4262933375353151, 2.7075802676641869, 5.2489301677367006, 5.2756409575110021], [8.0153847414692319, 0.24775676988813577, 1.235297459107271, 3.8508121896309628], [0.56800914607952269, 2.3254582674523832, 2.6030359826169445, 1.4481880488701062]]], [[[1.5440282246125552, 0.92276310682528973, 8.3912946218278339, 5.9083005057519893], [1.4799868862551273, 6.3045138796307301, 8.273523337403855, -1.3822421490087748], [3.301776024801919, -0.17710945174744541, 3.7085632882218738, 5.9980598724089145]], [[6.3546441190109171, 8.3910171675378642, 2.4514101048543604, 0.64171703392889512], [8.3592987073733056, 5.2708696069045251, 0.39401987424150953, 1.9980114610040869], [-0.00038399581347547951, 0.76135314105247787, -0.015081858941833115, 7.3108463682947846]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_add_overloaded_Symbol_rank4_taggedData_rank4(self):  
       arg0=Symbol(shape=(3, 2, 3, 4))  
       arg1=Data(numpy.array([[[[3.9920807219193897, -4.5779739122960814, 4.5854534474997717, 3.2053142858372432], [2.8103397320902959, 4.9887764787465052, -0.52104124325955858, -1.8304110130896789], [1.3476486726221824, 1.444586532940364, -2.8874874461741227, 4.7876918056255811]], [[0.32316601458590188, 4.0894528632998917, 4.8402123594565474, 1.8268831354386119], [-2.5011227376476155, 2.130885197340743, 2.3501863571803945, 2.2636248166847359], [4.3454634016962661, -3.6587132104500473, 4.1938822903422803, 4.5927019790778125]]], [[[4.1422390609491586, -3.6002479260604603, -3.6918409940192509, -1.7953734942280111], [-4.8502630024874547, -4.7798365314864171, 3.1688114559185223, 0.88922741455283294], [4.0481876389748201, -2.6381809250897534, -1.9172124638082777, -2.8643429131533757]], [[-4.5492217514143105, 1.4324260350216615, -4.0964979250283395, 1.8344180535783527], [-2.8280504816066743, 3.1267777791151357, -0.39744880561352147, 2.5151034893636552], [-3.2187654237677599, -1.5879534276446639, -2.4844582786538649, 1.0285593253922407]]], [[[2.1483393271306426, -0.82895044643683047, -3.6683933289992976, 3.4020823272421552], [0.68263426813779837, 2.5071012114514977, 1.5932728069205151, -0.24429515277727809], [0.12440513060382585, 0.7222354527954602, 3.0356107482664161, -4.7505779425615025]], [[2.4875772405314853, 4.4158781697482894, -2.6351083580954904, 0.8381210174584508], [-2.2830261919990456, -0.25946831547207871, -1.7069509953536399, -2.2084311793129672], [-0.06039777259593837, -2.4801513242961635, -0.72622140267950819, 3.1327810122509661]]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[[3.273834311258998, 4.9864339157750006, -4.9358871998952321, 3.5071802027851575], [-4.8114572451994375, -0.80304115279530741, 1.5643231640545814, 3.8230682007724059], [0.85299563337592943, -4.158266846305084, 2.4138189279533453, 0.097164865292410418]], [[-3.554337825548143, -0.11973908656716148, -1.0499425985929154, 0.39692971194033078], [1.9813600598024736, -2.3737590093149796, 1.170237744085374, 2.0638229237429382], [1.4105482366566324, 0.29337444922205158, 2.4538711842566121, -0.0047740657967052513]]], [[[-0.19528787703746175, -3.8808419447303399, 1.8708621308065077, -2.5156413982203727], [-3.2540849307678066, 2.7709651374501965, 2.5912058791275232, -3.0678428758626786], [-0.027258602126829956, 4.909027422760591, -0.88633715465297058, -1.1410073309815862]], [[-1.5598004826145182, -0.91564403517654736, -1.8501749804585419, 4.4203317135295013], [3.1407546235218433, 0.7930661561500516, 3.6200305484872271, -2.4175847845505825], [3.4943892757751911, -2.0394617308666163, -0.91659937591484297, 0.80866589463421956]]], [[[0.19341168503424822, -4.7148719793671559, 3.274571842969408, 0.6119360153516773], [-3.2075869313858139, -4.8762549026419686, -3.2736755992803399, -1.8211683266992837], [4.3190197696915202, 4.3180352261041595, -2.5728337833363391, -3.0273355465813347]], [[4.2853943606217797, -4.7972904925433504, -2.0174700804989119, 2.4544152021491943], [-4.016373677783732, -3.939264549765725, 1.0506570273475635, -0.4995582338608715], [-3.0864202192902068, 0.10338454287138976, -1.1620378958229036, -2.7999306270260025]]]]))  
       res=arg0+arg1  
       s0=numpy.array([[[[-1.9606269781907946, 2.9564445954233642, -2.6927221994669983, 1.8149397934456406], [-0.1240065473763261, -3.2713778582534525, 2.8345053055312972, -1.1855553458400236], [-3.7306436145529043, 0.99040960799143907, 0.96164189944624301, -3.8746836741206057]], [[-1.5458213361044404, 2.0520973187751768, 3.9962581611203287, -0.10154351687472385], [-0.81709600069978183, -3.7391938728220375, -1.7397779297069746, -1.513656766226712], [0.17870995650604371, -3.8847554698278874, 4.7221660788359578, -3.7059099777153914]]], [[[-2.4305965097157154, -0.49488157626753715, -3.639340293226101, -1.2169702277529417], [0.6702208753252954, 4.6593055404785702, 3.6809782027074771, -2.9906651842732668], [-1.6265193079740636, -4.825462221408614, -4.2902897820886299, -3.5917971387811565]], [[-4.0833359290082676, -2.4937585589598266, 1.7123080356591025, 2.0901928325549708], [-3.2067337309200949, 1.8691517018587698, -0.32982822629637276, -4.1793523729656794], [-3.3724315549166537, -0.42338571644645207, 4.5594485247020842, -3.6057443697914215]]], [[[3.1481920082172046, -2.6902148629888325, -0.75464109831149795, -2.4255137650319947], [-3.9512297039705278, -2.3880921546340792, 1.2468121458587254, 0.9373949098822294], [0.55522163251791046, 3.1464345910544331, -0.66815643085783627, -3.5771938122909397]], [[0.68974302974669222, -3.7231991714128956, 3.9850049568812445, -1.4032569743070136], [1.9663650753565101, 1.3119084983627989, -0.3641457290443082, -2.4799503614599363], [-1.0260253244116302, 2.4638209809858633, 1.9864365050313335, 4.3082596098007304]]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[2.0314537437285951, -1.6215293168727172, 1.8927312480327734, 5.0202540792828838], [2.6863331847139698, 1.7173986204930527, 2.3134640622717386, -3.0159663589297026], [-2.3829949419307219, 2.4349961409318031, -1.9258455467278797, 0.9130081315049754]], [[-1.2226553215185385, 6.1415501820750684, 8.8364705205768761, 1.7253396185638881], [-3.3182187383473973, -1.6083086754812945, 0.61040842747341983, 0.74996805045802395], [4.5241733582023098, -7.5434686802779343, 8.9160483691782382, 0.88679200136242109]]], [[[1.7116425512334432, -4.0951295023279979, -7.3311812872453519, -3.0123437219809528], [-4.1800421271621593, -0.12053099100784692, 6.8497896586259994, -2.1014377697204338], [2.4216683310007565, -7.4636431464983675, -6.207502245896908, -6.4561400519345327]], [[-8.632557680422579, -1.061332523938165, -2.384189889369237, 3.9246108861333235], [-6.0347842125267697, 4.9959294809739054, -0.72727703190989423, -1.6642488836020242], [-6.5911969786844136, -2.0113391440911159, 2.0749902460482192, -2.5771850443991808]]], [[[5.2965313353478471, -3.519165309425663, -4.423034427310796, 0.97656856221016053], [-3.2685954358327294, 0.11900905681741847, 2.8400849527792404, 0.69309975710495131], [0.67962676312173631, 3.8686700438498933, 2.3674543174085798, -8.3277717548524421]], [[3.1773202702781775, 0.69267899833539381, 1.3498965987857541, -0.56513595684856277], [-0.31666111664253549, 1.0524401828907202, -2.0710967243979481, -4.6883815407729035], [-1.0864230970075686, -0.016330343310300144, 1.2602151023518253, 7.4410406220516965]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[1.3132073330682035, 7.9428785111983649, -7.6286093993622304, 5.3221199962307981], [-4.9354637925757636, -4.0744190110487599, 4.3988284695858786, 2.6375128549323823], [-2.8776479811769748, -3.167857238313645, 3.3754608273995883, -3.7775188088281952]], [[-5.1001591616525834, 1.9323582322080153, 2.9463155625274133, 0.29538619506560693], [1.1642640591026918, -6.1129528821370176, -0.56954018562160069, 0.55016615751622622], [1.5892581931626761, -3.5913810206058359, 7.17603726309257, -3.7106840435120967]]], [[[-2.6258843867531771, -4.3757235209978766, -1.7684781624195933, -3.7326116259733144], [-2.5838640554425112, 7.4302706779287666, 6.2721840818350003, -6.0585080601359458], [-1.6537779101008936, 0.083565201351976981, -5.1766269367416005, -4.7328044697627423]], [[-5.6431364116227858, -3.4094025941363739, -0.13786694479943939, 6.5105245460844721], [-0.065979107398251635, 2.6622178580088214, 3.2902023221908543, -6.5969371575162619], [0.1219577208585374, -2.4628474473130684, 3.6428491487872412, -2.797078475157202]]], [[[3.3416036932514528, -7.4050868423559884, 2.51993074465791, -1.8135777496803174], [-7.1588166353563416, -7.2643470572760478, -2.0268634534216146, -0.88377341681705435], [4.8742414022094307, 7.4644698171585926, -3.2409902141941753, -6.6045293588722744]], [[4.9751373903684719, -8.520489663956246, 1.9675348763823326, 1.0511582278421807], [-2.0500086024272219, -2.6273560514029262, 0.6865112983032553, -2.9795085953208078], [-4.1124455437018366, 2.5672055238572531, 0.82439860920842989, 1.5083289827747279]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
1079     def test_sub_overloaded_float_rank0_taggedData_rank0(self):     def test_sub_overloaded_float_rank0_taggedData_rank0(self):
1080        arg0=2.24633892242        arg0=2.24633892242
1081        arg1=Data(2.12331690395,self.functionspace)        arg1=Data(2.12331690395,self.functionspace)
# Line 2278  class Test_util_overloaded_binary_with_t Line 2109  class Test_util_overloaded_binary_with_t
2109        self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")        self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
2110        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
2111     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    def test_sub_overloaded_Symbol_rank0_taggedData_rank0(self):  
       arg0=Symbol(shape=())  
       arg1=Data(0.582121894038,self.functionspace)  
       arg1.setTaggedValue(1,-1.2015882269)  
       res=arg0-arg1  
       s0=numpy.array(-3.29176287905)  
       sub=res.substitute({arg0:s0})  
       ref=Data(-3.87388477309,self.functionspace)  
       ref.setTaggedValue(1,-2.09017465215)  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank0_taggedData_rank1(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([-1.6226165681167162, -3.8614849107021665]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([3.914576292066883, 1.4557762386956306]))  
       res=arg0-arg1  
       s0=numpy.array(4.51386770027)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([6.1364842683899736, 8.3753526109754244]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([0.5992914082063745, 3.0580914615776269]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank0_taggedData_rank2(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[-1.1650961769520372, -1.9675237476087681, -2.7354609320608105, -0.88673441034929912, -3.944848416287583], [-0.335077584837844, 4.0177180335017368, -2.1122209888578647, 3.2050022063761237, -4.6710734843736148], [1.7917797077594164, 2.4247159974480157, 1.3318737513519041, -2.3397914229146766, -3.8312572517541419], [-3.638547477297791, -2.7318639467464969, 2.7408418280593994, -3.0281170909123967, 3.7370869594850049]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[-1.6790439883941133, 0.72207186916637411, 3.0149036359501444, -2.4706181109946512, 2.3971006630061282], [4.0183470758185962, 4.3927784252128497, 3.773690423051459, 2.2281071273141571, -1.1421475142021533], [-3.4286917686787488, -2.9387352061907848, -0.71011628484454015, -4.465710410304947, 2.4673716533084464], [-0.86830553055690807, -4.5339070380375173, 4.696634656732531, -4.8213659386281646, -1.5959949527386321]]))  
       res=arg0-arg1  
       s0=numpy.array(-2.74554613427)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[-1.5804499573177866, -0.77802238666105561, -0.010085202209013211, -1.8588117239205246, 1.1993022820177592], [-2.4104685494319797, -6.7632641677715606, -0.63332514541195906, -5.9505483406459474, 1.9255273501037911], [-4.5373258420292402, -5.1702621317178394, -4.0774198856217279, -0.40575471135514718, 1.0857111174843181], [0.8930013430279673, -0.013682187523326839, -5.4863879623292231, 0.28257095664257292, -6.4826330937548287]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[-1.0665021458757105, -3.4676180034361979, -5.7604497702199682, -0.27492802327517252, -5.142646797275952], [-6.7638932100884199, -7.1383245594826734, -6.5192365573212827, -4.9736532615839808, -1.6033986200676704], [0.68314563440892506, 0.19318907192096102, -2.0354298494252836, 1.7201642760351232, -5.2129177875782702], [-1.8772406037129157, 1.7883609037676935, -7.4421807910023547, 2.0758198043583409, -1.1495511815311916]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank0_taggedData_rank3(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[[1.7417929204702034, 4.1674580894402418], [1.1100945098480679, 3.1245192710741208]], [[2.0598090161963256, -3.4252820536834463], [1.4450643701541139, -4.5234590306490832]], [[3.8890562294101674, -0.98035065940240251], [-0.98518417929845636, 4.803926034707656]], [[-4.5836759670899818, -3.7538762268226797], [4.8045638019998069, -3.7970527621458361]], [[-3.9211787328864469, -2.5674146203030199], [1.3249021629386899, 2.2864166323603916]], [[-2.6268046925535318, -4.6073453219934706], [4.6605258104748231, 2.1462220797201645]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[4.0753854063785244, 1.434708088503676], [1.1762112954218864, -1.8725563543238999]], [[-3.5361615039107819, -4.9681946845051028], [-2.9848647970443656, -1.960261885263396]], [[-3.2171964896676375, 1.0449662877402286], [3.6060081597693578, 2.3197177059557008]], [[4.0442065919480434, -2.0402001068878048], [0.65736668018486188, 3.1748486592422669]], [[-0.57495469987139725, 2.3112447773487688], [-4.4519577238562587, 0.48048914845688095]], [[3.8837992025475927, -2.6824179644749178], [-1.9526836116218407, -0.29139786035874238]]]))  
       res=arg0-arg1  
       s0=numpy.array(-4.83913771585)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[-6.5809306363225195, -9.0065958052925588], [-5.949232225700384, -7.9636569869264369]], [[-6.8989467320486417, -1.4138556621688698], [-6.28420208600643, -0.31567868520323294]], [[-8.7281939452624826, -3.8587870564499136], [-3.8539535365538597, -9.6430637505599712]], [[-0.2554617487623343, -1.0852614890296364], [-9.6437015178521222, -1.04208495370648]], [[-0.9179589829658692, -2.2717230955492962], [-6.164039878791006, -7.1255543482127077]], [[-2.2123330232987843, -0.23179239385884554], [-9.4996635263271401, -6.9853597955724807]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[-8.9145231222308396, -6.2738458043559922], [-6.0153490112742025, -2.9665813615284162]], [[-1.3029762119415342, 0.12905696865278671], [-1.8542729188079505, -2.8788758305889202]], [[-1.6219412261846786, -5.8841040035925447], [-8.4451458756216731, -7.1588554218080169]], [[-8.8833443078003604, -2.7989376089645113], [-5.496504396037178, -8.0139863750945821]], [[-4.2641830159809189, -7.1503824932010849], [-0.38717999199605746, -5.3196268643091971]], [[-8.7229369183999097, -2.1567197513773984], [-2.8864541042304754, -4.5477398554935737]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank0_taggedData_rank4(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[[[-1.7239722643460995, -4.0785929036192679, -2.7878763370321691, 1.4090191333560398], [-1.3452045040420391, -3.0875463966561121, -2.3477804977395889, -2.7143527745366347], [4.6826856000362493, -4.4573214925419604, 4.0912571632456878, -3.6979391511335957]], [[4.7676517597064958, -0.69446578862612363, -2.7946600541160627, -4.6387557577151464], [-3.8152187834317419, -1.1103553680141953, -2.6992379997484131, -1.3939343925574499], [-2.8639709447110242, -0.93277023292250227, -3.005859027861236, -1.5194298419556054]]], [[[-3.6461012966289443, -3.595213084837968, 1.7652113752678735, 3.9354765962238645], [-4.8061320937344965, -2.0493307456299839, -1.9074141856619709, -2.4966825828085448], [0.0068570908462950442, 3.439496355973418, -2.9248866829726152, -3.0357365933113414]], [[-3.3337436038330406, -3.9596730132837097, 2.8903556569228694, -1.5528367145431563], [-1.6856225993506992, 1.9564035325452167, 0.77700921036954185, -3.2821859419057287], [-3.9249983585317274, 4.5293090673562375, -2.4660694632175897, 3.7059309218225795]]], [[[1.7003144943026873, 1.2924514612541662, -0.7290623055768588, 2.7809882374222443], [-1.5679628020304657, 3.9585736392805106, 1.801735046602694, -2.5359934509185003], [3.8245409615975294, 4.2836473864628477, -3.0587294395931321, 3.4035007507567876]], [[3.347111271275125, -3.5116729158417281, -2.817410420018577, 2.1476103240460951], [-0.78621191857894601, 3.0998955915287514, -2.5581039100591663, 0.11089765013161479], [2.3228762606423814, -1.6756824618662467, -4.0867750958128237, 2.67810782480423]]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[[2.1685172033039191, -4.5796634026950969, 0.92437238150228929, 4.20465835927636], [0.043867599800918811, -0.12491317306365701, -2.0987595267092853, -1.9618656144074009], [-2.5871038274633404, -4.0470396109286408, -4.7901676312131674, -1.0485902157240332]], [[-4.0000933550960349, 0.44795572375027781, 3.5880916147757524, 2.3799574571029858], [-3.4818864095722803, -2.1380681162259032, 1.0470901504273566, -3.9375660965913273], [-3.1517431204663948, 2.8503083115064385, 3.1921499427431659, -4.9004011924221054]]], [[[-3.6670624865037373, -1.2241536131342281, 4.2624975434602366, 4.4969987923781236], [-2.5339263610208951, -1.4940510720892943, -0.043337317994136981, -2.6738643271142126], [-4.1420847955225595, -3.1085932530323133, 2.8820843213544496, 3.4461103273906986]], [[-2.7610797971884891, 0.073157401608792583, 2.9210667476714729, -3.6129385164110364], [-1.269263301728385, 0.97941304783047123, 2.4447339221427677, 2.0179223137604492], [-3.8578093991943385, 1.0025946734194999, 2.999234348790961, 4.013811906725115]]], [[[0.22206791040277629, -1.1708680277506298, 4.8894775311787662, 1.2637845842821793], [1.582995604952302, 1.167140702652981, 2.7148475855656375, -2.3381544490416184], [0.467371900413319, 1.7549572709260381, 3.9090200667321735, 3.5449896100150333]], [[1.3605082022210757, 1.8986179164091102, 3.9605120589597114, -4.5797363589925579], [-1.1752064681229948, 2.5283937261839506, -2.5428419831319102, -1.6004256996930444], [0.85260519944465152, -3.0264903095821447, 0.20227676367132652, -2.2583080012849157]]]]))  
       res=arg0-arg1  
       s0=numpy.array(-0.360654108058)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[1.3633181562882664, 3.7179387955614347, 2.4272222289743359, -1.7696732414138729], [0.98455039598420591, 2.7268922885982789, 1.9871263896817557, 2.3536986664788015], [-5.0433397080940825, 4.0966673844841273, -4.4519112713035209, 3.3372850430757626]], [[-5.128305867764329, 0.33381168056829047, 2.4340059460582295, 4.2781016496573132], [3.4545646753739088, 0.74970125995636216, 2.3385838916905799, 1.0332802844996167], [2.503316836653191, 0.57211612486466912, 2.6452049198034029, 1.1587757338977722]]], [[[3.2854471885711112, 3.2345589767801348, -2.1258654833257067, -4.2961307042816976], [4.4454779856766633, 1.6886766375721507, 1.5467600776041377, 2.1360284747507117], [-0.3675111989041282, -3.8001504640312511, 2.5642325749147821, 2.6750824852535082]], [[2.9730894957752074, 3.5990189052258765, -3.2510097649807026, 1.1921826064853231], [1.3249684912928661, -2.3170576406030499, -1.137663318427375, 2.9215318338478955], [3.5643442504738942, -4.8899631754140707, 2.1054153551597565, -4.0665850298804127]]], [[[-2.0609686023605205, -1.6531055693119994, 0.36840819751902565, -3.1416423454800775], [1.2073086939726325, -4.3192277473383438, -2.1623891546605272, 2.1753393428606671], [-4.1851950696553626, -4.6443014945206809, 2.698075331535299, -3.7641548588146208]], [[-3.7077653793329581, 3.151018807783895, 2.4567563119607438, -2.5082644321039282], [0.42555781052111286, -3.4605496995865845, 2.1974498020013331, -0.47155175818944794], [-2.6835303687002146, 1.3150283538084135, 3.7261209877549906, -3.0387619328620632]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[-2.5291713113617522, 4.2190092946372637, -1.2850264895601224, -4.5653124673341932], [-0.40452170785875197, -0.23574093499417614, 1.7381054186514522, 1.6012115063495678], [2.2264497194055073, 3.6863855028708077, 4.4295135231553342, 0.68793610766620006]], [[3.6394392470382018, -0.80860983180811097, -3.9487457228335856, -2.7406115651608189], [3.1212323015144472, 1.77741400816807, -1.4077442584851898, 3.5769119885334941], [2.7910890124085617, -3.2109624195642716, -3.552804050800999, 4.5397470843642722]]], [[[3.3064083784459042, 0.86349950507639495, -4.6231516515180697, -4.8576529004359568], [2.1732722529630619, 1.1333969640314612, -0.31731679006369617, 2.3132102190563795], [3.7814306874647263, 2.7479391449744801, -3.2427384294122827, -3.8067644354485317]], [[2.4004256891306559, -0.43381150966662574, -3.2817208557293061, 3.2522844083532032], [0.90860919367055182, -1.3400671558883044, -2.8053880302006009, -2.3785764218182823], [3.4971552911365054, -1.3632487814773331, -3.3598884568487941, -4.3744660147829482]]], [[[-0.58272201846060945, 0.81021391969279666, -5.2501316392365993, -1.6244386923400125], [-1.9436497130101351, -1.5277948107108141, -3.0755016936234707, 1.9775003409837852], [-0.82802600847115215, -2.1156113789838713, -4.2696741747900067, -3.9056437180728665]], [[-1.7211623102789089, -2.2592720244669433, -4.3211661670175445, 4.2190822509347248], [0.81455236006516163, -2.8890478342417838, 2.1821878750740771, 1.2397715916352112], [-1.2132593075024847, 2.6658362015243116, -0.56293087172915968, 1.8976538932270826]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank1_taggedData_rank0(self):  
       arg0=Symbol(shape=(2,))  
       arg1=Data(4.61346897048,self.functionspace)  
       arg1.setTaggedValue(1,3.28068233392)  
       res=arg0-arg1  
       s0=numpy.array([-2.6407675311485077, -3.8649480192023447])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([-7.25423650163044, -8.4784169896842769]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([-5.9214498650644272, -7.1456303531182641]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank1_taggedData_rank1(self):  
       arg0=Symbol(shape=(2,))  
       arg1=Data(numpy.array([-3.3519968185730962, -2.1020492317267836]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([-3.0436846071258827, 1.1669921719101284]))  
       res=arg0-arg1  
       s0=numpy.array([0.048306015408320135, 3.2908236385188285])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([3.4003028339814163, 5.3928728702456121]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([3.0919906225342029, 2.1238314666087001]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank2_taggedData_rank0(self):  
       arg0=Symbol(shape=(4, 5))  
       arg1=Data(-2.82343254331,self.functionspace)  
       arg1.setTaggedValue(1,0.279291380547)  
       res=arg0-arg1  
       s0=numpy.array([[4.3906056591115785, -4.6150375975326767, -3.2481943500942911, -2.402527060620109, 0.52450326376809553], [-1.4076010159374999, -3.7755424381291371, 0.54247505033170551, 1.5815797338813962, -0.91911021830269846], [0.363495777280475, 2.2487371638043783, -2.7280230947598962, 4.9288315792104633, 3.5741727098981197], [2.9825148398946855, 0.35322697133915781, 2.3170499036050005, 1.3494842302803747, 1.7063528582434859]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[7.2140382024227714, -1.7916050542214839, -0.42476180678309827, 0.42090548269108385, 3.3479358070792884], [1.415831527373693, -0.95210989481794428, 3.3659075936428984, 4.405012277192589, 1.9043223250084944], [3.1869283205916679, 5.0721697071155711, 0.095409448551296627, 7.7522641225216562, 6.3976052532093126], [5.8059473832058783, 3.1766595146503507, 5.1404824469161934, 4.1729167735915675, 4.5297854015546788]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[4.1113142785645458, -4.8943289780797095, -3.5274857306413239, -2.6818184411671417, 0.2452118832210628], [-1.6868923964845326, -4.0548338186761699, 0.26318366978467278, 1.3022883533343634, -1.1984015988497312], [0.084204396733442266, 1.9694457832573455, -3.007314475306929, 4.6495401986634306, 3.294881329351087], [2.7032234593476527, 0.073935590792125083, 2.0377585230579678, 1.0701928497333419, 1.4270614776964532]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank2_taggedData_rank2(self):  
       arg0=Symbol(shape=(4, 5))  
       arg1=Data(numpy.array([[1.9642010797865348, -3.3128271985312407, 2.9391531612943931, 2.6735211006699107, 3.4803563490919522], [3.6093912081815276, 1.9278535119416862, 3.0085997055397495, -0.43388705905257918, 4.0786101179526959], [2.0316387326375533, -3.3345735081955521, -1.8458060558893177, 4.2933982982612022, -3.9574390266223847], [2.7019275715653093, 4.1255793158843268, 4.3063927827661992, 2.9510514442425153, 2.1210117253441227]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[3.7542996986115043, -4.3125911861815762, -0.53644775498943531, 3.0127660822748279, -0.23320232490737336], [-2.1120266167515114, 1.4334039180960536, 0.81855067526448089, 3.0273459308808288, -4.1314746959424218], [1.6229987296127639, 2.0601468963495755, -2.3385992077486852, -0.49246435920295539, -1.7771337277156549], [1.6743475967492287, 1.0535935730270367, 3.571860137829276, -0.11249138441769357, 2.9554495066142783]]))  
       res=arg0-arg1  
       s0=numpy.array([[-1.3502116822697707, -4.3387382200591791, 0.36018852985571748, -1.735504428687177, -2.6997369247507121], [-0.29956091066354951, -2.32118481439193, 0.79086091760780963, -1.6968370884183335, 4.8603591131388093], [-4.5378779857071319, -2.4784297572223348, -1.1424574114551245, -3.7317233585823195, 3.4731933691904899], [4.6637878137498276, -0.61110706371933698, 3.243807649799054, 2.6217887097648198, 4.952530144151515]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[-3.3144127620563055, -1.0259110215279383, -2.5789646314386756, -4.4090255293570877, -6.1800932738426644], [-3.9089521188450771, -4.2490383263336167, -2.2177387879319399, -1.2629500293657543, 0.7817489951861134], [-6.5695167183446852, 0.85614375097321727, 0.7033486444341932, -8.0251216568435222, 7.430632395812875], [1.9618602421845184, -4.7366863796036638, -1.0625851329671452, -0.3292627344776955, 2.8315184188073923]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[-5.1045113808812754, -0.026147033877602865, 0.89663628484515279, -4.7482705109620049, -2.4665345998433388], [1.8124657060879619, -3.7545887324879836, -0.027689757656671254, -4.7241830192991623, 8.991833809081232], [-6.1608767153198958, -4.5385766535719103, 1.1961417962935608, -3.2392589993793641, 5.2503270969061449], [2.9894402170005989, -1.6647006367463737, -0.32805248803022202, 2.7342800941825134, 1.9970806375372367]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank3_taggedData_rank0(self):  
       arg0=Symbol(shape=(6, 2, 2))  
       arg1=Data(-3.45437670397,self.functionspace)  
       arg1.setTaggedValue(1,0.0236659452005)  
       res=arg0-arg1  
       s0=numpy.array([[[-0.80994388949706231, -2.0551643466439251], [3.1776505373733261, -4.1979990554887756]], [[-0.93024244243644727, -3.9398686946278838], [0.33105162283262768, 3.0077640799605518]], [[-3.5714275654222369, 4.5676380971867978], [-0.32534647309740983, 2.7212833586925225]], [[1.5718134448369199, 4.8212804731722532], [2.9993157729648132, 4.0399059053592428]], [[1.4447905877115197, -3.649925114108342], [1.4304237208504631, 3.3707161729469703]], [[2.4291844611963773, -3.3908876283370848], [0.87332191406451898, -0.19631594176532818]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[2.6444328144728093, 1.3992123573259465], [6.6320272413431978, -0.74362235151890399]], [[2.5241342615334244, -0.48549199065801218], [3.7854283268024993, 6.4621407839304235]], [[-0.11705086145236532, 8.0220148011566685], [3.1290302308724618, 6.1756600626623941]], [[5.0261901488067915, 8.2756571771421257], [6.4536924769346848, 7.4942826093291144]], [[4.8991672916813913, -0.19554841013847035], [4.8848004248203347, 6.825092876916842]], [[5.8835611651662489, 0.063489075632786829], [4.3276986180343906, 3.2580607622045434]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[-0.8336098346975227, -2.0788302918443855], [3.1539845921728658, -4.221665000689236]], [[-0.95390838763690766, -3.9635346398283442], [0.30738567763216729, 2.9840981347600914]], [[-3.5950935106226973, 4.5439721519863374], [-0.34901241829787022, 2.6976174134920621]], [[1.5481474996364595, 4.7976145279717928], [2.9756498277643528, 4.0162399601587824]], [[1.4211246425110593, -3.6735910593088024], [1.4067577756500027, 3.34705022774651]], [[2.4055185159959169, -3.4145535735375452], [0.84965596886405859, -0.21998188696578858]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank3_taggedData_rank3(self):  
       arg0=Symbol(shape=(6, 2, 2))  
       arg1=Data(numpy.array([[[-4.1436539405565096, -0.99526622192709446], [-3.5202247135366713, 0.80678988404832008]], [[-1.380746985600898, 2.1969409529894781], [-0.7149708700001387, -4.6950225672320141]], [[-1.151430912606747, -4.9596801787767824], [0.018566973707438983, -3.5483077583661649]], [[0.75854973249211977, 0.59224689645928308], [0.31198026697607428, 2.412973409101844]], [[-3.7945100947149788, 3.9392888198645775], [-2.3440930993175471, 4.005053525092773]], [[0.26174411283672949, -3.4196866761389897], [4.2661748781066962, 1.9941977059693938]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[-1.7669082813372872, 2.9718370643639354], [-3.7213834792724776, -1.1704113948737405]], [[1.0325354736313024, 4.4852339601574567], [2.1850588841379102, 3.5431941183546307]], [[-2.6803084598218807, -0.1915365481124276], [-0.84095351345692926, 4.3270800637498645]], [[-1.0180285704136791, 0.38302981602356212], [3.4204787762913522, 3.5480068963187108]], [[-4.5625092346422358, -0.48786387942945275], [3.0945285633606741, -1.7488927269870369]], [[-2.223857533566711, -1.5774469319035944], [-3.9804224679532583, 0.5674075864451158]]]))  
       res=arg0-arg1  
       s0=numpy.array([[[-3.688078183539969, 2.5061807135286243], [4.7624814038474135, -4.2346786457593319]], [[1.8856781063993857, -1.1790026794083266], [-3.1867352448607345, -4.358206353173034]], [[-4.8530248372999907, 3.349319425297244], [4.0480210794050162, -0.57686387935690675]], [[0.68310157518585601, -3.4802459584532697], [1.3468387015024508, 1.7772648032207421]], [[-1.1166079172974062, -4.3536312347249222], [4.655835681242035, 4.9638827339689335]], [[0.052763670242587324, -0.64877678831831265], [-0.61817342300734346, 1.9914868201405556]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[0.45557575701654063, 3.5014469354557187], [8.2827061173840839, -5.041468529807652]], [[3.2664250920002837, -3.3759436323978047], [-2.4717643748605957, 0.3368162140589801]], [[-3.7015939246932437, 8.3089996040740264], [4.0294541056975772, 2.9714438790092581]], [[-0.075448157306263752, -4.0724928549125528], [1.0348584345263765, -0.6357086058811019]], [[2.6779021774175726, -8.2929200545894997], [6.999928780559582, 0.95882920887616052]], [[-0.20898044259414217, 2.770909887820677], [-4.8843483011140396, -0.002710885828838272]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[-1.9211699022026818, -0.46565635083531109], [8.4838648831198906, -3.0642672508855915]], [[0.85314263276808333, -5.6642366395657833], [-5.3717941289986442, -7.9014004715276647]], [[-2.17271637747811, 3.5408559734096716], [4.8889745928619455, -4.9039439431067713]], [[1.7011301455995351, -3.8632757744768318], [-2.0736400747889014, -1.7707420930979687]], [[3.4459013173448296, -3.8657673552954694], [1.5613071178813609, 6.7127754609559709]], [[2.2766212038092983, 0.92867014358528177], [3.3622490449459148, 1.4240792336954398]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank4_taggedData_rank0(self):  
       arg0=Symbol(shape=(3, 2, 3, 4))  
       arg1=Data(1.15447758201,self.functionspace)  
       arg1.setTaggedValue(1,-1.30150432984)  
       res=arg0-arg1  
       s0=numpy.array([[[[4.3452921406796339, -3.094720365553647, 4.2260159849404531, 0.53398143783173779], [-2.9652633107503643, 0.97268800776422459, -1.9548974978087577, 4.4017562399599051], [1.0407126301416101, 1.66731932678627, -1.8344653355878258, -1.1221583810471025]], [[4.0804047485771395, 3.1472379163713349, 4.859284050337779, -2.0251323074544549], [3.0470088161602007, 1.4094566984771415, -2.3397077031497373, -4.1377315129234304], [-0.40780534442604743, 0.46806061896557427, 3.6631990283341729, -2.2983977406553215]]], [[[0.99769073737299596, 1.2914771598755737, -1.6758353186032151, 1.7876514831187995], [1.1107687619238629, -3.0484173732375797, -2.9282256907061335, 3.3297820355940928], [3.4563792494298813, 0.50836104379246105, -0.34285311671409691, 0.1377235655495177]], [[-3.9955042472888955, 1.7407911016182487, -3.4797795736858528, -2.787055786196003], [-1.4724574323992057, 3.2557567291482687, -0.27905298144459678, 3.0775034462199287], [-0.26339026683045219, 2.8213687887964367, 0.1568915233734467, -1.8910889608829562]]], [[[0.2776131506609687, 3.6554012449506121, -2.2134284210815611, -4.4843239181053338], [3.3862429838540589, 3.3927044896472456, 4.7725297382350824, -4.1542235773934504], [-4.1911735823709417, -2.5860368545106271, -2.9880018069914858, -0.16303372577529895]], [[-0.8868275813099924, 2.2616935835362284, 0.79784679282106374, 4.3310317960219731], [1.9479630528609917, -4.5634036259553268, -0.93873776231854755, -2.569028141929075], [-0.83549827454520553, -1.1533271852860025, -1.933016595371797, -2.8336709935074902]]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[3.1908145586727876, -4.2491979475604928, 3.0715384029336068, -0.62049614417510845], [-4.1197408927572106, -0.18178957424262165, -3.1093750798156039, 3.2472786579530588], [-0.11376495186523616, 0.51284174477942379, -2.988942917594672, -2.2766359630539488]], [[2.9259271665702933, 1.9927603343644886, 3.7048064683309327, -3.1796098894613012], [1.8925312341533544, 0.25497911647029525, -3.4941852851565836, -5.2922090949302767], [-1.5622829264328937, -0.68641696304127198, 2.5087214463273266, -3.4528753226621678]]], [[[-0.15678684463385029, 0.13699957786872741, -2.8303129006100614, 0.63317390111195326], [-0.04370882008298338, -4.2028949552444264, -4.0827032727129797, 2.1753044535872466], [2.301901667423035, -0.64611653821438519, -1.4973306987209432, -1.0167540164573285]], [[-5.1499818292957418, 0.58631351961140243, -4.6342571556926995, -3.9415333682028493], [-2.6269350144060519, 2.1012791471414225, -1.433530563451443, 1.9230258642130824], [-1.4178678488372984, 1.6668912067895905, -0.99758605863339955, -3.0455665428898024]]], [[[-0.87686443134587755, 2.5009236629437659, -3.3679060030884074, -5.6388015001121801], [2.2317654018472126, 2.2382269076403993, 3.6180521562282362, -5.3087011594002966], [-5.345651164377788, -3.7405144365174734, -4.142479388998332, -1.3175113077821452]], [[-2.0413051633168386, 1.1072160015293822, -0.3566307891857825, 3.1765542140151268], [0.79348547085414545, -5.717881207962173, -2.0932153443253938, -3.7235057239359213], [-1.9899758565520518, -2.3078047672928488, -3.0874941773786433, -3.9881485755143364]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[5.6467964705168638, -1.7932160357164171, 5.527520314777683, 1.8354857676689678], [-1.6637589809131343, 2.2741923376014546, -0.65339316797152769, 5.703260569797135], [2.3422169599788401, 2.9688236566235, -0.5329610057505958, 0.17934594879012744]], [[5.3819090784143695, 4.4487422462085648, 6.160788380175009, -0.72362797761722497], [4.3485131459974307, 2.7109610283143715, -1.0382033733125073, -2.8362271830862005], [0.89369898541118253, 1.7695649488028042, 4.9647033581714028, -0.99689341081809157]]], [[[2.2991950672102259, 2.5929814897128036, -0.37433098876598514, 3.0891558129560295], [2.4122730917610928, -1.7469130434003497, -1.6267213608689035, 4.6312863654313228], [4.7578835792671113, 1.809865373629691, 0.95865121312313306, 1.4392278953867477]], [[-2.6939999174516656, 3.0422954314554786, -2.1782752438486228, -1.4855514563587731], [-0.17095310256197571, 4.5572610589854987, 1.0224513483926332, 4.3790077760571586], [1.0381140630067778, 4.1228731186336667, 1.4583958532106767, -0.58958463104572623]]], [[[1.5791174804981987, 4.9569055747878421, -0.91192409124433116, -3.1828195882681038], [4.6877473136912888, 4.6942088194844755, 6.0740340680723124, -2.8527192475562204], [-2.8896692525337118, -1.2845325246733972, -1.6864974771542558, 1.138470604061931]], [[0.41467674852723757, 3.5631979133734584, 2.0993511226582937, 5.632536125859203], [3.2494673826982217, -3.2618992961180968, 0.36276656751868241, -1.2675238120918451], [0.46600605529202443, 0.14817714455122744, -0.63151226553456707, -1.5321666636702602]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_sub_overloaded_Symbol_rank4_taggedData_rank4(self):  
       arg0=Symbol(shape=(3, 2, 3, 4))  
       arg1=Data(numpy.array([[[[3.5883150316854806, 1.6608399098281934, 2.2024683065081421, 4.5100850299575264], [3.5770417831544403, 2.9968047723170397, 2.552920172474046, -2.2268747697524272], [-0.92524702801358938, 1.0688902410623147, -1.8168048968765937, -0.1106310518029705]], [[-4.2457706769813628, 3.5834795151173555, 1.888365159927762, -0.48415045315364313], [-2.1679416560314269, -1.9957054169738542, 1.7415637083493234, 3.4045477187110151], [1.5560769276052167, -4.8500643825741161, 4.9016752514631072, 3.9834137906347902]]], [[[4.9207159049426075, 0.50001786299822371, -2.7275193492631322, 2.4589593350212731], [-1.4976403002838836, 3.9265631184608356, 0.4046077313793619, -1.4505250571168684], [-0.19497334230297803, 3.9957517880860411, -3.7816750392469078, -1.9185488040783527]], [[-3.4279959657946724, 0.79554773721639371, 1.233813642137215, 3.2915007519830333], [3.3233779447887208, -3.1839585013775542, -1.725570155778958, 2.6384846284807848], [-0.098796091195598734, -1.1420056078217344, -1.0787061667825992, -3.4930108959285966]]], [[[1.7718012243741246, -2.9133117180821899, -0.39175478191092239, 3.1270114114409093], [0.51367748157427506, 0.32867639635427892, -1.9186362775712027, -0.74698673270772709], [-3.324142919547135, 2.7822076971092748, 3.6056899352976686, -1.0241360874394614]], [[0.53104844915811267, 4.0540051810963789, 1.8896123904609539, 0.010139581810646447], [4.2923953898105598, 0.84371056430624503, 3.2521307294866713, 2.3249442171446866], [-1.383326444559112, 3.0524222599236488, -1.1931984807351981, -3.8332841848767996]]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[[-3.4177712167791863, 2.5837530099731136, 3.0704181188708546, -4.8563317507515986], [2.401865526398459, 2.8972861998473318, -0.95563900184045281, -1.1791291573342209], [4.4122882861981587, 4.3093002300367793, -3.6392847395950478, 3.0935768002301671]], [[-3.4158230001529444, -2.8982152760504167, -4.5016237412837024, 0.84448233313674148], [-0.97258538397911032, 4.7704238047870682, -2.0811614432557479, 4.3140735462398982], [0.6147118147199313, 4.3420739071897536, 0.49416069966163612, -4.1263082702987477]]], [[[3.9491889430333735, -0.05664128571792304, -2.771000977907164, -4.0428845588285132], [4.9663884283530439, 1.4149277070699728, 1.6711749159072831, 2.9954165464432423], [1.1111902364084703, -2.7535777620831139, -4.5958881442004547, -0.33909854703525966]], [[4.6897397051546736, 0.86468492035579914, -1.5195517286784277, -2.3838063928075592], [4.7254713910758426, 3.2177308837573104, 2.552758253454158, -4.7547493584437719], [-1.7400624498313508, 0.094904622006009909, 4.29025307184064, -2.9317333478617371]]], [[[3.9023184349518818, 2.6764267377374216, -0.74277278264960334, -3.6110556596424068], [0.23374191610285866, 3.9092557400282217, -4.2717614909733426, -0.60865910850218619], [-1.7027314363999304, -2.0785333027948374, 2.8303551292437508, 2.9375661809907019]], [[-4.7111418854042775, 3.6262534473804031, -4.6861217480850481, -1.2762530757617174], [3.6196399360706764, -1.3401828055957123, 4.7037525167985077, -0.40495146182906616], [3.9241877275920185, -0.34081807569509337, 4.9371069492341508, 4.8076632088755105]]]]))  
       res=arg0-arg1  
       s0=numpy.array([[[[-1.6337504093342012, -4.3289804572194592, -0.19446597284890732, -2.4938687060341023], [-2.0720972704885399, 4.5574501781720294, 1.5690535995509292, -1.0965856608406845], [3.4791587370144441, 2.4814799092551407, 2.8107234749505867, 4.2304156442244949]], [[-3.9788019951794382, 3.1115620042916774, -1.2433816259920949, -4.2228075080319281], [3.9238534833707064, -3.8517957119258339, -4.1415343993970311, 0.34584626169123922], [1.2030571170060069, 4.8525698531787764, -2.0472967910738973, -3.3231004889671545]]], [[[2.2271926137866878, -1.1023529636945972, 2.8563620050040859, 4.0058815300591366], [-1.0789349725931627, -2.2224319545129578, 1.4379291772333946, 1.4019805325400148], [-0.10727005112015764, 0.8059626682552592, -1.2168931483461609, 2.3554857136289851]], [[-4.9696385541588821, -4.574102390156467, -1.2095677827085161, 3.8491300709219249], [2.5564680110299616, 0.43077743890672426, -4.5387625536950811, 2.2743223642538091], [-1.6164781825668104, 3.3480064965109548, 1.653293549684566, 2.0748200683022775]]], [[[-0.98399417687226709, -4.0101331676221132, 4.4819203418417217, -4.0548577032012876], [-3.2405498678544795, 4.820373299676934, -1.6053515195089463, 0.80872639125282753], [1.5368822663689707, 0.011146683247260647, 2.0629166669940338, -4.3846678537416475]], [[-3.1385805740903541, 4.7717309868072295, 1.2300699265549238, 1.4575347304390203], [-2.114098395366458, -2.5861140304807728, 0.60725302056936137, 2.4997476471370064], [1.1035222744715911, 1.2530220414547237, 2.1828718546525732, -0.1475151762140321]]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[-5.2220654410196818, -5.9898203670476526, -2.3969342793570494, -7.0039537359916286], [-5.6491390536429797, 1.5606454058549897, -0.98386657292311686, 1.1302891089117426], [4.4044057650280335, 1.4125896681928261, 4.6275283718271805, 4.3410466960274654]], [[0.26696868180192457, -0.47191751082567812, -3.1317467859198569, -3.7386570548782849], [6.0917951394021337, -1.8560902949519797, -5.8830981077463544, -3.0587014570197759], [-0.35301981059920973, 9.7026342357528925, -6.9489720425370045, -7.3065142796019451]]], [[[-2.6935232911559197, -1.6023708266928209, 5.5838813542672181, 1.5469221950378635], [0.41870532769072089, -6.1489950729737934, 1.0333214458540327, 2.8525055896568832], [0.087703291182820386, -3.1897891198307819, 2.5647818909007469, 4.2740345177073378]], [[-1.5416425883642098, -5.3696501273728607, -2.4433814248457311, 0.55762931893889167], [-0.76690993375875927, 3.6147359402842785, -2.8131923979161231, -0.36416226422697573], [-1.5176820913712117, 4.4900121043326893, 2.7319997164671652, 5.5678309642308736]]], [[[-2.7557954012463917, -1.0968214495399233, 4.8736751237526441, -7.1818691146421969], [-3.7542273494287546, 4.491696903322655, 0.31328475806225642, 1.5557131239605546], [4.8610251859161053, -2.7710610138620142, -1.5427732683036348, -3.3605317663021861]], [[-3.6696290232484667, 0.71772580571085065, -0.65954246390603011, 1.4473951486283738], [-6.4064937851770178, -3.4298245947870178, -2.6448777089173099, 0.17480342999231979], [2.4868487190307031, -1.7994002184689251, 3.3760703353877712, 3.6857690086627675]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[1.784020807444985, -6.9127334671925729, -3.2648840917197619, 2.3624630447174964], [-4.4739627968869993, 1.6601639783246975, 2.524692601391382, 0.082543496493536317], [-0.9331295491837146, -1.8278203207816386, 6.450008214545635, 1.1368388439943278]], [[-0.56297899502649384, 6.0097772803420941, 3.2582421152916075, -5.0672898411686695], [4.8964388673498167, -8.622219516712903, -2.0603729561412831, -3.968227284548659], [0.58834530228607562, 0.51049594598902281, -2.5414574907355334, 0.80320778133159321]]], [[[-1.7219963292466858, -1.0457116779766742, 5.6273629829112499, 8.0487660888876498], [-6.0453234009462067, -3.6373596615829307, -0.23324573867388843, -1.5934360139032275], [-1.2184602875286279, 3.5595404303383731, 3.3789949958542937, 2.6945842606642447]], [[-9.6593782593135558, -5.4387873105122662, 0.30998394596991163, 6.2329364637294837], [-2.169003380045881, -2.7869534448505862, -7.091520807149239, 7.029071722697581], [0.12358426726454041, 3.2531018745049449, -2.636959522156074, 5.0065534161640146]]], [[[-4.8863126118241489, -6.6865599053595348, 5.2246931244913251, -0.44380204355888075], [-3.4742917839573382, 0.91111755964871222, 2.6664099714643963, 1.4173854997550137], [3.2396137027689011, 2.089679986042098, -0.76743846224971701, -7.3222340347323494]], [[1.5725613113139234, 1.1454775394268264, 5.9161916746399719, 2.7337878062007377], [-5.7337383314371344, -1.2459312248850605, -4.0964994962291463, 2.9046991089660725], [-2.8206654531204274, 1.5938401171498171, -2.7542350945815777, -4.9551783850895426]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
2112     def test_mult_overloaded_float_rank0_taggedData_rank0(self):     def test_mult_overloaded_float_rank0_taggedData_rank0(self):
2113        arg0=-1.18466090014        arg0=-1.18466090014
2114        arg1=Data(-2.11347188762,self.functionspace)        arg1=Data(-2.11347188762,self.functionspace)
# Line 3480  class Test_util_overloaded_binary_with_t Line 3142  class Test_util_overloaded_binary_with_t
3142        self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")        self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
3143        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
3144     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    def test_mult_overloaded_Symbol_rank0_taggedData_rank0(self):  
       arg0=Symbol(shape=())  
       arg1=Data(2.48459201133,self.functionspace)  
       arg1.setTaggedValue(1,2.15861638544)  
       res=arg0*arg1  
       s0=numpy.array(1.14942224066)  
       sub=res.substitute({arg0:s0})  
       ref=Data(2.8558453168,self.functionspace)  
       ref.setTaggedValue(1,2.48116168248)  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank0_taggedData_rank1(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([-2.8792731270881342, -4.3433575296530202]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([4.0424298611143534, 4.0356003239449674]))  
       res=arg0*arg1  
       s0=numpy.array(3.06118418131)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([-8.8139853502994896, -13.295817363526861]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([12.374622344879226, 12.353715873730666]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank0_taggedData_rank2(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[-2.2268992540360575, 4.5621274179501317, -3.8244854334103904, -4.7428791182239403, 4.7955192310366357], [-4.6884092246319211, 4.8672474871456668, -1.3555693918974585, 1.449022892916096, -2.0130426749377506], [-3.8121452535992981, -0.090968931574265, -1.1337497939391716, -2.8088760608864884, 3.0978230733979668], [4.9755696722807929, 4.9219898764178112, -0.058138158034268805, 1.2698381101178482, -3.9409770384072673]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[-3.9483142165473728, -2.9477962947765048, 4.2768567079872657, -0.32493250394391104, -3.9730254840815391], [-4.248840701239585, 3.2390068596255475, -3.1150026644847637, -1.0815908078392091, -4.675971789311248], [-4.5983788851073015, -4.4082276715978814, -1.2151245736214356, -2.1259811913232349, 4.4833611299806648], [2.1265466795893007, 1.7342130659349539, 0.17956548777356218, 4.9852602093939691, -3.8660803834968682]]))  
       res=arg0*arg1  
       s0=numpy.array(4.6510569065)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[-10.357435155557832, 21.218714235577124, -17.78789938886127, -22.059400679496729, 22.304232839753009], [-21.806058104709404, 22.637845040719917, -6.304830382420862, 6.7394879337699374, -9.3627760363427903], [-17.730504510323474, -0.42310167747515492, -5.2731348093405428, -13.064242402480705, 14.408151400633946], [23.14165768801951, 22.892455008422282, -0.27040388145631067, 5.9060893121969489, -18.329708472830937]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[-18.363834105893673, -13.71036831576707, 19.89190392978298, -1.5112795666137508, -18.478767617426758], [-19.761599888106709, 15.064805224653156, -14.488054656408989, -5.0305403968044216, -21.748210885262072], [-21.387321872269133, -20.502917757397324, -5.6516135403964229, -9.8880595029870424, 20.85236774791759], [9.89068962109247, 8.0659236576544231, 0.83516930207776197, 23.186728927587417, -17.981359868736391]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank0_taggedData_rank3(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[[-3.1040647125357013, -0.79064169069550694], [0.13413222355194065, 4.3926743356052054]], [[-3.8810438362766018, 0.45585821823464734], [2.2905186393536248, -0.06193971785905994]], [[1.8257326749027172, -2.8778552105775423], [-3.7710881145559738, 0.97750172722843942]], [[-1.1413427821362774, -2.4397446910641021], [-1.8662828868757697, -4.9389817296918324]], [[4.0981390349739151, 2.0341172857889678], [0.15316635612617002, 2.4104946768985123]], [[1.6068177768547587, 3.4781628302132983], [3.2544489066129039, 0.038277143669370517]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[0.693985317225013, -0.032839697125282896], [-1.7155971133665071, 4.0969153094773318]], [[2.8121187545687274, -4.492722956902182], [0.86461903380325467, -2.3129683384354536]], [[-2.7103119909333753, -0.13738816596957726], [4.3558107347491752, 1.7784469990629495]], [[2.8133522280020209, 1.6353331402744793], [-0.53361203027460924, 1.5961912368458977]], [[-2.1087867198291024, -2.4515453338125228], [0.60463429306290895, 2.3090394156677139]], [[-0.087018562192714199, 2.5691305190947933], [-0.94930252920641944, -3.275250321983493]]]))  
       res=arg0*arg1  
       s0=numpy.array(2.90258117501)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[-9.0097998006114786, -2.2949016875889536], [0.38932966704377292, 12.75009383446665]], [[-11.265044778555712, 1.32316548272039], [6.6484162835918355, -0.17978505904298894]], [[5.2993372927688833, -8.3532083586198844], [-10.945889370605043, 2.8372781119906745]], [[-3.31284007365955, -7.0815570121073756], [-5.417037574684433, -14.335795392309949]], [[11.895181215479067, 5.904190541488596], [0.44457778193632985, 6.9966564716216295]], [[4.6639190307661726, 10.095649954588247], [9.4463021313586566, 0.11110251664777589]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[2.0143487175089949, -0.095319886668797066], [-4.9796598851549891, 11.891629252889306]], [[8.1624029588969833, -13.040493079228719], [2.5096269310705797, -6.713578357531337]], [[-7.8669005632805629, -0.39878030421211363], [12.643094240578945, 5.1620867802288615]], [[8.1659832156643333, 4.7466871878267538], [-1.548852233832662, 4.6330746357809875]], [[-6.1209246350819617, -7.1158093356019316], [1.755000116808423, 6.7021743402676366]], [[-0.25257844049679962, 7.4571098808620304], [-2.7554276506616477, -9.5066799280268413]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank0_taggedData_rank4(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[[[-0.86820933634907327, -0.91439640624619045, 4.6686699357589987, -1.6202669874282249], [-3.5470559432927171, -3.0556281592168677, -1.0536783384582895, 3.2137729387899761], [-4.0634948935396942, 2.7578110876571387, -4.9941765259706656, 2.8883750788154856]], [[3.3408742197531254, -3.7708323399320576, -1.9339173210048646, 0.64162626344759488], [3.4165207867983138, -4.2695496633763543, 1.1397487867450469, 2.4813259775631034], [2.4743541257850863, -3.7225980721353058, -2.0369537200852017, 0.019356702397579362]]], [[[0.66127564914594039, 2.703754630831452, -4.0466086801017571, -3.9052738922494257], [-2.827666079688107, -3.3882056059830976, -3.4433805034773002, 2.9958640066429076], [-3.1317220453975425, 4.253554623114649, 3.3238398924208497, 0.33881714746041158]], [[-0.25931812591363457, -4.7308005113371774, 0.95762210674224768, -4.9477981929811063], [-3.6745699606559432, 2.3321276708140211, -0.79426814529513745, -0.15371288739805067], [-4.4297721208824692, 3.2722314129957191, 0.23312549532347404, 2.4843531676093598]]], [[[3.5688457367055157, -2.7025296705967685, 3.4763140867976219, -3.0930503637157605], [2.6391121552832244, -0.20529895913271368, 3.2357132583095467, 1.7667588494910706], [0.59777624556899589, -3.236665783758097, 4.7724844676063558, 1.9374207156733947]], [[-2.9066482051704501, 2.8258519605208594, -3.9869085700177043, -0.72215370693846292], [4.5636991554049171, 3.1666864627156617, -3.5351474913512213, 4.8697183259209922], [1.2389178993324812, -4.7370882132960563, 3.5961590362828311, 1.0195924675602575]]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[[0.51340577290485712, -4.1503229549075193, -1.922541059681655, -0.41798208127312186], [-1.9153793856501933, -2.8674633763903437, -4.3972500699105757, 2.9195808748219951], [-0.16379154081267, -4.4664740704945984, -0.016156856083816784, -1.9150376553012514]], [[1.9238944505686364, -4.915076441750557, 1.4107668613168132, 4.9921445765040993], [3.6212402828650632, -4.4606332106393998, 2.5493991461921848, 3.073112465660973], [3.0481498950608259, -2.5359778009397838, 3.3808195886273982, -0.25496050146683746]]], [[[-1.3066622728721953, 0.64000424476260953, -0.84904956771026274, 1.2222666463709402], [-2.7506476465004228, 0.72838283836911089, -3.3622516761765397, 4.558089309779584], [3.6116756046465923, -1.410824979351454, 2.8086193392053307, -3.5942380738307378]], [[-1.7651934929555146, 0.18257753614846628, -0.77725277905074819, -1.0301880869365809], [-0.61643313464250138, 3.6253682781522141, 2.4446447836467744, 3.8682991228183834], [1.6899726374753286, 3.6655221059841168, 3.3824524993960292, 0.15861186865572208]]], [[[-0.63551998190902648, -3.1777407679082237, 4.1965766085668239, 0.91331931534408461], [4.0150377507168624, 4.3512799435422114, -2.5082544102088002, 2.8383992290214985], [-2.6779967504905464, 2.0646377530163109, -0.41927651664690124, -1.0327593064392859]], [[3.900771895462519, 2.2718725354533618, -1.0976378451781041, 0.17447966247350521], [0.21580697067351018, 1.6939619822874432, -2.2011190270038838, -0.23305351967107768], [-1.3821187188560105, 1.9879452728558835, -1.82513548840077, 4.8786717215606199]]]]))  
       res=arg0*arg1  
       s0=numpy.array(1.20290156145)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[-1.0443703663595512, -1.099928864857582, 5.6159503556180015, -1.9490216891428935], [-4.266759132736424, -3.6756198839317942, -1.2674713185972541, 3.8658524862154127], [-4.8879843523819817, 3.3173752635262042, -6.0075027412457995, 3.4744308923596909]], [[4.0187428155482481, -4.5359401096694851, -2.3263121651514682, 0.77181323416828029], [4.1097381891652187, -5.1358479567626691, 1.3710055952360745, 2.9847908928764832], [2.9764044414865105, -4.4779190336213865, -2.4502548104913653, 0.023284207538566325]]], [[[0.79544951090634841, 3.2523506672041447, -4.8676718998705137, -4.6976600628757756], [-3.4014039425153157, -4.0756778139498628, -4.1420477842984695, 3.6037294914818565], [-3.7671533384353073, 5.1166074978564122, 3.9982521966020079, 0.40756367572607916]], [[-0.31193417857373379, -5.6906873219947647, 1.1519251274790485, -5.9517141720752225], [-4.4201459433293788, 2.8053200167223533, -0.95542639218531744, -0.18490147226606468], [-5.3285798010760912, 3.9361722761174707, 0.2804270223383532, 2.9884323045099301]]], [[[4.2929701092563466, -3.2508771606251301, 4.18166364309862, -3.7206351121564043], [3.1745921324312047, -0.2469544385047496, 3.8922445308242106, 2.1252369787579721], [0.71906597919251414, -3.8933903251735922, 5.7408290180783625, 2.330526404068618]], [[-3.4964116645846466, 3.3992217357363779, -4.7958585442316846, -0.86867982168300195], [5.4896808400234782, 3.8092120906224536, -4.2524344373015488, 5.8577917780708217], [1.4902962756150853, -5.6982508084990302, 4.3258253199662438, 1.2264693712706369]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[0.6175766058845682, -4.9924299629789939, -2.3126276426423189, -0.50279129822145441], [-2.3040128537672797, -3.4492761728599155, -5.2894589751804517, 3.5119683931022037], [-0.19702510019582112, -5.3727286335727715, -0.019435107411342096, -2.3036017857969426]], [[2.3142556386535209, -5.9123531264266243, 1.6970136603195569, 6.0050585060596795], [4.3559955906431176, -5.3657026541327433, 3.0666762137132375, 3.6966517834542745], [3.666624268301558, -3.0505316565523679, 4.0667931621397972, -0.30669238532246995]]], [[[-1.5717860883254424, 0.76986210535941069, -1.02132305074691, 1.4702664574275528], [-3.3087583489734373, 0.87617285360740405, -4.0444577912597977, 5.4829327479612733], [4.3444902242793546, -1.6970835705941747, 3.3784925886480561, -4.3235145912331348]], [[-2.1233540089371261, 0.21962280331863818, -0.93495858156130218, -1.2392148583629436], [-0.74150838019082865, 4.360961162619688, 2.9406670274386904, 4.6531830549929296], [2.0328707244264241, 4.4092622648168689, 4.068757393053092, 0.19079446447043069]]], [[[-0.76446797857088455, -3.8225093315993286, 5.0480685551885269, 1.0986332305296156], [4.829695179617004, 5.2341614383919044, -3.0171831465533865, 3.4143148646077259], [-3.2213664727224338, 2.4835559769314228, -0.50434837655376941, -1.2423077823175774]], [[4.6922446039111634, 2.7328390203116504, -1.3203502778710801, 0.2098818584306047], [0.25959454199490573, 2.0376695135300786, -2.6477295145197255, -0.28034044271369929], [-1.6625527650208225, 2.3913024727949908, -2.1954583288546377, 5.8685618316660078]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank1_taggedData_rank0(self):  
       arg0=Symbol(shape=(2,))  
       arg1=Data(1.11950441575,self.functionspace)  
       arg1.setTaggedValue(1,4.86996782818)  
       res=arg0*arg1  
       s0=numpy.array([-0.78549237662494953, 4.1344197615547902])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([-0.87936218417043222, 4.6285011796290663]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([-3.8253226034479404, 20.134491226983396]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank1_taggedData_rank1(self):  
       arg0=Symbol(shape=(2,))  
       arg1=Data(numpy.array([4.0941505256154311, 3.5760457588100252]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([-3.2461810978309282, 1.9696556786948394]))  
       res=arg0*arg1  
       s0=numpy.array([-2.5388743405062506, 3.5718907373660755])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([-10.394533715655196, 12.773244722290768]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([8.2416458939193546, 7.0353948745305876]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank2_taggedData_rank0(self):  
       arg0=Symbol(shape=(4, 5))  
       arg1=Data(-2.19395150438,self.functionspace)  
       arg1.setTaggedValue(1,4.48869130432)  
       res=arg0*arg1  
       s0=numpy.array([[-2.9785357676377866, -4.0376675756158233, -2.3620258842254085, 4.9778815696494867, -2.8830671733896396], [-0.12586433616834292, -2.9451699074334678, -4.8656112934831413, -3.5971368997440734, 4.4557439154858081], [-3.8192765742703649, 2.3156257015121984, 3.0704583266570875, -0.66262953755641174, 0.12369800124931984], [-3.9568596357564791, 2.0249085765657586, 1.4270518555596876, -3.4014562325626398, -3.6639354255880008]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[6.5347630282571902, 8.8584468517068267, 5.1821702420797484, -10.921230758355678, 6.3253095622854678], [0.27614024968426809, 6.4615599490670075, 10.674915217063418, 7.8919439126526649, -9.7756860665100707], [8.3793075857620032, -5.0803704914126158, -6.7364366649040024, 1.4537770707682085, -0.27138741592968751], [8.6811581504866062, -4.4425512177874795, -3.130882565332791, 7.4626300185119669, 8.0384966389182857]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[-13.369727599798457, -18.123843336396991, -10.602405047098676, 22.344173715614808, -12.941198550961253], [-0.56496615128270766, -13.219958553238213, -21.840227103253458, -16.146437122325754, 20.000458967712852], [-17.143553547716142, 10.394128950435084, 13.782339591139131, -2.9743394432142982, 0.55524214256944648], [-17.761121439430433, 9.0891895196714181, 6.4055952548628747, -15.26808701312514, -16.446275084422709]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank2_taggedData_rank2(self):  
       arg0=Symbol(shape=(4, 5))  
       arg1=Data(numpy.array([[0.071378135410174792, 0.47503895487103875, 3.5224887056384517, -1.4717171104201543, 2.6823593143634064], [-2.8213936138828446, -4.0437250476197271, 0.17344689589833795, -3.6102976488661795, -2.6201477884993416], [-2.3691138759209442, -4.5636764022223586, 4.0255246203339379, -1.3543374166280242, 0.26952220692118889], [1.9154867284228319, -2.7565367249589579, -0.57452243204763853, 3.6343768278798088, -2.3311344155810811]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[-0.84287577391445545, 4.5978172078266297, 1.7656763069782935, 0.062592057723618311, 2.2464030092564693], [-0.92376816474644929, -1.2698831348851334, -2.954895695245142, 4.7332978825573981, -0.18168870835468898], [4.8229851370166532, 3.4544210122744747, -0.49008964482088491, 1.2573681251545015, -2.4269758339602152], [-4.6614073547516233, 4.5993838470932715, -3.1169880702373707, 0.28195844198234088, 0.50190494358623905]]))  
       res=arg0*arg1  
       s0=numpy.array([[4.6484275857975721, -1.828437518730619, -4.960672907915761, 1.4978783338940138, 2.3964153105898234], [-4.083375470940763, -2.3230536368185648, -3.182928422828768, 1.6376405644630134, 0.82899239758675858], [-1.4891265209799731, -1.4705475958483429, -4.7470746384613705, -2.0686280096924046, -3.8926105380624278], [-2.7272992712580955, 4.2269585179883116, -2.3328752489696045, 1.3704011447473832, 0.73060132102738606]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[0.33179609366345097, -0.86857904794478857, -17.473914290499923, -2.204453173319453, 6.4280469294436884], [11.520809476798123, 9.3937901781673308, -0.55206905480624235, -5.9123698795687005, -2.1720825972197124], [3.5279103038555353, 6.711103361517905, -19.109465831689075, 2.8016203146111827, -1.0491449829032622], [-5.224105558532143, -11.65176638971287, 1.3402891617017574, 4.9805541653698535, -1.7031298835159414]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[-3.9180469988644324, -8.4068214870554652, -8.7589426201759721, 0.093755287138051341, 5.3833145651372556], [3.7720922647616169, 2.9500066348294691, 9.4052214948901351, 7.7514406161628839, -0.15061855795339496], [-7.1820350778237279, -5.0798905146482278, 2.3264921235017635, -2.6010269221890265, 9.4472717068963821], [12.713052881651228, 19.441404729968752, 7.2715443203902934, 0.38639617166378859, 0.36669241481428194]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank3_taggedData_rank0(self):  
       arg0=Symbol(shape=(6, 2, 2))  
       arg1=Data(3.25668687177,self.functionspace)  
       arg1.setTaggedValue(1,-1.35363619165)  
       res=arg0*arg1  
       s0=numpy.array([[[-4.7512596313635038, -3.1391446742879481], [-4.0612263957147459, -0.56101638814262778]], [[3.3110629862751946, 4.9492489740428915], [2.0385990934837448, -2.2086783862843196]], [[-1.7821786257521888, 0.9094320240194973], [-0.37941667748917052, -4.5537034535247969]], [[2.3628042947092993, 2.6391968183927972], [4.9950287175637289, 1.1993758508510801]], [[1.1387719709522726, -4.0571549586109086], [-4.3105069255152575, -0.20897398099304709]], [[2.9452799495845925, 0.97521515771252787], [-1.9785275703589313, 2.6060594402158452]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[-15.473364865814048, -10.223211249328218], [-13.226142686194413, -1.8270547061097642]], [[10.783095358993283, 16.118154158867622], [6.6390789045429059, -7.192973904565811]], [[-5.8039977336294095, 2.9617353333880239], [-1.2356413125081167, -14.82998625501043]], [[7.6949137271324757, 8.595037630466841], [16.267244448584755, 3.9059915877800804]], [[3.7086237277355409, -13.212883290429124], [-14.037971314982652, -0.68056282044076755]], [[9.5918545454882391, 3.1759704012697547], [-6.4434447638153287, 8.4871195659932113]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[6.4314769929423425, 4.2492598419435437], [5.4974230317263855, 0.759412087098987]], [[-4.4819746910569673, -6.699482532754284], [-2.7595215132057942, 2.9897469993909995]], [[2.4124214878043735, -1.2310401015588905], [0.51359214636518191, 6.1640578007356979]], [[-3.1983774071060851, -3.572512330265726], [-6.7614516504285733, -1.6235185591038086]], [[-1.5414829539183337, 5.4919117871106025], [5.8348581787382052, 0.28287474378550265]], [[-3.9868375343006925, -1.3200865321259698], [2.6782065254164684, -3.5276563758689896]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank3_taggedData_rank3(self):  
       arg0=Symbol(shape=(6, 2, 2))  
       arg1=Data(numpy.array([[[-1.3666443561953781, 0.46700412295519111], [-1.1309748954134413, 4.3407042566363288]], [[2.7537990112300781, -4.0506734006100409], [-4.7297800587666323, -2.5174649342891464]], [[3.4309374405985853, 1.5456719695686942], [-0.31707479995187526, 3.6389169165759867]], [[-4.117510339580762, -3.0339052454231097], [4.1459251280540599, 4.2360451618316102]], [[-1.2776261831510629, 2.7606768506642716], [1.3821647743730345, 0.16382807948611955]], [[2.2995017838082354, -4.5278231758874545], [4.6299152941043147, -2.9900462504808223]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[-4.0603441537546336, 1.594780159223955], [-0.31675011969352163, 1.5304315157941399]], [[-1.690635297894759, 1.1791156789191923], [2.1084632049727805, 4.2104724381386696]], [[4.5222244639592528, -2.0390691812790562], [-3.7000789675504366, -3.1680189160946135]], [[1.9246858864679695, 1.5966662294649057], [-0.11613374955625133, -1.4852417006879626]], [[-3.4351305253007092, -0.29924001154384428], [-1.4544490399854526, 4.5825266938804017]], [[2.5898486256381101, 3.2410707821218434], [1.1975142279446427, 3.7376857084583577]]]))  
       res=arg0*arg1  
       s0=numpy.array([[[-4.2736343155717735, 0.33567459600238614], [0.99513533766470186, 3.4628614089503866]], [[-3.8521378833463582, 1.9387762769853945], [3.1573179275638434, -3.234658027544135]], [[0.90770555350445825, -2.7238734003471365], [-3.2235114676670706, -1.0034764077922889]], [[2.3578719614264321, 2.5116319933919762], [2.96168472332368, -0.34109836483199274]], [[4.7504488804878449, 4.9381819694923745], [-4.5598415872271616, -2.7076296190210645]], [[-3.7607556692134758, -0.15633205595158195], [-0.20517808870437371, -3.4245112277430758]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[5.8405382178190619, 0.15676142030443244], [-1.1254730844375558, 15.031257257972618]], [[-10.608013494281128, -7.8533494949185023], [-14.933419372977857, 8.1431381587592551]], [[3.1142809685577082, -4.2102147635703346], [1.0220942537531124, -3.6515672757002631]], [[-9.7085621805809055, -7.6200534793244179], [12.278923115801481, -1.4449080780552364]], [[-6.0692978714319255, 13.632724647545299], [-6.3024524185866095, -0.44358576044395454]], [[-8.6478643698233224, 0.707843906071707], [-0.94995717090747156, 10.239446956242661]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[17.352426108517037, 0.53532718566012216], [-0.31520923731654737, 5.2996722350849712]], [[6.5125602779429563, 2.2860415061100574], [6.6570886766692787, -13.619438471778574]], [[4.1048482601295353, 5.5541663043536342], [11.927246983172568, 3.1790322417406434]], [[4.5381628862560026, 4.0102379846925915], [-0.34395155192304777, 0.50661351548495204]], [[-16.318411958244376, -1.4777016295565018], [6.6320572190282876, -12.40778500630525]], [[-9.7397879012732513, -0.50668325885370946], [-0.24570368048597549, -12.799746674390478]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank4_taggedData_rank0(self):  
       arg0=Symbol(shape=(3, 2, 3, 4))  
       arg1=Data(-1.92545898045,self.functionspace)  
       arg1.setTaggedValue(1,4.28094573513)  
       res=arg0*arg1  
       s0=numpy.array([[[[3.6341496483359208, 3.5087953596232193, 4.2501361977382661, 2.778112744824508], [1.5652548234804753, 2.8829843776262232, -1.0938509179897826, 3.125484361110205], [2.1514975591402896, 4.5742617376559398, -1.0667706926589036, -1.3420824805146614]], [[3.3670012619886851, 1.0051614998473655, -3.7072849407349686, 1.8523084381848278], [3.3172062996357443, -3.9867012176263552, 1.9836900304140066, -3.0601158799647274], [1.0694001027830673, -2.9936261100590587, 4.7176493596386422, 1.581703183165394]]], [[[-3.7672448938977388, -4.0387682711096717, 1.6413735813476782, -2.8766599540435642], [-3.1157202897797887, 0.96686967117997469, -1.1661786302937962, 3.0808024972914101], [-0.063290444417425817, -1.7037588260342917, 0.74282195316460609, -2.0559435427665029]], [[-2.303679104031422, -4.9388341201123804, 3.5443943155788045, 2.5499797392137857], [2.8006309952871238, 0.57307371147447661, -0.74526877496298383, 4.5830727664075237], [3.0490933399186542, 3.3411098466449989, 4.7711277761278374, 3.3011041708777675]]], [[[-3.7596911999563343, -1.491168451433873, -0.13831702882017538, 2.3603081976410465], [0.44749091564615373, -1.4923314846784774, -4.2973144667166814, 3.5151258687109994], [-4.3488669575883598, 1.8879211141207808, -4.5946461355007671, 0.0090806365541231671]], [[0.67738466750484783, 2.9562438220454599, 4.5351253197716623, -4.3795133507921777], [2.3714390469597344, 4.8238127878942478, -0.41027130624885633, 2.3105195178799942], [3.1538262435912507, -3.9296938650840616, 4.7576340542111346, -0.13162598675097481]]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[-6.9974060767039639, -6.7560415357636066, -8.1834629100898901, -5.3491421332374509], [-3.0138339565702053, -5.5510681604104404, 2.1061650733218262, -6.0179919313697416], [-4.1426202966726082, -8.8075533417190375, 2.0540232102657541, 2.5841247646176071]], [[-6.4830228170977504, -1.9353972366882251, 7.1382250822418767, -3.5665439168746267], [-6.3871446596538872, 7.6762296618675583, -3.8195137834987105, 5.892127602309511], [-2.0590860316026229, 5.7641042777362879, -9.083640326151647, -3.0455045984392779]]], [[[7.2536755125267636, 7.7764826375828147, -3.1603975024866529, 5.5388907422270117], [5.9991916125407929, -1.8616678913025724, 2.2454291165133187, -5.9319588354163981], [0.12186315458048895, 3.2805177321163441, -1.4302732005995433, 3.9586349577272046]], [[4.4356396189426794, 9.5095225095454854, -6.8245858652030922, -4.9098813888462089], [-5.3925001008148188, -1.1034299242209225, 1.4349844556048015, -8.8245186161558173], [-5.8709041535903799, -6.4331699589075724, -9.1866108234412547, -6.3561406712324056]]], [[[7.239131184691681, 2.8711836861837816, 0.26632376529159069, -4.5446766157883296], [-0.86162540220269412, 2.8734230589891725, 8.2743027317766771, -6.7682306713375215], [8.3735649382903485, -3.6351146635735234, 8.8468026636105179, -0.017484393201379862]], [[-1.3042763912693951, -5.6921262155705676, -8.7321977744409356, 8.4325733113031802], [-4.566108609569083, -9.2880536524822404, 0.78996057103965911, -4.4488105552174382], [-6.0725630635158572, 7.5664643429630631, -9.1606292153969839, 0.25344043825084955]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[15.557597437850434, 15.020962530206141, 18.194602429408896, 11.892949906653461], [6.7007709609629007, 12.341899675831582, -4.6827164222311533, 13.380028945895267], [9.2104442999339167, 19.582166277164617, -4.566787447094697, -5.7453822711454992]], [[14.413949692671654, 4.3030418358836364, -15.870685655933272, 7.9296319085837732], [14.200780160956112, -17.066851574816017, 8.4920693755112353, -13.100190025323922], [4.5780438091516311, -12.815550928416792, 20.196000905961213, 6.7711854962058586]]], [[[-16.12737096170374, -17.289747805365959, 7.0266312328175315, -12.314825161668272], [-13.338229486375862, 4.139116595259825, -4.9923474337503837, 13.188748311542751], [-0.2709429581029581, -7.2936990799934325, 3.1799804723573972, -8.8013827410644705]], [[-9.8619252355003759, -21.142880862985955, 15.173359728879113, 10.916324889242945], [11.989349314933879, 2.4532974610490346, -3.1904551836997737, 19.619885813120778], [13.053003129523438, 14.303109948579745, 20.424939104951882, 14.131847821523214]]], [[[-16.095034007840844, -6.3836112225190993, -0.59212769462292025, 10.104351312272504], [1.915684326842676, -6.3885901047273972, -18.396570038782635, 15.048063096086643], [-18.617263454714827, 8.0820878417481872, -19.669430778181525, 0.038873712328595635]], [[2.8998470033940853, 12.655519381975756, 19.414625395934841, -18.748459000997681], [10.152001874191662, 20.65048078137832, -1.7563491987302895, 9.891208675991912], [13.50135900682792, -16.822806192079309, 20.367173213661609, -0.56348370661323277]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_mult_overloaded_Symbol_rank4_taggedData_rank4(self):  
       arg0=Symbol(shape=(3, 2, 3, 4))  
       arg1=Data(numpy.array([[[[4.662007327598662, 2.0408721475955129, -0.7277914219359749, 3.4434729258441124], [3.4368593669617216, 3.012482600051591, -0.81228423230275038, -4.7828119986136191], [-2.840065918111041, 1.4852158235423163, 1.2805055258413587, 2.6095860909389135]], [[-0.81843890265295371, 3.9226571086690925, 0.25089822327114142, 3.8173045881590202], [0.14805231463801949, 0.36365881012681633, 1.6953694457356736, -4.6229951601189443], [-1.4986935661893321, -4.6683681039951725, 0.14909155151648079, -0.60116414204397373]]], [[[2.4743450183698741, -2.2058876993067611, 1.8507376577821066, 2.4436321569396799], [0.47184583564959226, 3.0426886236429098, -4.2764006431592438, 0.47432667125176309], [-1.5125315759782398, -2.6203394896962595, 0.71279514556321111, -0.93444113076080093]], [[-1.2837018639906628, 2.1685283844573622, 2.8624386451870079, 3.1201440759171213], [1.4566823403867293, -3.8055479342020337, 2.0504130227223918, 4.3599211797457755], [3.9092638631910948, -4.9227607549135, -3.0425719333531545, 1.9213194861863894]]], [[[0.59925535101758776, 3.1963298570837662, -1.9202113719321314, 2.7079708053963527], [3.6342895085970337, -3.9590088166626991, -1.8029171211863524, 0.077792826242236934], [-3.605121211776936, 4.377814589866162, 3.9171760382696412, -1.6203224354578993]], [[3.075304213019983, 0.55575334124868192, 3.8302240501221938, -4.8675111369795516], [0.57010712599474456, 2.3869354997246814, 0.88352210475845538, -3.0311383677814341], [-2.6274605983941979, 2.4608091153358629, 3.9796737037408256, -3.8835238099456149]]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[[-0.86524339638395453, 4.0688659986518179, 2.1926053792944984, 2.2341918232856584], [1.4267805540345808, 0.68963720585160893, -0.89728064662479312, 3.3814252301388876], [-4.3797892271469072, 3.9733880984869998, -3.3665253810336262, 3.3711009103110339]], [[-4.293904894668076, 0.24363556373489725, -0.60683282942370909, 1.0897152039814726], [3.0324012183998601, -4.9623509726221045, 0.23440114548259494, 2.7790189505814027], [-0.79632537277101356, -2.6950532468287616, -1.284749564838179, -3.2310711213962238]]], [[[4.1921363228914661, 2.7800363865475184, 4.3624955133912771, 3.2239871146638812], [-0.2366751400854108, -0.89845019568176809, -2.7142013563281431, 2.6103226891475328], [3.5685663198053774, -0.36447912427738061, 2.5921810800779008, -3.0648213738789023]], [[-3.947875358126447, -3.7517098026853715, 2.6025732922236209, 2.6338820426581222], [-2.9904775329419464, -1.5736601135170392, -1.1398531224416608, 3.2690897275279891], [4.9655350286674196, -4.8560474154484732, 2.242524809128569, -3.6462237490055651]]], [[[-2.1227322457160822, -1.7922800557983889, 4.7895197639141767, 2.0705360082733346], [-1.2707179388733101, -1.5863829747910763, -0.82042456592778112, -1.3714916625410947], [1.7955528087123573, 1.951084351755533, 2.3198070357537368, 0.38937163423242005]], [[-4.6996264211751289, -0.052202987603847895, -4.5119120086797802, -3.8710953444951537], [1.0726580660525888, -1.271873057616987, 4.1109303077749821, 0.59333764757331675], [-2.3269046475665753, 0.79372289487354308, 0.74309938932639241, 0.089177460497557703]]]]))  
       res=arg0*arg1  
       s0=numpy.array([[[[-4.8719764609141922, -4.2205759487485057, 3.1543858261813078, 1.4338547113855338], [0.27853001623000306, -0.81173402344260914, 0.54118496418608686, 2.7102497742271483], [-3.2694280288419622, -0.51499877583335696, 3.4885301266803843, 1.2050030262216449]], [[-0.84912998897794978, -2.9967131768339961, -4.6300646909745256, 2.1622600769702993], [0.89622152200583471, -1.0742657491745486, -3.544066855869048, 2.4732482990029778], [2.4162246601609825, 0.63245005777125129, -0.84763155938477297, -2.3061488418306419]]], [[[4.6162670129077412, 4.5452939701527377, 0.048377962091747051, 1.9984685497646746], [1.8480696201800129, 3.3546283490821818, -4.7931584759583821, -2.4666703939538315], [-4.1425576139862255, 2.1427822682795847, 0.039834098151581898, -0.019144957205581292]], [[-3.9187790571569856, -0.98831742509689846, -4.4802165452908396, 0.34454952550188089], [0.77915505718021993, 3.4290627648945673, -0.72914570375442889, -1.2581389708824045], [4.6740018757206805, -3.6902979930701885, 3.25664768554552, -2.4091450173193985]]], [[[0.29123591725076103, 1.5247782307109015, 2.3232254274106161, 3.1444489036288701], [1.9933825041106825, 0.78752854522155058, -3.4449855569231991, -4.1274651959722384], [4.616172047772519, 3.3154459262488487, -1.8476245878501976, 2.3309873981674052]], [[-2.9066859863423087, 1.3374189675051102, 4.4809017322316826, -2.2168956279364513], [2.4125627534847096, 4.3351549332052883, -0.80939050608006546, -0.50992890550083025], [2.8697580416671649, 0.46944395904650715, -2.0334936833978166, 1.1364803606111824]]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[-22.71318996067016, -8.6136559006123328, -2.2957349457711791, 4.9374398782501094], [0.95726849526008639, -2.4453346214907303, -0.43959601316768704, -12.962615139413456], [9.2853911164310183, -0.76488433097262398, 4.4670821042782869, 3.1445591367673034]], [[0.6949610163888279, -11.755078245750214, -1.161675004595955, 8.2540053126117989], [0.13268767076137256, -0.39066620410480929, -6.0085026610848793, -11.433814916063177], [-3.6211803526512698, -2.9525096770692136, -0.12637470430300982, 1.3863739899248215]]], [[[11.422237286853449, -10.026408058493116, 0.089534916249951482, 4.8835220128375658], [0.87200395427246269, 10.20708951430235, 20.497465989352605, -1.170007557039396], [6.2657491964632426, -5.6148169953939204, 0.028393551790336057, 0.017889835459550526]], [[5.0305439802399947, -2.1431943891764371, -12.824344978046728, 1.0750441608547487], [1.1349814122174386, -13.049462721193635, -1.4950498464401643, -5.4853867462137487], [18.271906629242249, 18.166454134221976, -9.9085848448603091, -4.628737266824607]]], [[[0.17452468182103395, 4.8736941842526136, -4.4610838852757517, 8.5150758300875502], [7.2445291213103369, -3.1178324539056681, 6.2110234428165372, -0.32108718281114873], [-16.641859766636482, 14.514407547844542, -7.237470763244616, -3.776951178020282]], [[-8.9389436597246466, 0.74327505984032738, 17.162857581027989, 10.790764158501954], [1.3754192176711353, 10.347735206874283, -0.71511440350337085, 1.5456650703043597], [-7.5401761814053705, 1.1552119735610002, -8.0926413385413625, -4.4135485399691055]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[4.2154454601440747, -17.172957972590432, 6.9163233308554561, 3.2035064719571773], [0.39740121087190455, -0.55980198382164537, -0.48559479460850752, 9.1645069665499026], [14.319405659654175, -2.0462900066316347, -11.744225213969965, 4.0621867986233378]], [[3.646083415881868, -0.73010590418974552, 2.8096752568388825, 2.3562476808366846], [2.7177032352866703, 5.3308836852709351, -0.83073333068260358, 6.8732038924224943], [-1.92410100320121, -1.7044865816534487, 1.0889942770626941, 7.4513309244803345]]], [[[19.35202062097623, 12.636082624579641, 0.2110486425722598, 6.4430368535023241], [-0.43739213624369644, -3.0139664966724928, 13.009597236541977, -6.4388056959861695], [-14.78299157912457, -0.78099940465964224, 0.10325719557049667, 0.058675874045662449]], [[15.470851273692055, 3.7078801719007992, -11.660091924152317, 0.90750280802578076], [-2.3300456931755451, -5.3961792998610365, 0.83111900713940801, -4.112969185514304], [23.208920037948261, 17.920262031483176, 7.3031132294269634, 8.7842817769484149]]], [[[-0.61821587265889111, -2.732829612418703, 11.127134100611107, 6.5106946811391841], [-2.5330269070096438, -1.249321876301452, 2.8263507801661909, 5.6607841037044704], [8.2885806858774203, 6.4687146657957575, -4.2861325183264869, 0.90762037259961936]], [[13.660338259473804, -0.06981726578182032, -20.217434335370157, 8.5818143445364576], [2.5878548973834175, -5.5137667601391751, -3.3273479622698723, -0.30256001721949877], [-6.6776533245468794, 0.37260841815529067, -1.5110879143319937, 0.10134843246465386]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
3145     def test_quotient_overloaded_float_rank0_taggedData_rank0(self):     def test_quotient_overloaded_float_rank0_taggedData_rank0(self):
3146        arg0=0.530720959001        arg0=0.530720959001
3147        arg1=Data(-2.72292512329,self.functionspace)        arg1=Data(-2.72292512329,self.functionspace)
# Line 4682  class Test_util_overloaded_binary_with_t Line 4175  class Test_util_overloaded_binary_with_t
4175        self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")        self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
4176        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
4177     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    def test_quotient_overloaded_Symbol_rank0_taggedData_rank0(self):  
       arg0=Symbol(shape=())  
       arg1=Data(-4.13228805597,self.functionspace)  
       arg1.setTaggedValue(1,0.788196083249)  
       res=arg0/arg1  
       s0=numpy.array(-2.48956741229)  
       sub=res.substitute({arg0:s0})  
       ref=Data(0.602467054225,self.functionspace)  
       ref.setTaggedValue(1,-3.15856354174)  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank0_taggedData_rank1(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([-0.73993239781602504, 2.9226819782461275]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([2.946738055547141, -1.0606803414835655]))  
       res=arg0/arg1  
       s0=numpy.array(-0.821375712205)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([1.1100685881967345, -0.28103492556434717]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([-0.27874066059534736, 0.77438572214490886]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank0_taggedData_rank2(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[4.3991568817879418, -3.1284437769597973, 4.8063957163574162, 1.8665558141248662, 1.0675644361261041], [-4.5712231796031872, 4.1118538209663154, -0.5421837355930883, 4.3419399585099558, 1.8641118628482776], [-1.3148118230480277, -3.3468499848753464, -1.4703636162333988, 4.6482930967870502, -0.4858946887955593], [-1.0099504767616798, -1.0358831526209853, 4.2406730053811472, 4.7091947730811334, -2.7205563383611562]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[-0.89506604540170365, 0.41257981975861835, 4.2993583198506684, -3.8050176842398455, -4.974985875539617], [-1.0171101570009577, -3.4463599287190769, -0.48134708576769469, -4.6498437112938102, -1.7461996930845691], [3.0554622474037298, -0.26300441302319211, -2.2169461894043696, 4.6214432931241323, 0.80748496371225631], [-4.3197084797608927, 1.7474806406033325, -2.5298242828114956, 2.6522239379646173, 4.347262556378876]]))  
       res=arg0/arg1  
       s0=numpy.array(-2.93082635744)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[-0.66622455988592622, 0.93683203739287735, -0.60977633353490845, -1.5701787941511043, -2.745339071122932], [0.64114707208251653, -0.71277493924858193, 5.4055962306436935, -0.67500388891699481, -1.5722373833081813], [2.2290842735533092, 0.87569696003194897, 1.9932663764805025, -0.63051668567632568, 6.0318139403895881], [2.9019505657700764, 2.8293020791222987, -0.69112293112892242, -0.62236252664502412, 1.0772893456063564]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[3.2744246890998605, -7.1036590184003865, -0.6816892520696235, 0.77025301868572693, 0.58911249815767974], [2.8815230457240979, 0.85041215022704486, 6.0888004604078478, 0.63030642305670492, 1.6784027445687875], [-0.95920882672619512, 11.14363946881709, 1.3220105979323498, -0.63417988094733346, -3.6295739105337721], [0.67847781191024814, -1.6771724328954067, 1.1585098527796442, -1.1050448325594648, -0.67417744371980037]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank0_taggedData_rank3(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[[-1.4177404265411617, -3.3147863083812954], [-0.72466650518948317, 2.4486553800256505]], [[1.142106090217232, 2.5905121607640798], [-1.2147841256263883, -0.93506235721053699]], [[1.267658460947148, 3.7689296764547482], [-4.3972907141664388, -4.0572823668942153]], [[-0.99456892443753642, 4.174811980892148], [0.71050812934455365, -2.871115772754175]], [[2.535196165680901, 4.0412048287340667], [-0.82947677430700306, 3.2791557666430009]], [[2.7053730346792229, 1.4591666264871659], [3.1298478664969114, -2.0001315435282407]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[-3.3980438728911908, 2.9346934917885683], [-2.2725736847902067, 2.8476308473055765]], [[-3.6952972887917057, -4.2161892868167419], [-2.1020037683362003, 1.7699462571976952]], [[4.7187716805095583, 3.0680602149069429], [0.1202616138348418, -1.211404080127271]], [[2.3718470733770269, -0.67572826457071677], [0.82348659934982038, -4.2311228028666195]], [[4.0038556197052326, 4.0120329843355034], [4.4538793810882424, -4.7828187422014681]], [[-4.7204727349407927, 0.75557967524823155], [4.2798387660411379, -3.2013412578986489]]]))  
       res=arg0/arg1  
       s0=numpy.array(-1.33245724721)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[0.93984570254597311, 0.40197379959044255], [1.8387178621730276, -0.544158748544047]], [[-1.1666667909606965, -0.51436054514308605], [1.0968675167065924, 1.4249929290121044]], [[-1.0511169122121762, -0.35353730676762973], [0.30301777476702257, 0.32841126811451882]], [[1.3397334407607366, -0.31916580993562793], [-1.8753582009534533, 0.46409039295974458]], [[-0.52558348945456668, -0.32971782022437268], [1.6063828288906872, -0.40634155314143372]], [[-0.49252255793567323, -0.91316318713935807], [-0.42572588318861682, 0.66618480745518638]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[0.39212479210184481, -0.45403625657626373], [0.58632081156629778, -0.467917830174924]], [[0.36058188099017463, 0.31603354512017701], [0.63389860060293135, -0.75282356274480722]], [[-0.28237374838752949, -0.43429957493543536], [-11.079655467124379, 1.0999279836257583]], [[-0.56178042090768443, 1.9718832511126378], [-1.6180679178780086, 0.31491812204260661]], [[-0.33279353047912913, -0.33211522747016875], [-0.29916778906680641, 0.278592461690717]], [[0.28227199308823425, -1.7634900604924979], [-0.31133351512747104, 0.41621843467104369]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank0_taggedData_rank4(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[[[0.56623784519155862, -0.11423889515937802, 1.2371149160020254, -4.0561094275701981], [-4.8813428690845582, -3.0343297243145253, 3.2525365424781594, 0.064007319979378252], [2.6930044815322987, 1.6445689681050792, 1.6332026256278471, -4.7670792736051659]], [[-3.6386382332588427, 4.1651752162494482, 0.83928675814116893, 3.8320607256680272], [-1.3938402803404468, 2.0107268720524889, 4.796598769578015, -2.9996077723625203], [-0.99266738468548255, 1.0836148840543984, 3.3447422595987373, 3.093711220756731]]], [[[3.500289415701431, -4.8448055476191998, 4.0610314335167814, 2.3642075345496103], [3.3147446456402125, 1.5818027085790654, 1.2823723994146876, -3.9744256064881132], [2.0339673434123204, 2.1587167913663858, 0.40481958965395837, 4.4005292256574986]], [[0.29876582231064575, 1.880885444019496, 3.7993768029054369, 4.8763708505592529], [4.3972398939016539, -1.3226271310817106, -4.9373517106508293, -3.6013459566886352], [1.0333556564653072, -0.64759510629420447, 0.83185983115091311, 4.3661019610207141]]], [[[2.2207327405828554, -3.121312139724528, 3.8615399039685414, 0.1864132930418485], [-3.4615321691014609, 1.1898630118504165, -3.9345987177126931, 0.8867162816653007], [1.3026581018633578, 3.9419332108943195, 1.8540986093031906, -1.6162040996087201]], [[-1.4590928590052954, -1.3306006805310622, 0.50688042472596173, -0.31010304325613358], [2.2801172589513961, -3.1721758179369566, -3.6745988958416245, -2.7946913449846988], [2.0081154904148306, -4.7531214797906181, 2.9353402632047736, -2.5850968568542632]]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[[4.0272444843661237, -4.4537691931727528, -2.4545376231963036, -4.1582050592919906], [1.6543066371195625, -1.9275830768178883, -2.6203108350435169, 0.80514649820598372], [-0.67283130947634895, -0.79846615755972739, -3.6105745811502334, 1.8988441752814058]], [[-4.438437059141398, -3.5337371378410651, -4.4662693813546808, 0.4436098841195264], [1.3963827694466522, 1.53900054526021, 3.0917496424870077, -2.6136217073070989], [-4.188157107035404, 3.1528634345308166, 3.9434938039059126, 0.79105496323341296]]], [[[-0.025690266477495172, 1.5366069679898384, 0.44235227160539736, -3.2741390369915258], [2.7658074839703382, -0.31929829557352019, -3.1046729479230573, -4.8310084906300998], [1.092883621354126, -3.1685603296106701, 2.5308436039517943, -0.760762545463324]], [[3.9473579365685492, -2.4082200992258929, 0.53266381604287094, 1.2641064564798565], [4.9529699131665463, 0.11227411342775184, 0.57521544544467318, -0.7757556747934089], [3.7454652556785852, 3.6675188960693426, -0.078416898733850715, 4.8706188611431713]]], [[[2.2603649059897748, 3.590343724216396, 2.9596469498186364, -2.812169543029519], [4.9868179453691468, 2.828010560934203, -2.7183780602061436, -0.37830105156183258], [2.9839713966769219, -2.6299880011982779, 1.3522105714009447, 1.4345613253385228]], [[2.0533141462259401, 0.053286732988436114, 0.22827221443525225, -2.0231500841902053], [-2.9821874078453323, -2.3490651251592354, -2.658270541884733, 0.4257584576183131], [-2.1311968264189387, -1.2429699637815284, 0.6158641113129546, -1.8107320154946605]]]]))  
       res=arg0/arg1  
       s0=numpy.array(0.0234808839733)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[0.041468234899395585, -0.20554193858906181, 0.018980357984215511, -0.0057890163943129383], [-0.0048103328536998934, -0.0077384088436979704, 0.0072192529328020056, 0.36684685409256579], [0.0087192145926065102, 0.014277834757144002, 0.014377201949638345, -0.0049256332075999698]], [[-0.0064532065206991352, 0.0056374300609794321, 0.027977188661162739, 0.0061274822228287685], [-0.01684617979873269, 0.011677808806206769, 0.0048953196006838191, -0.0078279847751019042], [-0.023654332091076858, 0.021669030500463655, 0.0070202371814885684, 0.0075898758151019836]]], [[[0.0067082692842488165, -0.0048466101977756269, 0.0057820000553399104, 0.0099318201258521647], [0.0070837685805495969, 0.01484438220138341, 0.01831050323919051, -0.0059079943363386676], [0.011544376093048788, 0.010877241547960832, 0.058003329318629844, 0.0053359227422976122]], [[0.07859293874958892, 0.012483952198147671, 0.0061801935399971343, 0.004815237538924713], [0.0053399142507316441, -0.017753215113716369, -0.0047557649017950865, -0.0065200300820089339], [0.022722945218735024, -0.036258587727288516, 0.028226971773410856, 0.0053779971661133052]]], [[[0.010573484843191141, -0.0075227605962547069, 0.0060807047336736359, 0.12596142469335514], [-0.006783378812113214, 0.019734106984983783, -0.0059677963772075153, 0.026480718194587322], [0.018025362095966276, 0.0059566924950521828, 0.01266431238096649, -0.014528415055385531]], [[-0.01609279617017571, -0.017646829974534196, 0.046324306143851933, -0.075719617991419741], [0.010298103696706274, -0.0074021382549350869, -0.0063900536191591924, -0.0084019596709559736], [0.011692994793083606, -0.0049400975912708023, 0.0079993737924253325, -0.009083173773962349]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[0.0058305086926022489, -0.0052721375883881304, -0.0095663165850170557, -0.0056468797566537497], [0.01419379179558602, -0.012181515938651055, -0.00896110631582424, 0.029163492638483713], [-0.034898619672746566, -0.029407488033172793, -0.0065033648926456347, 0.0123658825084219]], [[-0.0052903496569743965, -0.0066447738067118315, -0.005257381937452477, 0.052931381409446795], [0.016815506813103953, 0.015257229145010511, 0.0075946912552864697, -0.0089840407690538662], [-0.0056064954998672773, 0.007447478922227844, 0.0059543352014586742, 0.029682999367520242]]], [[[-0.91399923756729196, 0.015280995376487467, 0.053081865925800852, -0.0071716209079828149], [0.0084897029563403142, -0.073539020717774378, -0.0075630780978200056, -0.0048604518122609582], [0.021485255625148268, -0.0074105844707764513, 0.0092778881858471378, -0.030864931657526178]], [[0.005948506406222475, -0.0097503064528358212, 0.044081995559167676, 0.018575084284212982], [0.0047407685459408093, 0.20913889458981161, 0.040821024816500066, -0.030268401168427581], [0.006269150124335353, 0.0064023893642366084, -0.29943652901941409, 0.0048209241254036457]]], [[[0.010388094378526582, 0.0065400100316177733, 0.0079336773512023208, -0.0083497398055294523], [0.0047085905743031861, 0.0083029689838125947, -0.0086378286806620685, -0.062069306644507806], [0.0078690043743316253, -0.0089281334981881136, 0.017364813195480347, 0.01636798898631274]], [[0.011435602300061973, 0.44065159668217585, 0.10286352209542055, -0.011606100880414765], [-0.0078737117297052704, -0.0099958420572692532, -0.0088331430542366949, 0.055150716452429117], [-0.01101769845105588, -0.018890950431251358, 0.03812672883839989, -0.012967619599367704]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank1_taggedData_rank0(self):  
       arg0=Symbol(shape=(2,))  
       arg1=Data(-3.04017426778,self.functionspace)  
       arg1.setTaggedValue(1,2.0177990306)  
       res=arg0/arg1  
       s0=numpy.array([2.6336528375756014, -2.2964782901728977])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([-0.86628351061419373, 0.75537718824459577]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([1.3052106764023088, -1.138110513160504]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank1_taggedData_rank1(self):  
       arg0=Symbol(shape=(2,))  
       arg1=Data(numpy.array([-2.1476994766614013, -2.2925218227652557]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([-2.865748607538686, 2.7969241193125178]))  
       res=arg0/arg1  
       s0=numpy.array([0.82727816210892335, -3.7841253564403332])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([-0.3851927008870567, 1.6506387502457425]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([-0.28867785538922419, -1.3529596067019756]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank2_taggedData_rank0(self):  
       arg0=Symbol(shape=(4, 5))  
       arg1=Data(3.11905380251,self.functionspace)  
       arg1.setTaggedValue(1,-3.26260245328)  
       res=arg0/arg1  
       s0=numpy.array([[3.0462837092170485, -0.97349888574622412, -2.1904588229979574, 1.9088050283705336, 3.393007741381993], [4.9591954971144467, 1.5138905431237184, 3.5288413529528277, 3.1785441452145164, -1.2645953476570861], [-1.3999242230609554, -1.7693051569458849, 1.8763148280220374, 4.2267861866780674, -0.95866741024447499], [-1.0020755729038622, -2.8366665140756608, 2.373662377734135, -2.2831337439497079, -3.0374760390458109]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[0.97666917664908182, -0.31211352781548146, -0.70228311587267933, 0.61198207829481144, 1.0878323864297039], [1.589967923326967, 0.48536852487370369, 1.131382007619864, 1.0190732018349355, -0.40544197943662547], [-0.44882977713834177, -0.56725701734440448, 0.60156539349046501, 1.3551501366481711, -0.30735840769224537], [-0.32127550095447782, -0.90946379693648527, 0.76102001697679744, -0.73199562704427623, -0.97384534906259934]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[-0.93369748623782545, 0.29838109291212128, 0.67138391954514298, -0.58505596550813677, -1.039969714353393], [-1.5200121890839242, -0.46401318113509921, -1.0816032303934637, -0.97423581044115259, 0.38760326020945202], [0.42908207270405729, 0.54229872694706682, -0.57509759613467115, -1.295525963463334, 0.29383518953769777], [0.30713995568099617, 0.86944902258240297, -0.72753650244785883, 0.69978913356645245, 0.93099790199568344]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank2_taggedData_rank2(self):  
       arg0=Symbol(shape=(4, 5))  
       arg1=Data(numpy.array([[-4.2400152931057988, 2.0380491194835235, 0.91101349191802861, -4.4834079091239971, -2.2154734695518252], [-4.5332053408256243, -3.9823629323026264, -2.1535347807161043, -0.092528910394756636, 4.6087455584438271], [1.0777725216549641, 1.6282680237741873, 0.194097001670678, -2.4480536007048768, 3.6026891519391757], [0.74551046837404567, 4.4225945068445291, 4.5230132131405796, -4.8616083864649928, -4.5205712640253441]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[0.56705377199597873, 2.3039719977109421, 2.9960000717338797, -3.2818407291842089, -1.4460264608849469], [1.3157515984200341, 2.3734508747145036, 2.7570426675429704, -4.8178820558450539, -0.10654482177862601], [-3.1115559014344649, -0.57989246992490528, -2.4903638922672924, -4.6560314177869468, -3.8541104055725994], [4.4341234642152507, 4.4601355033505214, 4.5281414945421545, -3.2369430202845786, -2.4374147482839481]]))  
       res=arg0/arg1  
       s0=numpy.array([[0.017132904094092183, 2.7183087292861465, -0.86108106344755342, 2.037152925610064, 2.5289640943219185], [4.6078788216918749, -3.5209975243753378, -0.26938305767388204, -1.7418837579301694, 0.71178842325440339], [4.6707026471356468, -1.4975249190877959, -0.46075714347325913, 3.3514661400547681, 4.3608131735861164], [-3.2808604108926698, 1.2496442565578922, -1.309165243333037, -4.8657613996693438, -2.9231190070873971]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[-0.0040407646929835435, 1.3337797913207374, -0.94519024261062423, -0.4543759940879657, -1.1415005095202111], [-1.016472556447807, 0.88414782485419419, 0.12508878894647127, 18.82529201412575, 0.15444298545627314], [4.3336627658344735, -0.91970418703958823, -2.3738498766458025, -1.369032989755522, 1.2104328155091799], [-4.4008240662913947, 0.28255908485933051, -0.2894453722862354, 1.0008542467583184, 0.64662602055398299]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[0.030213896706454996, 1.1798358365409212, -0.28741022791405296, -0.62073485391731786, -1.7489058206958603], [3.5020887128125517, -1.4834929013640823, -0.097707250179755706, 0.36154553759092467, -6.6806477440388896], [-1.5010826721713071, 2.5824182874485713, 0.18501599099791549, -0.71981175368609296, -1.1314707454360631], [-0.73991183091094082, 0.28018078276302155, -0.28911756510060382, 1.5031964940926166, 1.1992702551526806]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank3_taggedData_rank0(self):  
       arg0=Symbol(shape=(6, 2, 2))  
       arg1=Data(-1.67731234215,self.functionspace)  
       arg1.setTaggedValue(1,-1.72067089907)  
       res=arg0/arg1  
       s0=numpy.array([[[4.5907749563300388, 1.5875718307876756], [-1.8879761511868267, -0.5888012600844208]], [[3.6067233527838738, -2.0743244145580011], [-3.5920105448857855, -0.10157831239624304]], [[-2.2109196550890289, -1.5749219083910426], [-2.0748226541734049, 3.8872771127942976]], [[2.2974774134784433, -1.1183945602327396], [3.4266016234789518, -3.3321791567926917]], [[4.574171588479846, 4.2279402312718091], [-0.12309602723303481, 2.8405730382721517]], [[2.4146010338472292, -0.83691233346034366], [2.3832257449536778, -1.5769241986659921]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[-2.7369827556582464, -0.94649743574193157], [1.1255960525286268, 0.35103853068180096]], [[-2.1502991793113013, 1.2366953741563409], [2.1415275226983246, 0.060560165118535229]], [[1.3181323475202638, 0.93895565471599396], [1.23699242056975, -2.3175630531644127]], [[-1.3697373802944357, 0.6667777563694921], [-2.0429120667395666, 1.9866181587337588]], [[-2.7270839625516126, -2.5206636384971954], [0.07338885199813594, -1.6935265823079702]], [[-1.4395655318111238, 0.49896033817127683], [-1.4208598393142526, 0.94014940392097346]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[-2.6680145278227148, -0.92264699289239427], [1.0972325691120499, 0.34219283908470866]], [[-2.0961145764281777, 1.2055323395513056], [2.0875639535833268, 0.059034131658142433]], [[1.2849172123962946, 0.91529525444929982], [1.2058219008007416, -2.259163629074723]], [[-1.3352218688160773, 0.64997586745664215], [-1.9914334724460609, 1.9365580940473801]], [[-2.6583651707846356, -2.4571463570100476], [0.071539553147154211, -1.6508520251034418]], [[-1.4032904462714451, 0.48638721902657306], [-1.3850561116811149, 0.91645892280449059]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank3_taggedData_rank3(self):  
       arg0=Symbol(shape=(6, 2, 2))  
       arg1=Data(numpy.array([[[-1.1948669336416184, -4.8482630862083242], [0.92944539503691459, -3.4094883291268498]], [[1.8841788799368029, 1.825366586557843], [-4.5424287789410833, -0.69073134489368826]], [[-3.801163324551168, -1.701745464906359], [0.37544764774162154, 3.7891887673484721]], [[-3.9790561947478964, 4.7856572382120071], [0.32621319833563778, 2.0137078118978371]], [[0.49765355228984198, 4.9015467368389345], [-0.59290340205704872, 0.79141400459364242]], [[4.1011904097859606, 2.5199788684829034], [-2.5856368937631702, 4.1387732113108342]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[-1.0216083037215498, 3.0257683549384051], [3.6767690562700519, 3.8224721501187275]], [[-2.3159120339101511, -0.044855829302194117], [4.9740059686176359, -1.2924878794982697]], [[-2.5359543133445897, -0.58793341762563589], [4.4426197657945607, -2.850864809224408]], [[-2.1680607667951191, 3.8939752851173761], [-3.7004502417092953, -3.9600228505699064]], [[-2.7257226465019002, -0.93072740919210162], [3.3056380363385927, 1.3462954530613622]], [[1.5375865561259614, -3.3799194674592261], [-4.0972461177403847, 1.7917499356364708]]]))  
       res=arg0/arg1  
       s0=numpy.array([[[-3.389872055955486, -0.5933997853304902], [-2.423328002705575, 4.9497795406620746]], [[-4.7310145480330732, 0.22504905282839527], [-3.3723177605622832, -3.2680729972445413]], [[-1.9564365277772842, -0.70039232833582243], [1.0017249271848776, 1.0630312237037991]], [[1.4102668307735104, -2.414978988988171], [0.59551903248164084, 1.9132581873595829]], [[-4.0218373652613995, -0.61991406467677024], [-0.87499991587414172, 2.6970179606598919]], [[1.9739600165881015, 0.63286922634186027], [-0.67323236454096236, -1.7729676626032944]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[2.837028928086669, 0.12239430385255139], [-2.607283887408284, -1.4517660900542471]], [[-2.5109158150587887, 0.12328978435656482], [0.74240410244768373, 4.7313228528054365]], [[0.51469415037784394, 0.41157290721756823], [2.6680815107257043, 0.28054322151062094]], [[-0.35442244636679771, -0.50462849067110438], [1.8255516193704608, 0.95011708056910971]], [[-8.0816008380846682, -0.12647315183544697], [1.4757883203880653, 3.4078471508028172]], [[0.48131391604690738, 0.25114068782761856], [0.26037390097769336, -0.42837999863291837]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[3.3181719878418607, -0.19611540465812358], [-0.65909170949234241, 1.2949157891204865]], [[2.0428299860963626, -5.0171640192456994], [-0.67798828184750048, 2.5285134577147237]], [[0.7714794061873308, 1.1912783103303617], [0.22548068031784835, -0.3728802643549422]], [[-0.65047384850665491, -0.62018344035672945], [-0.16093150659595448, -0.4831432190054753]], [[1.4755123271338295, 0.66605330256135209], [-0.26469925208245532, 2.0032883231738623]], [[1.2838041596575924, -0.18724387738670134], [0.16431338152374586, -0.98951735805336893]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank4_taggedData_rank0(self):  
       arg0=Symbol(shape=(3, 2, 3, 4))  
       arg1=Data(-2.34724786312,self.functionspace)  
       arg1.setTaggedValue(1,-1.14150112823)  
       res=arg0/arg1  
       s0=numpy.array([[[[2.2373818557840162, 3.1340257495409869, -1.0536941198940699, 3.0161396623260934], [4.4248609199024767, -0.84999637952951801, -2.7984893689500288, -4.5581163527918536], [-0.23985414177654718, -0.88021658848877582, -1.582528376701331, -3.9645526610286472]], [[-2.1718523722532304, -4.6417248516403644, 3.6813647679482635, 2.0893635746900205], [-3.05829042517784, 0.66742963575652592, 2.0437930000368993, 1.982729909589076], [0.023962079976154627, 4.7181467187026858, 2.4603727771681374, -2.7339273555556751]]], [[[-3.0142761694704867, -4.0787996727202769, 0.2882880314951306, -0.8144833397716571], [-4.0606517594340019, -2.6551868175558901, -0.36122150095975414, 2.8344702233426151], [4.851552973728495, -3.7441147014353779, -1.5930789932971212, -2.5739038690044449]], [[3.1227057076592359, 2.6062531121577113, 4.226008650652318, 3.6576049512725017], [4.1709498204014306, 2.3629490924611467, -2.8826381543852886, -4.934185709330551], [0.94242568243803326, 3.5209248862219802, -1.4876976889685123, -4.3246274027484066]]], [[[-2.4214617470603472, 0.56743293566357877, -4.1180645751103242, 2.7064584738833251], [0.91799564887180019, -3.6714660524712448, -2.0854788736244059, 2.320110352201783], [-0.57135518535499763, 4.6990094353684047, -2.5996606036461545, 4.8034218637291861]], [[3.0823625263780698, 1.6553904381646278, -0.80587803646322165, -3.494766453085246], [-2.5825603806173225, -3.1843609182842911, 3.7592232009521513, 3.2264265481707373], [-4.4497547126401464, -2.2371965590569687, 2.731184887770751, -1.7407215233271445]]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[-0.95319369161669543, -1.3351916509486228, 0.44890620051295788, -1.284968541124021], [-1.8851272545313096, 0.3621246792406187, 1.1922428018460964, 1.9418981797425969], [0.10218526366364331, 0.37499942052129687, 0.67420590793498225, 1.6890217361892699]], [[0.92527611011179078, 1.9775179794928794, -1.5683749576661394, -0.89013333765074132], [1.3029260664088755, -0.28434561438696293, -0.8707188670406355, -0.84470410677295249], [-0.010208585276687885, -2.0100760524016494, -1.0481947031792285, 1.1647373924648239]]], [[[1.2841746356805916, 1.7376944875790232, -0.12281959482211907, 0.3469950287610567], [1.7299629166736077, 1.1311914942079531, 0.15389150274059871, -1.2075717557916776], [-2.066911232495773, 1.5951083651060265, 0.67870079608104239, 1.0965624506251836]], [[-1.3303689638947223, -1.1103442261511423, -1.8004100534317697, -1.5582525427950449], [-1.7769532932335648, -1.0066892080681955, 1.2280927803496495, 2.1021153270017194], [-0.4015024136336835, -1.5000226186365406, 0.63380510952637947, 1.8424246841172243]]], [[[1.0316174039859014, -0.24174393534649199, 1.7544225472812072, -1.1530348014841376], [-0.39109446569170936, 1.5641577995071909, 0.88847833515754238, -0.98843858318426248], [0.24341493471262204, -2.00192297933468, 1.1075356141527477, -2.046405894838168]], [[-1.3131815241210671, -0.70524739384202939, 0.3433289040864313, 1.4888783191580883], [1.1002503916172277, 1.3566359856242372, -1.6015450519826775, -1.3745572416396046], [1.8957327781868347, 0.9531147494947495, -1.1635690165859842, 0.74160106850218965]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[-1.960034730104296, -2.7455301374958823, 0.9230775982919327, -2.6422572766116468], [-3.8763526469427698, 0.74463034552363672, 2.4515870372282191, 3.9930896606818651], [0.21012168612436227, 0.77110444021517444, 1.3863572602466003, 3.4731044612948212]], [[1.9026283185728454, 4.0663340025233436, -3.2250207002918914, -1.8303648792093496], [2.6791830069585854, -0.58469467900696848, -1.7904432588743939, -1.7369495838024231], [-0.020991726931807952, -4.133282571536868, -2.1553835702144157, 2.395028167685564]]], [[[2.6406247833888883, 3.5731893485246577, -0.25255168336289763, 0.71351952234562777], [3.5572910608773953, 2.3260483515009933, 0.3164442785263506, -2.4831076844731137], [-4.2501517114146958, 3.279992116381873, 1.395600016416408, 2.2548412834208396]], [[-2.7356133344355964, -2.2831804960184012, -3.7021502179372909, -3.2042061639868735], [-3.6539165115578136, -2.0700365808005237, 2.5253046914242696, 4.3225412461759856], [-0.82560205954360977, -3.0844690374345261, 1.3032818384291351, 3.7885441335079282]]], [[[2.121295973500319, -0.49709362665584034, 3.607586951311903, -2.3709643441876906], [-0.80420038681454797, 3.2163490352078909, 1.8269617278943455, -2.0325081551161883], [0.50052967204766641, -4.1165175567147143, 2.2774051986064929, -4.2079869611494543]], [[-2.7002711168210398, -1.450187299185131, 0.70598093732313305, 3.0615532185274565], [2.2624247289372712, 2.7896257301313043, -3.2932277577168936, -2.8264768806436766], [3.8981605909929611, 1.959872402864782, -2.3926256577649854, 1.5249406945626993]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_quotient_overloaded_Symbol_rank4_taggedData_rank4(self):  
       arg0=Symbol(shape=(3, 2, 3, 4))  
       arg1=Data(numpy.array([[[[-4.692244649272256, 1.0356733816668493, -1.4115435735313939, -3.3533239896597], [-1.7559316701608063, 0.25583175712406359, 1.1225449156205647, 1.5491515905051383], [-3.4099511613632316, 1.4749821375305574, 0.88895191602829637, -0.20648918924605741]], [[-4.3419539072386391, -2.5743904544580722, -2.2486440163371837, -3.9767602694345348], [-2.3487522239863603, 2.3113499953832619, -3.9655787887451699, 4.6511096002030143], [-2.3962332651787399, -0.66856762307285855, 3.1652536747762454, -3.8524545464225444]]], [[[0.52869939407037414, -4.6169772559763977, 3.9054435061353825, 3.1123662657564886], [-0.944914545508305, 4.1348614834104538, 4.916828368912519, -3.1901061735337279], [1.5585733480276041, -2.5968351957220404, -0.60243324405629117, 1.3988240180012514]], [[-4.4299304783051818, -2.0781122206261973, -0.52551578674964983, 3.2474443643928588], [-0.13292178094243123, -4.8658444131397838, 0.40539257466406831, 4.1591773218399659], [-4.4274711916813212, 4.5441020180139819, 0.96965640881446635, -1.1281604296420156]]], [[[2.3380322834013754, -0.31956081844297124, 0.2961722340211761, -3.7319983310204363], [-4.5019872727389085, 1.2884371570347, -2.9351049981613642, -4.685290159641041], [1.6944724390118786, 0.055906721011096394, -4.7035466615486481, -0.47983210077196148]], [[-0.86302542714260877, -4.8477625213575104, 4.6227141939572576, 3.0092738439168585], [-4.96716961060479, -0.70539310773829911, -4.2299798154973907, -3.2296469596672295], [-1.9222247911212822, 0.73599414632792737, -4.0955146048137081, -2.3603850862550599]]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[[3.4003771586744396, 3.0662705755449782, -2.7499254065200751, 3.9113769149389412], [4.4222946755925676, 4.215093108259742, 1.4794877017904637, -1.1740072654262166], [-4.765335827712736, -3.3421053903750453, -4.8137826631026268, -1.8772778150029943]], [[3.5882188990795445, 0.51382540173399427, -4.143893994755584, -1.8285016096973838], [-1.8708161869798756, 2.2370449376942094, 1.7499548523941559, -2.5362886583866984], [-1.5477536924401591, 0.48074055259244464, -2.3864247410680459, 4.2043813221572002]]], [[[-1.3895049239395316, 3.2431718872202957, 1.4357238260131, 0.20179321757892765], [0.68941011919723394, -1.78770894200033, 4.0371355207474977, -4.6650351532376799], [1.882751181321737, -1.9112360199045408, -3.076139157936022, 3.8609093825317]], [[-4.6591702336609107, 2.9429556481184926, -4.1993028203300131, 3.7115098940409226], [-1.0393532624583135, 2.3958807218009639, 3.2441749097022985, 3.3881023550429799], [-3.7865124084870896, -2.9548151227110053, -2.6059301846590177, 3.6399756365380327]]], [[[-4.9501548026635902, -1.6891710122974724, -3.9758740967684805, -2.1548334947738712], [3.25685029448222, 1.4989420208118256, 0.42094169001293924, -0.31774079392453114], [0.11496458521239639, -2.3202208701728577, 1.9900496913140007, 3.0570361041433074]], [[3.2562985953506782, -2.6912814261326714, -0.76604404638984569, -1.4344622252523411], [-4.6567619773097508, -4.6660681115099445, 3.0433603387552903, 2.3631818456893843], [1.262914703318474, 4.338064437492319, -2.3846981616547938, -0.88396708643685074]]]]))  
       res=arg0/arg1  
       s0=numpy.array([[[[-2.1209295269444373, 1.0665616767500126, -2.3101036734749805, 0.35739505998499155], [-2.4118486651096029, -0.94755073159174774, 4.0609633272175429, 3.241288174830018], [4.077556586891669, -1.5508191087143763, 0.04985063800477807, 1.6072176458651164]], [[-3.7145107312034975, 3.9223709738482508, -1.3831440847043952, 1.0221924700528149], [-3.5776623939752525, 4.0531180305170977, 1.3358867116773689, 1.1140419021297143], [2.7257423898833402, -2.9472476788073667, -0.17475536917173162, 3.7154089354077939]]], [[[-2.9260311239199677, -4.9275767527897081, -0.55168176160118065, -4.7260207976806692], [-1.3240177968179956, -2.3260764369285605, 4.2832126128475423, -3.3837842195212318], [-1.9699329042942115, -0.48363898781816328, 0.63404158347792805, 1.4045902260206216]], [[4.05410845868807, 3.5719006793752612, 3.976985979175776, -2.7148922990018143], [-1.5263557864720401, 1.239157450503833, -0.82782452001640117, 2.4361578920361735], [3.9457440108646757, -2.6242296080852667, 2.7048290875229721, 2.005969207848417]]], [[[-4.0429918921704742, -1.0009300986381717, -4.8836419651579019, 1.2944810856306148], [-4.7328465040912331, -3.9494459317315411, 2.608846054382898, -0.14096873524613773], [-0.031606871343319298, 4.9089766217980486, 4.0560091899621309, -0.67116564976284732]], [[1.3369779542251621, 1.1098178792322466, -4.1680232848868028, -4.1932781823317669], [-1.6319622508081189, 3.3109558863002171, 2.0153210378206579, 2.0931334324761046], [-4.1181183898438745, 0.82340257974590259, 4.8184523031135775, 3.4622807772219701]]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[0.45200744749602578, 1.0298243593298213, 1.6365797817318333, -0.10657934070404587], [1.3735435758093755, -3.7038041806992732, 3.6176399453669639, 2.0922989039265794], [-1.1957815211821221, -1.0514155183674201, 0.056077991515562767, -7.7835437861587886]], [[0.85549289802705952, -1.5236115279466953, 0.61510140095780863, -0.25704151138035858], [1.5232183103176187, 1.7535717388594887, -0.33687055101988889, 0.23952174811814539], [-1.1375112888602779, 4.4083015346469807, -0.055210541437594331, -0.96442641714176403]]], [[[-5.5343946990234105, 1.0672733434870745, -0.14125969578986314, -1.5184654999246907], [1.4012037417687933, -0.56255244492736944, 0.87113323701288425, 1.0607121003038478], [-1.2639333957475847, 0.18624169474246874, -1.0524677874826633, 1.0041221825942117]], [[-0.91516299827782055, -1.7188199193106815, -7.5677764197602881, -0.83600887170530158], [11.483112667088839, -0.25466442107306136, -2.0420317779682677, 0.58573071151447065], [-0.8911958632905953, -0.57750235309025844, 2.7894716756732261, -1.7780886079162916]]], [[[-1.7292284289114772, 3.1322053295366605, -16.489195826536275, -0.34686003872800936], [1.0512794055972252, -3.0652996230107754, -0.88884249661158821, 0.030087514421292087], [-0.018652927374699972, 87.806555866936151, -0.86232995690674941, 1.3987510395470946]], [[-1.5491756235407372, -0.22893404417868768, -0.90163983971476758, -1.3934518424796505], [0.32854973329759424, -4.6937740813999875, -0.47643750696802845, -0.64809976403481984], [2.1423708657100775, 1.1187624030083383, -1.1765193798723503, -1.4668287803475135]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[-0.62373361188299292, 0.34783677776396138, 0.8400604860036287, 0.091373208912690712], [-0.54538397868894295, -0.22479947826892888, 2.74484426082285, -2.7608757375562636], [-0.85567035237657385, 0.46402459754279207, -0.010355814022697868, -0.8561426726616661]], [[-1.0351962451778931, 7.6336649776587917, 0.3337788289118569, -0.55903285216248033], [1.9123537731148237, 1.8118178862757985, 0.76338352949489507, -0.43924097458147471], [-1.7610957112859387, -6.1306408683728044, 0.073228946282848095, 0.88369932475617541]]], [[[2.1058083879430014, -1.5193695937630696, -0.38425339999626568, -23.420117159448999], [-1.9205082141232774, 1.3011494110030195, 1.0609533890639575, 0.7253502081699813], [-1.0463054937037781, 0.25305037304723843, -0.20611602756727918, 0.36379777064324537]], [[-0.87013529349035668, 1.2137120318679859, -0.94705863076176877, -0.73147920294130309], [1.4685630397328544, 0.51720331451741408, -0.25517259181699498, 0.71903314503179161], [-1.042052312312693, 0.88811972969651298, -1.0379514783036659, 0.55109413033222576]]], [[[0.81674049668002546, 0.59255699473364065, 1.2283190680326721, -0.60073369416714861], [-1.4531974380614476, -2.6348223459587348, 6.1976423725165004, 0.44365954243703504], [-0.27492702456957324, -2.1157367752805047, 2.038144679334116, -0.21954783224613969]], [[0.41058211189050364, -0.41237526051931228, 5.4409707960391405, 2.9232405765122973], [0.35045000340578214, -0.70958155928606625, 0.66220257001998906, 0.88572677396541966], [-3.2608048501003104, 0.18980874802816031, -2.0205711484131599, -3.9167530447066143]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
4178     def test_pow_overloaded_constData_rank0_taggedData_rank0(self):     def test_pow_overloaded_constData_rank0_taggedData_rank0(self):
4179        arg0=Data(4.55643012421,self.functionspace)        arg0=Data(4.55643012421,self.functionspace)
4180        arg1=Data(1.24128234849,self.functionspace)        arg1=Data(1.24128234849,self.functionspace)
# Line 5829  class Test_util_overloaded_binary_with_t Line 5153  class Test_util_overloaded_binary_with_t
5153        self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")        self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")
5154        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")        self.assertTrue(Lsup(res-ref)<=self.RES_TOL*Lsup(ref),"wrong result")
5155     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    def test_pow_overloaded_Symbol_rank0_taggedData_rank0(self):  
       arg0=Symbol(shape=())  
       arg1=Data(4.65477896754,self.functionspace)  
       arg1.setTaggedValue(1,3.36988343843)  
       res=arg0**arg1  
       s0=numpy.array(0.317381592263)  
       sub=res.substitute({arg0:s0})  
       ref=Data(0.00478600492549,self.functionspace)  
       ref.setTaggedValue(1,0.0209116615842)  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank0_taggedData_rank1(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([0.69315572224017752, 2.7333717476088184]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([4.2022862145916609, 3.9020914957330768]))  
       res=arg0**arg1  
       s0=numpy.array(4.17118475338)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([2.6911404908122494, 49.590626192230708]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([404.11748075379563, 263.21402893239576]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank0_taggedData_rank2(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[4.6259359281665624, 3.0143973938587245, 1.3792767477593184, 4.8327526211082477, 0.79457161900478102], [3.3601754089748557, 0.4879087713845261, 0.36716830962188074, 3.0505909148744546, 1.0888487044447726], [0.92303676169212312, 2.0600110807479561, 3.5266767887519079, 0.42293318729913754, 3.6875763709098623], [0.5723282892778736, 1.7623530223825936, 0.98966709307246969, 4.2560610852463165, 1.2400354692705746]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[3.6565921773783683, 0.38872713403930653, 3.8064030475853641, 0.43344890716953099, 2.5833714859222687], [1.4972595588951054, 1.1180260225944179, 4.5732741436616449, 0.1793782382062844, 3.0177153207792888], [1.8965829548720592, 1.8424355263337335, 2.5587897209052204, 1.5906794977081009, 1.4615916395499238], [0.71761196868077026, 2.6383825089347113, 2.8946058241228991, 3.0029337617613083, 2.4681682741040514]]))  
       res=arg0**arg1  
       s0=numpy.array(3.78911380539)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[474.54576100129918, 55.455213634386546, 6.2800561613170709, 625.07098749106751, 2.8819709361492007], [87.899819404165854, 1.9154622342205596, 1.6308750578366829, 58.194467322694223, 4.2652055932690622], [3.4198851268423875, 15.552276485592849, 109.72745330929344, 1.7566400174321044, 135.95706034622597], [2.1434505229272252, 10.46134621174647, 3.7373147400874354, 289.92894558355022, 5.2168362575887093]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[130.45966026746274, 1.6783915424017426, 159.27494799132256, 1.7814207714482977, 31.23040865459873], [7.3488777995139714, 4.4342497183982008, 442.39608324254181, 1.2699220507588034, 55.700863562089587], [12.50963518488054, 11.639071031639558, 30.224295769379719, 8.3227716202419728, 7.0078660426212629], [2.6011508641075634, 33.604977969281613, 47.27575241020272, 54.614786459824749, 26.787258685624245]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank0_taggedData_rank3(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[[1.8098243936930547, 1.4926222202012394], [1.711854900562608, 2.0543349511993045]], [[1.1957677916530671, 3.5268985798570611], [4.0074424624589122, 2.9870116085078529]], [[3.5076682404065038, 4.6792965532537565], [1.2301209356964933, 1.9587806242672154]], [[1.1440226674638707, 4.1318959390611036], [2.0387033697563512, 2.280870862919322]], [[4.2533366277907287, 1.9232652696624144], [0.66929615214251414, 2.8006686894602888]], [[2.3818424983996693, 1.5369180525352804], [3.7304588292584651, 2.9567207153905066]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[1.2362008114807228, 0.90264820476560104], [1.5254197386463493, 1.6634078356881092]], [[3.4486654715991336, 0.21880742770814512], [0.029372782375211341, 3.0779650437104253]], [[0.35644093125037318, 1.8648347231660989], [0.84621358397647595, 3.8154085718745732]], [[4.307553559787233, 1.4362435906291338], [1.2642327938351516, 4.1344024743653911]], [[4.0243140195992853, 3.1108685002123639], [0.20878693482005381, 4.2487319103855796]], [[2.7841582054974854, 0.19407759815247097], [2.1605844909387923, 1.5760394439512817]]]))  
       res=arg0**arg1  
       s0=numpy.array(2.88409019217)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[6.8004118536448974, 4.8598113677717043], [6.130111628562025, 8.8107369042588299]], [[3.548654776288688, 41.918382501370637], [69.736307681047379, 23.662015694702237]], [[41.073185835036938, 142.07503395024588], [3.6801583151427315, 7.9626274767630312]], [[3.3593908694917407, 79.562541628923285], [8.6660575230171144, 11.200070450943738]], [[90.484134847465029, 7.6686518422882006], [2.031805562636873, 19.423717296949746]], [[12.464320256149461, 5.0932604734533271], [52.004871781876915, 22.91488381298398]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[3.7039345028692576, 2.601513904741354], [5.0316052420210404, 5.8234762019787123]], [[38.58483034666704, 1.2608207583305395], [1.0316009644224908, 26.055002675180379]], [[1.4586999849578357, 7.2084261488555175], [2.4505621827909221, 56.901231039967335]], [[95.832475362991758, 4.578094412205262], [3.8155597430518786, 79.774056535612061]], [[70.993733263725332, 26.97907173425941], [1.247509424362266, 90.04388561256269]], [[19.086987098565594, 1.2282235218251325], [9.8602507720014092, 5.3087475394439361]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank0_taggedData_rank4(self):  
       arg0=Symbol(shape=())  
       arg1=Data(numpy.array([[[[1.3346605136955221, 3.5472793723723375, 3.1358961706680035, 0.33786091871554336], [4.8226796986710605, 0.43982467147196058, 0.082956170230268522, 0.34457483268841538], [3.8920260753235287, 1.360121214883441, 1.9811415206892882, 3.9055237354737455]], [[3.8732914688164781, 3.9211979417698268, 4.0714809853839951, 4.8757043397698814], [2.5640840701604612, 1.3612959193812593, 0.9138557382521928, 3.7969909983421268], [1.5795766537060372, 4.3740447365754065, 1.5661695440868157, 3.8978164856262763]]], [[[0.76893651637798022, 0.97823295551311173, 1.5884011904820876, 1.7503375764322524], [4.2618272764204415, 4.8004237318821952, 2.0247093818359065, 1.9312351048047933], [0.17162406879871164, 1.2033899578985241, 3.5488417144857216, 3.859493434018308]], [[2.9054106356400866, 0.56636929542949699, 0.97121406714668923, 0.80642540266171059], [0.78666965574772318, 3.9596175360646324, 0.83459639801642338, 2.6504788310271339], [3.1615336518886861, 1.8079817031279914, 3.229914219501222, 0.78411549533597713]]], [[[1.6500767271702674, 3.6898528033048472, 4.5294849507020993, 0.5407973229336287], [3.0842525297233738, 3.9043689807377455, 4.3070432612440896, 1.5797464815651703], [0.93632040846302067, 1.460113516447904, 3.2827935993516557, 2.4567471688422775]], [[4.947381060922778, 1.8936748319177423, 0.11025475467579147, 1.6098147086472956], [0.46062017638697078, 2.973523557399921, 1.8820665915361474, 0.86755476707673429], [1.0929782152253598, 1.1853564095345503, 3.816067859184507, 4.671814380766806]]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[[0.76349254794982213, 2.0311489905533588, 0.059975962982779248, 1.0955577548640327], [2.339029408353126, 4.2970029550928173, 3.2861535339093448, 1.8199709362905272], [1.0745872523369768, 2.1244704098346703, 1.0899550136420875, 2.4777043438801338]], [[2.5328115472592589, 0.66121345005295551, 4.2295479417790833, 0.74157832662428591], [4.9380135987222928, 0.092051712722764481, 0.81091639918377478, 0.44777255355952889], [4.022432222285703, 4.5956435445480039, 1.47927802345139, 4.5835228455919799]]], [[[0.88624640324640092, 1.9629670185506318, 3.4758123483294994, 2.9389980561353624], [2.3519770542343466, 2.9399392793719334, 1.8693847146102984, 0.77578406680159939], [0.5563526965789799, 1.956090861836008, 1.040544191482826, 3.7342346832531068]], [[4.6247056432963829, 0.98827089528000178, 4.882146918972353, 3.1377851753221329], [1.2922634333409078, 1.5052898946474578, 3.4246959167969884, 3.0283044204050351], [1.0665610587669303, 3.1689467015420578, 2.8634250696396157, 2.2871694198605996]]], [[[4.679760564634619, 0.76380709402294256, 1.78973567261855, 4.9884262601539682], [2.5860232714887106, 4.6489668925054861, 4.328380862176731, 2.3879746771229686], [4.5764010227355296, 4.9181527611755733, 3.5172119060753255, 2.4459995269297266]], [[2.9897876093805928, 3.57384468656055, 2.3041363920519009, 3.2079152271664602], [0.40491938543444617, 1.2808718239123225, 0.81593586791822448, 2.5139644574855988], [0.33153618176738103, 2.420114377485524, 0.29890270126537893, 3.72864427016663]]]]))  
       res=arg0**arg1  
       s0=numpy.array(1.23644356327)  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[1.3274598547988328, 2.1230879533066025, 1.945579709035385, 1.0743408590419603], [2.7830891350867271, 1.0978437413032103, 1.0177624572022288, 1.075872838192123], [2.284255984714143, 1.3346525428132947, 1.5226859097141436, 2.290809148238715]], [[2.2751913201804537, 2.2984426282820323, 2.3729353262555835, 2.8145866599509533], [1.7232276293759814, 1.3349853376022673, 1.2140428377502319, 2.2386437137109354], [1.3982871585783294, 2.5303144938323086, 1.3943139688124093, 2.2870649510106107]]], [[[1.177270288590557, 1.2307445916289208, 1.400908481803397, 1.4498936153476834], [2.4707621378463323, 2.7699739689100609, 1.536831190157413, 1.506642590539186], [1.0370968807978476, 1.2909862735221933, 2.1237920651656217, 2.26853820673636]], [[1.8526960937642902, 1.1277288535536856, 1.2289125372581611, 1.1866747331662479], [1.1817094901532774, 2.3172610771140434, 1.1937911009140534, 1.755116809680233], [1.9561950025077859, 1.4677410619402005, 1.9847923433065411, 1.1810690674617672]]], [[[1.4193668701932347, 2.1883137641116539, 2.6151830683151629, 1.1216248266069266], [1.9243710370840554, 2.2902477759504736, 2.4945871977829368, 1.3983375595209169], [1.2198450729591455, 1.3632796075881704, 2.0071932860431185, 1.6844144008026058]], [[2.8577312002833888, 1.4946797418222595, 1.0236763139889689, 1.4072898026382019], [1.1026999158181219, 1.8796736207446831, 1.491001797183382, 1.2021710121801563], [1.2610854058299701, 1.2860545639699419, 2.2477260361060201, 2.6953875069967124]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[1.1759108285824575, 1.5389330705079589, 1.0128106100193772, 1.2617760130624627], [1.6428518221828257, 2.4892770265521551, 2.0086251455283315, 1.4714806093619834], [1.2561726273272811, 1.5697177482779421, 1.2602765002888874, 1.6919232507975897]], [[1.7118280026247339, 1.1506596542008296, 2.4538929479861005, 1.1704543005807737], [2.8520552680037943, 1.0197290743268086, 1.1878063696364349, 1.0996972038733086], [2.3483610388829304, 2.6521630352173187, 1.368835983944392, 2.6453491483072296]]], [[[1.2069496138133184, 1.5168237042261818, 2.0911277404137345, 1.8659503460503846], [1.6473725836337032, 1.8663231337977275, 1.4869940262776105, 1.1789824810200347], [1.1253339449378481, 1.5146116817433348, 1.2471291500561885, 2.2090241339200261]], [[2.6685724388266525, 1.2333694190298921, 2.818437867043579, 1.9463598887346043], [1.3155685262531154, 1.3764138670262922, 2.0685639042330721, 1.9016554577797551], [1.2540345932110237, 1.9592751837577622, 1.8362600924437522, 1.624868561050258]]], [[[2.6999370902551787, 1.1759893338289511, 1.4620681932316655, 2.8827347864031245], [1.7312703039776991, 2.6823488562809557, 2.505909990725979, 1.6600068860668009], [2.6413536448357173, 2.8400584515067657, 2.1095826183604078, 1.6805765116460227]], [[1.8861732189071827, 2.1350921572496513, 1.630730351721402, 1.9755468536831755], [1.0897406717411389, 1.312391658123951, 1.1890724471176723, 1.7049942125433191], [1.0728996776978683, 1.6713690044477902, 1.0654943390785434, 2.2064046709260339]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank1_taggedData_rank0(self):  
       arg0=Symbol(shape=(2,))  
       arg1=Data(1.04775739262,self.functionspace)  
       arg1.setTaggedValue(1,0.2572415351)  
       res=arg0**arg1  
       s0=numpy.array([0.53642582183577836, 2.7891902616735034])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([0.52070501756673182, 2.9292269061822047]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([0.85195891861447759, 1.3019535215987847]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank1_taggedData_rank1(self):  
       arg0=Symbol(shape=(2,))  
       arg1=Data(numpy.array([4.1277661252323785, 2.4836741733783012]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([0.038521639582654491, 0.97388637006947631]))  
       res=arg0**arg1  
       s0=numpy.array([1.7632566641756298, 0.21763294517021159])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([10.392808310543014, 0.022652899119631507]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([1.0220884443609985, 0.22647436621927075]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(2,),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank2_taggedData_rank0(self):  
       arg0=Symbol(shape=(4, 5))  
       arg1=Data(0.412010546129,self.functionspace)  
       arg1.setTaggedValue(1,0.770063562017)  
       res=arg0**arg1  
       s0=numpy.array([[3.9173789764326328, 3.069397472450063, 2.4971315062208164, 0.096635498545861093, 0.71633817290693946], [1.0369762894074914, 0.096594402257553905, 2.7920465254103211, 1.3802983853552735, 2.724556644140574], [3.9127349499944573, 2.2454052023404683, 1.8217562523273612, 2.3019401569243367, 2.7544182648443085], [1.8399846889819911, 4.8388234463073569, 0.88556392763527225, 0.6170810535108987, 2.0716709731271825]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[1.7551750477100849, 1.587343897004065, 1.4579749225752394, 0.3818261021513909, 0.87157974138784977], [1.0150721740926474, 0.38175919166879746, 1.5265985126901356, 1.1420111493690255, 1.5112853671034363], [1.7543174585224079, 1.3955234263767262, 1.2803383021131078, 1.4098943128575849, 1.5180880272265036], [1.2856011342778304, 1.9147849671418393, 0.95116103217634007, 0.81963176341670518, 1.3499805075916789]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[2.8618330506998428, 2.3717115527639385, 2.0232760983356788, 0.1653829543339555, 0.77344907439687816], [1.0283548450202671, 0.165328791115289, 2.2048994287073258, 1.2817050383829482, 2.1637419551592614], [2.8592201122445076, 1.8643148842033468, 1.5870626249145658, 1.9003579755967439, 2.1819810983661116], [1.5992773007834433, 3.3673879325935205, 0.91065941479685564, 0.68952525443484614, 1.752213844313306]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank2_taggedData_rank2(self):  
       arg0=Symbol(shape=(4, 5))  
       arg1=Data(numpy.array([[4.4874253255108743, 1.6822401699549085, 1.9365163909416403, 2.0605999823499852, 1.6118177180473294], [3.3971563597230587, 0.53810297061804035, 2.1995919752908648, 0.88011385578693535, 4.6373539681678979], [2.8526705771970926, 2.3417366257007033, 3.1213933738109452, 1.6444747846809009, 2.6566682992093105], [2.4424072000570343, 0.78627134772500196, 1.0993718490226783, 4.2060166414298994, 3.8510650981120542]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[4.6062083448558351, 2.7568492364178807, 0.60724104557131786, 4.6453408602004993, 3.3154906420445918], [0.013325862679250709, 0.9824972004476189, 4.6212871573555816, 4.3292948108624136, 0.90646848767723032], [4.6245688113556636, 1.8982790609271212, 2.7313470194491987, 3.7935005308289207, 0.065481431189768152], [4.6847611871428407, 4.130028552337123, 0.7298492922815778, 3.3037100511396216, 1.6079688286695426]]))  
       res=arg0**arg1  
       s0=numpy.array([[4.0132939832762622, 2.9560460383888878, 3.667879218143792, 3.0293230089344116, 3.0392165788843233], [0.68406737035103404, 4.0148516254484274, 1.6267020144603388, 0.13133860608425243, 1.4327710890222065], [4.2874876899850811, 0.87573186212283938, 1.8898874216427242, 2.3750071881067636, 0.58776643087187164], [0.76374793164629329, 2.8497316167356592, 0.1153544507157519, 1.555612629077086, 4.0606370886981988]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[510.69964349255838, 6.1922613570044822, 12.387935894892031, 9.81433099749386, 5.9996205009395176], [0.27529929264126868, 2.1126927948351319, 2.9160259935895163, 0.16752704894349305, 5.2996494972119121], [63.601384856349881, 0.73290623081195649, 7.2923128859959805, 4.1473577796468861, 0.24369894641914477], [0.51774552312935107, 2.2782392157433451, 0.093073699181215663, 6.4141739755155776, 220.66618871273477]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[602.35320094513906, 19.846311093184397, 2.2015876004499244, 172.19252993606634, 39.86499662528076], [0.9949529642796382, 3.9183533172861931, 9.4735983343849774, 0.0001524968257967741, 1.3853814122628199], [838.81415318227687, 0.77732809167897254, 5.689085567200328, 26.612465119919495, 0.96579999449476495], [0.28291040717222043, 75.570682357818882, 0.20674091697813707, 4.3051350846035206, 9.5192003167345156]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(4, 5),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank3_taggedData_rank0(self):  
       arg0=Symbol(shape=(6, 2, 2))  
       arg1=Data(1.73149105415,self.functionspace)  
       arg1.setTaggedValue(1,1.65045033032)  
       res=arg0**arg1  
       s0=numpy.array([[[2.7209407330256021, 2.6059224053203676], [4.1280136644186269, 1.8664956454482668]], [[1.8012841705649192, 4.0040961027792745], [2.9271350302835586, 0.41601331834497157]], [[0.98307840342340358, 3.3802880581864709], [1.4573349433065892, 4.8724821738976285]], [[2.4021059371424913, 3.2456582990920952], [2.683075116177088, 1.2193585736264103]], [[4.7393493053994318, 1.2189320403878352], [2.377174078421572, 2.7496133511820271]], [[2.0203546703851241, 2.3997591787254806], [0.077212101610221115, 0.085181644589896396]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[5.6586417803255333, 5.2508979905177755], [11.645288486588937, 2.9463259653241916]], [[2.77037365871736, 11.046663854913032], [6.4215735514266177, 0.21902192105366]], [[0.97088201815970854, 8.2390780860803741], [1.9195595975113799, 15.517916862490157]], [[4.5602842575446276, 7.6792042073648981], [5.5229856295952526, 1.4097295762001381]], [[14.791115102544792, 1.4088758434550015], [4.4786408076972863, 5.7622871175953536]], [[3.3794434584566835, 4.5525728586033951], [0.011858702523086262, 0.014057357954227769]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[5.2177378176391045, 4.8587411421683884], [10.381261840607891, 2.8010223256627222]], [[2.6413489512697441, 9.8719679934920688], [5.8862757400502232, 0.23515564536575362]], [[0.97222574849841148, 7.4646908698141292], [1.8618583207904824, 13.6488996896421]], [[4.2476473232804155, 6.9803928975438883], [5.0984386563263389, 1.3872529512900478]], [[13.038876823537464, 1.3864521400718963], [4.1751297678879267, 5.3087955878155464]], [[3.192222170956418, 4.2408005001299545], [0.014594188701106559, 0.017162843268202201]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank3_taggedData_rank3(self):  
       arg0=Symbol(shape=(6, 2, 2))  
       arg1=Data(numpy.array([[[4.1076049791736216, 4.5619519555442256], [4.6365835265067643, 3.4945050123098143]], [[1.840078461829147, 3.9295523482141692], [1.4612801318000832, 1.6334466170507507]], [[3.8714032298478136, 2.9729692151151488], [2.3850944812454968, 3.7930135336192938]], [[2.7856753618943961, 2.9552079185550415], [1.4503166796516564, 2.3366906988853002]], [[1.5648310291063126, 4.7212840830695502], [3.4765673602705278, 2.4279654660486445]], [[4.5809660151898166, 0.32086037770621822], [4.3197687283770438, 4.0781547961024822]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[2.3342346214845162, 4.0160326737827834], [3.2067238982466453, 1.9337147745723908]], [[1.2605824073557412, 1.7010311333387078], [1.8837220844106868, 3.921191101005038]], [[4.8202630637926251, 2.1811602991547323], [0.49459956221592583, 4.4520862357928035]], [[0.028149987701444695, 4.7934272092743724], [0.53944735781601483, 2.1635431156213252]], [[3.4764990844114387, 4.8160649191538809], [1.1592236523741395, 0.52644741790829963]], [[0.13218133872801044, 3.8984979532443913], [2.2076287980136411, 3.8478056070542137]]]))  
       res=arg0**arg1  
       s0=numpy.array([[[3.391807494489671, 0.79791379851562305], [3.6150622714083602, 3.7352656072729129]], [[3.2496569153753767, 4.4529478263265041], [3.9333596516493938, 4.1187596223216936]], [[3.4475494953389334, 2.034250318688442], [2.234449915784805, 3.5670511464609516]], [[2.298010590827833, 2.2800929571031614], [1.1224979046023031, 1.4361469386658665]], [[0.91861020326599652, 0.28577349919915324], [2.0041948655733193, 4.41442281937851]], [[2.8870766608268679, 3.04038908209579], [0.36532091058136562, 4.1012870080209876]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[150.93912205361266, 0.35704904079568928], [387.03518109749217, 99.995466814753556]], [[8.7462358171058092, 353.91154169360516], [7.3980339035360672, 10.096902728764928]], [[120.48137746170251, 8.2580358767054296], [6.8046364894732276, 124.42761830463753]], [[10.153351830851953, 11.424158486875251], [1.1824558228230784, 2.3298349363148567]], [[0.87560182759731042, 0.0027022473738616969], [11.21281245587079, 36.790155838681379]], [[128.63048185844266, 1.4287387839645116], [0.012907885875672927, 315.92449460410018]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[17.304173493989261, 0.403879671293429], [61.620216267766253, 12.785170357387809]], [[4.4178743890176486, 12.687316486616231], [13.193786086258736, 257.4048463300166]], [[389.88996491271422, 4.7062979401040756], [1.4883313784065142, 287.6926688948318]], [[1.0236984720872981, 51.977993170003813], [1.0643205714826451, 2.1882984245896817]], [[0.74443344495709018, 0.0023997522597884484], [2.2388032365446473, 2.185205144814983]], [[1.1504400614693218, 76.330544200390605], [0.10827986399122753, 228.24308938080856]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(6, 2, 2),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank4_taggedData_rank0(self):  
       arg0=Symbol(shape=(3, 2, 3, 4))  
       arg1=Data(1.51289274199,self.functionspace)  
       arg1.setTaggedValue(1,2.7275614227)  
       res=arg0**arg1  
       s0=numpy.array([[[[3.0829423550663098, 2.7779717609064956, 0.039211518792650134, 0.74202481609281923], [0.20563685979442486, 2.9884030572235711, 2.6945297293460637, 1.9850273734371318], [1.8152009773313742, 4.0357127396832491, 0.81850596827795563, 2.7705886448248185]], [[4.7214341423083805, 0.30346514181629242, 1.7518794897875192, 1.9551407793738775], [0.70344731771458369, 2.1099089789697727, 3.0770669806992643, 0.9982610342649475], [4.5951904623602573, 3.9576194348954532, 0.820565471248353, 1.2918900986309372]]], [[[3.7278675372018557, 3.2490810524326648, 0.765732576095696, 1.2293499601713287], [2.6752307163595357, 0.87767222923904631, 3.946636714057441, 0.47962983121944269], [4.5462296626509149, 2.4480879665073059, 3.8649409755813671, 2.7216425828587623]], [[2.7407290366205919, 0.76588327270205858, 2.7467331389564102, 4.7851549369225825], [2.5024278383434209, 4.9309588860819433, 3.2371478547877772, 1.9851588080568587], [4.209861654422645, 3.9279700533102195, 2.3576015534984749, 3.1486503892224142]]], [[[2.6724300811349293, 2.9221189217832002, 3.6974184188476014, 0.81389649988207691], [2.5503641850148173, 3.1441366102362363, 1.0910785740133326, 1.2581287707864433], [0.84348102424780935, 1.1473767554459879, 3.5001170437421529, 3.6709848481574046]], [[3.0922201442827943, 0.60755909488006621, 4.6550348750995205, 2.0252914605963377], [2.6110870703358438, 1.6417490523332474, 1.9277276373075587, 4.2103529202973489], [1.5392449766728198, 1.7510709543039815, 1.0869762132685941, 4.0871289181090074]]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[5.4922742027317799, 4.6915095896434753, 0.0074470752409480159, 0.63673244951726671], [0.091368276518189087, 5.2394834469007954, 4.4799645292964962, 2.8215566659219982], [2.4644801506957004, 8.2545298440483421, 0.73860354693838959, 4.6726585030562164]], [[10.46650211886679, 0.16462135827023866, 2.3355855485497998, 2.7575356413531442], [0.5873240205768272, 3.0943984080711386, 5.4764464913867155, 0.99737030493203527], [10.0460233577625, 8.014078791093139, 0.74141700295535784, 1.4732361166844672]]], [[[7.3207976106497723, 5.9461904481200074, 0.66776110841899372, 1.3666882503394204], [4.4315098771258752, 0.82085780892997418, 7.9804564195920484, 0.32903741605755854], [9.884529146664244, 3.874838223083882, 7.7318635354266823, 4.5483387450532691]], [[4.5966818511501844, 0.66795993641106544, 4.6119251302001603, 10.680946262991833], [4.0056990454250059, 11.177144296030901, 5.9131813427076763, 2.8218393149935577], [8.7993432702962053, 7.9234205775006554, 3.6602249612101927, 5.6703367554936248]]], [[[4.4244930862050609, 5.0646676588426374, 7.2305223128334202, 0.73231977687276417], [4.1223562337378672, 5.6580433243356811, 1.1409644399894523, 1.4153810304942227], [0.77296509575939021, 1.2312006770462307, 6.6548545401535524, 7.1524607658655359]], [[5.5172992162719581, 0.47053577909984318, 10.244617941958552, 2.908591710271681], [4.2717517056006171, 2.1170740854355188, 2.6992526162732551, 8.8008968021731064], [1.9203329236178726, 2.3339549488184335, 1.1344805019380191, 8.4141522060691614]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[21.56170867763397, 16.229117410083362, 0.00014569658521260915, 0.44315770893524631], [0.01337952471686015, 19.805670267811688, 14.933746274440303, 6.4889797442706927], [5.0843222482793493, 44.945341809764585, 0.57911092067480396, 16.111740195508123]], [[68.956953230426066, 0.038674078526695757, 4.6150109830470907, 6.2259549372242695], [0.38310228780806727, 7.6638891472072883, 21.449813163977922, 0.9952639857341341], [64.043273544573623, 42.612598001479611, 0.58309401253009863, 2.0108263756007716]]], [[[36.198747034214158, 24.880455191874052, 0.48285110966131001, 1.7562871356991832], [14.643808400004959, 0.70054416931792762, 42.290827010060646, 0.13478824693195862], [62.199158608155678, 11.496074710498664, 39.945533934020709, 15.347177287113823]], [[15.64251878714907, 0.48311034126472807, 15.736163804756888, 71.525040525484414], [12.20550156646587, 77.627018229691274, 24.63199867240267, 6.4901517212181448], [50.434629483062551, 41.747471207643471, 10.373753370936804, 22.838365024990264]]], [[[14.60203199316563, 18.63028891102709, 35.397966532442659, 0.57025873666285054], [12.853827804781856, 22.749174756036474, 1.2683953465397984, 1.870709358752171], [0.62858771028236105, 1.4549628730546003, 30.480256791415592, 34.711965867884928]], [[21.739154221308418, 0.2568765225030748, 66.343876177409314, 6.8543072418371001], [13.705845942680639, 3.8660053576121167, 5.9907277508904739, 50.450683951189227], [3.2426000068713301, 4.6092037536069368, 1.2554296599580146, 46.524430765087025]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
    def test_pow_overloaded_Symbol_rank4_taggedData_rank4(self):  
       arg0=Symbol(shape=(3, 2, 3, 4))  
       arg1=Data(numpy.array([[[[2.8307007372947415, 4.7001557528011162, 4.062523101652233, 1.4929736801066029], [3.4463802257978688, 2.9217042261272579, 1.5843757270563776, 3.5133564917211286], [2.9507106732440533, 4.6594237212403762, 3.6892405936301995, 3.7664516458688468]], [[3.1116292470933371, 0.87323606501307638, 2.6986378511787663, 1.4559832046715342], [4.3684926293241615, 2.9173472858069043, 0.59799136898996241, 2.0868207731941926], [2.6948455406752077, 0.1556466874360608, 1.4973065429280021, 1.7570095893398783]]], [[[0.50740195407162558, 3.1043562639605273, 1.537102071136617, 4.0440447580361765], [0.43736392703292071, 0.10471422889962825, 1.346940210558623, 4.173709021817694], [2.3368629722716747, 1.7898374164578175, 1.1168302223300897, 1.811251773168238]], [[1.6917965630046721, 2.2793974168280289, 2.3300601183057692, 4.9549551147300832], [1.3344980229763928, 2.3321157308147531, 3.2951771056568147, 4.6567042014166615], [1.1395071193562423, 0.731302788116171, 2.5366459136839103, 4.520458252596848]]], [[[0.20540954537277034, 2.7794626866877321, 1.434872670134359, 0.40911980386178998], [4.3398385019239232, 0.93215581499416489, 0.066958479266484058, 3.1354651053571145], [2.3280536742075384, 1.6831587199346851, 1.5337803946393682, 3.3937120827854819]], [[4.0022905826422086, 0.80161485513342723, 2.9888358488696314, 3.0391744972228771], [0.48779816182565822, 3.4421879700717337, 4.8522182280838173, 2.2085539590870322], [2.1959025600235815, 3.9200726323709292, 1.094548400146774, 2.272319553063451]]]]),self.functionspace)  
       arg1.setTaggedValue(1,numpy.array([[[[0.60498564348641093, 3.9169820651812621, 4.1093138863048013, 1.6683495355225548], [0.65241991087866769, 0.56412794138887168, 4.9308383367454365, 1.1283214430108595], [0.37140807653109709, 0.58692101053503254, 4.4763525632413135, 3.1045814932365072]], [[3.4166404288976282, 4.5300018081386026, 4.5430084955055099, 0.82764386514904587], [4.374267282632414, 4.2101377177339181, 3.9127269458410527, 3.4051544533278539], [1.7367841663305779, 4.1039096968934423, 0.55877602884109567, 4.7793265060104808]]], [[[0.34956855775650103, 1.1588551021008606, 3.1407612573972035, 1.1795931629979293], [0.01449238734386377, 2.9480101688375151, 0.3192335134700367, 2.9568683687105506], [4.890073374444122, 0.32692129150535265, 0.71946469694323101, 0.49939964673599097]], [[0.12139231563548469, 1.6861549972227898, 1.2738995089003222, 1.411478385066568], [0.27647755094401583, 4.695785498972838, 2.9690216149174065, 0.20592427830252583], [0.94206142968111972, 4.1799707089410933, 4.442336056219597, 2.6963529058961724]]], [[[0.52364890016542909, 3.3135340499341486, 3.438264318002056, 1.2481354732757362], [0.58075557910079934, 2.9653928728411203, 2.1392202014974839, 4.6886776861395116], [3.1792376387968186, 1.5165935995227202, 0.78016680721582066, 4.7727793403933987]], [[2.8347619262995107, 4.5534974884954238, 2.645637486486307, 3.4902038431725315], [3.9967048627907324, 2.0811634976344608, 1.4268463621902889, 0.56705530408743243], [4.1087764064068031, 2.3614068946897304, 2.1548942137288369, 4.1251275128266878]]]]))  
       res=arg0**arg1  
       s0=numpy.array([[[[2.3074332425080248, 4.864101486213368, 1.03321887752215, 0.014041853619900013], [0.41835611481918433, 2.4285199093148959, 1.691052707565305, 0.74804905285392598], [3.8079329153544514, 0.23923569387514901, 1.1754007816191763, 3.3404951733666994]], [[4.5890197006697004, 3.0142935921495448, 4.1785589438496498, 2.0719082938577946], [2.9628388133709866, 1.8638007306994626, 1.703579087923351, 1.8745228629326072], [3.8949965656075642, 3.3875093043515903, 2.2987239492894136, 3.0436982850942731]]], [[[0.59467618336306582, 2.6101616196205408, 2.3334784456742983, 0.51237655037426699], [0.38869679320393785, 3.3861183112043651, 3.9345558940805643, 1.0728613144534545], [0.89795493472214538, 2.642500024678522, 1.0311194308497693, 3.1543413719617934]], [[0.045080553159700158, 3.4963151011414029, 4.964363861817831, 3.1266244960189469], [0.68933456001049764, 3.4641601829691497, 1.4807605250825593, 0.13516279192206973], [3.0340609151781703, 2.1755603705041406, 2.5658807393943288, 2.6256793858762091]]], [[[3.6328322563001101, 3.442585166700002, 3.1862300090190501, 0.89954811757635278], [1.0993864044399091, 4.4745188281214441, 4.861258038238315, 1.8844364057239058], [0.45003778949420137, 2.3751782115018862, 3.2754971037917819, 4.9776124773171881]], [[2.9022734218377706, 4.4186943706067963, 0.74465902091027769, 0.99366783202873166], [0.81661580961165692, 4.8671348787301341, 1.626311177206023, 1.5057864655500486], [2.8658156929182637, 4.7058812538370169, 3.592222401883951, 1.8396482137284957]]]])  
       sub=res.substitute({arg0:s0})  
       ref=Data(numpy.array([[[[10.663749601706906, 1694.413302779835, 1.141975214893425, 0.0017145630122718414], [0.049625401734341747, 13.361474296440226, 2.2987229993833966, 0.36063794444154729], [51.694707489055446, 0.001275519260588208, 1.815235384639486, 93.952476627189171]], [[114.55843263345636, 2.6208496308790434, 47.416086668750367, 2.8882193716207376], [114.98813540798513, 6.1496327688121672, 1.3751581868474365, 3.7108557164456979], [39.023423649781066, 1.2091331944357226, 3.4774154680453782, 7.0687275994709573]]], [[[0.76819151819155995, 19.655497982674706, 3.6784037225115296, 0.066921537523614849], [0.66147073816705981, 1.1362328729197377, 6.328327775680199, 1.3411582918415146], [0.77761077328753447, 5.6929613763543312, 1.0348177298263213, 8.0103087021296613]], [[0.00528230673503344, 17.342213154695003, 41.821926549901953, 283.84287774169525], [0.60867466379478252, 18.130296390713482, 3.6456729246355604, 8.9672413193902668e-05], [3.5421758428465493, 1.7654959079279755, 10.916615426628919, 78.5533259752372]]], [[[1.3034060773197174, 31.063541806609621, 5.2739813563735733, 0.95761396578064495], [1.5086410657990468, 4.0420062879966645, 1.1116898663912413, 7.2915850617215439], [0.15586371394692936, 4.2890028631721915, 6.1705247339013347, 232.00047246161878]], [[71.123519492385981, 3.2906161674561303, 0.41428752044221462, 0.98087941078905183], [0.90590454082287941, 232.12620243187149, 10.587811112548204, 2.4694488620946711], [10.094216541879673, 433.3127170589072, 4.0538896300545444, 3.9954161798705874]]]]),self.functionspace)  
       ref.setTaggedValue(1,numpy.array([[[[1.6583947701429991, 490.88184599277952, 1.1437227203741798, 0.00081144002765838141], [0.56635554133036514, 1.6496127400292844, 13.33539834066241, 0.72069681538071628], [1.643132901185326, 0.43193650963262842, 2.061470716119381, 42.287641740178003]], [[182.33038060612085, 148.1533272438341, 662.71807318433093, 1.8274357946958033], [115.71162216865314, 13.753683931673098, 8.0400269900048684, 8.4964034085150804], [10.606774724398981, 149.47952488385221, 1.592172688995517, 204.33091417747542]]], [[[0.83386467424051225, 3.0398849111287811, 14.315682496057395, 0.45439491163862283], [0.98639868141309095, 36.439068018071012, 1.548498006545491, 1.2311567833899368], [0.59076026663621717, 1.3739334240057166, 1.0222928769434536, 1.774822086585842]], [[0.68644324637031484, 8.2529967176430539, 7.6994606775668091, 4.9979129355460312], [0.90225549686632889, 341.85056513392249, 3.2075478218628564, 0.66225064002948308], [2.845093198054208, 25.765434702692957, 65.7606219181759, 13.502791490784379]]], [[[1.9650420973675413, 60.115395908086398, 53.752637190338291, 0.87622617321691232], [1.0565700657358881, 85.058664239695105, 29.45144700561023, 19.509102583053913], [0.078994365475356293, 3.7134574608247428, 2.5234934590688263, 2121.9142136150099]], [[20.4999586349319, 867.64974324199909, 0.45840130257458123, 0.97807314045497684], [0.44500106234086201, 26.935700519263577, 2.0014979753351412, 1.2612514332070035], [75.636399695304092, 38.75957536713382, 15.730733826681861, 12.361316815165388]]]]))  
       self.assertTrue(isinstance(res,Symbol),"wrong type of result.")  
       self.assertEqual(res.getShape(),(3, 2, 3, 4),"wrong shape of result.")  
       self.assertTrue(Lsup(sub-ref)<=self.RES_TOL*Lsup(ref),"wrong result")  
    #+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  
5156     def test_pow_overloaded_float_rank0_taggedData_rank0(self):     def test_pow_overloaded_float_rank0_taggedData_rank0(self):
5157        arg0=0.341812064896        arg0=0.341812064896
5158        arg1=Data(4.30670501129,self.functionspace)        arg1=Data(4.30670501129,self.functionspace)

Legend:
Removed from v.3974  
changed lines
  Added in v.3975

  ViewVC Help
Powered by ViewVC 1.1.26