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 3066 - (view) (download)

1 : cchiw 2844 (* creates EIN operators
2 : cchiw 2499 *
3 :     * COPYRIGHT (c) 2012 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     * All rights reserved.
5 :     *)
6 :    
7 : jhr 3060 structure MkOperators = struct
8 : cchiw 2499
9 :     local
10 :    
11 :     structure E = Ein
12 :     structure P=Printer
13 :     in
14 :    
15 : cchiw 2844 fun specialize(alpha,inc)= List.tabulate(length(alpha), (fn(x)=>E.V (x+inc)))
16 : cchiw 3048 fun sumIds(n,inc,alpha)=let
17 :     val vs=List.tabulate(n, (fn v=>E.V (v+inc)))
18 :     in ListPair.map (fn(v,i)=>(v, 0, i-1)) (vs, alpha) end
19 :     fun sumIds2(n,i)=List.tabulate(n, (fn v=>(E.V v, 0, i)))
20 : cchiw 2499
21 : cchiw 2906 (******************************* Add *****************************************)
22 :     val addRR = E.EIN{
23 :     params = [E.TEN(1,[]), E.TEN(1,[])] ,
24 :     index = [],
25 :     body = E.Add[ E.Tensor(0, []), E.Tensor(1, [])]
26 :     }
27 :    
28 : cchiw 2499 (* Adding tensors : < X{\alpha} + Y_{\alpha}>_{\alpha} *)
29 : cchiw 2906 fun addTT alpha =let
30 : cchiw 2844 val expindex= specialize(alpha,0)
31 : cchiw 2499 in
32 :     E.EIN{
33 : cchiw 2845 params = [E.TEN(1,alpha), E.TEN(1,alpha)],
34 :     index = alpha,
35 :     body = E.Add[E.Tensor(0, expindex), E.Tensor(1, expindex)]
36 : cchiw 2499 }
37 :     end
38 :    
39 : cchiw 2906 (* mkField functions*)
40 :     (*Adding Fields : < F{\alpha} + G_{\alpha}>_{\alpha} *)
41 :     fun addFF(dim,shape) =let
42 :     val expindex= specialize(shape,0)
43 :     in E.EIN{
44 :     params = [E.FLD(dim),E.FLD(dim)],
45 :     index = shape,
46 :     body = E.Add[E.Field(0, expindex),E.Field(1, expindex)]
47 :     }
48 :     end
49 : cchiw 2502
50 : cchiw 2906 (*Tensor and Fields*)
51 :     fun addTF(dim,shape) =let
52 :     val expindex= specialize(shape,0)
53 :     in E.EIN{
54 :     params = [E.TEN(1,shape),E.FLD(dim)],
55 :     index = shape,
56 :     body = E.Add[E.Lift(E.Tensor(0, expindex)),E.Field(1, expindex)]
57 :     }
58 :     end
59 :     (********************************* Sub **************************************)
60 :     (* Subtract Scalars*)
61 :     val subRR = E.EIN{
62 :     params = [E.TEN(1,[]), E.TEN(1,[])],
63 :     index = [],
64 :     body = E.Sub( E.Tensor(0, []), E.Tensor(1, []))
65 :     }
66 :    
67 :     fun subTT alpha=let
68 : cchiw 2844 val expindex= specialize(alpha,0)
69 : cchiw 2499 in
70 :     E.EIN{
71 : cchiw 2845 params = [E.TEN(1,alpha), E.TEN(1,alpha)],
72 :     index = alpha,
73 :     body = E.Sub(E.Tensor(0, expindex), E.Tensor(1, expindex))
74 :     }
75 : cchiw 2499 end
76 : cchiw 2906
77 :     fun subTF(dim,shape) =let
78 :     val expindex= specialize(shape,0)
79 : cchiw 2845 in
80 :     E.EIN{
81 : cchiw 2906 params = [E.TEN(1,shape),E.FLD(dim)],
82 :     index = shape,
83 :     body = E.Add[E.Lift(E.Tensor(0, expindex)),E.Neg(E.Field(1, expindex))]
84 : cchiw 2845 }
85 : cchiw 2906 end
86 :    
87 :     fun subFT(dim,shape) = let
88 :     val expindex= specialize(shape,0)
89 :     in
90 :     E.EIN{
91 :     params = [E.TEN(1,[]),E.FLD(dim)],
92 :     index = shape,
93 :     body = E.Sub(E.Field(1, expindex),E.Lift(E.Tensor(0, expindex)))
94 :     }
95 : cchiw 2499 end
96 : cchiw 2906
97 :     fun subFF(dim,shape) =let
98 :     val expindex= specialize(shape,0)
99 :     in E.EIN{
100 :     params = [E.FLD(dim),E.FLD(dim)],
101 :     index = shape,
102 :     body = E.Sub(E.Field(0, expindex),E.Field(1, expindex))
103 :     }
104 :     end
105 :     (********************************** mul *************************************)
106 :     (* Product Scalars*)
107 :     val mulRR = E.EIN{
108 :     params =[E.TEN(1,[]), E.TEN(1,[])],
109 : cchiw 2845 index = [],
110 : cchiw 2906 body = E.Prod[ E.Tensor(0, []), E.Tensor(1, [])]
111 : cchiw 2845 }
112 : cchiw 2499
113 : cchiw 2906 (* scalar times tensor product: <s * T_{\alpha}>_{\alpha} *)
114 :     fun mulRT alpha = let
115 :     val expindex= specialize(alpha,0)
116 : cchiw 2845 in
117 :     E.EIN{
118 : cchiw 2906 params = [E.TEN(1,[]), E.TEN(1,alpha)],
119 : cchiw 2845 index = alpha,
120 : cchiw 2906 body = E.Prod[ E.Tensor(0, []), E.Tensor(1, expindex)]
121 : cchiw 2845 }
122 : cchiw 2499 end
123 : cchiw 2906
124 :     fun mulRF(dim,shape) =let
125 :     val expindex= specialize(shape,0)
126 :     in E.EIN{
127 :     params = [E.TEN(1,[]),E.FLD(dim)],
128 :     index = shape,
129 :     body = E.Prod[E.Lift( E.Tensor(0,[])), E.Field(1,expindex)]
130 :     }
131 :     end
132 :    
133 : cchiw 3066
134 :     fun mulST(dim,shape) =let
135 :     val expindex= specialize(shape,0)
136 :     in E.EIN{
137 :     params = [E.TEN(1,shape),E.FLD(dim)],
138 :     index = shape,
139 :     body = E.Prod[E.Lift( E.Tensor(0,expindex)), E.Field(1,[])]
140 :     }
141 :     end
142 :    
143 :    
144 :    
145 : cchiw 2906 fun mulSS dim = E.EIN{
146 :     params = [E.FLD(dim),E.FLD(dim)],
147 :     index = [],
148 :     body = E.Prod[E.Field(0, []),E.Field(1, [])]
149 :     }
150 :    
151 :     fun mulSF(dim,shape) =let
152 :     val expindex= specialize(shape,0)
153 :     in E.EIN{
154 :     params = [E.FLD(dim),E.FLD(dim)],
155 :     index = shape,
156 :     body = E.Prod[E.Field(0, []),E.Field(1, expindex)]
157 :     }
158 :     end
159 :    
160 :     (************************************div ************************************)
161 :     (* Divide Scalars*)
162 :     val divRR = E.EIN{
163 :     params = [E.TEN(1,[]), E.TEN(1,[])],
164 :     index = [],
165 :     body = E.Div( E.Tensor(0, []), E.Tensor(1, []))
166 :     }
167 :    
168 :     fun divTR alpha =let
169 : cchiw 2844 val expindex= specialize(alpha,0)
170 : cchiw 2845 in
171 :     E.EIN{
172 : cchiw 2906 params = [E.TEN(1,alpha), E.TEN(1,[])],
173 : cchiw 2845 index = alpha,
174 : cchiw 2906 body = E.Div(E.Tensor(0, expindex), E.Tensor(1,[]))
175 : cchiw 2845 }
176 : cchiw 2906 end
177 :    
178 :     fun divFR(dim,shape) = let
179 :     val expindex= specialize(shape,0)
180 :     in E.EIN{
181 :     params = [E.FLD(dim),E.TEN(1,[])],
182 :     index = shape,
183 :     body = E.Div(E.Field(0, expindex),E.Lift( E.Tensor(1, [])))
184 :     }
185 :     end
186 :    
187 :     fun divSS dim = E.EIN{
188 :     params = [E.FLD(dim),E.FLD(dim)],
189 :     index = [],
190 :     body = E.Div(E.Field(0, []),E.Field(1, []))
191 :     }
192 :    
193 :     fun divFS(dim,shape) = let
194 :     val expindex= specialize(shape,0)
195 :     in E.EIN{
196 :     params = [E.FLD(dim),E.FLD(dim)],
197 :     index = shape,
198 :     body = E.Prod[E.Field(0, expindex),E.Div(E.Const 1,E.Field(1, []))]
199 :     }
200 :     end
201 :     (************************************* Neg **********************************)
202 :     fun negTT alpha=let
203 :     val expindex= specialize(alpha,0)
204 :     in
205 :     E.EIN{
206 :     params = [E.TEN(1,alpha)],index = alpha,
207 :     body = E.Neg(E.Tensor(0, expindex))
208 :     }
209 :     end
210 :    
211 :     fun negFF(dim,shape) = let
212 :     val expindex = specialize(shape,0)
213 :     in E.EIN{
214 :     params = [E.FLD(dim)],index = shape,
215 :     body = E.Neg(E.Field(0, expindex))
216 :     }
217 :     end
218 :    
219 :     (****************************** cross ***********************************)
220 :     (*crossProduct is on 3D vectors ..vec3 t8=t0 × t1; *)
221 :     val cross3TT = E.EIN{
222 :     params = [E.TEN(1,[3]), E.TEN(1,[3])],
223 :     index= [3],
224 :     body=E.Sum([(E. V 1,0,2),(E.V 2,0,2)],
225 :     E.Prod[ E.Epsilon(0, 1, 2),
226 :     E.Tensor(0, [E.V 1]), E.Tensor(1, [E.V 2 ]) ])
227 :     }
228 :    
229 :     (*2-d cross product Eps_{ij}U_i V_j*)
230 :     val cross2TT = E.EIN{
231 :     params = [E.TEN(1,[2]), E.TEN(1,[2])],
232 :     index= [],
233 :     body=E.Sum([(E. V 0,0,1),(E.V 1,0,1)],
234 :     E.Prod[ E.Eps2(0, 1), E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])])
235 :     }
236 :    
237 :     (*Field Cross Product*)
238 :     val cross2FF = E.EIN{
239 :     params = [E.FLD(2), E.FLD(2)],index= [],
240 :     body=E.Sum([(E. V 0,0,1),(E.V 1,0,1)],
241 :     E.Prod[ E.Eps2(0, 1), E.Field(0, [E.V 0]), E.Field(1, [E.V 1]) ])
242 :     }
243 :    
244 :     (*Field Cross Product*)
245 :     val cross3FF = E.EIN{
246 :     params = [E.FLD(3), E.FLD(3)],index= [3],
247 :     body=E.Sum([(E. V 1,0,2),(E.V 2,0,2)],
248 :     E.Prod[ E.Epsilon(0, 1, 2),
249 :     E.Field(0, [E.V 1]), E.Field(1, [E.V 2 ]) ])
250 :     }
251 :     (******************** outerProduct ********************************)
252 :     (*Vector Examples : <T_i * T_j>_ij..t0⊗t1*)
253 :     fun outerTT(dimA,dimB) =
254 : cchiw 2845 E.EIN{
255 : cchiw 2906 params = [E.TEN(1,[dimA]), E.TEN(1,[dimB])],
256 :     index= [dimA,dimB],
257 :     body= E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])]
258 :     }
259 :    
260 :     (*Assumes same dimension vector field *)
261 : cchiw 3017 fun outerFF(dim,i,j) =
262 : cchiw 2906 E.EIN{
263 :     params = [E.FLD(dim),E.FLD(dim)],
264 : cchiw 3017 index = [i,j],
265 : cchiw 2906 body = E.Prod[E.Field(0, [E.V 0]),E.Field(1, [E.V 1])]
266 :     }
267 : cchiw 2845
268 : cchiw 2906 (*************************** inner product **********************************)
269 : cchiw 2499 (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
270 : cchiw 2906 fun innerTT(shape1,i::beta) = let
271 : cchiw 2499 val alpha= List.take(shape1,length(shape1)-1)
272 : cchiw 2844 val expindexA= specialize(alpha,0)
273 :     val expindexB= specialize(beta,(length(alpha)))
274 : cchiw 2499 val s'=E.V(length(alpha)+ length(beta))
275 : cchiw 2515 val s''=[(s',0,i-1)]
276 : cchiw 2845 in
277 :     E.EIN{
278 :     params = [E.TEN(1,shape1) ,E.TEN(1,i::beta)],
279 :     index = alpha@beta,
280 :     body = E.Sum(s'', E.Prod[
281 : cchiw 2906 E.Tensor(0, expindexA@[s']), (* T_{\alpha i} *)
282 :     E.Tensor(1, [s']@expindexB ) (* T'_{i \beta} *)])
283 : cchiw 2845 }
284 : cchiw 2605 end
285 : cchiw 2906 | innerTT _ = raise Fail "Wrong shape for inner product"
286 :    
287 :     (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
288 :     fun innerFF(shape1,dim,i::beta) = let
289 :     val alpha= List.take(shape1,length(shape1)-1)
290 :     val expindexA= specialize(alpha,0)
291 :     val expindexB= specialize(beta,(length(alpha)))
292 :     val sid=E.V(length(alpha)+ length(beta))
293 :     in E.EIN{
294 :     params = [E.FLD(dim) ,E.FLD(dim)],index = alpha@beta,
295 :     body = E.Sum([(sid,0,i-1)],
296 :     E.Prod[
297 :     E.Field(0, expindexA@[sid]), (* F_{\alpha i} *)
298 :     E.Field(1, [sid]@expindexB ) (* F'_{i \beta} *)
299 :     ])}
300 :     end
301 :     | innerFF _ = raise Fail "Wrong shape for innerProductField"
302 : cchiw 2929
303 :    
304 :     fun innerFT(shape1,dim,i::beta) = let
305 :     val alpha= List.take(shape1,length(shape1)-1)
306 :     val expindexA= specialize(alpha,0)
307 :     val expindexB= specialize(beta,(length(alpha)))
308 :     val sid=E.V(length(alpha)+ length(beta))
309 :     in E.EIN{
310 :     params = [E.FLD(dim),E.TEN(1,i::beta)],
311 :     index = alpha@beta,
312 :     body = E.Sum([(sid,0,i-1)],
313 :     E.Prod[
314 :     E.Field(0, expindexA@[sid]), (* F_{\alpha i} *)
315 :     E.Lift(E.Tensor(1, [sid]@expindexB )) (* F'_{i \beta} *)
316 :     ])}
317 :     end
318 :     | innerFT _ = raise Fail "Wrong shape for innerProductFieldTensor"
319 :    
320 :    
321 :     fun innerTF(shape1,dim,i::beta) = let
322 :     val alpha= List.take(shape1,length(shape1)-1)
323 :     val expindexA= specialize(alpha,0)
324 :     val expindexB= specialize(beta,(length(alpha)))
325 :     val sid=E.V(length(alpha)+ length(beta))
326 :     in E.EIN{
327 :     params = [E.TEN(1,shape1),E.FLD(dim)],index = alpha@beta,
328 :     body = E.Sum([(sid,0,i-1)],
329 :     E.Prod[E.Lift(E.Tensor(0, expindexA@[sid])), (* F_{\alpha i} *)
330 :     E.Field(1, [sid]@expindexB ) (* F'_{i \beta} *)
331 :     ])}
332 :     end
333 :     | innerTF _ = raise Fail "Wrong shape for innerProductTensorField"
334 :    
335 :    
336 : cchiw 2499
337 : cchiw 2906 (*************************** colon product **********************************)
338 : cchiw 2499 (*<T_{\alpha i j} * B{i j \beta }>_\alpha \beta*)
339 : cchiw 2906 fun colonTT(shape1,i::j::beta) = let
340 : cchiw 2499 val alpha= List.take(shape1,length(shape1)-2)
341 : cchiw 2844 val expindexA= specialize(alpha,0)
342 :     val expindexB= specialize(beta,(length(alpha)))
343 : cchiw 2499 val sumi=length(alpha)+ length(beta)
344 :     val s'=[E.V sumi,E.V(sumi+1)]
345 : cchiw 2906 val sx=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]
346 : cchiw 2845 in
347 :     E.EIN{
348 :     params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],
349 :     index = alpha@beta,
350 : cchiw 2906 body = E.Sum(sx,E.Prod[ E.Tensor(0, expindexA@s'), E.Tensor(1,s'@expindexB)])
351 : cchiw 2845 }
352 : cchiw 2499 end
353 : cchiw 2906
354 :     (*<F_{\alpha i j} * G{i j \beta }>_\alpha \beta*)
355 :     fun colonFF(shape1,i::j::beta) = let
356 :     val alpha= List.take(shape1,length(shape1)-2)
357 :     val expindexA= specialize(alpha,0)
358 :     val expindexB= specialize(beta,(length(alpha)))
359 :     val sumi=length(alpha)+ length(beta)
360 :     val s'=[E.V sumi,E.V(sumi+1)]
361 :     val sx=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]
362 :     in
363 :     E.EIN{
364 :     params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],
365 :     index = alpha@beta,
366 :     body = E.Sum(sx,E.Prod[E.Field(0, expindexA@s'), E.Field(1,s'@expindexB)])
367 :     }
368 :     end
369 :    
370 :     (******************** Norm ********************************)
371 : cchiw 3048
372 : cchiw 2845 (*get norm, but without the sqrt
373 :     * implemented as a summation over a modulate
374 :     *)
375 : cchiw 2906 fun magnitudeTT alpha =let
376 :     val expindex= specialize(alpha,0)
377 : cchiw 3048 val sx= sumIds(length(alpha),0,alpha)
378 :     val e= E.EIN{
379 : cchiw 2845 params = [E.TEN(1,alpha), E.TEN(1,alpha)],
380 :     index = [],
381 :     body = E.Sum(sx,
382 : cchiw 2906 E.Prod[E.Tensor(0, expindex), E.Tensor(1, expindex)])
383 : cchiw 2845 }
384 : cchiw 3048 (*val _=print(String.concat["\ntesting mag tt",P.printerE e ])*)
385 :     in e
386 : cchiw 2845 end
387 :    
388 : cchiw 3048 fun magnitudeFF(dim,[]) =E.EIN{params = [E.FLD(dim),E.FLD(dim)],index = [],body = E.Field(0, [])}
389 :     | magnitudeFF(dim,alpha) =let
390 :     val expindex= specialize(alpha,0)
391 :     val sx= sumIds(length(alpha),0,alpha)
392 :     val e=
393 : cchiw 2906 E.EIN{
394 : cchiw 3048 params = [E.FLD(dim),E.FLD(dim)],
395 : cchiw 2976 index = [],
396 : cchiw 3048 body = E.Sqrt(E.Sum(sx, E.Prod[E.Field(0, expindex),E.Field(1,expindex)]))
397 : cchiw 2906 }
398 : cchiw 3048 (*val _=print(String.concat["\ntesting mag FF",P.printerE e ])*)
399 :     in e
400 :     end
401 :    
402 :     fun normalizeFF(dim,[]) =E.EIN{params = [E.FLD(dim)],index = [],body = E.Field(0, [])}
403 :     | normalizeFF(dim,alpha) =let
404 :     val expindex= specialize(alpha,0)
405 :     (*shift indices in the inner product*)
406 :     val expindexDot= specialize(alpha,length(alpha))
407 :     val i=List.hd alpha
408 :     val sx= sumIds(length(alpha),length(alpha),alpha)
409 :     val f=E.Field(0, expindex)
410 :     val g=E.Field(1, expindexDot)
411 :     val e=
412 : cchiw 2976 E.EIN{
413 :     params = [E.FLD(dim) ,E.FLD(dim)],
414 : cchiw 3048 index = [dim],
415 :     body = E.Prod[f,E.Div(E.Const 1,E.Sqrt(E.Sum(sx, E.Prod[g,g])))]
416 : cchiw 2906 }
417 : cchiw 3048 (*val _=print(String.concat["\ntesting normalize FF",P.printerE e ])*)
418 :     in e
419 : cchiw 2845 end
420 : cchiw 2499
421 : cchiw 2906 (************************* trace *************************)
422 :     (* Trace: <M_{i, i}> This one Sx represents both i's*)
423 :     fun traceT dim = E.EIN{
424 :     params = [E.TEN(1,[dim,dim])],index = [],
425 :     body = E.Sum([(E.V 0,0,dim-1)],E.Tensor(0, [E.V 0, E.V 0]))
426 :     }
427 :    
428 :     (* Trace: <Sigma_i F_{\alpha i, i}> This one Sx represents both i's*)
429 :     fun traceF(dim,alpha) =let
430 :     val expindex= specialize(alpha,0)
431 :     val s=E.V(length(alpha))
432 :     in
433 :     E.EIN{
434 :     params = [E.FLD(dim)],
435 :     index = alpha,
436 :     body = E.Sum([(s,0,dim-1)],E.Field(0, expindex@[s,s]))
437 :     }
438 :     end
439 : cchiw 2499
440 : cchiw 2906 (************************* tranpose *************************)
441 :     fun transposeT alpha =E.EIN{
442 :     params = [E.TEN(1,alpha)],
443 :     index= List.rev alpha,
444 :     body= E.Tensor(0, [E.V 1,E.V 0])
445 :     }
446 : cchiw 2843
447 : cchiw 2906 (*Transpose Field F_{ji}*)
448 :     fun transposeF(dim,i,j) =E.EIN{
449 :     params = [E.FLD(dim)], index= [i,j],
450 :     body= E.Field(0, [E.V 1,E.V 0])
451 :     }
452 : cchiw 3054 (************************* determinant *************************)
453 : cchiw 3066 val detT2 =E.EIN{
454 :     params = [E.TEN(1,[2,2])],
455 :     index= [],
456 :     body= E.Sub(E.Prod[E.Tensor(0, [E.C 0,E.C 0]),E.Tensor(0, [E.C 1,E.C 1])],
457 :     E.Prod[E.Tensor(0, [E.C 0,E.C 1]),E.Tensor(0, [E.C 1,E.C 0])])
458 :     }
459 : cchiw 2843
460 : cchiw 3066 val detF2 =E.EIN{
461 :     params = [E.FLD 2], index= [],
462 :     body= E.Sub(E.Prod[E.Field(0, [E.C 0,E.C 0]),E.Field(0, [E.C 1,E.C 1])],
463 :     E.Prod[E.Field(0, [E.C 0,E.C 1]),E.Field(0, [E.C 1,E.C 0])])
464 :     }
465 : cchiw 3054
466 :    
467 : cchiw 3066 val detF3 =E.EIN{
468 :     params = [E.FLD(3)], index= [],
469 :     body=E.Add[
470 :     E.Prod[E.Field(0, [E.C 0,E.C 0]),E.Field(0, [E.C 1,E.C 1]),E.Field(0, [E.C 2,E.C 2])],
471 :     E.Prod[E.Field(0, [E.C 0,E.C 1]),E.Field(0, [E.C 1,E.C 2]),E.Field(0, [E.C 2,E.C 0])],
472 :     E.Prod[E.Field(0, [E.C 0,E.C 2]),E.Field(0, [E.C 1,E.C 0]),E.Field(0, [E.C 2,E.C 1])],
473 :     E.Prod[E.Field(0, [E.C 0,E.C 2]),E.Field(0, [E.C 1,E.C 1]),E.Field(0, [E.C 2,E.C 0])],
474 :     E.Prod[E.Field(0, [E.C 0,E.C 1]),E.Field(0, [E.C 1,E.C 0]),E.Field(0, [E.C 2,E.C 2])],
475 :     E.Prod[E.Field(0, [E.C 0,E.C 0]),E.Field(0, [E.C 1,E.C 2]),E.Field(0, [E.C 2,E.C 1])]
476 :     ]
477 :     }
478 :    
479 : cchiw 2906 (************************* other tensor ops *************************)
480 :     fun modulate dim =E.EIN{
481 :     params = [E.TEN(1,[dim]), E.TEN(1,[dim])],
482 :     index = [dim],
483 :     body = E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 0])]
484 :     }
485 :    
486 : cchiw 2844 fun identity dim =E.EIN{
487 : cchiw 2906 params = [],index = [dim,dim], body = E.Delta(E.V(0), E.V(1))
488 :     }
489 : cchiw 2499
490 : cchiw 2906 fun slice (argTy,mask,const,rstTy) =let
491 :     fun iter ([],_,cnt)=[]
492 :     | iter(true::es,c::cs,cnt)=[E.C c]@iter(es,cs,cnt)
493 :     |iter(false::es,cs,cnt)=[E.V cnt]@iter(es,cs,cnt+1)
494 :     val ix=iter(mask,const,0)
495 :     in
496 :     E.EIN{ params = [E.TEN(1,argTy)],index = rstTy,body = E.Tensor(0, ix)}
497 : cchiw 2499 end
498 :    
499 : cchiw 2906 (******************** other field ops ********************************)
500 :     (*FLD here is bounded to image field, and dimension of h*)
501 :     fun conv(dim,shape) =let
502 :     val expindex= specialize(shape,0)
503 :     in E.EIN{
504 :     params = [E.IMG(dim,shape),E.KRN],
505 : cchiw 2844 index = shape,
506 : cchiw 2906 body= E.Conv(0,expindex,1,[])
507 :     }
508 :     end
509 :    
510 :     (* Probe: <F(x)>_{\alpha} *)
511 :     fun probe(alpha,dim) = let
512 :     val expindex= specialize(alpha,0)
513 : cchiw 2499 in E.EIN{
514 : cchiw 2906 params = [E.FLD(dim),E.TEN(0,[])], index= alpha,
515 :     body= E.Probe(E.Field(0, expindex), E.Tensor(1,[]))
516 :     }
517 : cchiw 2499 end
518 : cchiw 2906 (***************************** derivative ****************************)
519 :     (*\EinExp{\sum_{ij}\mathcal{E}_{ij} \frac{ F_j}{\partial x_i}*)
520 :     val curl2d=E.EIN{
521 :     params = [E.FLD 2],
522 :     index = [],
523 :     body = E.Sum([(E.V 0,0,1), (E.V 1,0,1)],
524 :     E.Prod[E.Eps2(0, 1),
525 :     E.Apply( E.Partial([E.V 0]), E.Field(0,[E.V 1]))])
526 : cchiw 2499 }
527 : cchiw 2906
528 :     val curl3d=E.EIN{
529 :     params = [E.TEN(1,[3])],
530 :     index = [3],
531 :     body = E.Sum([(E.V 1,0,2), (E.V 2,0,2)],E.Prod[E.Epsilon(0, 1, 2),
532 :     E.Apply( E.Partial([E.V 1]), E.Field(0,[E.V 2]))])
533 : cchiw 2499 }
534 : cchiw 2906
535 : cchiw 2509 (*< d F / d_i>_i *)
536 : cchiw 2845 fun grad alpha=let
537 : cchiw 2605 val a=List.hd(alpha)
538 : cchiw 2844 val expindex= specialize(alpha,0)
539 : cchiw 2499 in E.EIN{
540 :     params = [E.FLD(a)],
541 : cchiw 2844 index =alpha,
542 :     body = E.Apply(E.Partial(expindex),E.Field(0,[]))
543 : cchiw 2906 }
544 : cchiw 2499 end
545 : cchiw 2906
546 : cchiw 2845 (*< Sigma d F_alpha / d x_i>ALpha i CHANGE HERE *)
547 :     fun dotimes(dim,alpha)= let
548 :     val n=length(alpha)
549 :     fun expIndex(n,inc)=List.tabulate(n, (fn(x)=>E.V (x+inc)))
550 :     val i'=expIndex(n,0)
551 : cchiw 2515 in E.EIN{
552 : cchiw 2530 params = [E.FLD(dim)], index =alpha@[dim],
553 :     body = E.Apply(E.Partial [E.V n] ,E.Field(0,i'))
554 : cchiw 2906 }
555 : cchiw 2515 end
556 : cchiw 2906
557 :     (* <d F_i /d_i> *)
558 :     fun divergence(dim,alpha)=let
559 : cchiw 2845 val expindex= specialize(alpha,0)
560 :     val sumI=length(alpha)
561 :     val sumIndex=E.V(sumI)
562 :     val sumIndexL=[sumIndex]
563 :     val S=expindex@sumIndexL
564 : cchiw 2499 in E.EIN{
565 :     params = [E.FLD(dim)],
566 : cchiw 2844 index = alpha,
567 : cchiw 2906 body = E.Sum([(sumIndex,0,dim-1)],
568 :     E.Apply(E.Partial(sumIndexL),E.Field(0,S)))
569 : cchiw 2845 }
570 : cchiw 2576 end
571 : cchiw 2867
572 : cchiw 2499 end; (* local *)
573 :    
574 :     end (* local *)

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