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

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