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

SCM Repository

[diderot] Annotation of /branches/charisee/src/compiler/ein/mkoperators.sml
ViewVC logotype

Annotation of /branches/charisee/src/compiler/ein/mkoperators.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2515 - (view) (download)

1 : cchiw 2499 (* examples.sml
2 :     *
3 :     * COPYRIGHT (c) 2012 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     * All rights reserved.
5 :     *)
6 :    
7 :     structure mkOperators = struct
8 :    
9 :     local
10 :    
11 :     structure E = Ein
12 :     structure P=Printer
13 :     in
14 :    
15 :    
16 :     fun expIndex(n,inc)=List.tabulate(n, (fn(x)=>E.V (x+inc)))
17 : cchiw 2506 fun expIndexP(n,inc)=List.tabulate(n, (fn(x)=> (x+inc)))
18 : cchiw 2499
19 :     fun specialize(alpha,inc)=(alpha,expIndex(length(alpha),inc))
20 : cchiw 2506 fun specializeP(alpha,inc)=(alpha,expIndexP(length(alpha),inc))
21 : cchiw 2499
22 :     (*mkTensor functions*)
23 :     (* Adding tensors : < X{\alpha} + Y_{\alpha}>_{\alpha} *)
24 :     fun addTen(alpha)=let
25 :     val (index', expindex')= specialize(alpha,0)
26 :     in
27 :     E.EIN{
28 :     params = [E.TEN, E.TEN], index = index',
29 :     body = E.Add[E.Tensor(0, expindex'), E.Tensor(1, expindex')]
30 :     }
31 :     end
32 :    
33 : cchiw 2502 fun createVec(dim)=E.EIN{
34 :     params = [E.TEN], index = [dim],
35 :     body = E.Tensor(0, [E.V 0])
36 :     }
37 :    
38 :    
39 : cchiw 2508 val zero=E.EIN{
40 :     params = [], index = [],
41 : cchiw 2515 body = E.Const(0.0)
42 : cchiw 2508 }
43 : cchiw 2502
44 : cchiw 2515
45 : cchiw 2508
46 : cchiw 2499 (* Subtracting tensors *)
47 :     fun subTen(alpha)=let
48 :     val (index', expindex')= specialize(alpha,0)
49 :     in
50 :     E.EIN{
51 :     params = [E.TEN, E.TEN], index = index',
52 :     body = E.Sub(E.Tensor(0, expindex'), E.Tensor(1, expindex'))}
53 :     end
54 :    
55 :     fun divTen(alpha) =let
56 :     val (index', expindex')= specialize(alpha,0)
57 :     in E.EIN{
58 :     params = [E.TEN, E.TEN], index = index',
59 :     body = E.Div(E.Tensor(0, expindex'), E.Tensor(1,[]))
60 :     }
61 :     end
62 :    
63 :     (* Trace: <M_{i, i}> This one Sx represents both i's*)
64 :     fun trace(dim) = E.EIN{
65 :     params = [E.TEN], (* M *)
66 :     index = [], (* i *)
67 : cchiw 2515 body = E.Sum([(E.V 0,1,dim-1)],E.Tensor(0, [E.V 0, E.V 0]))
68 : cchiw 2499 }
69 :    
70 :     fun negTen(alpha)=let
71 :     val (index', expindex')= specialize(alpha,0)
72 :     in E.EIN{
73 :     params = [E.TEN],
74 :     index = index',
75 :     body = E.Neg(E.Tensor(0, expindex'))
76 :     }
77 :     end
78 :    
79 :     (* scalar times tensor product: <s * T_{\alpha}>_{\alpha} *)
80 :     fun scaleTen(alpha) = let
81 :     val (index', expindex')= specialize(alpha,0)
82 :     in E.EIN{
83 :     params = [E.TEN, E.TEN], (* s and T *)
84 :     index = index', (* \alpha *)
85 :     body = E.Prod[ E.Tensor(0, []), E.Tensor(1, expindex')]
86 :     }
87 :     end
88 :    
89 :     (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
90 :     fun innerProduct(shape1,i::beta) = let
91 :     val alpha= List.take(shape1,length(shape1)-1)
92 :     val (indexA, expindexA)= specialize(alpha,0)
93 :     val (indexB, expindexB)= specialize(beta,(length(alpha)))
94 :     val s'=E.V(length(alpha)+ length(beta))
95 : cchiw 2515 val s''=[(s',0,i-1)]
96 : cchiw 2499 in E.EIN{
97 :     params = [E.TEN, E.TEN], (* T and T' *)
98 :     index = indexA@indexB, (* \alpha \beta, i *)
99 :     body = E.Sum(s'', E.Prod[
100 :     E.Tensor(0, expindexA@[s']), (* T_{\alpha i} *)
101 :     E.Tensor(1, [s']@expindexB ) (* T'_{i \beta} *)
102 :     ])
103 :     }
104 :     end
105 :    
106 :     (*<T_{\alpha i j} * B{i j \beta }>_\alpha \beta*)
107 :     fun doubleDot(shape1,i::j::beta) = let
108 :     val alpha= List.take(shape1,length(shape1)-2)
109 :     val (indexA, expindexA)= specialize(alpha,0)
110 :     val (indexB, expindexB)= specialize(beta,(length(alpha)))
111 :     val sumi=length(alpha)+ length(beta)
112 :     val s'=[E.V sumi,E.V(sumi+1)]
113 : cchiw 2515 val s''=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]
114 : cchiw 2499 in E.EIN{
115 :     params = [E.TEN,E.TEN],
116 :     index = indexA@indexB,
117 :     body = E.Sum(s'',E.Prod[
118 :     E.Tensor(0, expindexA@s'),
119 :     E.Tensor(1,s'@expindexB)
120 :     ])
121 :     }
122 :     end
123 :    
124 : cchiw 2507 (*Vector Examples : <T_i * T_j>_ij..t0⊗t1*)
125 : cchiw 2499 fun outerProduct(dimA,dimB) =E.EIN{
126 :     params = [E.TEN, E.TEN],
127 :     index= [dimA,dimB],
128 :     body= E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])]
129 :     }
130 :    
131 :    
132 :     fun transpose([i,j]) =E.EIN{
133 :     params = [E.TEN], index= [i,j],
134 :     body= E.Tensor(0, [E.V 1,E.V 0])
135 :     }
136 :    
137 : cchiw 2515
138 : cchiw 2499 fun modulate(dim) =E.EIN{
139 :     params = [E.TEN, E.TEN],
140 :     index = [dim],
141 :     body = E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 0])]
142 :     }
143 :    
144 :    
145 : cchiw 2507 (*crossProduct is on 3D vectors ..vec3 t8=t0 × t1; *)
146 : cchiw 2499 val crossProduct = E.EIN{
147 :     params = [E.TEN, E.TEN],
148 :     index= [3],
149 : cchiw 2515 body=E.Sum([(E. V 1,0,2),(E.V 2,0,2)],
150 : cchiw 2499 E.Prod[ E.Epsilon(0, 1, 2), E.Tensor(0, [E.V 1]), E.Tensor(1, [E.V 2 ]) ])
151 :     }
152 :    
153 :     (* Identiy: <\delta_{i j}>_{i j} *)
154 : cchiw 2502 fun identity(dim) =E.EIN{
155 : cchiw 2499 params = [],
156 : cchiw 2502 index = [dim,dim],
157 : cchiw 2499 body = E.Delta(E.V(0), E.V(1))
158 :     }
159 :    
160 :     (*Tensor and Fields*)
161 :     fun addTenField(dim) = E.EIN{
162 :     params = [E.TEN,E.FLD(dim)],
163 :     index = [],
164 :     body = E.Add[E.Tensor(0, []),E.Field(1, [])]
165 :     }
166 :    
167 :     fun subTenField(dim) = E.EIN{
168 :     params = [E.TEN,E.FLD(dim)],
169 :     index = [],
170 :     body = E.Add[E.Tensor(0, []),E.Neg(E.Field(1, []))]
171 :     }
172 :    
173 :     fun subFieldTen(dim) = E.EIN{
174 :     params = [E.TEN,E.FLD(dim)],
175 :     index = [],
176 :     body = E.Sub(E.Field(1, []),E.Tensor(0, []))
177 :     }
178 :    
179 :     (* mkField functions*)
180 :     (*Adding Fields : < F{\alpha} + G_{\alpha}>_{\alpha} *)
181 :     fun addField(dim,shape) =let
182 :     val (index', expindex')= specialize(shape,0)
183 :     in E.EIN{
184 :     params = [E.FLD(dim),E.FLD(dim)],
185 :     index = index',
186 :     body = E.Add[E.Field(0, expindex'),E.Field(1, expindex')]
187 :     }
188 :     end
189 :    
190 :     fun subField(dim,shape) =let
191 :     val (index', expindex')= specialize(shape,0)
192 :     in E.EIN{
193 :     params = [E.FLD(dim),E.FLD(dim)],
194 :     index = index',
195 :     body = E.Sub(E.Field(0, expindex'),E.Field(1, expindex'))
196 :     }
197 :     end
198 :    
199 :     fun scaleField(dim,shape) =let
200 :     val (index', expindex')= specialize(shape,0)
201 :     in E.EIN{
202 :     params = [E.TEN,E.FLD(dim)],
203 :     index = index',
204 :     body = E.Prod[ E.Tensor(0,[]), E.Field(1,expindex')]
205 :     }
206 :     end
207 :    
208 :     fun divideField(dim,shape) = let
209 :     val (index', expindex')= specialize(shape,0)
210 :     in E.EIN{
211 :     params = [E.TEN,E.FLD(dim)],
212 :     index = index',
213 :     body = E.Div(E.Field(1, expindex'), E.Tensor(0, []))
214 :     }
215 :     end
216 :    
217 :     fun negField(dim,shape) = let
218 :     val (index', expindex')= specialize(shape,0)
219 :     in E.EIN{
220 :     params = [E.FLD(dim)],
221 :     index = index',
222 :     body = E.Neg(E.Field(0, expindex'))
223 :     }
224 :     end
225 :    
226 : cchiw 2509 (*< d F / d_i>_i *)
227 : cchiw 2499 fun grad(a::alpha)=let
228 :     val (index', expindex')= specialize(a::alpha,0)
229 :     in E.EIN{
230 :     params = [E.FLD(a)],
231 :     index =index',
232 :     body = E.Apply(E.Partial(expindex'),E.Field(0,[]))
233 :     }
234 :     end
235 : cchiw 2506
236 : cchiw 2515 (*< Sigma d F_alpha / d x_i>iALpha *)
237 :     fun dotimes(dim,alpha)= let
238 : cchiw 2506 val n=length(alpha)
239 :     fun expIndex(n,inc)=List.tabulate(n, (fn(x)=>E.V (x+inc)))
240 : cchiw 2515 val i'=expIndex(n,0)
241 :     val z=length i'
242 : cchiw 2506
243 : cchiw 2515 in E.EIN{
244 :     params = [E.FLD(dim)], index =[dim]@alpha,
245 :     body = E.Apply(E.Partial [E.V (z)] ,E.Field(0,i'))
246 :     }
247 :     end
248 : cchiw 2506
249 : cchiw 2499 (* <d F_i /d_i> *)
250 :     fun divergence(dim,alpha)=let
251 :     val (index', expindex')= specialize(alpha,0)
252 :     in E.EIN{
253 :     params = [E.FLD(dim)],
254 :     index = [],
255 : cchiw 2515 body = E.Sum([(E.V 0,0,dim-1)],E.Apply(E.Partial([E.V(0)]),E.Field(0,[E.V(0)])))
256 : cchiw 2499 }
257 :     end
258 :    
259 :     (*FLD here is bounded to image field, and dimension of h*)
260 :     fun conv(dim,shape) =let
261 :     val (index', expindex')= specialize(shape,0)
262 :     in E.EIN{
263 : cchiw 2507 params = [E.IMG(dim),E.KRN],
264 : cchiw 2499 index = index',
265 :     body= E.Conv(0,expindex',1,[])
266 :     }
267 :     end
268 :    
269 :     (* Probe: <F(x)>_{\alpha} *)
270 : cchiw 2510 fun probe(alpha,dim) = let
271 : cchiw 2499 val (indexT, expindexT)= specialize(alpha,0)
272 : cchiw 2510
273 : cchiw 2499 in E.EIN{
274 : cchiw 2510 params = [E.FLD(dim),E.TEN],
275 :     index= indexT,
276 :     body= E.Probe(E.Field(0, expindexT), E.Tensor(1,[]))
277 : cchiw 2499 }
278 :     end
279 :    
280 :     (*(F_y/dx - F_x/dy )k*)
281 :     val curl2d=E.EIN{
282 :     params = [E.FLD 2],
283 :     index = [],
284 :     body = E.Sub(E.Apply(E.Partial([E.C 0]), E.Field(0,[E.C 1])),
285 :     E.Apply(E.Partial([E.C 1]), E.Field(0,[E.C 0])))
286 :     }
287 :    
288 :     val curl3d=E.EIN{
289 :     params = [E.TEN],
290 :     index = [3],
291 : cchiw 2515 body = E.Sum([(E.V 1,0,2), (E.V 2,0,2)],E.Prod[E.Epsilon(0, 1, 2),E.Apply( E.Partial([E.V 1]), E.Field(0,[E.V 2]))])
292 : cchiw 2499 }
293 :    
294 :     (*Scalars*)
295 :     (* Add Scalars*)
296 :     val addScalar = E.EIN{
297 :     params = [E.TEN, E.TEN],
298 :     index = [],
299 :     body = E.Add[ E.Tensor(0, []), E.Tensor(1, [])]
300 :     }
301 :    
302 :     (* Subtract Scalars*)
303 :     val subScalar = E.EIN{
304 :     params = [E.TEN, E.TEN],
305 :     index = [],
306 :     body = E.Sub( E.Tensor(0, []), E.Tensor(1, []))
307 :     }
308 :    
309 :     (* Divide Scalars*)
310 :     val divScalar = E.EIN{
311 :     params = [E.TEN, E.TEN],
312 :     index = [],
313 :     body = E.Div( E.Tensor(0, []), E.Tensor(1, []))
314 :     }
315 :    
316 :    
317 :     (* Product Scalars*)
318 :     val prodScalar = E.EIN{
319 :     params = [E.TEN, E.TEN],
320 :     index = [],
321 :     body = E.Prod[ E.Tensor(0, []), E.Tensor(1, [])]
322 :     }
323 :    
324 : cchiw 2502 (*Transform M_ij x_j+T*)
325 :     fun transform(i, j) = E.EIN{
326 :     params = [E.TEN, E.TEN, E.TEN],
327 :     index = [i],
328 :     body = E.Add
329 : cchiw 2515 [E.Sum([(E.V 1, 0,j-1)],E.Prod[E.Tensor(0, [E.V 0, E.V 1]), E.Tensor(1, [E.V 1])]),
330 : cchiw 2502 E.Tensor(1,[E.V 0])]
331 :     }
332 : cchiw 2499
333 :    
334 :     end; (* local *)
335 :    
336 :     end (* local *)

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