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

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