Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /branches/ein16/synth/d2/obj_apply.py
ViewVC logotype

Annotation of /branches/ein16/synth/d2/obj_apply.py

Parent Directory Parent Directory | Revision Log Revision Log


Revision 4484 - (view) (download) (as text)

1 : cchiw 3939 import sys
2 :     import re
3 :     import os
4 :     from obj_ex import *
5 :     from obj_apply import *
6 : cchiw 3915 from obj_ty import *
7 :     from obj_operator import *
8 : cchiw 3939 from obj_field import *
9 :    
10 : cchiw 3915 class apply:
11 : cchiw 3946 def __init__(self, name, opr, lhs, rhs, oty, isrootlhs, isrootrhs):
12 : cchiw 3915 self.name=name
13 :     self.opr=opr
14 : cchiw 3939 self.lhs=lhs
15 :     self.rhs=rhs
16 : cchiw 3915 self.oty=oty
17 : cchiw 3946 self.isrootlhs=isrootlhs
18 :     self.isrootrhs=isrootrhs
19 : cchiw 4210 def oprToStr(self):
20 :     out=self.opr.name
21 :     def g(t):
22 :     if(t):
23 :     return "x"
24 :     else:
25 :     op1 = self.lhs.opr
26 :     return "_"+operator.toStr(op1,"x")
27 :     out+=g(self.isrootlhs)+g(self.isrootrhs)
28 :     return out
29 :    
30 :    
31 :     def get_all_FieldTys(self):
32 :     flds = ""
33 :     lhs = self.lhs
34 :     rhs = self.rhs
35 :     if (lhs!=None):
36 :     if (self.isrootlhs):
37 :     flds+=lhs.fldty.name
38 :     else :
39 :     flds += apply.get_all_FieldTys(lhs)
40 :     if (rhs!=None):
41 :     if (self.isrootrhs):
42 :     flds+= ","+rhs.fldty.name
43 :     else :
44 :     flds += apply.get_all_FieldTys(rhs)
45 :     return flds
46 :    
47 : cchiw 3946 def toStr(self, layer):
48 :     if (self==None):
49 :     return "None"
50 :     s = (str(layer)+": opr:"+self.opr.name+" isrootlhs: "+str(self.isrootlhs)+" isrootrhs: "+str(self.isrootrhs)+" oty: "+str(self.oty.name))
51 : cchiw 3939 lhs = self.lhs
52 :     rhs= self.rhs
53 : cchiw 3946 if(self.isrootlhs):
54 :     if(lhs!=None):
55 :     s+="\n"+str( layer)+"\tlhs:"+ field.toStr(lhs)
56 : cchiw 3939 else:
57 : cchiw 3946 s+= "\nnot a root: look to lhs"
58 :     if (lhs!=None):
59 :     s+="\n"+str( layer)+"lhs:"+apply.toStr(lhs, layer+1)
60 :     else:
61 :     s+="\n"+str( layer)+"lhs:None"
62 :     if (self.isrootrhs):
63 :     if(rhs!=None):
64 :     s+="\n"+str( layer)+"\trhs:"+field.toStr(rhs)
65 :     else:
66 :     s+= "\nnot a root: look to rhs"
67 :     if(rhs!=None):
68 :     s+="\n"+str( layer)+"rhs:"+apply.toStr(rhs, layer+1)
69 :     else:
70 :     s+="\n"+str( layer)+"rhs:None"
71 :     return s
72 : cchiw 3915
73 : cchiw 3939 def checkDim(self):
74 :     if (self.isroot):
75 :     d1=self.lhs.fldty.ty.dim
76 :     d2=self.rhs.fldty.ty.dim
77 :     if (d1==d2):
78 :     return d1
79 :     else :
80 :     raise "dimension is not the same"
81 : cchiw 3915 else :
82 : cchiw 3939 raise "not a root app"
83 :     def get_arity(self):
84 :     return self.opr.arity
85 :     def get_unary(self):
86 :     return self.lhs
87 : cchiw 3915
88 : cchiw 3939 def get_binary(self):
89 :     f=self.lhs
90 :     g=self.rhs
91 :     return (f,g)
92 :    
93 : cchiw 3915 def get_types(self):
94 : cchiw 3946 #if (self.isroot):
95 :     rtn=[]
96 :     if(self.lhs!=None):
97 :     rtn.append(self.lhs.fldty)
98 :     if(self.rhs!=None):
99 :     rtn.append(self.rhs.fldty)
100 :     return rtn
101 :     #else :
102 :     #raise "not a root app"
103 : cchiw 3939
104 :     # single list
105 :     def get_exps(self):
106 : cchiw 3915 rtn=[]
107 : cchiw 3939 if(self.lhs!=None):
108 :     rtn.append(self.lhs)
109 :     if(self.rhs!=None):
110 :     rtn.append(self.rhs)
111 : cchiw 3915 return rtn
112 :    
113 : cchiw 3939 def get_root_types(self):
114 : cchiw 3915 rtn=[]
115 : cchiw 3939 if (self.isroot):
116 :     for i in [self.lhs, self.rhs]:
117 :     rtn.append(i.fldty)
118 :     return rtn
119 :     else :
120 :     for i in [self.lhs, self.rhs]:
121 :     rtn=rtn+(apply.get_root_types(i))
122 :     return rtn
123 :     def get_root_app(self):
124 : cchiw 3946 if (self.isrootlhs):
125 : cchiw 3939 return self
126 :     else :
127 :     if(self.rhs== None):
128 :     return (apply.get_root_app(self.lhs))
129 :     else:
130 :     raise "more expressions in root"
131 : cchiw 3915
132 : cchiw 3946 def get_all_Fields(self):
133 :     flds = []
134 :     lhs = self.lhs
135 :     rhs = self.rhs
136 :     if (lhs!=None):
137 :     if (self.isrootlhs):
138 :     flds.append(lhs)
139 :     else :
140 :     flds = flds + apply.get_all_Fields(lhs)
141 :     if (rhs!=None):
142 :     if (self.isrootrhs):
143 :     flds.append(rhs)
144 :     else :
145 :     flds = flds + apply.get_all_Fields(rhs)
146 :     return flds
147 :    
148 : cchiw 3939 def get_oty(self):
149 :     return self.oty
150 : cchiw 3915 #------------------------------ helpers -----------------------------------------------------
151 : cchiw 3939 #field dimension is the same as vector length
152 :     def checkNd(ityp1):
153 :     if(fty.is_Vector(ityp1)):
154 :     n1 = fty.get_vecLength(ityp1)
155 :     dim1 = fty.get_dim(ityp1)
156 :     return (n1==dim1)
157 :     else:
158 :     return (false,"needs vector")
159 : cchiw 3915
160 : cchiw 4158 def isDifferentiable(ityp):
161 : cchiw 4230 #print "isDifferentiabl-ityp",ityp
162 : cchiw 4158 dim = fty.get_dim(ityp)
163 :     k=ityp.k
164 : cchiw 4230 return (k>0)
165 : cchiw 4158
166 : cchiw 3915 #type of field after operation is applied
167 : cchiw 4308 # note need to generalize for field and tensor operators
168 :     # note need to check if field for correct
169 : cchiw 3915 def applyUnaryOp(op1,ityps):
170 :     ityp1=ityps[0]
171 : cchiw 4411 #print "itype1", ityp1.name
172 : cchiw 4252 k = ityp1.k
173 :     dim = ityp1.dim
174 :     ashape = ityp1.shape
175 :     name = "op1 "+op1.name+"("+ityp1.name+")"
176 : cchiw 4411 #print "apply unary op", name, ashape
177 : cchiw 4252 def same():
178 :     return (true, ityp1)
179 :     def err():
180 :     return (false, name)
181 :     def mkTyp(shape):
182 : cchiw 4411 #print "mark-a"
183 : cchiw 4261 (tf, rty1) = shapeToTyhelper(shape, dim)
184 :     if(tf):
185 : cchiw 4411 #print "mark-b"
186 : cchiw 4261 rtn1 = fty.convertTy(rty1, k)
187 :     return (true, rtn1)
188 :     else:
189 : cchiw 4252 return err()
190 : cchiw 4261
191 : cchiw 4252 def mkTyp_deductk(shape):
192 :     if(k<1 and len(shape)>3):
193 :     return err()
194 : cchiw 4250 else:
195 : cchiw 4261 (tf, rty1) = shapeToTyhelper(shape, dim)
196 :     if(tf):
197 :     rtn1 = fty.convertTy(rty1, k-1)
198 :     return (true, rtn1)
199 :     else:
200 :     return err()
201 : cchiw 4338 if ((op_copy==op1) or (op_negation==op1)):
202 : cchiw 4252 return same() #type unaffected by operation
203 : cchiw 4321 if (op_normalize==op1):
204 : cchiw 4325 if(fty.is_Scalar(ityp1)):
205 : cchiw 4321 return err()
206 :     else:
207 :     return same() #type unaffected by operation
208 : cchiw 3998 elif(op_norm==op1): # apply op_norm
209 : cchiw 4411
210 : cchiw 4252 return mkTyp([])
211 : cchiw 4308 elif (op_negationT==op1):
212 :     return same() #type unaffected by operation
213 : cchiw 4411 elif(op_jacob==op1): # apply op_jacob
214 :     if(not fty.is_Field(ityp1)):
215 :     return err()
216 :     if(fty.is_Vector(ityp1)):
217 :     [n1] = ashape
218 :     if(n1==2 and dim==2):
219 :     return mkTyp_deductk([2,2])
220 :     elif(n1==3 and dim==3):
221 :     return mkTyp_deductk([3,3])
222 :     else:
223 :     return err()
224 :     elif(fty.is_Matrix(ityp1)):
225 :     [n1,n2] = ashape
226 :     if(n1==n2 and n2==dim):
227 :     if(dim==2):
228 :     return mkTyp_deductk([2,2,2])
229 :     elif(dim==3):
230 :     return mkTyp_deductk([3,3,3])
231 :     else:
232 :     return err()
233 :     else:
234 :     return err()
235 :     else:
236 :     return err()
237 : cchiw 4252 elif(fty.is_Scalar(ityp1)):
238 :     if(op_sqrt==op1):
239 :     return same()
240 : cchiw 4341 elif(op_cosine==op1) or (op_sine==op1)or (op_tangent==op1) or (op_acosine==op1) or (op_asine==op1)or (op_atangent==op1):
241 :     if(fty.is_Field(ityp1)):
242 :     return same()
243 :     else:
244 :     return err()
245 : cchiw 4252 elif (op_gradient==op1):
246 : cchiw 4341 if(not fty.is_Field(ityp1)):
247 :     return err()
248 : cchiw 4252 if (dim==1):
249 :     return mkTyp_deductk([])
250 : cchiw 4158 else:
251 : cchiw 4252 return mkTyp_deductk([dim])
252 : cchiw 4243 else:
253 : cchiw 4252 return err()
254 :     elif(fty.is_Vector(ityp1)):
255 :    
256 :     [n1] = ashape
257 :     if((op_slicev0==op1) or(op_slicev1 ==op1)): # apply op_slice
258 :     return mkTyp([])
259 :     elif(not (n1==dim)):
260 :     # since the rest are differentiation operators
261 :     return err()
262 :     elif(op_curl==op1): # apply curl
263 : cchiw 4341 if(not fty.is_Field(ityp1)):
264 :     return err()
265 : cchiw 4252 if((n1==2) and (dim==2)):
266 :     return mkTyp_deductk([])
267 :     elif((n1==3) and (dim==3)):
268 :     return mkTyp_deductk([3])
269 :     else:
270 :     return err()
271 : cchiw 4411 #elif(op_jacob==op1): # apply op_jacob
272 :     # if(not fty.is_Field(ityp1)):
273 :     # return err()
274 :     #if(n1==2 and dim==2):
275 :     # return mkTyp_deductk([2,2])
276 :     # elif(n1==3 and dim==3):
277 :     # return mkTyp_deductk([3,3])
278 :     # else:
279 :     # return err()
280 : cchiw 4252 elif(op_divergence==op1):
281 : cchiw 4341 if(not fty.is_Field(ityp1)):
282 :     return err()
283 : cchiw 4252 return mkTyp_deductk([])
284 : cchiw 4243 else:
285 : cchiw 4252 return err()
286 :     elif(fty.is_Matrix(ityp1)):
287 :     [n, m] = ashape
288 :     if(op_slicem1 ==op1): # apply op_slice [:,0]
289 : cchiw 4284 return mkTyp([n])
290 : cchiw 4252 elif(op_slicem0==op1): # apply op_slice [1,:]
291 : cchiw 4284 return mkTyp([m])
292 : cchiw 4252 elif(n!=m):
293 :     return err()
294 :     elif(op_transpose==op1): # apply op_tranpose
295 :     return mkTyp([m, n])
296 :     elif((op_trace==op1) or (op_det==op1)):
297 : cchiw 4411 if(n==m and (n==2 or n==3)):
298 : cchiw 4252 return mkTyp([])
299 : cchiw 3998 else:
300 : cchiw 4252 return err()
301 : cchiw 4411 elif(op_inverse==op1): # apply op_inverse_d2
302 :     return same()
303 : cchiw 3998 else:
304 : cchiw 4252 return err()
305 :     elif(fty.is_Ten3(ityp1)):
306 :     if(op_slicet0==op1): # apply op_slice [:,1,:]
307 :     [a, _, c] = ashape
308 :     return mkTyp([a,c])
309 :     elif(op_slicet1 ==op1): # apply op_slice [1,0,:]
310 :     [_,_,c] = ashape
311 :     return mkTyp([c])
312 : cchiw 3998 else:
313 : cchiw 4252 return err()
314 : cchiw 3915 else:
315 : cchiw 4252 return err()
316 : cchiw 3915
317 :     #type of field after operation is applied
318 :     def applyBinaryOp(op1,ityps):
319 : cchiw 4257 name = "op1 "+op1.name
320 : cchiw 4459 ityp1 = ityps[0]
321 :     ityp2 = ityps[1]
322 : cchiw 4334
323 : cchiw 4252 ashape = fty.get_shape(ityp1)
324 :     bshape = fty.get_shape(ityp2)
325 : cchiw 4257 name += "("+ityp1.name+","+ityp2.name+")"
326 : cchiw 4459
327 : cchiw 3998 (tf, fldty) = find_field(ityp1,ityp2) # assures same dimension for both fields
328 : cchiw 3946 if(not tf):
329 :     return (false, "not the same dimension")
330 : cchiw 3939 k = fldty.k
331 :     dim = fldty.dim
332 : cchiw 4252 def err():
333 : cchiw 4261 # type not supported
334 : cchiw 4252 return (false, name)
335 :     def mkTyp(shape):
336 :     if (len(shape)>3):
337 :     return err()
338 :     else:
339 : cchiw 4261 (tf, rty1) = shapeToTyhelper(shape, dim)
340 :     if(tf):
341 :     rtn1 = fty.convertTy(rty1, k)
342 :     return (true, rtn1)
343 :     else:
344 :     return err()
345 : cchiw 4334 if (fty.is_Field(ityp1) and fty.is_Field(ityp2) and (not (ityp1.k==ityp2.k))):
346 :     return err()
347 : cchiw 4261 def sameshape(ty3):
348 : cchiw 3998 if(ashape==bshape):
349 : cchiw 4261 return (true, ty3) #type unaffected by operation
350 : cchiw 3946 else:
351 : cchiw 4252 return err()
352 :     if (op_add==op1) or (op_subtract==op1):
353 : cchiw 4261 return sameshape(fldty)
354 : cchiw 3998 elif(op_division==op1):
355 :     if(fty.is_Scalar(ityp2)):
356 : cchiw 4252 return mkTyp(ashape)
357 : cchiw 3998 else:
358 : cchiw 4252 return err()
359 : cchiw 3939 elif(op_cross==op1):
360 :     if(fty.is_Vector(ityp1) and fty.is_Vector(ityp2)):
361 :     n1 = fty.get_vecLength(ityp1)
362 :     n2 = fty.get_vecLength(ityp2)
363 : cchiw 4308 if(not (n1==n2)):
364 :     return err()
365 : cchiw 4481 # if(fty.is_Field(fldty)):
366 :     #if ((dim==2) and (n1==2)):
367 :     #return mkTyp([])
368 :     #elif((dim==3) and (n1==3)):
369 :     #return mkTyp([3])
370 :     # else:
371 :     #return err()
372 :     #else:
373 : cchiw 4484 if(n1==2 and dim==2):
374 : cchiw 4481 return mkTyp([])
375 : cchiw 4484 elif(n1==3 and dim==3):
376 : cchiw 4481 return mkTyp([3])
377 : cchiw 3939 else:
378 : cchiw 4481 return err()
379 : cchiw 4308 else:
380 :     return err()
381 : cchiw 4252 else:
382 :     # rest of operators are non scalar
383 : cchiw 4243 if(fty.is_Scalar(ityp1) or fty.is_Scalar(ityp2)):
384 : cchiw 4252 if(op_scale==op1):
385 :     return mkTyp(ashape+bshape)
386 :     else:
387 :     return err()
388 : cchiw 4247 else:
389 : cchiw 4252 if((op_modulate==op1)):
390 : cchiw 4321 n = len(ashape)
391 : cchiw 4325 return sameshape(fldty)
392 : cchiw 4252 elif(op_outer==op1):
393 :     return mkTyp(ashape+bshape)
394 :     elif(op_doubledot==op1):
395 : cchiw 4321 n = len(ashape)
396 :     if(n==2):
397 : cchiw 4261 if(ashape==bshape):
398 : cchiw 4411 #print "same shape"
399 : cchiw 4261 return mkTyp([])
400 :     else:
401 : cchiw 4411 #print "not the same shape"
402 : cchiw 4261 return err()
403 : cchiw 4252 else:
404 :     return err()
405 :     elif(op_inner==op1):
406 :     n1 = fty.get_last_ix(ityp1)
407 :     n2 = fty.get_first_ix(ityp2)
408 :     if(n1!=n2): #must have equal vector lengths
409 :     return err()
410 :     shape1 = fty.drop_first(ityp1)
411 :     shape2 = fty.drop_last(ityp2)
412 :     return mkTyp(shape1+shape2)
413 : cchiw 4247 else:
414 : cchiw 4252 return err()
415 : cchiw 3915
416 : cchiw 3939
417 : cchiw 4252 ##################################################################################################
418 : cchiw 4257 # apply unary and binary operator
419 : cchiw 4252 def get_tshape(opr1, ishape):
420 : cchiw 4411 #print "getting tshape of", opr1.name,"arg0=", ishape[0].name
421 : cchiw 4252 arity=opr1.arity
422 :     if(arity==1):
423 :     return applyUnaryOp(opr1,ishape)
424 :     elif(arity==2):
425 :     return applyBinaryOp(opr1, ishape)
426 :    
427 :    
428 : cchiw 3939 # create apply, operator and field objects
429 :     # from an example opr number, type number, and input file
430 :     #Apply to two field expressions
431 : cchiw 4459 def mkApply_fld(name, opr, ishape, inputfile, otype1, i_coeff_style, i_ucoeff, g_krn):
432 :     # arity
433 :     arity = opr.arity
434 : cchiw 4252 def set_App(lhs, rhs):
435 : cchiw 4459 return apply(name, opr, lhs, rhs, otype1, true, true)
436 :     def set_fld(id):
437 :     c_ity = ishape[id]
438 :     c_dim = fty.get_dim(c_ity)
439 :     # get kernel
440 :     c_krn = transform_krn(g_krn, id)
441 :     c_continuity = c_krn.continuity
442 :     return mk_Field(id, c_ity, c_continuity, inputfile, c_dim, i_coeff_style, i_ucoeff, c_krn)
443 :     # first argument
444 :     index1 = 0
445 :     (F1, finfo1, coeff1) = set_fld(index1)
446 : cchiw 3939 if (arity==1): # unary operator
447 : cchiw 4459 z = set_App(F1, None)
448 :     return (z, [coeff1])
449 : cchiw 3939 elif (arity==2): # binary operator
450 : cchiw 4459 index2 = 1 # second argument
451 :     (F2, finfo2, coeff2) = set_fld(index2)
452 :     z = set_App(F1, F2)
453 :     return (z, [coeff1, coeff2])
454 : cchiw 3939 else:
455 :     raise Exception ("arity is not supported: "+str(arity))
456 :    
457 : cchiw 4459
458 :     # otype1 = tshape1
459 :     def mkApply_twice(name,opr_inner,opr_outer, ishape, inputfile, otype1, tshape2, coeff_style, ucoeff, g_krn):
460 : cchiw 4250 outer_arity = opr_outer.arity
461 : cchiw 4252 inner_arity = opr_inner.arity
462 :     def set_innerApp(shape):
463 : cchiw 4459 return mkApply_fld(name, opr_inner, shape, inputfile, otype1, coeff_style, ucoeff, g_krn)
464 : cchiw 4252 def set_outerApp(lhs, rhs, shape):
465 :     return apply(name, opr_outer,lhs, rhs, tshape2, false, true)
466 :     def set_field(id):
467 : cchiw 4459 # get kernel
468 :     c_krn = transform_krn(g_krn, id)
469 :     c_k = c_krn.continuity
470 :     c_fty = ishape[id]
471 :     c_dim = fty.get_dim( c_fty)
472 :     return mk_Field(id, c_fty, c_k, inputfile, c_dim, coeff_style, ucoeff, c_krn)
473 : cchiw 4250 if (outer_arity==1): # both are unary operators
474 : cchiw 4411 #print "outer arity=1"
475 : cchiw 4459 (z1, coeffs) = set_innerApp(ishape)
476 : cchiw 4252 z2 = set_outerApp(z1, None, [otype1])
477 : cchiw 4340 return (z2, coeffs)
478 : cchiw 4250 if (outer_arity==2 and inner_arity==1): # one is a unary operator
479 : cchiw 4252 # apply inner operator to first arg
480 : cchiw 4250 ishape1 = [ishape[0]]
481 : cchiw 4459 (z1, coeffs) = set_innerApp(ishape1)
482 : cchiw 4252 # create second field
483 : cchiw 4250 id2 = 1
484 : cchiw 4252 (F2, finfo2, coeff2) = set_field(id2)
485 :     # apply outer operator to otype and second arg
486 :     ishape3 = [otype1, ishape[1]]
487 :     z2 = set_outerApp(z1, F2, ishape3)
488 : cchiw 4459 coeffs = coeffs+[coeff2]
489 : cchiw 4341 return (z2, coeffs)
490 : cchiw 4250 elif (outer_arity==2 and inner_arity==2): # binary operator
491 : cchiw 4252 # apply inner operator to first arg
492 : cchiw 4459 (z1, coeff1) = set_innerApp(ishape)
493 : cchiw 4252 # create third field
494 :     id2 = 2
495 :     (F2, finfo2, coeff2) = set_field(id2)
496 :     ishape3 =[otype1, finfo2]
497 :     z2 = set_outerApp(z1, F2, ishape3)
498 : cchiw 3946 coeffs = coeff1+[coeff2]
499 : cchiw 4340 return (z2, coeffs)
500 : cchiw 3939 else:
501 : cchiw 4250 raise Exception ("arity is not supported: "+str(outer_arity))

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0