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

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