Home My Page Projects Code Snippets Project Openings diderot

# SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/ein/mkoperators.sml
 [diderot] / branches / charisee / src / compiler / ein / mkoperators.sml

# Diff of /branches/charisee/src/compiler/ein/mkoperators.sml

revision 2843, Mon Dec 8 01:27:25 2014 UTC revision 2844, Tue Dec 9 18:05:29 2014 UTC
# Line 1  Line 1
1  (* examples.sml  (* creates EIN operators
2   *   *
3   * COPYRIGHT (c) 2012 The Diderot Project (http://diderot-language.cs.uchicago.edu)   * COPYRIGHT (c) 2012 The Diderot Project (http://diderot-language.cs.uchicago.edu)
# Line 12  Line 12
12      structure P=Printer      structure P=Printer
13      in      in
14
15        fun specialize(alpha,inc)=  List.tabulate(length(alpha), (fn(x)=>E.V (x+inc)))
16
fun expIndex(n,inc)=List.tabulate(n, (fn(x)=>E.V (x+inc)))
fun expIndexP(n,inc)=List.tabulate(n, (fn(x)=> (x+inc)))

fun specialize(alpha,inc)=(alpha,expIndex(length(alpha),inc))
fun specializeP(alpha,inc)=(alpha,expIndexP(length(alpha),inc))

(*mkTensor functions*)
17      (* Adding tensors : < X{\alpha} + Y_{\alpha}>_{\alpha} *)      (* Adding tensors : < X{\alpha} + Y_{\alpha}>_{\alpha} *)
19          val (index', expindex')= specialize(alpha,0)          val expindex= specialize(alpha,0)
20          in          in
21              E.EIN{              E.EIN{
22              params = [E.TEN(1,alpha), E.TEN(1,alpha)], index = index',              params = [E.TEN(1,alpha), E.TEN(1,alpha)], index = alpha,
23              body = E.Add[E.Tensor(0, expindex'), E.Tensor(1, expindex')]              body = E.Add[E.Tensor(0, expindex), E.Tensor(1, expindex)]
24              }              }
25          end          end
26
27      fun createVec(dim)=E.EIN{      fun createVec dim=E.EIN{
28          params = [E.TEN(1,[dim])], index = [dim],          params = [E.TEN(1,[dim])], index = [dim],
29          body = E.Tensor(0, [E.V 0])          body = E.Tensor(0, [E.V 0])
30          }          }
31

32       val zero=E.EIN{       val zero=E.EIN{
33          params = [], index = [],          params = [], index = [],
34          body = E.Const(0)          body = E.Const(0)
35          }          }
36
37
38         fun subTen alpha=let
39       (* Subtracting tensors *)          val expindex= specialize(alpha,0)
fun subTen(alpha)=let
val (index', expindex')= specialize(alpha,0)
40          in          in
41              E.EIN{              E.EIN{
42              params = [E.TEN(1,alpha), E.TEN(1,alpha)], index = index',              params = [E.TEN(1,alpha), E.TEN(1,alpha)], index = alpha,
43              body = E.Sub(E.Tensor(0, expindex'), E.Tensor(1, expindex'))}              body = E.Sub(E.Tensor(0, expindex), E.Tensor(1, expindex))}
44          end          end
45
46      fun divTen(alpha) =let      fun divTen alpha =let
47          val (index', expindex')= specialize(alpha,0)          val expindex= specialize(alpha,0)
48          in  E.EIN{          in  E.EIN{
49              params = [E.TEN(1,alpha), E.TEN(1,[])], index = index',              params = [E.TEN(1,alpha), E.TEN(1,[])], index = alpha,
50              body = E.Div(E.Tensor(0, expindex'), E.Tensor(1,[]))              body = E.Div(E.Tensor(0, expindex), E.Tensor(1,[]))
51          }          }
52          end          end
53
54      (* Trace: <M_{i, i}>  This one Sx represents both i's*)      (* Trace: <M_{i, i}>  This one Sx represents both i's*)
55      fun trace(dim) = E.EIN{      fun trace dim = E.EIN{
56          params = [E.TEN(1,[dim,dim])],         (* M *)          params = [E.TEN(1,[dim,dim])],
57          index = [],           (* i *)          index = [],
58          body = E.Sum([(E.V 0,0,dim-1)],E.Tensor(0, [E.V 0, E.V 0]))          body = E.Sum([(E.V 0,0,dim-1)],E.Tensor(0, [E.V 0, E.V 0]))
59      }      }
60
61      fun negTen(alpha)=let      fun negTen alpha=let
62          val (index', expindex')= specialize(alpha,0)          val  expindex= specialize(alpha,0)
63          in E.EIN{          in E.EIN{
64              params = [E.TEN(1,alpha)],              params = [E.TEN(1,alpha)],
65              index = index',              index = alpha,
66              body = E.Neg(E.Tensor(0, expindex'))              body = E.Neg(E.Tensor(0, expindex))
67          }          }
68          end          end
69
70      (* scalar times tensor product: <s * T_{\alpha}>_{\alpha} *)      (* scalar times tensor product: <s * T_{\alpha}>_{\alpha} *)
71      fun scaleTen(alpha) = let      fun scaleTen alpha = let
72          val (index', expindex')= specialize(alpha,0)          val expindex= specialize(alpha,0)
73          in E.EIN{          in E.EIN{
74              params = [E.TEN(1,[]), E.TEN(1,alpha)],    (* s and T *)              params = [E.TEN(1,[]), E.TEN(1,alpha)],    (* s and T *)
75              index = index',           (* \alpha *)              index = alpha,           (* \alpha *)
76              body = E.Prod[ E.Tensor(0, []),  E.Tensor(1, expindex')]              body = E.Prod[ E.Tensor(0, []),  E.Tensor(1, expindex)]
77          }          }
78          end          end
79
80      (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)      (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
81      fun innerProduct(shape1,i::beta) = let      fun innerProduct(shape1,i::beta) = let
82          val alpha= List.take(shape1,length(shape1)-1)          val alpha= List.take(shape1,length(shape1)-1)
83          val (indexA, expindexA)= specialize(alpha,0)          val expindexA= specialize(alpha,0)
84          val (indexB, expindexB)= specialize(beta,(length(alpha)))          val expindexB= specialize(beta,(length(alpha)))
85          val s'=E.V(length(alpha)+ length(beta))          val s'=E.V(length(alpha)+ length(beta))
86          val s''=[(s',0,i-1)]          val s''=[(s',0,i-1)]
87          in E.EIN{          in E.EIN{
88               params = [E.TEN(1,shape1) ,E.TEN(1,i::beta)],              (* T and T' *)               params = [E.TEN(1,shape1) ,E.TEN(1,i::beta)],              (* T and T' *)
89              index = indexA@indexB,   (* \alpha \beta, i *)              index = alpha@beta,   (* \alpha \beta, i *)
90              body = E.Sum(s'', E.Prod[              body = E.Sum(s'', E.Prod[
91                  E.Tensor(0, expindexA@[s']),   (* T_{\alpha i} *)                  E.Tensor(0, expindexA@[s']),   (* T_{\alpha i} *)
92                  E.Tensor(1, [s']@expindexB )  (* T'_{i \beta} *)                  E.Tensor(1, [s']@expindexB )  (* T'_{i \beta} *)
# Line 107  Line 98
98      (*<T_{\alpha i j} * B{i j \beta }>_\alpha \beta*)      (*<T_{\alpha i j} * B{i j \beta }>_\alpha \beta*)
99      fun doubleDot(shape1,i::j::beta) = let      fun doubleDot(shape1,i::j::beta) = let
100          val alpha= List.take(shape1,length(shape1)-2)          val alpha= List.take(shape1,length(shape1)-2)
101          val (indexA, expindexA)= specialize(alpha,0)          val expindexA= specialize(alpha,0)
102          val (indexB, expindexB)= specialize(beta,(length(alpha)))          val expindexB= specialize(beta,(length(alpha)))
103          val sumi=length(alpha)+ length(beta)          val sumi=length(alpha)+ length(beta)
104          val s'=[E.V sumi,E.V(sumi+1)]          val s'=[E.V sumi,E.V(sumi+1)]
105          val s''=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]          val s''=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]
106          in E.EIN{          in E.EIN{
107              params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],              params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],
108              index = indexA@indexB,              index = alpha@beta,
109              body = E.Sum(s'',E.Prod[              body = E.Sum(s'',E.Prod[
110                  E.Tensor(0, expindexA@s'),                  E.Tensor(0, expindexA@s'),
111                  E.Tensor(1,s'@expindexB)                  E.Tensor(1,s'@expindexB)
# Line 138  Line 129
129          | transpose _= raise Fail "too many indices for transpose"          | transpose _= raise Fail "too many indices for transpose"
130
131
132      fun modulate(dim) =E.EIN{      fun modulate dim =E.EIN{
133          params = [E.TEN(1,[dim]), E.TEN(1,[dim])],          params = [E.TEN(1,[dim]), E.TEN(1,[dim])],
134          index = [dim],          index = [dim],
135          body = E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 0])]          body = E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 0])]
# Line 163  Line 154
154
155
156      (* Identiy: <\delta_{i j}>_{i j}  *)      (* Identiy: <\delta_{i j}>_{i j}  *)
157      fun identity(dim) =E.EIN{      fun identity dim =E.EIN{
158          params = [],          params = [],
159          index = [dim,dim],          index = [dim,dim],
160          body = E.Delta(E.V(0), E.V(1))          body = E.Delta(E.V(0), E.V(1))
161      }      }
162
163      (*Tensor and Fields*)      (*Tensor and Fields*)
165          params = [E.TEN(1,[]),E.FLD(dim)],          params = [E.TEN(1,[]),E.FLD(dim)],
166          index = [],          index = [],
168      }      }
169
170      fun subTenField(dim) = E.EIN{      fun subTenField dim = E.EIN{
171          params = [E.TEN(1,[]),E.FLD(dim)],          params = [E.TEN(1,[]),E.FLD(dim)],
172          index = [],          index = [],
174      }      }
175
176      fun subFieldTen(dim) = E.EIN{      fun subFieldTen dim = E.EIN{
177          params = [E.TEN(1,[]),E.FLD(dim)],          params = [E.TEN(1,[]),E.FLD(dim)],
178          index = [],          index = [],
179          body = E.Sub(E.Field(1, []),E.Lift(E.Tensor(0, [])))          body = E.Sub(E.Field(1, []),E.Lift(E.Tensor(0, [])))
# Line 191  Line 182
182      (* mkField functions*)      (* mkField functions*)
183      (*Adding Fields : < F{\alpha} + G_{\alpha}>_{\alpha} *)      (*Adding Fields : < F{\alpha} + G_{\alpha}>_{\alpha} *)
185          val (index', expindex')= specialize(shape,0)          val expindex= specialize(shape,0)
186          in E.EIN{          in E.EIN{
187              params = [E.FLD(dim),E.FLD(dim)],              params = [E.FLD(dim),E.FLD(dim)],
188              index = index',              index = shape,
190          }          }
191          end          end
192
193      fun subField(dim,shape) =let      fun subField(dim,shape) =let
194          val (index', expindex')= specialize(shape,0)          val expindex= specialize(shape,0)
195          in E.EIN{          in E.EIN{
196              params = [E.FLD(dim),E.FLD(dim)],              params = [E.FLD(dim),E.FLD(dim)],
197              index = index',              index = shape,
198              body = E.Sub(E.Field(0, expindex'),E.Field(1, expindex'))              body = E.Sub(E.Field(0, expindex),E.Field(1, expindex))
199          }          }
200          end          end
201
202      fun scaleField(dim,shape) =let      fun scaleField(dim,shape) =let
203          val (index', expindex')= specialize(shape,0)          val  expindex= specialize(shape,0)
204          in E.EIN{          in E.EIN{
205              params = [E.TEN(1,[]),E.FLD(dim)],              params = [E.TEN(1,[]),E.FLD(dim)],
206              index = index',              index = shape,
207              body = E.Prod[E.Lift( E.Tensor(0,[])), E.Field(1,expindex')]              body = E.Prod[E.Lift( E.Tensor(0,[])), E.Field(1,expindex)]
208          }          }
209          end          end
210
211      fun divideField(dim,shape) = let      fun divideField(dim,shape) = let
212          val (index', expindex')= specialize(shape,0)          val expindex= specialize(shape,0)
213          in E.EIN{          in E.EIN{
214              params = [E.FLD(dim),E.TEN(1,[])],              params = [E.FLD(dim),E.TEN(1,[])],
215              index = index',              index = shape,
216              body = E.Div(E.Field(0, expindex'),E.Lift(  E.Tensor(1, [])))              body = E.Div(E.Field(0, expindex),E.Lift(  E.Tensor(1, [])))
217          }          }
218          end          end
219
220      fun negField(dim,shape) = let      fun negField(dim,shape) = let
221          val (index', expindex')= specialize(shape,0)          val expindex = specialize(shape,0)
222          in E.EIN{          in E.EIN{
223              params = [E.FLD(dim)],              params = [E.FLD(dim)],
224              index = index',              index = shape,
225              body = E.Neg(E.Field(0, expindex'))              body = E.Neg(E.Field(0, expindex))
226          }          }
227          end          end
228
229      (*< d F /  d_i>_i  *)      (*< d F /  d_i>_i  *)
231          val a=List.hd(alpha)          val a=List.hd(alpha)
232            val  expindex= specialize(alpha,0)
val (index', expindex')= specialize(alpha,0)
233          in E.EIN{          in E.EIN{
234              params = [E.FLD(a)],              params = [E.FLD(a)],
235              index =index',              index =alpha,
236              body = E.Apply(E.Partial(expindex'),E.Field(0,[]))              body = E.Apply(E.Partial(expindex),E.Field(0,[]))
237          }          }
238          end          end
239
# Line 252  Line 242
242               val n=length(alpha)               val n=length(alpha)
243               fun expIndex(n,inc)=List.tabulate(n, (fn(x)=>E.V (x+inc)))               fun expIndex(n,inc)=List.tabulate(n, (fn(x)=>E.V (x+inc)))
244               val i'=expIndex(n,0)               val i'=expIndex(n,0)

245          in E.EIN{          in E.EIN{
246              params = [E.FLD(dim)], index =alpha@[dim],              params = [E.FLD(dim)], index =alpha@[dim],
247              body = E.Apply(E.Partial [E.V n] ,E.Field(0,i'))              body = E.Apply(E.Partial [E.V n] ,E.Field(0,i'))
# Line 261  Line 249
249          end          end
250
251      (*  <d F_i /d_i> *)      (*  <d F_i /d_i> *)
(*Need to change here *)

fun fs i =Int.toString(length(i))
fun f i =Int.toString(i)
252
253          fun divergence(dim,alpha)=let          fun divergence(dim,alpha)=let
254                val  expindex= specialize(alpha,0)
val (index', expindex')= specialize(alpha,0)
255              val sumI=length(alpha)              val sumI=length(alpha)
val _=print (String.concat["\n\n Divergence, length alpha", fs(alpha),"length expindex", fs(expindex'),"\n Dimension", f(dim),
"SumI", f(sumI)
])

256          val sumIndex=E.V(sumI)          val sumIndex=E.V(sumI)
257          val sumIndexL=[sumIndex]          val sumIndexL=[sumIndex]
258          val S=expindex'@sumIndexL              val S=expindex@sumIndexL
259
260          in E.EIN{          in E.EIN{
261              params = [E.FLD(dim)],              params = [E.FLD(dim)],
262              index = index',              index = alpha,
263              body = E.Sum([(sumIndex,0,dim-1)],E.Apply(E.Partial(sumIndexL),E.Field(0,S)))              body = E.Sum([(sumIndex,0,dim-1)],E.Apply(E.Partial(sumIndexL),E.Field(0,S)))
264          }          }
265          end          end
266
267      (*FLD here is bounded to image field, and dimension of h*)      (*FLD here is bounded to image field, and dimension of h*)
268      fun conv(dim,shape) =let      fun conv(dim,shape) =let
269          val (index', expindex')= specialize(shape,0)          val expindex= specialize(shape,0)
270          in E.EIN{          in E.EIN{
271              params = [E.IMG(dim),E.KRN],              params = [E.IMG(dim,shape),E.KRN],
272              index = index',              index = shape,
273              body= E.Conv(0,expindex',1,[])              body= E.Conv(0,expindex,1,[])
274          }          }
275          end          end
276
277      (* Probe: <F(x)>_{\alpha}   *)      (* Probe: <F(x)>_{\alpha}   *)
278      fun probe(alpha,dim) = let      fun probe(alpha,dim) = let
279          val (indexT, expindexT)= specialize(alpha,0)          val  expindex= specialize(alpha,0)
280
281          in E.EIN{          in E.EIN{
282              params = [E.FLD(dim),E.TEN(0,[])],              params = [E.FLD(dim),E.TEN(0,[])],
283              index= indexT,              index= alpha,
284              body= E.Probe(E.Field(0, expindexT), E.Tensor(1,[]))              body= E.Probe(E.Field(0, expindex), E.Tensor(1,[]))
285          }          }
286          end          end
287
# Line 324  Line 303
303
304          }          }
305

306      val curl3d=E.EIN{      val curl3d=E.EIN{
307          params = [E.TEN(1,[3])],          params = [E.TEN(1,[3])],
308          index = [3],          index = [3],
# Line 394  Line 372
372      }      }
373
374      fun mulFieldsf(dim,shape) =let      fun mulFieldsf(dim,shape) =let
375          val (index', expindex')= specialize(shape,0)          val  expindex= specialize(shape,0)
376          in E.EIN{          in E.EIN{
377          params = [E.FLD(dim),E.FLD(dim)],          params = [E.FLD(dim),E.FLD(dim)],
378          index = index',          index = shape,
379          body = E.Prod[E.Field(0, []),E.Field(1, expindex')]          body = E.Prod[E.Field(0, []),E.Field(1, expindex)]
380          }          }
381          end          end
382
# Line 409  Line 387
387          }          }
388
389
390  (*      (*Assumes same dimension vector field *)
391      (*Outer Product  Fields : < F{i} + G_{j}>_{ij} *)      fun outerField dim =
fun outerField(dim,i, j) =let
val (index', expindex')= specialize(i@j,0)
in
E.EIN{
params = [E.FLD(dim),E.FLD(dim)],
index = index',
body = E.Prod[E.Field(0, [E.V 0]),E.Field(1, [E.V 1])]
}
end

*)

(*Assumes same dimension vetcor field *)
fun outerField(dim) =
392          E.EIN{          E.EIN{
393              params = [E.FLD(dim),E.FLD(dim)],              params = [E.FLD(dim),E.FLD(dim)],
394              index = [dim, dim],              index = [dim, dim],
# Line 438  Line 402
402
403          fun innerProductField(shape1,dim,i::beta) = let          fun innerProductField(shape1,dim,i::beta) = let
404              val alpha= List.take(shape1,length(shape1)-1)              val alpha= List.take(shape1,length(shape1)-1)
405              val (indexA, expindexA)= specialize(alpha,0)          val expindexA= specialize(alpha,0)
406              val (indexB, expindexB)= specialize(beta,(length(alpha)))          val expindexB= specialize(beta,(length(alpha)))
407              val s'=E.V(length(alpha)+ length(beta))              val s'=E.V(length(alpha)+ length(beta))
408              val s''=[(s',0,i-1)]              val s''=[(s',0,i-1)]
409
410              val _=print(String.concat["Inner product Field. ",f(indexA)])          val _=print(String.concat["Inner product Field. ",f(alpha)])
411              in E.EIN{              in E.EIN{
412                  params = [E.FLD(dim) ,E.FLD(dim)],              (* T and T' *)                  params = [E.FLD(dim) ,E.FLD(dim)],              (* T and T' *)
413                  index = indexA@indexB,(* \alpha \beta, i *)              index = alpha@beta,(* \alpha \beta, i *)
414                  body = E.Sum(s'', E.Prod[                  body = E.Sum(s'', E.Prod[
415                      E.Field(0, expindexA@[s']),   (* F_{\alpha i} *)                      E.Field(0, expindexA@[s']),   (* F_{\alpha i} *)
416                      E.Field(1, [s']@expindexB )  (* F'_{i \beta} *)                      E.Field(1, [s']@expindexB )  (* F'_{i \beta} *)
# Line 462  Line 426
426              E.Prod[ E.Epsilon(0, 1, 2), E.Field(0, [E.V 1]),  E.Field(1, [E.V 2 ]) ])              E.Prod[ E.Epsilon(0, 1, 2), E.Field(0, [E.V 1]),  E.Field(1, [E.V 2 ]) ])
427           }           }
428

429      (* Trace: <Sigma_i F_{\alpha i, i}>  This one Sx represents both i's*)      (* Trace: <Sigma_i F_{\alpha i, i}>  This one Sx represents both i's*)
430          fun traceField(dim,alpha) =let          fun traceField(dim,alpha) =let
431              val (indexA, expindexA)= specialize(alpha,0)              val expindex= specialize(alpha,0)
432              val s=E.V(length(alpha))              val s=E.V(length(alpha))
433              in              in
434              E.EIN{              E.EIN{
435               params = [E.FLD(dim)],               params = [E.FLD(dim)],
436               index = indexA,               index = alpha,
437               body = E.Sum([(s,0,dim-1)],E.Field(0, expindexA@[s,s]))               body = E.Sum([(s,0,dim-1)],E.Field(0, expindex@[s,s]))
438               }               }
439              end              end
440
# Line 481  Line 444
444          body= E.Field(0, [E.V 1,E.V 0])          body= E.Field(0, [E.V 1,E.V 0])
445          }          }
446

447      (*<F_{\alpha i j} * G{i j \beta }>_\alpha \beta*)      (*<F_{\alpha i j} * G{i j \beta }>_\alpha \beta*)
448      fun doubleDotField(shape1,i::j::beta) = let      fun doubleDotField(shape1,i::j::beta) = let
449          val alpha= List.take(shape1,length(shape1)-2)          val alpha= List.take(shape1,length(shape1)-2)
450          val (indexA, expindexA)= specialize(alpha,0)          val expindexA= specialize(alpha,0)
451          val (indexB, expindexB)= specialize(beta,(length(alpha)))          val expindexB= specialize(beta,(length(alpha)))
452          val sumi=length(alpha)+ length(beta)          val sumi=length(alpha)+ length(beta)
453          val s'=[E.V sumi,E.V(sumi+1)]          val s'=[E.V sumi,E.V(sumi+1)]
454          val s''=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]          val s''=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]
455          in          in
456              E.EIN{              E.EIN{
457                  params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],                  params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],
458                  index = indexA@indexB,                  index = alpha@beta,
459                  body = E.Sum(s'',E.Prod[E.Field(0, expindexA@s'), E.Field(1,s'@expindexB)])                  body = E.Sum(s'',E.Prod[E.Field(0, expindexA@s'), E.Field(1,s'@expindexB)])
460              }              }
461          end          end

Legend:
 Removed from v.2843 changed lines Added in v.2844