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

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