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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : cchiw 4484
2 : cchiw 4481 import re
3 :     import os
4 : cchiw 4483 import time
5 : cchiw 4481
6 : cchiw 4484
7 : cchiw 4481 from obj_field import *
8 :     from obj_counter import *
9 :     from obj_frame import *
10 :    
11 :     from core import *
12 :     from write import *
13 :     from var_ty import *
14 :     from frame import *
15 :     from shape import *
16 : cchiw 4484 from shape_backwards import *
17 : cchiw 4481
18 :     ##################################################################################################
19 :     # print types on list
20 :     def pes(pre, es):
21 :     n = len(es)
22 :     l = pre+" length: "+str(n)+" : "
23 :     for i in es:
24 : cchiw 4483 if(i==None):
25 :     l+=" None,"
26 :     else:
27 :     l+=(i.name)+","
28 :     #print l
29 : cchiw 4481
30 :    
31 :    
32 :     ##################################################################################################
33 :     ##################################################################################################
34 :     # shape1 : shapes (ty_vecT, ty_matT) not a type
35 :     # ty1 : types with specific shapes (ty_vecFT, ty_vecF_d1..)
36 :     # exp1: specific types on ty1s list ^
37 :    
38 : cchiw 4483 def core_ops(exps, dim, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt):
39 : cchiw 4481 # can apply (shape1*shape2)* shape3 ->tshape2
40 :     # assuming shape_to_fty() is ordered by dimension
41 :     counter.inc_total(cnt)
42 :     convert_fields(exps, testing_frame)
43 :     create_embed_app_passed(exps, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt)
44 :     return
45 :    
46 :    
47 :    
48 : cchiw 4483 # inner operation is binary
49 :     # outer operation is unary
50 :     def core_binary_unary(exp1, exp2, dim, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt):
51 :     #print "\n--------------------------- core_binary_unary ---------------------------"
52 :     exps = [exp1, exp2]
53 :     core_ops(exps, dim, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt)
54 : cchiw 4481 return
55 :    
56 : cchiw 4483
57 : cchiw 4481 ##################################################################################################
58 :     ##################################################################################################
59 :    
60 :     # all of the type choosing split into multiple function
61 :     # iterate over third type
62 : cchiw 4483 def pick_ty_to_exp3(exps, dim, ty3s, tshape1, tshape2_shape, opr_inner, opr_outer, title, testing_frame, cnt):
63 : cchiw 4481 # terating over tyes that are possible
64 : cchiw 4483 #print "\n---------------------------pick_third_type ---------------------------"
65 : cchiw 4481 # can apply (shape1*shape2)* shape3 ->tshape2
66 :     # assuming shape_to_fty() is ordered by dimension
67 :     [t3, f3d1, f3d2, f3d3] = ty3s
68 :     # now get exp3
69 :     def instance(exp3, dim):
70 :     if(exp3 == None):
71 :     return
72 :     else:
73 : cchiw 4483 t = exps+[exp3]
74 :     #print "tshape1:", tshape1, "tshape2_shape:",tshape2_shape
75 : cchiw 4484 tshape2 = check2_tshape(opr_outer, tshape1, exp3, tshape2_shape, dim)
76 : cchiw 4483 if(not(tshape2 == None)):
77 :     # both operations are binary so there are three expressions
78 :     core_ops(t, dim, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt)
79 :     return
80 : cchiw 4481 if(dim==0):
81 :     # tensors for exp1,exp2
82 :     for exp3 in ty3s:
83 :     instance(exp3, dim)
84 :     dim+=1
85 :     else:
86 :     # choose a field as first|second argument so the rest of the choices must have same dimension
87 :     exp3s = [t3, ty3s[dim]]
88 :     for exp3 in exp3s:
89 :     instance(exp3, dim)
90 :     return
91 :    
92 : cchiw 4483
93 :     #opr_inner arity == 2, opr_outer.arity == _
94 : cchiw 4481 def pick_ty_to_exp2(exp1, dim, ty2s, ty3s, tshape1_shape, tshape2_shape, opr_inner, opr_outer, title, testing_frame, cnt):
95 :     # terating over tyes that are possible
96 :     #writeCumulative(cnt)
97 : cchiw 4483 #print "\n---------------------------pick_second_type ---------------------------"
98 : cchiw 4481 #m = title + "Types: ("+exp1.name+", _)"
99 :     #writenow(m)
100 :     title = ""
101 :    
102 :     # can apply (shape1*shape2)* shape3 ->tshape2
103 :     # assuming shape_to_fty() is ordered by dimension
104 :     [t2, f2d1, f2d2, f2d3] = ty2s
105 :    
106 :     # run single instance
107 :     def instance(exp2, dim):
108 :     if(exp2 == None):
109 :     return
110 :     else:
111 :     # current dim: dimension should be based on exp1*exp2
112 : cchiw 4483 #print " mark: convert_rst_binary"
113 : cchiw 4484 tshape1 = check2_tshape(opr_inner, exp1, exp2, tshape1_shape, dim)
114 : cchiw 4483 if(not (tshape1==None)):
115 :     # then we iterate over tys3s
116 :     if (opr_outer.arity == 2):
117 :     # opr_outer.arity == 2, opr_inner arity == 2
118 :    
119 :     # so then we do iterate over tys3s
120 :     exps = [exp1, exp2]
121 :     pick_ty_to_exp3(exps, dim, ty3s, tshape1, tshape2_shape, opr_inner, opr_outer, title, testing_frame, cnt)
122 : cchiw 4481 else:
123 : cchiw 4483 # opr_outer.arity == 1,opr_inner arity == 2
124 :    
125 : cchiw 4481 # third type not needed
126 :     ## need to check actual expression
127 : cchiw 4484 #print " mark: check1_tshape"
128 : cchiw 4483 #print "pre",tshape1,"op1",opr_outer.name
129 : cchiw 4481 # converts shape to type (tshape2_shape)
130 :     # check to see if it is expression (tshape1) is a differentiable field (if needed)
131 : cchiw 4484 tshape2 = check1_tshape(opr_outer, tshape1, tshape2_shape, dim)
132 : cchiw 4483 if(not(tshape2 == None)):
133 :     #print "can not be differentiated"
134 : cchiw 4481 # go straigh to core
135 : cchiw 4483 #print "dim", dim, "post",tshape1.name
136 : cchiw 4481 core_binary_unary(exp1, exp2, dim, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt)
137 :    
138 :     # run multiple instance
139 :     def iter(exp2s, dim):
140 :     # [tensor, field,_]
141 :     for exp2 in exp2s:
142 :     instance(exp2, dim)
143 :     # choose t1 as first argument
144 :     if(dim==0):
145 :     # [tensor,_, _]
146 :     # [tensor, tensor,_]
147 :     exp2 = t2
148 :     instance(exp2, dim)
149 :     # [tensor, field,_]
150 :     # create second field type
151 :     for d in range(3):
152 :     d+=1
153 :     exp2 = ty2s[d]
154 :     instance(exp2, d)
155 :     else:
156 :     #[field, _,_]
157 :     exp2s = [t2, ty2s[dim]]
158 :     iter(exp2s, dim)
159 :    
160 : cchiw 4483
161 :     ##################################################################################################
162 : cchiw 4481 # iterate over third type
163 : cchiw 4483 def backwards_ty_to_exp2(exp1, dim, ty2s, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt):
164 :     # terating over tyes that are possible
165 :     #writeCumulative(cnt)
166 :     #print "\n---------------------------pick_second_type ---------------------------"
167 :     #m = title + "Types: ("+exp1.name+", _)"
168 :     #writenow("Types: ("+exp1.name+", _)")
169 :     title = ""
170 :     # can apply (shape1*shape2)* shape3 ->tshape2
171 :     # assuming shape_to_fty() is ordered by dimension
172 :     [t2, f2d1, f2d2, f2d3] = ty2s
173 :     #print "t2:",t2, "f2d1",f2d1
174 :     # run single instance
175 :     def instance(exp2, dim):
176 :     if(exp2 == None):
177 :     return
178 :     else:
179 :     #print "\n\t exp2"+exp2.name
180 :     core_binary_unary(exp1, exp2, dim, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt)
181 :     return
182 :    
183 :     # run multiple instance
184 :     def iter(exp2s, dim):
185 :     # [tensor, field,_]
186 :     for exp2 in exp2s:
187 :     #print "\n\t exp2-attempt"
188 :     instance(exp2, dim)
189 :     # choose t1 as first argument
190 :     if(dim==0):
191 :     #print "dim=0"
192 :     # [tensor,_, _]
193 :     # [tensor, tensor,_]
194 :     exp2 = t2
195 :     instance(exp2, dim)
196 :     # [tensor, field,_]
197 :     # create second field type
198 :     for d in range(3):
199 :     d+=1
200 :     exp2 = ty2s[d]
201 :     instance(exp2, d)
202 :     else:
203 :     #[field, _,_]
204 :     #print "dimmorethan 0"
205 :     exp2s = [t2, ty2s[dim]]
206 :     iter(exp2s, dim)
207 :    
208 :     def backwards_ty_to_exp1(ty1s, dim, exp2, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt):
209 :     # terating over tyes that are possible
210 :     #writeCumulative(cnt)
211 :     #print "\n---------------------------pick_second_type ---------------------------"
212 :     #m = title + "Types: ("+exp1.name+", _)"
213 :     #writenow(m)
214 :     title = ""
215 :     # can apply (shape1*shape2)* shape3 ->tshape2
216 :     # assuming shape_to_fty() is ordered by dimension
217 :     [t2, f2d1, f2d2, f2d3] = ty1s
218 :    
219 :     # run single instance
220 :     def instance(exp1, dim):
221 :     if(exp1 == None):
222 :     return
223 :     else:
224 :     core_binary_unary(exp1, exp2, dim, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt)
225 :     return
226 :    
227 :     # run multiple instance
228 :     def iter(exp1s, dim):
229 :     # [tensor, field,_]
230 :     for exp1 in exp1s:
231 :     instance(exp1, dim)
232 :     # choose t1 as first argument
233 :     if(dim==0):
234 :     # [tensor,_, _]
235 :     # [tensor, tensor,_]
236 :     exp1 = t2
237 :     instance(exp1, dim)
238 :     # [tensor, field,_]
239 :     # create second field type
240 :     for d in range(3):
241 :     d+=1
242 :     exp2 = ty1s[d]
243 :     instance(exp1, d)
244 :     else:
245 :     #[field, _,_]
246 :     exp1s = [t2, ty1s[dim]]
247 :     iter(exp1s, dim)
248 :    
249 :    
250 :    
251 :     ##################################################################################################
252 :     # iterate over third type
253 : cchiw 4481 def pick_ty_to_exp1(ty1s, ty2s, ty3s, tshape1_shape, tshape2_shape, opr_inner, opr_outer, title, testing_frame, cnt):
254 :     # terating over tyes that are possible
255 :     #writeCumulative(cnt)
256 : cchiw 4483 #print "\n---------------------------pick_first_type ---------------------------"
257 : cchiw 4481 # can apply (shape1*shape2)* shape3 ->tshape2
258 :     # assuming shape_to_fty() is ordered by dimension
259 :     dim = 0
260 :     for exp1 in ty1s:
261 :     #[t1, f1d1, f1d2, f1d3] = ty1s
262 : cchiw 4483 if(not(exp1 == None)):
263 : cchiw 4481 # expressions must be created
264 :     pick_ty_to_exp2(exp1, dim, ty2s, ty3s, tshape1_shape, tshape2_shape, opr_inner, opr_outer, title, testing_frame, cnt)
265 :     dim+=1
266 :     ##################################################################################################
267 :     ##################################################################################################
268 :     # shape1 : shapes (ty_vecT)
269 :     # ty1 : types with specific shapes (ty_vecFT, ty_vecF_d1..)
270 :     # exp1: specific types on ty1s list ^
271 :    
272 :     # apply second operation
273 :     def pick_get_ty3s(ty1s, ty2s, rtn3s, tshape1_shape, opr_inner, opr_outer, title, testing_frame, cnt):
274 :     # can apply (shape1*shape2)* shape3 ->tshape2
275 :     titlec ="\n\t"
276 :     for (shape3, tshape2_shape) in rtn3s:
277 :     #print "-------------"
278 :     tmp = ""
279 :     tmp = title+ " * "+shape3.name+")"
280 : cchiw 4483 #writenow("\n\t---Shape3:("+tmp)
281 : cchiw 4481 #writenow("\n shape3: "+shape3.name+" tshape2_shape: "+tshape2_shape.name)
282 :     # convert shape to type
283 :     ty3s = shape_to_fty(shape3)
284 :     #pes("ty3s", ty3s)
285 :     #make sure non-tmpty third types
286 :     if (len(ty3s)>3):
287 :     pick_ty_to_exp1(ty1s, ty2s, ty3s, tshape1_shape, tshape2_shape, opr_inner, opr_outer, titlec, testing_frame, cnt)
288 :     else:
289 :     # no shapes make this combination of operations possible
290 :     continue
291 :    
292 :    
293 :    
294 :     # main function
295 :     def pick_get_ty2s(ty1s, rtn2s, opr_inner, opr_outer, title, testing_frame, cnt):
296 : cchiw 4483 # print " --------------second time---------------"
297 :     # print "opr_inner:", opr_inner.name, "opr_outer:", opr_outer.name
298 : cchiw 4481 titlec ="\n\t"
299 : cchiw 4484 n = len(op_all)
300 :     k_init = 2
301 : cchiw 4481 for (shape2, tshape1_shape) in rtn2s:
302 :     #print "------------------------------"
303 :     # convert shape to type
304 : cchiw 4484 ty2s = shape_to_fty(shape2, k_init)
305 : cchiw 4481 # pes("ty2s", ty2s)
306 :     tmp = title+ " * "+shape2.name+")"
307 : cchiw 4483 #writenow("\n\t--Shape2:("+tmp)
308 : cchiw 4481 # Do we need a third type?
309 : cchiw 4484 def sort(opr_outer):
310 :     if (opr_outer.arity == 2):
311 :     # yes if outer operation is binary
312 :     rtn3s = op2_to_shape(opr_outer, tshape1_shape)
313 :     if (len(rtn3s)>0):
314 :     pick_get_ty3s(ty1s, ty2s, rtn3s, tshape1_shape, opr_inner, opr_outer, tmp, testing_frame, cnt)
315 : cchiw 4481 else:
316 : cchiw 4484 # outer operation is a unary
317 :     tshape2_shape = op1_to_shape(opr_outer, tshape1_shape)
318 :     if(not (tshape2_shape == None)):
319 :     ty3s = None
320 :     pick_ty_to_exp1(ty1s, ty2s, ty3s, tshape1_shape, tshape2_shape, opr_inner, opr_outer, titlec, testing_frame, cnt)
321 :    
322 :    
323 :     if(opr_outer==None):
324 :     for t_outer in range(n):
325 :     startyy = time.time()
326 :     opr_outer = id_toOpr(t_outer)
327 :     counter.zero_locals(cnt)
328 :     counter.zero_total(cnt)
329 :     writeTitle_outer(opr_inner, opr_outer)
330 :     sort(opr_outer)
331 :     endyy = time.time()
332 :     tty = " time-outer:"+str(endyy - startyy)
333 :     writeall(tty)
334 :     print (tty)
335 : cchiw 4481 else:
336 : cchiw 4484 sort(opr_outer)
337 : cchiw 4481 return
338 :    
339 : cchiw 4483 #(opr_outer.arity == 1 and opr_inner.arity == 1)
340 : cchiw 4484 def iter_inner_unary(ty1s, shape1, opr_inner, opr_outer, title, testing_frame, cnt):
341 :     def iter_unary_unary(opr_outer):
342 :     tshape1_shape = op1_to_shape(opr_inner, shape1)
343 :     print "------------------------------------------------------"
344 :     print "opr_outer.arity == 1 and opr_inner.arity == 1"
345 :     print "inner", opr_inner.name, "outer", opr_outer.name
346 :     print "\n apply inner operator", opr_inner.name, "on shape:", shape1.name, tshape1_shape
347 :     for exp1 in ty1s:
348 :     if(not (exp1==None)):
349 :     print "------------------- ----"
350 :     print "exp1:", exp1.name
351 :     tshape1 = check1_tshape(opr_inner, exp1, tshape1_shape, exp1.dim)
352 :    
353 :     if(not (tshape1 == None)):
354 :     print "tshape1: ", tshape1.name
355 :     dim = tshape1.dim
356 :     tshape1_shape = tshape1.tensorType
357 :     print "\n apply outer operator", opr_outer.name, "on shape:", tshape1_shape.name
358 :     tshape2_shape = op1_to_shape(opr_outer, tshape1_shape)
359 :     if(not (tshape2_shape == None)):
360 :     print "\n checking outer op->"+tshape2_shape.name
361 :     tshape2 = check1_tshape(opr_outer, tshape1, tshape2_shape, dim)
362 :     print "\n checking outer op tshape1:", tshape1.name,"tshape2-shape:",tshape2_shape.name, "dim",dim, "tshape2:", tshape2
363 : cchiw 4483 if(not (tshape2 == None)):
364 : cchiw 4484 print "tshape2: ", tshape2.name
365 : cchiw 4483 exps = [exp1]
366 :     core_ops(exps, dim, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt)
367 :    
368 : cchiw 4484 #(opr_outer.arity == 2 and opr_inner.arity == 1)
369 :     def iter_binary_unary(opr_outer):
370 :     #(opr_outer.arity == 2 and opr_inner.arity == 1)
371 :     # print "binary_unary opr_inner.arity == 1 and pr_outer.arity == 2 "
372 :     # apply unary
373 :     #pes("ty1s",ty1s)
374 :     #print " shape1: ", shape1.name
375 :     tshape1_shape = op1_to_shape(opr_inner, shape1)
376 :     #print "tshape1_shap:",tshape1_shape.name
377 :     k_init = 2
378 :     if(not (tshape1_shape == None)):
379 :     #apply binary
380 :     rtn3s = op2_to_shape(opr_outer, tshape1_shape)
381 :     #print "rtn3s:",len(rtn3s)
382 :     for (shape3, tshape2_shape) in rtn3s:
383 :     # convert shape to type
384 :     ty3s = shape_to_fty(shape3, k_init)
385 :     #pes("ty3s",ty3s)
386 :     # single argument
387 :     if ((len(ty3s)>0) and (len(ty1s)>0)):
388 :     for exp1 in ty1s:
389 :     if(not (exp1==None)):
390 :     dim = exp1.dim
391 :     exps = [exp1]
392 :     tshape1 = check1_tshape(opr_inner, exp1, tshape1_shape, dim)
393 :     if(not (tshape1 == None)):
394 :     pick_ty_to_exp3(exps, dim, ty3s, tshape1, tshape2_shape, opr_inner, opr_outer, title, testing_frame, cnt)
395 :     def sort(opr_outer):
396 :     if(opr_inner.arity == 1 and opr_outer.arity == 1): # arity is 1
397 :     iter_unary_unary(opr_outer)
398 :     elif(opr_outer.arity == 2 and opr_inner.arity == 1):
399 :     iter_binary_unary(opr_outer)
400 :     # need to iterate over outer operator
401 :     if(opr_outer==None):
402 :     n = len(op_all)
403 :     for t_outer in range(n):
404 :     startouter = time.time()
405 :     opr_outer = id_toOpr(t_outer)
406 :     counter.zero_locals(cnt)
407 :     counter.zero_total(cnt)
408 :     writeTitle_outer(opr_inner, opr_outer)
409 :     sort(opr_outer)
410 :     endouter = time.time()
411 :     ttouter = " time-outer:"+str(endouter - startouter)
412 :     writeall(ttouter)
413 :     print (ttouter)
414 :     else:
415 :     sort(opr_outer)
416 : cchiw 4483
417 : cchiw 4481 # main function
418 : cchiw 4484 def pick_get_ty1s(ty1s, shape1, opr_inner, opr_outer, testing_frame, cnt):
419 : cchiw 4481 # apply operation a first time
420 : cchiw 4483 #print " --------------first time---------------"
421 :     #print "\t\topr_inner:", opr_inner.name, opr_inner.arity,"\n\topr_outer:", opr_outer.name,opr_outer.arity
422 : cchiw 4481 title = "("+shape1.name
423 : cchiw 4483 #writenow("\n-Shape1:"+title+" * _)")
424 : cchiw 4484
425 : cchiw 4481 #pes("ty1s",ty1s)
426 : cchiw 4483 #print "attempt:"+opr_inner.name+"shape1", shape1.name
427 : cchiw 4484 if(opr_inner.arity == 1): # arity is 1
428 :     iter_inner_unary(ty1s, shape1, opr_inner, opr_outer, title, testing_frame, cnt)
429 : cchiw 4481 else:
430 : cchiw 4483 rtn2s = op2_to_shape(opr_inner, shape1)
431 :     if (len(rtn2s)>0):
432 :     pick_get_ty2s(ty1s, rtn2s, opr_inner, opr_outer, title, testing_frame, cnt)
433 :     else:
434 :     return
435 : cchiw 4481 return
436 : cchiw 4483 ##################################################################################################
437 : cchiw 4481
438 : cchiw 4483 # go backwards
439 :     def go_backwards(opr_outer, opr_inner, testing_frame, cnt):
440 :     rst2 = expected_inshape(opr_outer)
441 :     # assumes binary outer
442 :     # assume unary inner
443 :     for (tshape1, tshape2) in rst2:
444 :     # (_,_)-> tshape
445 :     dim = tshape2.dim
446 :     # set one of the expressions to be a field
447 :     ty1s = d_tofield(dim)
448 :     # (exp1, _)-> tshapes
449 :     # print "##############################"
450 :     # print "dim: ", dim, "tshape1:",tshape1.name, "tshape2:",tshape2.name
451 :     # arity is 2
452 :     for exp in ty1s:
453 :     # needs to find 2nd argument
454 :     #print "#############"
455 :     #print "exp:",exp.name
456 :     exp1 = exp
457 :     shape2 = backwards_op2_arg1(opr_inner, tshape1, exp1)
458 :     if(not(shape2==None)):
459 :     title= "\t\tex.(exp1:"+exp1.name+", shape2:"+shape2.name+")-> "+tshape2.name
460 :     #print(title)
461 :     # convert shape to type
462 :     ty2s = shape_to_fty(shape2)
463 :     #print "(shape2",shape2.name,"ty2s",ty2s
464 :     backwards_ty_to_exp2(exp1, dim, ty2s, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt)
465 :     exp2 = exp
466 :     shape1 = backwards_op2_arg2(opr_inner, tshape1, exp1)
467 :     if(not (shape1==None)):
468 :     title= "\t\tex.(shape1:"+shape1.name+", exp2:"+exp2.name+")-> "+tshape2.name
469 :     #print(title)
470 :     # convert shape to type
471 :     # gets duplicated
472 :     #ty1s = shape_to_fty(shape1)
473 :     #backwards_ty_to_exp1(ty1s, dim, exp2, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt)
474 :     exp1 = shape_to_tensor(shape1)
475 :     core_binary_unary(exp1, exp2, dim, tshape1, tshape2, opr_inner, opr_outer, title, testing_frame, cnt)
476 : cchiw 4481
477 : cchiw 4483
478 :    
479 : cchiw 4481 ##################################################################################################
480 : cchiw 4483 ##################################################################################################
481 : cchiw 4484 # main does everything fowards
482 :     def pick(opr_inner, opr_outer, testing_frame, cnt):
483 :     #writeTitle_outer(opr_inner, opr_outer)
484 :     # iterate over shapes for first terms
485 :     shapes = tvs+tms+tt2+tt3+tt4
486 :     n = len(op_all)
487 :     startall = time.time()
488 :     for shape1 in shapes:
489 :     startshape = time.time()
490 :     writeall ("shape:"+shape1.name)
491 :     #print "shape1 ", shape1
492 :     k_init = 2
493 :     ty1s = shape_to_fty(shape1, k_init)
494 :     if(opr_inner == None):
495 :     for t_inner in range(n):
496 :     startxx = time.time()
497 :     opr_inner = id_toOpr(t_inner)
498 :     counter.zero_locals(cnt)
499 :     counter.zero_total(cnt)
500 :     pick_get_ty1s(ty1s, shape1, opr_inner, opr_outer, testing_frame, cnt)
501 :     endxx = time.time()
502 :     ttxx = " timexx-done inner: "+opr_inner.name+str(endxx - startxx)
503 :     writeall(ttxx)
504 :     print (ttxx)
505 :     else:
506 :     pick_get_ty1s(ty1s, shape1, opr_inner, opr_outer, testing_frame, cnt)
507 :     endall = time.time()
508 :     ttall = " time all: "+ str(endall - startall)
509 :     writeall(ttall)
510 :     print (ttall)
511 :     #print "forwards"
512 :     writeResults_outer(opr_inner, opr_outer, testing_frame, cnt)
513 :     return
514 : cchiw 4483
515 : cchiw 4484
516 : cchiw 4483 #handles some backwards
517 : cchiw 4484 def pickback(opr_inner, opr_outer, testing_frame, cnt):
518 : cchiw 4483 #writeTitle_outer(opr_inner, opr_outer)
519 :     # iterate over shapes for first terms
520 :     backwards= False
521 : cchiw 4484 if(backwards):
522 :     if(not (opr_outer==None)):
523 :     if(opr_outer.fieldop):
524 :     go_backwards(opr_outer, opr_inner, testing_frame, cnt)
525 :    
526 :     elif(opr_inner.arity == 1):
527 :     go_backwards(opr_outer, opr_inner, testing_frame, cnt)
528 : cchiw 4483 else:
529 :     shapes = tvs+tms+tt2+tt3+tt4
530 :     for shape1 in shapes:
531 :     #print "shape1 ", shape1
532 : cchiw 4484 k_init = 2
533 :     ty1s = shape_to_fty(shape1, k_init)
534 :     pick_get_ty1s(ty1s, shape1, opr_inner, opr_outer, testing_frame, cnt)
535 : cchiw 4483 #print "forwards"
536 : cchiw 4481 writeResults_outer(opr_inner, opr_outer, testing_frame, cnt)
537 :     return
538 :    
539 : cchiw 4484 #

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