Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /branches/charisee/src/compiler/ein/operators.sml
ViewVC logotype

Annotation of /branches/charisee/src/compiler/ein/operators.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2383 - (view) (download)

1 : cchiw 2383 (* examples.sml
2 :     *
3 :     * COPYRIGHT (c) 2012 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     * All rights reserved.
5 :     *)
6 :    
7 :     structure Operators = struct
8 :    
9 :     local
10 :     structure G = GenericEin
11 :     structure E = Ein
12 :     structure S = Specialize
13 :     structure R = Rewrite
14 :     in
15 :    
16 :     (***************************Generic Operators *********************************)
17 :    
18 :    
19 :     val addScalars= G.EIN{
20 :     params = [G.TEN, G.TEN],
21 :     index = [],
22 :     body = G.Add[G.Tensor(0, []),G.Tensor(1, [])]
23 :     }
24 :    
25 :    
26 :    
27 :    
28 :     (* Adding tensors : < X{\alpha} + Y_{\alpha}>_{\alpha} *)
29 :     val addTensor = G.EIN{
30 :     params = [G.TEN, G.TEN],
31 :     index = [G.MX],
32 :     body = G.Add[
33 :     G.Tensor(0, [0]),
34 :     G.Tensor(1, [0])
35 :     ]
36 :     }
37 :    
38 :     (* Adding Fields : < F{\alpha} + G_{\alpha}>_{\alpha} *)
39 :     val addField = G.EIN{
40 :     params = [G.FLD,G.FLD], (*changed from tensor to field*)
41 :     index = [G.MX],
42 :     body = G.Add[G.Field(0, [0]),G.Field(1, [0])]
43 :     }
44 :    
45 :     val addTenField = G.EIN{
46 :     params = [G.TEN,G.FLD],
47 :     index = [G.MX],
48 :     body = G.Add[G.Tensor(0, []),G.Field(1, [0])]
49 :     }
50 :    
51 :    
52 :     val subScalars = G.EIN{
53 :     params = [G.TEN, G.TEN],
54 :     index = [],
55 :     body = G.Sub(G.Tensor(0, []), G.Tensor(1, []))
56 :     }
57 :    
58 :    
59 :     (* Subtracting tensors *)
60 :     val subTensor = G.EIN{
61 :     params = [G.TEN, G.TEN],
62 :     index = [G.MX],
63 :     body = G.Sub(G.Tensor(0, [0]), G.Tensor(1, [0]))
64 :     }
65 :    
66 :    
67 :     (* Subtracting Fields *)
68 :     val subField = G.EIN{
69 :     params = [G.FLD, G.FLD],
70 :     index = [G.MX],
71 :     body = G.Sub(G.Field(0, [0]), G.Field(1, [0]))
72 :     }
73 :    
74 :     val subTenField = G.EIN{
75 :     params = [G.TEN,G.FLD],
76 :     index = [G.MX],
77 :     body = G.Sub(G.Tensor(0, []),G.Field(1, [0]))
78 :     }
79 :    
80 :    
81 :     (* scalar times a scalar product: <s1 * s2> *)
82 :     val scalarxscalar = G.EIN{
83 :     params = [G.TEN, G.TEN],
84 :     index = [],
85 :     body = G.Prod[G.Tensor(0, []), G.Tensor(1, []) ]
86 :     }
87 :    
88 :    
89 :     (* scalar times tensor product: <s * T_{\alpha}>_{\alpha} *)
90 :     val scaleTensor = G.EIN{
91 :     params = [G.TEN, G.TEN], (* s and T *)
92 :     index = [G.MX], (* \alpha *)
93 :     body = G.Prod[ G.Tensor(0, []), G.Tensor(1, [0]) ]
94 :     }
95 :    
96 :     val scaleField = G.EIN{
97 :     params = [G.TEN, G.FLD], (* s and T *)
98 :     index = [G.MX], (* \alpha *)
99 :     body = G.Prod[ G.Tensor(0, []), G.Field(1, [0]) ]
100 :     }
101 :    
102 :    
103 :    
104 :     val conv = G.EIN{
105 :     params = [],
106 :     index = [G.MX],
107 :     body= G.Conv("V",[], "h", 0)
108 :     }
109 :    
110 :     val conv1d = G.EIN{
111 :     params = [],
112 :     index = [],
113 :     body= G.Conv("V",[(3,2)], "h", 0)
114 :     }
115 :    
116 :    
117 :     (* Probe: <F(x)>_{\alpha} *)
118 :     val probe = G.EIN{
119 :     params = [G.FLD],
120 :     index= [G.MX],
121 :     body= G.Probe(G.Field(0, [0]), 1) (* F_{\alpha} Tensor1 is position*)
122 :     }
123 :    
124 :    
125 :     (*< d F / d_i>_i *)
126 :     val Grad=G.EIN{
127 :     params = [G.FLD],
128 :     index = [G.IX],
129 :     body = G.Apply( G.Partial([0]),G.Field(0,[]))
130 :     }
131 :    
132 :    
133 :     (* <d F_i /d_i> *)
134 :     val Divergence= G.EIN{
135 :     params = [G.FLD],
136 :     index = [G.SX],
137 :     body = G.Sum(1,G.Apply( G.Partial([0]),G.Field(0,[0])))
138 :     }
139 :    
140 :    
141 :    
142 :    
143 :    
144 :     val divOuterProduct=G.EIN{
145 :     params = [G.TEN],
146 :     index = [G.MX,G.IX],
147 :     body = G.Apply( G.Partial([0]),G.Tensor(5,[1]))
148 :     }
149 :    
150 :    
151 :    
152 :    
153 :    
154 :     (* generic inner product: <T_{\alpha i} * T'_{i \beta}>_{\alpha \beta} *)
155 :     val innerProduct = G.EIN{
156 :     params = [G.TEN, G.TEN], (* T and T' *)
157 :     index = [G.MX, G.MX, G.SX], (* \alpha \beta, i *)
158 :     body = G.Sum(1, G.Prod[
159 :     G.Tensor(0, [0,2]), (* T_{\alpha i} *)
160 :     G.Tensor(1, [2,1]) (* T'_{i \beta} *)
161 :     ])
162 :     }
163 :    
164 :    
165 :    
166 :     (* <T_{\alpha i j} * T'{i j \beta }>_\alpha \beta *)
167 :     val doubleDot= G.EIN{
168 :     params = [G.TEN,G.TEN],
169 :     index = [G.MX, G.MX, G.SX, G.SX],
170 :     body = G.Sum(2,G.Prod[
171 :     G.Tensor(0, [0,2,3]),
172 :     G.Tensor(1,[2,3,1])
173 :     ])
174 :     }
175 :    
176 :    
177 :     (* Trace: <M_{i, i}> This one Sx represents both i's*)
178 :     val trace = G.EIN{
179 :     params = [G.TEN], (* M *)
180 :     index = [G.SX], (* i *)
181 :     body = G.Sum(1,G.Tensor(0, [0,0]))
182 :     }
183 :    
184 :    
185 :    
186 :     (* Identiy: <\delta_{i j}>_{i j} *)
187 :     val identity = G.EIN{
188 :     params = [],
189 :     index = [G.IX,G.IX],(*[G.IX,G.IX], *) (*MX-i then MX-j*)
190 :     body = G.Delta(0, 1)
191 :     }
192 :    
193 :     (*OuterProduct can between vectors and Tensors
194 :     A_i T_jk=> P_ijk
195 :     T_ij A_k=>P_ijk
196 :     Vector Examples : <T_i * T_j>_ij*)
197 :     val outerProduct = G.EIN{
198 :     params = [G.TEN, G.TEN],
199 :     index= [G.MX, G.MX],
200 :     body= G.Prod[
201 :     G.Tensor(0, [0]), (* T_i *)
202 :     G.Tensor(1, [1]) (* T_j *)
203 :     ]}
204 :    
205 :    
206 :    
207 :    
208 :     (***************************Ein Terms*********************************)
209 :     (*crossProduct is on 3D vectors *)
210 :     val crossProductE = E.EIN{
211 :     params = [E.TEN, E.TEN],
212 :     index= [E.IX(3),E.SX(3), E.SX(3)],
213 :     body=(* E.Sum(2,*) E.Prod[ E.Epsilon(0, 1, 2), E.Tensor(0, [1]), E.Tensor(1, [2]) ]
214 :     }
215 :     (*Need to examine curl here
216 :     val Curl2d=E.EIN{
217 :     params = [E.FLD],
218 :     index = [E.IX, E.SX, E.SX],
219 :     body = E.Sum(2,E.Apply( E.Partial([1]), E.Prod[E.Epsilon(0, 1, 2), E.Field(5,[2])]))
220 :     }
221 :    
222 :     val Curl3d=E.EIN{
223 :     params = [E.TEN],
224 :     index = [E.IX, E.SX, E.SX],
225 :     body = E.Sum(2,E.Apply( E.Partial([1]), E.Prod[E.Epsilon(0, 1, 2), E.Field(5,[2])]))
226 :     }
227 :     *)
228 :     (***************************************************************)
229 :    
230 :     end; (* local *)
231 :    
232 :     end (* local *)

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