/[escript]/trunk/esys2/escript/test/python/DataTest.py
ViewVC logotype

Contents of /trunk/esys2/escript/test/python/DataTest.py

Parent Directory Parent Directory | Revision Log Revision Log


Revision 82 - (show annotations)
Tue Oct 26 06:53:54 2004 UTC (14 years, 8 months ago) by jgs
File MIME type: text/x-python
File size: 25128 byte(s)
Initial revision

1 from finley import *
2
3 """
4 tests arithmetic operations on Data:
5
6 +arg1
7 -arg1
8 arg1+arg2
9 arg1-arg2
10 arg1*arg2
11 arg1/arg2
12 arg1**arg2
13 arg1+=arg2
14 arg1-=arg2
15 arg1*=arg2
16 arg1/=arg2
17
18 various values for arg1 and arg2 are tested on various atoms.
19
20 moreover various slicing operations are tested.
21
22 the results are compared to reference result. if the relative difference is
23 bigger than tol an exception is raised.
24
25 by Lutz Gross, ACcESS, University of Queensland, Australia, 2003.
26
27 Version $Id$
28
29 """
30
31 from Data import *
32 from numarray import array,Float64,ones,greater
33 from Constants import EPSILON
34
35 Tag1=10
36 Tag2=11
37
38 tol=1.E-15
39
40 #
41 # list of arguments: a list item has the form [a0,a1,a2]
42 # where a0 is the default value and a1 is used for tag Tag1
43 # and a2 for tag2. a0,a1,a2 are converted into numarrays.
44 #
45 # binary operations are tested on all pairs from arglist
46 #
47 # each item in the arglist are used to construct the following 5 argument
48 # types arg for arithmetic operations:
49 #
50 # 1) arg is a numarray/list a0
51 # 2) arg is a Data with default value a0
52 # 3) arg is an DataArray with constant value a0
53 # 4) arg is a Data object with constant value a0 and value a1 for tag Tag1
54 # 5) arg is a Data object with constant value a0 and value a1 for tag Tag1
55 # and value a2 for Tag2.
56 #
57 # i.e for a single binary arithmetic operation (len(arglist)*5)**2
58 # test are performed.
59 #
60
61 arglist = [ \
62 [ [3,4],[-5,6.],[2,3] ], \
63 [ [[1,2],[3,4]],[[5,6],[7,8]],[[-5,-6],[7,8]] ], \
64 [ [[15,8],[12,8]],[[-9,9],[13,8]],[[7,34],[19,7]] ], \
65 [ [[[15,8],[12,8]],[[-9,9],[13,8]]] , [[[3,4],[-9,4]],[[1,-9],[7,4]]] , [[[5,2],[6,2]],[[-6,4],[7,5]]] ], \
66 [ [3.],[6.],[3] ] \
67 ]
68
69 # these are used test slicing:
70 a_r1=[[1,2,3],[-1,-2,-3],[100,200,300]]
71 a_r1_in=[[1./1,2,3],[-1./1,-1./2,-1./3],[1./100,1./200,1./300]]
72 a_r4=[ \
73 [ [ [[ 1,2,3],[11,12,13]], [[21,22,23],[31,32,33]], [[41,42,43],[51,52,53]] ], [ [[101,102,103],[111,112,113]], [[121,122,123],[131,132,133]], [[141,142,143],[151,152,153]] ], [ [[201,202,203],[211,212,213]], [[221,222,223],[231,232,233]], [[241,242,243],[251,252,253]] ] ], \
74 [ [ [[ -1,-2,-3],[-11,-12,-13]], [[-21,-22,-23],[-31,-32,-33]], [[-41,-42,-43],[-51,-52,-53]] ], [ [[-101,-102,-103],[-111,-112,-113]], [[-121,-122,-123],[-131,-132,-133]], [[-141,-142,-143],[-151,-152,-153]] ], [ [[-201,-202,-203],[-211,-212,-213]], [[-221,-222,-223],[-231,-232,-233]], [[-241,-242,-243],[-251,-252,-253]] ] ], \
75 [ [[[ 11,12,13],[111,112,113]], [[121,122,123],[131,132,133]], [[141,142,143],[151,152,153]] ], [ [[1101,1102,1103],[1111,1112,1113]], [[1121,1122,1123],[1131,1132,1133]], [[1141,1142,1143],[1151,1152,1153]] ], [ [[1201,1202,1203],[1211,1212,1213]], [[1221,1222,1223],[1231,1232,1233]], [[1241,1242,1243],[1251,1252,1253]] ] ] ]
76 a_r4_in=[ \
77 [ [ [[ 1./1,1./2,1./3],[1./11,1./12,1./13]], [[1./21,1./22,1./23],[1./31,1./32,1./33]], [[1./41,1./42,1./43],[1./51,1./52,1./53]] ], [ [[1./101,1./102,1./103],[1./111,1./112,1./113]], [[1./121,1./122,1./123],[1./131,1./132,1./133]], [[1./141,1./142,1./143],[1./151,1./152,1./153]] ], [ [[1./201,1./202,1./203],[1./211,1./212,1./213]], [[1./221,1./222,1./223],[1./231,1./232,1./233]], [[1./241,1./242,1./243],[1./251,1./252,1./253]] ] ], \
78 [ [ [[ -1./1,-1./2,-1./3],[-1./11,-1./12,-1./13]], [[-1./21,-1./22,-1./23],[-1./31,-1./32,-1./33]], [[-1./41,-1./42,-1./43],[-1./51,-1./52,-1./53]] ], [ [[-1./101,-1./102,-1./103],[-1./111,-1./112,-1./113]], [[-1./121,-1./122,-1./123],[-1./131,-1./132,-1./133]], [[-1./141,-1./142,-1./143],[1./-151,-1./152,-1./153]] ], [ [[-1./201,-1./202,-1./203],[-1./211,-1./212,-1./213]], [[-1./221,-1./222,-1./223],[-1./231,-1./232,-1./233]], [[-1./241,-1./242,-1./243],[-1./251,-1./252,-1./253]] ] ], \
79 [ [[[ 1./11,1./12,1./13],[1./111,1./112,1./113]], [[1./121,1./122,1./123],[1./131,1./132,1./133]], [[1./141,1./142,1./143],[1./151,1./152,1./153]] ], [ [[1./1101,1./1102,1./1103],[1./1111,1./1112,1./1113]], [[1./1121,1./1122,1./1123],[1./1131,1./1132,1./1133]], [[1./1141,1./1142,1./1143],[1./1151,1./1152,1./1153]] ], [ [[1./1201,1./1202,1./1203],[1./1211,1./1212,1./1213]], [[1./1221,1./1222,1./1223],[1./1231,1./1232,1./1233]], [[1./1241,1./1242,1./1243],[1./1251,1./1252,1./1253]] ] ] ]
80
81
82 def turnToArray(val,tagged):
83 if tagged=="Tagged1":
84 out=[array(val[0],Float64),array(val[1],Float64),array(val[0],Float64)]
85 elif tagged=="Tagged2":
86 out=[array(val[0],Float64),array(val[1],Float64),array(val[2],Float64)]
87 else:
88 out=[array(val[0],Float64),array(val[0],Float64),array(val[0],Float64)]
89 return out
90
91 def prepareArg(val,ex,wh):
92 if ex=="Array":
93 out=val[0]
94 else:
95 if ex=="Expanded":
96 exx=TRUE
97 else:
98 exx=FALSE
99 out=Data(val[0],where=wh,expand=exx)
100 if ex=="Tagged1":
101 out.addTaggedValue(Tag1,val[1])
102 elif ex=="Tagged2":
103 out.addTaggedValue(Tag1,val[1])
104 out.addTaggedValue(Tag2,val[2])
105 return out
106
107 def checkResult(text,res,val0,val1,val2,wh):
108 ref=Data(val0,where=wh,expand=TRUE)
109 ref.addTaggedValue(Tag1,val1)
110 ref.addTaggedValue(Tag2,val2)
111 norm=ref.L2()+tol
112 error=(ref-res.expand()).L2()/norm
113 print "@@ %s at %s, shape %s: error = %e"%(text,wh,ref.getShape(),error)
114 if error>tol:
115 raise SystemError,"@@ %s at %s: error is too large"%(text,wh)
116
117 def getRank(arg):
118 if isinstance(arg,Data):
119 return arg.getRank()
120 else:
121 g=array(arg)
122 if g.rank==0:
123 return 1
124 else:
125 return g.rank
126
127 def isScalar(arg):
128 if isinstance(arg,Data):
129 if arg.getRank()==1 and arg.getShape()[0]==1:
130 return not None
131 else:
132 return None
133 else:
134 g=array(arg)
135 if g.rank==0:
136 return not None
137 else:
138 if g.rank==1 and g.shape[0]==1:
139 return not None
140 else:
141 return None
142
143 msh=Finley.Rectangle(20,6,1)
144 for wh in [msh.Nodes(),msh.Elements()]:
145 #
146 # ==============================================================
147 #
148 # test slicing
149 #
150 for ex1 in ["Array","Single","Expanded","Tagged1","Tagged2"]:
151 # rank 2
152 arg=prepareArg(a_r1,ex1,wh)
153 arrays=turnToArray(a_r1,ex1)
154 if isinstance(arg,Data):
155 checkResult("slicing: rank=1,[:],"+ex1,arg[:], \
156 arrays[0][:], \
157 arrays[1][:], \
158 arrays[2][:], \
159 wh)
160 checkResult("slicing: rank=1 [1]"+ex1,arg[1], \
161 arrays[0][1], \
162 arrays[1][1], \
163 arrays[2][1], \
164 wh)
165 checkResult("slicing: rank=1 [1:3]"+ex1,arg[1:3], \
166 arrays[0][1:3], \
167 arrays[1][1:3], \
168 arrays[2][1:3], \
169 wh)
170 # rank 4
171 arg=prepareArg(a_r4,ex1,wh)
172 arrays=turnToArray(a_r4,ex1)
173 if isinstance(arg,Data):
174 checkResult("slicing: rank=4,[:],"+ex1,arg[:], \
175 arrays[0][:], \
176 arrays[1][:], \
177 arrays[2][:], \
178 wh)
179 checkResult("slicing: rank=4 [1]"+ex1,arg[1], \
180 arrays[0][1], \
181 arrays[1][1], \
182 arrays[2][1], \
183 wh)
184 checkResult("slicing: rank=4 [1:3]"+ex1,arg[1:3], \
185 arrays[0][1:3], \
186 arrays[1][1:3], \
187 arrays[2][1:3], \
188 wh)
189 checkResult("slicing: rank=4,[:,:],"+ex1,arg[:,:], \
190 arrays[0][:,:], \
191 arrays[1][:,:], \
192 arrays[2][:,:], \
193 wh)
194 checkResult("slicing: rank=4 [:,1]"+ex1,arg[:,1], \
195 arrays[0][:,1], \
196 arrays[1][:,1], \
197 arrays[2][:,1], \
198 wh)
199 checkResult("slicing: rank=4 [:,1:3]"+ex1,arg[:,1:3], \
200 arrays[0][:,1:3], \
201 arrays[1][:,1:3], \
202 arrays[2][:,1:3], \
203 wh)
204
205 checkResult("slicing: rank=4 [1:2,1:3]"+ex1,arg[1:2,1:3], \
206 arrays[0][1:2,1:3], \
207 arrays[1][1:2,1:3], \
208 arrays[2][1:2,1:3], \
209 wh)
210
211 checkResult("slicing: rank=4 [1:2,1:3,1,1]"+ex1,arg[1:2,1:3,1,1], \
212 arrays[0][1:2,1:3,1,1], \
213 arrays[1][1:2,1:3,1,1], \
214 arrays[2][1:2,1:3,1,1], \
215 wh)
216
217 checkResult("slicing: rank=4 [1:2,1:3,:,1]"+ex1,arg[1:2,1:3,:,1], \
218 arrays[0][1:2,1:3,:,1], \
219 arrays[1][1:2,1:3,:,1], \
220 arrays[2][1:2,1:3,:,1], \
221 wh)
222 checkResult("slicing: rank=4 [1:2,1:3,0,:]"+ex1,arg[1:2,1:3,0,:], \
223 arrays[0][1:2,1:3,0,:], \
224 arrays[1][1:2,1:3,0,:], \
225 arrays[2][1:2,1:3,0,:], \
226 wh)
227
228 checkResult("slicing: rank=4 [1:2,1:3,0,1]"+ex1,arg[1:2,1:3,0,1], \
229 arrays[0][1:2,1:3,0,1], \
230 arrays[1][1:2,1:3,0,1], \
231 arrays[2][1:2,1:3,0,1], \
232 wh)
233
234 checkResult("slicing: rank=4 [1,1,0,1]"+ex1,arg[1,1,0,1], \
235 arrays[0][1,1,0,1], \
236 arrays[1][1,1,0,1], \
237 arrays[2][1,1,0,1], \
238 wh)
239 # inserting:
240 for ex2 in ["Array","Single","Expanded","Tagged1","Tagged2"]:
241 # ranks 1:
242 arrays_in=turnToArray(a_r1_in,ex2)
243
244 arg2=prepareArg(a_r1,ex1,wh)
245 arrays2=turnToArray(a_r1,ex1)
246 a_in=[arrays_in[0][:],arrays_in[1][:],arrays_in[2][:]]
247 arg2[:]=prepareArg(a_in,ex2,wh)
248 arrays2[0][:]=a_in[0]
249 arrays2[1][:]=a_in[1]
250 arrays2[2][:]=a_in[2]
251 checkResult("slicing, set: rank=1,[:],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
252
253 arg2=prepareArg(a_r1,ex1,wh)
254 arrays2=turnToArray(a_r1,ex1)
255 a_in=[arrays_in[0][1],arrays_in[1][1],arrays_in[2][1]]
256 arg2[1]=prepareArg(a_in,ex2,wh)
257 arrays2[0][1]=a_in[0]
258 arrays2[1][1]=a_in[1]
259 arrays2[2][1]=a_in[2]
260 checkResult("slicing, set: rank=1,[1],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
261
262 arg2=prepareArg(a_r1,ex1,wh)
263 arrays2=turnToArray(a_r1,ex1)
264 a_in=[arrays_in[0][1:3],arrays_in[1][1:3],arrays_in[2][1:3]]
265 arg2[1:3]=prepareArg(a_in,ex2,wh)
266 arrays2[0][1:3]=a_in[0]
267 arrays2[1][1:3]=a_in[1]
268 arrays2[2][1:3]=a_in[2]
269 checkResult("slicing, set: rank=1,[1:3],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
270
271
272 # ranks 4:
273 arrays_in=turnToArray(a_r4_in,ex2)
274
275 arg2=prepareArg(a_r4,ex1,wh)
276 arrays2=turnToArray(a_r4,ex1)
277 a_in=[arrays_in[0][:],arrays_in[1][:],arrays_in[2][:]]
278 arg2[:]=prepareArg(a_in,ex2,wh)
279 arrays2[0][:]=a_in[0]
280 arrays2[1][:]=a_in[1]
281 arrays2[2][:]=a_in[2]
282 checkResult("slicing, set: rank=4,[:],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
283
284 arg2=prepareArg(a_r4,ex1,wh)
285 arrays2=turnToArray(a_r4,ex1)
286 a_in=[arrays_in[0][1],arrays_in[1][1],arrays_in[2][1]]
287 arg2[1]=prepareArg(a_in,ex2,wh)
288 arrays2[0][1]=a_in[0]
289 arrays2[1][1]=a_in[1]
290 arrays2[2][1]=a_in[2]
291 checkResult("slicing, set: rank=4,[1],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
292
293 arg2=prepareArg(a_r4,ex1,wh)
294 arrays2=turnToArray(a_r4,ex1)
295 a_in=[arrays_in[0][1:3],arrays_in[1][1:3],arrays_in[2][1:3]]
296 arg2[1:3]=prepareArg(a_in,ex2,wh)
297 arrays2[0][1:3]=a_in[0]
298 arrays2[1][1:3]=a_in[1]
299 arrays2[2][1:3]=a_in[2]
300 checkResult("slicing, set: rank=4,[1:3],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
301
302 arg2=prepareArg(a_r4,ex1,wh)
303 arrays2=turnToArray(a_r4,ex1)
304 a_in=[arrays_in[0][:,:],arrays_in[1][:,:],arrays_in[2][:,:]]
305 arg2[:,:]=prepareArg(a_in,ex2,wh)
306 arrays2[0][:,:]=a_in[0]
307 arrays2[1][:,:]=a_in[1]
308 arrays2[2][:,:]=a_in[2]
309 checkResult("slicing, set: rank=4,[:,:],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
310
311 arg2=prepareArg(a_r4,ex1,wh)
312 arrays2=turnToArray(a_r4,ex1)
313 a_in=[arrays_in[0][:,1],arrays_in[1][:,1],arrays_in[2][:,1]]
314 print "WWW",a_in[0].shape,prepareArg(a_in,ex2,wh).shape
315 arg2[:,1]=prepareArg(a_in,ex2,wh)
316 arrays2[0][:,1]=a_in[0]
317 arrays2[1][:,1]=a_in[1]
318 arrays2[2][:,1]=a_in[2]
319 checkResult("slicing, set: rank=4,[:,1],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
320
321 arg2=prepareArg(a_r4,ex1,wh)
322 arrays2=turnToArray(a_r4,ex1)
323 a_in=[arrays_in[0][:,1:3],arrays_in[1][:,1:3],arrays_in[2][:,1:3]]
324 arg2[:,1:3]=prepareArg(a_in,ex2,wh)
325 arrays2[0][:,1:3]=a_in[0]
326 arrays2[1][:,1:3]=a_in[1]
327 arrays2[2][:,1:3]=a_in[2]
328 checkResult("slicing, set: rank=4,[:,1:3],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
329
330 arg2=prepareArg(a_r4,ex1,wh)
331 arrays2=turnToArray(a_r4,ex1)
332 a_in=[arrays_in[0][1:2,1:3],arrays_in[1][1:2,1:3],arrays_in[2][1:2,1:3]]
333 arg2[1:2,1:3]=prepareArg(a_in,ex2,wh)
334 arrays2[0][1:2,1:3]=a_in[0]
335 arrays2[1][1:2,1:3]=a_in[1]
336 arrays2[2][1:2,1:3]=a_in[2]
337 checkResult("slicing, set: rank=4,[1:2,1:3],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
338
339 arg2=prepareArg(a_r4,ex1,wh)
340 arrays2=turnToArray(a_r4,ex1)
341 a_in=[arrays_in[0][1:2,1:3,1,1],arrays_in[1][1:2,1:3,1,1],arrays_in[2][1:2,1:3,1,1]]
342 arg2[1:2,1:3,1,1]=prepareArg(a_in,ex2,wh)
343 arrays2[0][1:2,1:3,1,1]=a_in[0]
344 arrays2[1][1:2,1:3,1,1]=a_in[1]
345 arrays2[2][1:2,1:3,1,1]=a_in[2]
346 checkResult("slicing, set: rank=4,[1:2,1:3,1,1],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
347
348 arg2=prepareArg(a_r4,ex1,wh)
349 arrays2=turnToArray(a_r4,ex1)
350 a_in=[arrays_in[0][1:2,1:3,:,1],arrays_in[1][1:2,1:3,:,1],arrays_in[2][1:2,1:3,:,1]]
351 arg2[1:2,1:3,:,1]=prepareArg(a_in,ex2,wh)
352 arrays2[0][1:2,1:3,:,1]=a_in[0]
353 arrays2[1][1:2,1:3,:,1]=a_in[1]
354 arrays2[2][1:2,1:3,:,1]=a_in[2]
355 checkResult("slicing, set: rank=4,[1:2,1:3,:,1],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
356
357 arg2=prepareArg(a_r4,ex1,wh)
358 arrays2=turnToArray(a_r4,ex1)
359 a_in=[arrays_in[0][1:2,1:3,0,:],arrays_in[1][1:2,1:3,0,:],arrays_in[2][1:2,1:3,0,:]]
360 arg2[1:2,1:3,0,:]=prepareArg(a_in,ex2,wh)
361 arrays2[0][1:2,1:3,0,:]=a_in[0]
362 arrays2[1][1:2,1:3,0,:]=a_in[1]
363 arrays2[2][1:2,1:3,0,:]=a_in[2]
364 checkResult("slicing, set: rank=4,[1:2,1:3,0,:],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
365
366 arg2=prepareArg(a_r4,ex1,wh)
367 arrays2=turnToArray(a_r4,ex1)
368 a_in=[arrays_in[0][1:2,1:3,0,1],arrays_in[1][1:2,1:3,0,1],arrays_in[2][1:2,1:3,0,1]]
369 arg2[1:2,1:3,0,1]=prepareArg(a_in,ex2,wh)
370 arrays2[0][1:2,1:3,0,1]=a_in[0]
371 arrays2[1][1:2,1:3,0,1]=a_in[1]
372 arrays2[2][1:2,1:3,0,1]=a_in[2]
373 checkResult("slicing, set: rank=4,[1:2,1:3,0,1],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
374
375 arg2=prepareArg(a_r4,ex1,wh)
376 arrays2=turnToArray(a_r4,ex1)
377 a_in=[arrays_in[0][1,1,0,1],arrays_in[1][1,1,0,1],arrays_in[2][1,1,0,1]]
378 arg2[1,1,0,1]=prepareArg(a_in,ex2,wh)
379 arrays2[0][1,1,0,1]=a_in[0]
380 arrays2[1][1,1,0,1]=a_in[1]
381 arrays2[2][1,1,0,1]=a_in[2]
382 checkResult("slicing, set: rank=4,[1,1,0,1],"+ex1+","+ex2,arg2,arrays2[0],arrays2[1],arrays2[2],wh)
383 #
384 # ==============================================================
385 #
386 # test operators:
387 #
388 for ex1 in ["Array","Single","Expanded","Tagged1","Tagged2"]:
389
390
391 # test slicing
392
393 for a1 in arglist:
394 arg1=prepareArg(a1,ex1,wh)
395 arrays1=turnToArray(a1,ex1)
396 if isScalar(arg1):
397 t1="(scalar)"
398 else:
399 t1=""
400 #
401 # unitary operation:
402 #
403 # the argument must be an object of class Data
404 #
405 if isinstance(arg1,Data):
406 # pos:
407 ref=checkResult("+"+ex1,+arg1, \
408 +arrays1[0], \
409 +arrays1[1], \
410 +arrays1[2], \
411 wh)
412 # neg:
413 ref=checkResult("-"+ex1,-arg1, \
414 -arrays1[0], \
415 -arrays1[1], \
416 -arrays1[2], \
417 wh)
418 # pos:
419 ref=checkResult("where positive("+ex1+")",(arg1-3).wherePositive(), \
420 numarray.greater(arrays1[0],3.), \
421 numarray.greater(arrays1[1],3.), \
422 numarray.greater(arrays1[2],3.), \
423 wh)
424
425 # non-negative:
426 ref=checkResult("where nonnegative("+ex1+")",(arg1-3).whereNonnegative(), \
427 numarray.greater_equal(arrays1[0],3.), \
428 numarray.greater_equal(arrays1[1],3.), \
429 numarray.greater_equal(arrays1[2],3.), \
430 wh)
431
432 # negative:
433 ref=checkResult("where negative("+ex1+")",(arg1-3).whereNegative(), \
434 numarray.greater(3.,arrays1[0]), \
435 numarray.greater(3.,arrays1[1]), \
436 numarray.greater(3.,arrays1[2]), \
437 wh)
438
439 # zero:
440 ref=checkResult("where zero("+ex1+")",(arg1-3).whereZero(), \
441 numarray.less_equal(numarray.abs(arrays1[0]-3.),EPSILON), \
442 numarray.less_equal(numarray.abs(arrays1[1]-3.),EPSILON), \
443 numarray.less_equal(numarray.abs(arrays1[2]-3.),EPSILON), \
444 wh)
445
446 # non-zero:
447 ref=checkResult("where nonzero("+ex1+")",(arg1-3).whereNonzero(), \
448 numarray.greater(numarray.abs(arrays1[0]-3.),EPSILON), \
449 numarray.greater(numarray.abs(arrays1[1]-3.),EPSILON), \
450 numarray.greater(numarray.abs(arrays1[2]-3.),EPSILON), \
451 wh)
452
453
454 #
455 # binary operations
456 #
457 for ex2 in ["Array","Single","Expanded","Tagged1","Tagged2"]:
458 for a2 in arglist:
459 arg2=prepareArg(a2,ex2,wh)
460 arrays2=turnToArray(a2,ex2)
461 if isScalar(arg2):
462 t2="(scalar)"
463 else:
464 t2=""
465 # at least of of the argument must be an object of class Data
466 if isinstance(arg1,Data) or isinstance(arg2,Data):
467 # the shape must match or at least one argument is sclar:
468 if getRank(arg1)==getRank(arg2) or isScalar(arg1) or isScalar(arg2) :
469 # sum
470 checkResult(ex1+t1+"+"+ex2+t2,arg1+arg2, \
471 arrays1[0]+arrays2[0], \
472 arrays1[1]+arrays2[1], \
473 arrays1[2]+arrays2[2], \
474 wh)
475 # sub
476 checkResult(ex1+t1+"-"+ex2+t2,arg1-arg2, \
477 arrays1[0]-arrays2[0], \
478 arrays1[1]-arrays2[1], \
479 arrays1[2]-arrays2[2], \
480 wh)
481 # mul
482 checkResult(ex1+t1+"*"+ex2+t2,arg1*arg2, \
483 arrays1[0]*arrays2[0], \
484 arrays1[1]*arrays2[1], \
485 arrays1[2]*arrays2[2], \
486 wh)
487 # div
488 checkResult(ex1+t1+"/"+ex2+t2,arg1/arg2, \
489 arrays1[0]/arrays2[0], \
490 arrays1[1]/arrays2[1], \
491 arrays1[2]/arrays2[2], \
492 wh)
493 # pow
494 # this is needed because of a bug in python2.2
495 if isinstance(arg1,Data):
496 a=arg1
497 else:
498 a=Data(value=arg1,where=arg2.getAtoms())
499 checkResult(ex1+t1+"^"+ex2+t2,a**arg2, \
500 arrays1[0]**arrays2[0], \
501 arrays1[1]**arrays2[1], \
502 arrays1[2]**arrays2[2], \
503 wh)
504
505 # inplace for arg2 which must be of class Data
506 # if arg1 is expanded arg2 must be expanded
507 if isinstance(arg2,Data) :
508 # and not (not ex2=="Expanded" and ex1=="Expanded") :
509 # if arg2 is scalar arg1 must be scalar:
510 if not (isScalar(arg2) and not isScalar(arg1)):
511 # inplace add:
512 arrays2[0]+=arrays1[0]
513 arrays2[1]+=arrays1[1]
514 arrays2[2]+=arrays1[2]
515 arg2+=arg1
516 checkResult(ex2+t2+"+="+ex1+t1,arg2, \
517 arrays2[0], \
518 arrays2[1], \
519 arrays2[2], \
520 wh)
521 # inplace sub:
522 arrays2[0]-=arrays1[0]
523 arrays2[1]-=arrays1[1]
524 arrays2[2]-=arrays1[2]
525 arg2-=arg1
526 checkResult(ex2+t2+"-="+ex1+t1,arg2, \
527 arrays2[0], \
528 arrays2[1], \
529 arrays2[2], \
530 wh)
531
532 # inplace mul:
533 arrays2[0]*=arrays1[0]
534 arrays2[1]*=arrays1[1]
535 arrays2[2]*=arrays1[2]
536 arg2*=arg1
537 checkResult(ex2+t2+"*="+ex1+t1,arg2, \
538 arrays2[0], \
539 arrays2[1], \
540 arrays2[2], \
541 wh)
542 # inplace div:
543 arrays2[0]/=arrays1[0]
544 arrays2[1]/=arrays1[1]
545 arrays2[2]/=arrays1[2]
546 arg2/=arg1
547 checkResult(ex2+t2+"/="+ex1+t1,arg2, \
548 arrays2[0], \
549 arrays2[1], \
550 arrays2[2], \
551 wh)
552
553 # $Log$
554 # Revision 1.1 2004/10/26 06:53:56 jgs
555 # Initial revision
556 #
557 # Revision 1.1 2004/09/21 03:39:42 jgs
558 # copied over DataTest.py script from esysproto
559 #
560 # Revision 1.5 2004/05/21 05:55:59 gross
561 # PDE class added
562 #
563 # Revision 1.4 2003/09/11 08:09:48 gross
564 # slicing for Data class object tested and fixed. DataTest successfully run
565 #

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26