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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

1 : cchiw 4457 import sys
2 :     import re
3 :     import os
4 : cchiw 4483 import time
5 : cchiw 4457
6 :     from obj_apply import *
7 :     from obj_ex import *
8 :     from obj_field import *
9 :     from obj_counter import *
10 :     from obj_frame import *
11 :     from obj_counter import *
12 :    
13 :     from iter import *
14 : cchiw 4481 from fold import *
15 : cchiw 4457 # unu save -f nrrd -e ascii -i out.nrrd | less
16 :     ##################################################################################################
17 :     # possible commands
18 :     # unu grid -i inputfile.nrrd | unu save -f text
19 :     # ^ where all the points are.
20 :    
21 :     ##############################################################################################
22 :     def cmd(layer, testing_frame, cnt, shift, args):
23 :     if (layer==0):
24 :     #does nothing
25 :     print "******************************************"
26 :     print "List of commands"
27 :     print "*** single layered program"
28 :     print "Ex. (A+B). operation (+) has id \"i\" and types to arguments ([A,B]) are specificed with \"t\""
29 :     print "cmd: 1 2 i t \t single program with specific operator(i) and argument(s) (t)"
30 :     print "cmd: 1 1 i \t specifies operator(i) and iterates over applicable argument types"
31 :     print "cmd: 1 0 \t iterates over all possibilities"
32 :     print "*** double layered programs -(A+B)"
33 :     print "Ex. -(A+B). outer operator(-) is specified with \"o\""
34 :     print "cmd: 2 3 i o m \t specifies inner operator(i), outer operator(o) and args (t)"
35 :     print "cmd: 2 2 i o \t specifies inner operator(i), outer operator(o) and iterates over args"
36 :     print "cmd: 2 20 i m \t specifies inner operator(i), args(t) and iterates over outer operations (o)"
37 :     print "cmd: 2 1 i \t specifies inner operator(i) and iterates over outer operator, and args"
38 :     print "cmd: 2 0 \t iterate over all possibilities"
39 :    
40 :     print "ex. cmd: 2 2 1 3 => normalize (-F)"
41 :     print "ex. cmd: 2 2 24 3 => normalize(F0+F1)"
42 :     print "ex. cmd: 2 2 _ n => n must be less than <24"
43 :     print "ex. cmd: 3 2 1 24 => (-F)+F1"
44 :     print "ex. cmd: 3 2 25 24 => (F-F)+F"
45 :     print "******************************************"
46 :     elif(layer==0): #run all the programs
47 :     embed2_iter_inner(testing_frame, cnt)
48 :     writeCumulative(cnt)
49 :    
50 :     elif (layer==1):
51 :     if(args==0):
52 :     # iterate over single layer
53 :     rtn = []
54 :     for t_inner in range(getN()):
55 :     opr_inner = id_toOpr(t_inner)
56 :     writeTitle_inner(opr_inner)
57 :     single_all_ops(opr_inner, testing_frame, cnt)
58 :     writeResults_inner(opr_inner, testing_frame, cnt)
59 :     writeCumulative(cnt)
60 :     elif (args==1):
61 :     # iterate over single layer
62 :     t_inner= int(sys.argv[shift+1])
63 :     opr_inner = id_toOpr(t_inner)
64 :     writeTitle_inner(opr_inner)
65 :     single_all_ops(opr_inner, testing_frame, cnt)
66 :     writeResults_inner(opr_inner, testing_frame, cnt)
67 :     elif (args==2):
68 :     t_inner= int(sys.argv[shift+1])
69 :     opr_inner = id_toOpr(t_inner)
70 :     t_num= int(sys.argv[shift+2])
71 :     single_specific_ex(opr_inner,t_num, testing_frame, cnt)
72 :     writeResults_inner(opr_inner, testing_frame, cnt)
73 :     elif (layer==2):
74 :     if(args==0):
75 :     #run all the programs
76 :     embed2_iter_inner(testing_frame, cnt)
77 :     writeCumulative(cnt)
78 :     elif(args==1):
79 :     # iterate over double layer with unary operator
80 :     t_inner = int(sys.argv[shift+1])
81 :     opr_inner = id_toOpr(t_inner)
82 :     ex = oprToEx(opr_inner, testing_frame, cnt)
83 :     embed_base_iter_outer(ex, opr_inner, testing_frame, cnt)
84 :     writeCumulative(cnt)
85 :     elif(args==5):
86 :     t_outer = int(sys.argv[shift+1])
87 :     opr_outer = id_toOpr(t_outer)
88 :     writeTitle_outer2(opr_outer)
89 :     embed2_iter_inner_gotouter(opr_outer, testing_frame, cnt)
90 :     writeCumulative(cnt)
91 :     elif (args==2):
92 :     t_inner = int(sys.argv[shift+1])
93 :     t_outer = int(sys.argv[shift+2])#outer operator
94 :     opr_outer = id_toOpr(t_outer)
95 :     opr_inner = id_toOpr(t_inner)
96 :     writeTitle_outer(opr_inner, opr_outer)
97 :     ex = oprToEx(opr_inner, testing_frame, cnt)
98 :     embed_base_iter_ty2(ex, opr_inner, opr_outer, testing_frame, cnt)
99 :     writeResults_outer(opr_inner, opr_outer, testing_frame, cnt)
100 :     elif (args==20):
101 :     t_inner = int(sys.argv[shift+1])
102 :     t_num = int(sys.argv[shift+2])#outer binary operator
103 :     opr_inner = id_toOpr(t_inner)
104 :     writeTitle_inner(opr_inner)
105 :     embed_base_iter_outer2(opr_inner, t_num, testing_frame, cnt)
106 :     writeResults_inner(opr_inner, testing_frame, cnt)
107 :     elif(args==3):
108 :     # run a specific iterate over double layer with unary operator
109 :     t_inner = int(sys.argv[shift+1])
110 :     t_outer= int(sys.argv[shift+2])
111 :     t_num = int(sys.argv[shift+3])
112 :     t_ty2 = None
113 :     opr_outer = id_toOpr(t_outer)
114 :     opr_inner = id_toOpr(t_inner)
115 :     writeTitle_outer(opr_inner, opr_outer)
116 :     ex = oprToEx(opr_inner, testing_frame, cnt)
117 :     embed_base_iter_ty2_wihty1(ex, opr_inner, opr_outer, t_num, testing_frame, cnt)
118 :     writeResults_outer(opr_inner, opr_outer, testing_frame, cnt)
119 :     elif(args==4):
120 :     # run a specific iterate over double layer with unary operator
121 :     t_inner = int(sys.argv[shift+1])
122 :     t_outer= int(sys.argv[shift+2])
123 :     t_num = int(sys.argv[shift+3])
124 :     t_ty2 = int(sys.argv[shift+4])
125 :     opr_outer = id_toOpr(t_outer)
126 :     opr_inner = id_toOpr(t_inner)
127 :     writeTitle_outer(opr_inner, opr_outer)
128 :     # get example
129 :     ex = oprToEx(opr_inner, testing_frame, cnt)
130 :     embed_base_specific_ex(ex, opr_inner, opr_outer, t_num, t_ty2, testing_frame, cnt)
131 :     writeResults_outer(opr_inner, opr_outer, testing_frame, cnt)
132 :    
133 :     else:
134 :     raise "unsupported"
135 :    
136 :     #ends with Clean up
137 :     def clean():
138 :     os.system("rm *.o")
139 :     os.system("rm *.pyc")
140 :     os.system("rm *.h")
141 :     os.system("rm *.nrrd")
142 :     os.system("rm *.cxx")
143 :     os.system("rm *.diderot")
144 :     os.system("rm fs3d-vec2")
145 :     os.system("rm fs3d-vec2")
146 :    
147 : cchiw 4481 # iterating over the different types
148 :     def main_Standard():
149 :     n_frame = 0 # int(sys.argv[1])
150 :     args = 2 #int(sys.argv[2])
151 :     shift = 1 # how many commands used so far
152 : cchiw 4457 # get testing framework
153 :     testing_frame = get_testing_frame(n_frame)
154 :     # get counter
155 :     cnt = get_counter()
156 :     # writing heading based on framework
157 :     write_heading(testing_frame)
158 :     # constants (decides layer of testing)
159 :     layer = 2
160 :     # layer, and shift from constants (decides layer of testing)
161 :    
162 :     #choose testing range based on commands
163 :     cmd(layer, testing_frame, cnt, shift, args)
164 :     clean()
165 :    
166 : cchiw 4481
167 :     def main():
168 :     #n_frame = int(sys.argv[1])
169 :     #args = int(sys.argv[2])
170 :     #shift = 2 # how many commands used so far
171 :     n_frame = 0
172 :     shift = 1
173 :    
174 :     # get testing framework
175 :     testing_frame = get_testing_frame(n_frame)
176 :     # get counter
177 :     cnt = get_counter()
178 :     # writing heading based on framework
179 : cchiw 4483 #write_heading(testing_frame)
180 : cchiw 4481
181 :     #choose testing range based on commands
182 :     t_inner = int(sys.argv[shift+1])
183 :     t_outer = int(sys.argv[shift+2])#outer operator
184 :     opr_outer = id_toOpr(t_outer)
185 :     opr_inner = id_toOpr(t_inner)
186 :     writeTitle_outer(opr_inner, opr_outer)
187 :    
188 :     #choose testing range based on commands
189 :     pick(opr_inner, opr_outer, testing_frame, cnt)
190 :     clean()
191 :    
192 : cchiw 4483 def main_iter():
193 :     #n_frame = int(sys.argv[1])
194 :     #args = int(sys.argv[2])
195 :     #shift = 2 # how many commands used so far
196 :     n_frame = 0
197 :     # get testing framework
198 :     testing_frame = get_testing_frame(n_frame)
199 :     # get counter
200 :     cnt = get_counter()
201 :     # writing heading based on framework
202 :     #write_heading(testing_frame)
203 :    
204 :     #choose testing range based on commands
205 :     n = len(op_all)
206 :     for i in range(n):
207 :     for j in range(n):
208 :     t_inner = int(sys.argv[i])
209 :     t_outer = int(sys.argv[j])
210 :     opr_outer = id_toOpr(t_outer)
211 :     opr_inner = id_toOpr(t_inner)
212 :     writeTitle_outer(opr_inner, opr_outer)
213 :     #choose testing range based on commands
214 :     pick(opr_inner, opr_outer, testing_frame, cnt)
215 :     clean()
216 : cchiw 4481
217 : cchiw 4483 start = time.time()
218 : cchiw 4481 x = int(sys.argv[1])
219 :     if(x==0):
220 :     main_Standard()
221 :     else:
222 : cchiw 4483 main()
223 :     end = time.time()
224 :     t = " time:"+str(end - start)
225 :     writeall(t)
226 :     print (t)

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