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 2905, Mon Mar 2 11:57:32 2015 UTC revision 2906, Mon Mar 2 17:44:30 2015 UTC
# Line 15  Line 15
15      fun specialize(alpha,inc)=  List.tabulate(length(alpha), (fn(x)=>E.V (x+inc)))      fun specialize(alpha,inc)=  List.tabulate(length(alpha), (fn(x)=>E.V (x+inc)))
16      fun sumIds(n,i)=List.tabulate(n, (fn v=>(E.V v, 0, i)))      fun sumIds(n,i)=List.tabulate(n, (fn v=>(E.V v, 0, i)))
17
18
21            params = [E.TEN(1,[]), E.TEN(1,[])] ,
22            index = [],
23            body = E.Add[ E.Tensor(0, []), E.Tensor(1, [])]
24        }
25
26      (* Adding tensors : < X{\alpha} + Y_{\alpha}>_{\alpha} *)      (* Adding tensors : < X{\alpha} + Y_{\alpha}>_{\alpha} *)
28          val expindex= specialize(alpha,0)          val expindex= specialize(alpha,0)
29          in          in
30              E.EIN{              E.EIN{
# Line 26  Line 34
34              }              }
35          end          end
36
37      fun createVec dim=      (* mkField functions*)
38          E.EIN{params = [E.TEN(1,[dim])], index = [dim], body = E.Tensor(0, [E.V 0])}      (*Adding Fields : < F{\alpha} + G_{\alpha}>_{\alpha} *)
40       val zero=          val expindex= specialize(shape,0)
41          E.EIN{params = [], index = [], body = E.Const(0)}          in E.EIN{
42                params = [E.FLD(dim),E.FLD(dim)],
43       fun subTen alpha=let              index = shape,
44          val expindex= specialize(alpha,0)              body = E.Add[E.Field(0, expindex),E.Field(1, expindex)]
in
E.EIN{
params = [E.TEN(1,alpha), E.TEN(1,alpha)],
index = alpha,
body = E.Sub(E.Tensor(0, expindex), E.Tensor(1, expindex))
45              }              }
46          end          end
47
48      fun divTen alpha =let      (*Tensor and Fields*)
49          val expindex= specialize(alpha,0)      fun addTF(dim,shape) =let
50          in          val expindex= specialize(shape,0)
51              E.EIN{          in E.EIN{
52                  params = [E.TEN(1,alpha), E.TEN(1,[])],              params = [E.TEN(1,shape),E.FLD(dim)],
53                  index = alpha,              index = shape,
54                  body = E.Div(E.Tensor(0, expindex), E.Tensor(1,[]))              body = E.Add[E.Lift(E.Tensor(0, expindex)),E.Field(1, expindex)]
55              }              }
56          end          end
57        (********************************* Sub **************************************)
58      (* Trace: <M_{i, i}>  This one Sx represents both i's*)      (* Subtract Scalars*)
59      fun trace dim = E.EIN{      val subRR = E.EIN{
60              params = [E.TEN(1,[dim,dim])],          params = [E.TEN(1,[]), E.TEN(1,[])],
61              index = [],              index = [],
62              body = E.Sum([(E.V 0,0,dim-1)],E.Tensor(0, [E.V 0, E.V 0]))          body = E.Sub( E.Tensor(0, []), E.Tensor(1, []))
63          }          }
64
65      fun negTen alpha=let      fun subTT alpha=let
66          val  expindex= specialize(alpha,0)          val  expindex= specialize(alpha,0)
67          in          in
68              E.EIN{              E.EIN{
69                  params = [E.TEN(1,alpha)],                  params = [E.TEN(1,alpha), E.TEN(1,alpha)],
70                  index = alpha,                  index = alpha,
71                  body = E.Neg(E.Tensor(0, expindex))                  body = E.Sub(E.Tensor(0, expindex), E.Tensor(1, expindex))
72              }              }
73          end          end
74
75      (* scalar times tensor product: <s * T_{\alpha}>_{\alpha} *)      fun subTF(dim,shape) =let
76      fun scaleTen alpha = let          val expindex= specialize(shape,0)
val expindex= specialize(alpha,0)
77          in          in
78              E.EIN{              E.EIN{
79                  params = [E.TEN(1,[]), E.TEN(1,alpha)],                  params = [E.TEN(1,shape),E.FLD(dim)],
80                  index = alpha,                  index = shape,
81                  body = E.Prod[ E.Tensor(0, []),  E.Tensor(1, expindex)]                  body = E.Add[E.Lift(E.Tensor(0, expindex)),E.Neg(E.Field(1, expindex))]
82              }              }
83          end          end
84
85      fun dot i =      fun subFT(dim,shape) = let
86          E.EIN{          val expindex= specialize(shape,0)
params = [E.TEN(1,[i]) ,E.TEN(1,[i])],
index = [],
body = E.Sum([(E.V 0,0,i-1)], E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 0])])
}

(* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
fun innerProduct(shape1,i::beta) = let
val alpha= List.take(shape1,length(shape1)-1)
val expindexA= specialize(alpha,0)
val expindexB= specialize(beta,(length(alpha)))
val s'=E.V(length(alpha)+ length(beta))
val s''=[(s',0,i-1)]
87          in          in
88              E.EIN{              E.EIN{
89                  params = [E.TEN(1,shape1) ,E.TEN(1,i::beta)],                  params = [E.TEN(1,[]),E.FLD(dim)],
90                  index = alpha@beta,                  index = shape,
91                  body = E.Sum(s'', E.Prod[                  body = E.Sub(E.Field(1, expindex),E.Lift(E.Tensor(0, expindex)))
E.Tensor(0, expindexA@[s']),   (* T_{\alpha i} *)
E.Tensor(1, [s']@expindexB )  (* T'_{i \beta} *)])
92              }              }
93          end          end
| innerProduct _ = raise Fail "Wrong shape for inner product"
94
95      (*<T_{\alpha i j} * B{i j \beta }>_\alpha \beta*)      fun subFF(dim,shape) =let
96      fun doubleDot(shape1,i::j::beta) = let          val expindex= specialize(shape,0)
97          val alpha= List.take(shape1,length(shape1)-2)          in E.EIN{
98          val expindexA= specialize(alpha,0)              params = [E.FLD(dim),E.FLD(dim)],
99          val expindexB= specialize(beta,(length(alpha)))              index = shape,
100          val sumi=length(alpha)+ length(beta)              body = E.Sub(E.Field(0, expindex),E.Field(1, expindex))
val s'=[E.V sumi,E.V(sumi+1)]
val s''=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]
in
E.EIN{
params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],
index = alpha@beta,
body = E.Sum(s'',E.Prod[ E.Tensor(0, expindexA@s'), E.Tensor(1,s'@expindexB)])
101              }              }
102          end          end
103      | doubleDot _ = raise Fail "Wrong shape for double dot "       (********************************** mul *************************************)
104         (* Product Scalars*)
105      (*Vector Examples : <T_i * T_j>_ij..t0⊗t1*)      val mulRR = E.EIN{
106      fun outerProduct(dimA,dimB) =              params =[E.TEN(1,[]), E.TEN(1,[])],
107          E.EIN{              index = [],
108              params = [E.TEN(1,[dimA]), E.TEN(1,[dimB])],              body = E.Prod[ E.Tensor(0, []), E.Tensor(1, [])]
index= [dimA,dimB],
body= E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])]
}

fun transpose alpha =E.EIN{
params = [E.TEN(1,alpha)],
index= List.rev alpha,
body= E.Tensor(0, [E.V 1,E.V 0])
}

fun modulate dim =E.EIN{
params = [E.TEN(1,[dim]), E.TEN(1,[dim])],
index = [dim],
body = E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 0])]
109          }          }
110
111      (*get norm, but without the sqrt       (* scalar times tensor product: <s * T_{\alpha}>_{\alpha} *)
112      * implemented as a summation over a modulate      fun mulRT alpha = let
*)
fun norm alpha =let
val i=List.hd alpha
113          val expindex= specialize(alpha,0)          val expindex= specialize(alpha,0)
114          val sx= sumIds(length(alpha),i-1)          in
115          in E.EIN{              E.EIN{
116              params = [E.TEN(1,alpha), E.TEN(1,alpha)],                  params = [E.TEN(1,[]), E.TEN(1,alpha)],
117              index = [],                  index = alpha,
118              body = E.Sum(sx,                  body = E.Prod[ E.Tensor(0, []),  E.Tensor(1, expindex)]
E.Prod[E.Tensor(0, expindex), E.Tensor(1, expindex)])
119              }              }
120          end          end
121
122      fun norm2 dim =let      fun mulRF(dim,shape) =let
123             val  expindex= specialize(shape,0)
124          in E.EIN{          in E.EIN{
params = [ E.TEN(1,[]),E.TEN(1,[dim])],
index = [dim],
body =E.Prod[ E.Div(E.Const 1,E.Tensor(0, [])),E.Tensor(1, [E.V 0])]
}
end

(*crossProduct is on 3D vectors ..vec3 t8=t0 × t1; *)
val crossProduct = E.EIN{
params = [E.TEN(1,[3]), E.TEN(1,[3])],
index= [3],
body=E.Sum([(E. V 1,0,2),(E.V 2,0,2)],
E.Prod[ E.Epsilon(0, 1, 2), E.Tensor(0, [E.V 1]),  E.Tensor(1, [E.V 2 ]) ])
}

(*2-d cross product Eps_{ij}U_i V_j*)
val crossProduct2 = E.EIN{
params = [E.TEN(1,[2]), E.TEN(1,[2])],
index= [],
body=E.Sum([(E. V 0,0,1),(E.V 1,0,1)],
E.Prod[ E.Eps2(0, 1), E.Tensor(0, [E.V 0]),  E.Tensor(1, [E.V 1])])
}

(* Identiy: <\delta_{i j}>_{i j}  *)
fun identity dim =E.EIN{
params = [],index = [dim,dim], body = E.Delta(E.V(0), E.V(1))
}

(*Tensor and Fields*)
125              params = [E.TEN(1,[]),E.FLD(dim)],              params = [E.TEN(1,[]),E.FLD(dim)],
126              index = [],               index = shape,
127              body = E.Add[E.Lift(E.Tensor(0, [])),E.Field(1, [])]               body = E.Prod[E.Lift( E.Tensor(0,[])), E.Field(1,expindex)]
}

fun subTenField dim = E.EIN{
params = [E.TEN(1,[]),E.FLD(dim)],
index = [],
128          }          }
129             end
130
131      fun subFieldTen dim = E.EIN{      fun mulSS dim = E.EIN{
132              params = [E.TEN(1,[]),E.FLD(dim)],               params = [E.FLD(dim),E.FLD(dim)],
133              index = [],              index = [],
134              body = E.Sub(E.Field(1, []),E.Lift(E.Tensor(0, [])))               body = E.Prod[E.Field(0, []),E.Field(1, [])]
135          }          }
136
137      (* mkField functions*)      fun mulSF(dim,shape) =let
(*Adding Fields : < F{\alpha} + G_{\alpha}>_{\alpha} *)
138          val expindex= specialize(shape,0)          val expindex= specialize(shape,0)
139          in E.EIN{          in E.EIN{
140              params = [E.FLD(dim),E.FLD(dim)],              params = [E.FLD(dim),E.FLD(dim)],
141              index = shape,              index = shape,
142              body = E.Add[E.Field(0, expindex),E.Field(1, expindex)]               body = E.Prod[E.Field(0, []),E.Field(1, expindex)]
143          }          }
144          end          end
145
146      fun subField(dim,shape) =let      (************************************div ************************************)
147          val expindex= specialize(shape,0)      (* Divide Scalars*)
148          in E.EIN{      val divRR = E.EIN{
149              params = [E.FLD(dim),E.FLD(dim)],               params = [E.TEN(1,[]), E.TEN(1,[])],
150              index = shape,               index = [],
151              body = E.Sub(E.Field(0, expindex),E.Field(1, expindex))               body = E.Div( E.Tensor(0, []), E.Tensor(1, []))
152          }          }
end
153
154      fun scaleField(dim,shape) =let      fun divTR alpha =let
155          val  expindex= specialize(shape,0)          val expindex= specialize(alpha,0)
156          in E.EIN{          in
157              params = [E.TEN(1,[]),E.FLD(dim)],              E.EIN{
158              index = shape,                  params = [E.TEN(1,alpha), E.TEN(1,[])],
159              body = E.Prod[E.Lift( E.Tensor(0,[])), E.Field(1,expindex)]                  index = alpha,
160                    body = E.Div(E.Tensor(0, expindex), E.Tensor(1,[]))
161          }          }
162          end          end
163
164      fun divideField(dim,shape) = let      fun divFR(dim,shape) = let
165          val expindex= specialize(shape,0)          val expindex= specialize(shape,0)
166          in E.EIN{          in E.EIN{
167              params = [E.FLD(dim),E.TEN(1,[])],              params = [E.FLD(dim),E.TEN(1,[])],
# Line 247  Line 170
170          }          }
171          end          end
172
173      fun negField(dim,shape) = let      fun divSS dim = E.EIN{
174          val expindex = specialize(shape,0)           params = [E.FLD(dim),E.FLD(dim)],
175          in E.EIN{           index = [],
176              params = [E.FLD(dim)],           body = E.Div(E.Field(0, []),E.Field(1, []))
index = shape,
body = E.Neg(E.Field(0, expindex))
}
end

(*< d F /  d_i>_i  *)
val a=List.hd(alpha)
val  expindex= specialize(alpha,0)
in E.EIN{
params = [E.FLD(a)],
index =alpha,
body = E.Apply(E.Partial(expindex),E.Field(0,[]))
177          }          }
end
178
179      (*< Sigma d F_alpha /  d x_i>ALpha  i CHANGE HERE *)      fun divFS(dim,shape) = let
180      fun dotimes(dim,alpha)= let           val  expindex= specialize(shape,0)
val n=length(alpha)
fun expIndex(n,inc)=List.tabulate(n, (fn(x)=>E.V (x+inc)))
val i'=expIndex(n,0)
181          in E.EIN{          in E.EIN{
182              params = [E.FLD(dim)], index =alpha@[dim],               params = [E.FLD(dim),E.FLD(dim)],
183              body = E.Apply(E.Partial [E.V n] ,E.Field(0,i'))               index = shape,
184                 body = E.Prod[E.Field(0, expindex),E.Div(E.Const 1,E.Field(1, []))]
185          }          }
186          end          end
187        (************************************* Neg **********************************)
188              (*  <d F_i /d_i> *)      fun negTT alpha=let

fun divergence(dim,alpha)=let
189          val  expindex= specialize(alpha,0)          val  expindex= specialize(alpha,0)
190          val sumI=length(alpha)           in
191          val sumIndex=E.V(sumI)              E.EIN{
192          val sumIndexL=[sumIndex]              params = [E.TEN(1,alpha)],index = alpha,
193          val S=expindex@sumIndexL              body = E.Neg(E.Tensor(0, expindex))

in E.EIN{
params = [E.FLD(dim)],
index = alpha,
body = E.Sum([(sumIndex,0,dim-1)],E.Apply(E.Partial(sumIndexL),E.Field(0,S)))
194          }          }
195          end          end
196
197      (*FLD here is bounded to image field, and dimension of h*)      fun negFF(dim,shape) = let
fun conv(dim,shape) =let
198          val expindex= specialize(shape,0)          val expindex= specialize(shape,0)
199          in E.EIN{          in E.EIN{
200              params = [E.IMG(dim,shape),E.KRN],              params = [E.FLD(dim)],index = shape,
201              index = shape,              body = E.Neg(E.Field(0, expindex))
body= E.Conv(0,expindex,1,[])
}
end

(* Probe: <F(x)>_{\alpha}   *)
fun probe(alpha,dim) = let
val  expindex= specialize(alpha,0)
in E.EIN{
params = [E.FLD(dim),E.TEN(0,[])],
index= alpha,
body= E.Probe(E.Field(0, expindex), E.Tensor(1,[]))
202          }          }
203          end          end
204
205      (*(F_y/dx - F_x/dy )k*)     (****************************** cross ***********************************)
206      (*val curl2d=E.EIN{      (*crossProduct is on 3D vectors ..vec3 t8=t0 × t1; *)
207          params = [E.FLD 2],      val cross3TT = E.EIN{
208          index = [],               params = [E.TEN(1,[3]), E.TEN(1,[3])],
body = E.Sub(E.Apply(E.Partial([E.C 0]), E.Field(0,[E.C 1])),
E.Apply(E.Partial([E.C 1]), E.Field(0,[E.C 0])))
}*)

(*\EinExp{\sum_{ij}\mathcal{E}_{ij} \frac{ F_j}{\partial x_i}*)
val curl2d=E.EIN{
params = [E.FLD 2],
index = [],
body = E.Sum([(E.V 0,0,1), (E.V 1,0,1)],
E.Prod[E.Eps2(0, 1),E.Apply( E.Partial([E.V 0]), E.Field(0,[E.V 1]))])
}

val curl3d=E.EIN{
params = [E.TEN(1,[3])],
209              index = [3],              index = [3],
210              body = E.Sum([(E.V 1,0,2), (E.V 2,0,2)],E.Prod[E.Epsilon(0, 1, 2),               body=E.Sum([(E. V 1,0,2),(E.V 2,0,2)],
211                  E.Apply( E.Partial([E.V 1]), E.Field(0,[E.V 2]))])                      E.Prod[ E.Epsilon(0, 1, 2),
212          }                      E.Tensor(0, [E.V 1]),  E.Tensor(1, [E.V 2 ]) ])

(*Scalars*)
params = [E.TEN(1,[]), E.TEN(1,[])] ,
index = [],
body = E.Add[ E.Tensor(0, []), E.Tensor(1, [])]
}

(* Subtract Scalars*)
val subScalar = E.EIN{
params = [E.TEN(1,[]), E.TEN(1,[])],
index = [],
body = E.Sub( E.Tensor(0, []), E.Tensor(1, []))
213          }          }
214
215      (* Divide Scalars*)      (*2-d cross product Eps_{ij}U_i V_j*)
216      val divScalar = E.EIN{      val cross2TT = E.EIN{
217              params = [E.TEN(1,[]), E.TEN(1,[])],               params = [E.TEN(1,[2]), E.TEN(1,[2])],
218              index = [],              index = [],
219              body = E.Div( E.Tensor(0, []), E.Tensor(1, []))               body=E.Sum([(E. V 0,0,1),(E.V 1,0,1)],
220                 E.Prod[ E.Eps2(0, 1), E.Tensor(0, [E.V 0]),  E.Tensor(1, [E.V 1])])
221          }          }
222
223      (* Product Scalars*)      (*Field Cross Product*)
224      val prodScalar = E.EIN{      val cross2FF = E.EIN{
225              params =[E.TEN(1,[]), E.TEN(1,[])],              params = [E.FLD(2), E.FLD(2)],index= [],
226              index = [],              body=E.Sum([(E. V 0,0,1),(E.V 1,0,1)],
227              body = E.Prod[ E.Tensor(0, []), E.Tensor(1, [])]              E.Prod[ E.Eps2(0, 1), E.Field(0, [E.V 0]),  E.Field(1, [E.V 1]) ])
228          }          }
229
230      (*Transform M_ij x_j+T*)      (*Field Cross Product*)
231      fun transform(i, j) = E.EIN{      val cross3FF = E.EIN{
232              params = [E.TEN(1,[i,j]), E.TEN(1,[j]), E.TEN(1,[j])],              params = [E.FLD(3), E.FLD(3)],index= [3],
233              index = [i],              body=E.Sum([(E. V 1,0,2),(E.V 2,0,2)],
234              body = E.Add[E.Sum([(E.V 1, 0,j-1)],E.Prod[E.Tensor(0, [E.V 0, E.V 1]),                  E.Prod[ E.Epsilon(0, 1, 2),
235                  E.Tensor(1, [E.V 1])]), E.Tensor(2,[E.V 0])]                  E.Field(0, [E.V 1]),  E.Field(1, [E.V 2 ]) ])
236          }          }
237        (********************  outerProduct ********************************)
238      fun transformA(i, j) = E.EIN{      (*Vector Examples : <T_i * T_j>_ij..t0⊗t1*)
239              params = [E.TEN(1,[i,j]), E.TEN(1,[j])],      fun outerTT(dimA,dimB) =
240              index = [i],          E.EIN{
241              body = E.Sum([(E.V 1, 0,j-1)],E.Prod[E.Tensor(0, [E.V 0, E.V 1]), E.Tensor(1, [E.V 1])])               params = [E.TEN(1,[dimA]), E.TEN(1,[dimB])],
242                 index= [dimA,dimB],
243                 body= E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])]
244          }          }
245
246      fun transformB i = E.EIN{      (*Assumes same dimension vector field *)
247              params = [E.TEN(1,[i]), E.TEN(1,[i])],      fun outerFF dim =
248              index = [i],          E.EIN{
249              body = E.Add[E.Tensor(0, [E.V 0]), E.Tensor(1,[E.V 0])]          params = [E.FLD(dim),E.FLD(dim)],
250            index = [dim, dim],
251            body = E.Prod[E.Field(0, [E.V 0]),E.Field(1, [E.V 1])]
252          }          }
253
254        (*************************** inner product **********************************)
255      (*multiply scalar fields *)      (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
256      fun mulFieldss dim = E.EIN{      fun innerTT(shape1,i::beta) = let
257              params = [E.FLD(dim),E.FLD(dim)],          val alpha= List.take(shape1,length(shape1)-1)
258              index = [],          val expindexA= specialize(alpha,0)
259              body = E.Prod[E.Field(0, []),E.Field(1, [])]          val expindexB= specialize(beta,(length(alpha)))
260            val s'=E.V(length(alpha)+ length(beta))
261            val s''=[(s',0,i-1)]
262            in
263                E.EIN{
264                    params = [E.TEN(1,shape1) ,E.TEN(1,i::beta)],
265                    index = alpha@beta,
266                    body = E.Sum(s'', E.Prod[
267                    E.Tensor(0, expindexA@[s']),   (* T_{\alpha i} *)
268                    E.Tensor(1, [s']@expindexB )  (* T'_{i \beta} *)])
269          }          }
270            end
271         | innerTT _ = raise Fail "Wrong shape for inner product"
272
273      fun mulFieldsf(dim,shape) =let      (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
274          val  expindex= specialize(shape,0)      fun innerFF(shape1,dim,i::beta) = let
275            val alpha= List.take(shape1,length(shape1)-1)
276            val expindexA= specialize(alpha,0)
277            val expindexB= specialize(beta,(length(alpha)))
278            val sid=E.V(length(alpha)+ length(beta))
279          in E.EIN{          in E.EIN{
280              params = [E.FLD(dim),E.FLD(dim)],                  params = [E.FLD(dim) ,E.FLD(dim)],index = alpha@beta,
281              index = shape,                  body = E.Sum([(sid,0,i-1)],
282              body = E.Prod[E.Field(0, []),E.Field(1, expindex)]                      E.Prod[
283                        E.Field(0, expindexA@[sid]),   (* F_{\alpha i} *)
284                        E.Field(1, [sid]@expindexB )  (* F'_{i \beta} *)
285                    ])}
286                end
287        | innerFF _ = raise Fail "Wrong shape for innerProductField"
288
289        (*************************** colon product **********************************)
290        (*<T_{\alpha i j} * B{i j \beta }>_\alpha \beta*)
291        fun colonTT(shape1,i::j::beta) = let
292            val alpha= List.take(shape1,length(shape1)-2)
293            val expindexA= specialize(alpha,0)
294            val expindexB= specialize(beta,(length(alpha)))
295            val sumi=length(alpha)+ length(beta)
296            val s'=[E.V sumi,E.V(sumi+1)]
297            val sx=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]
298            in
299                E.EIN{
300                    params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],
301                    index = alpha@beta,
302                    body = E.Sum(sx,E.Prod[ E.Tensor(0, expindexA@s'), E.Tensor(1,s'@expindexB)])
303              }              }
304          end          end
305
306      fun divFieldss dim = E.EIN{      (*<F_{\alpha i j} * G{i j \beta }>_\alpha \beta*)
307              params = [E.FLD(dim),E.FLD(dim)],      fun colonFF(shape1,i::j::beta) = let
308              index = [],          val alpha= List.take(shape1,length(shape1)-2)
309              body = E.Div(E.Field(0, []),E.Field(1, []))          val expindexA= specialize(alpha,0)
310            val expindexB= specialize(beta,(length(alpha)))
311            val sumi=length(alpha)+ length(beta)
312            val s'=[E.V sumi,E.V(sumi+1)]
313            val sx=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]
314            in
315                E.EIN{
316                    params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],
317                    index = alpha@beta,
318                    body = E.Sum(sx,E.Prod[E.Field(0, expindexA@s'), E.Field(1,s'@expindexB)])
319          }          }
320            end
321
322      fun divFieldfs(dim,shape) = let      (******************** Norm  ********************************)
323          val  expindex= specialize(shape,0)      (*get norm, but without the sqrt
324        * implemented as a summation over a modulate
325        *)
326        fun magnitudeTT alpha =let
327             val i=List.hd alpha
328             val expindex= specialize(alpha,0)
329             val sx= sumIds(length(alpha),i-1)
330          in  E.EIN{          in  E.EIN{
331              params = [E.FLD(dim),E.FLD(dim)],              params = [E.TEN(1,alpha), E.TEN(1,alpha)],
332              index = shape,              index = [],
333              body = E.Prod[E.Field(0, expindex),E.Div(E.Const 1,E.Field(1, []))]              body = E.Sum(sx,
334                E.Prod[E.Tensor(0, expindex), E.Tensor(1, expindex)])
335              }              }
336          end          end
337
338      (*Assumes same dimension vector field *)      fun magnitudeFF(dim,[]) =
339      fun outerField dim =          E.EIN{params = [E.FLD(dim)],index = [],body =  E.Field(0, [])}
340          | magnitudeFF(dim,shape1 as i::beta) = let
341            val alpha= List.take(shape1,(length(shape1))-1)
342            val alphan=length(alpha)
343            val betan=length(beta)
344            val expindexA= specialize(alpha,0)
345            val expindexB= specialize(beta,alphan)
346            val sid=E.V(alphan+ betan)
347            in
348          E.EIN{          E.EIN{
349              params = [E.FLD(dim),E.FLD(dim)],              params = [E.FLD(dim),E.FLD(dim)],
350              index = [dim, dim],                  index = alpha@beta,
351              body = E.Prod[E.Field(0, [E.V 0]),E.Field(1, [E.V 1])]                  body = E.Sqrt(E.Sum([(sid,0,i-1)], E.Prod[
352                        E.Field(0, expindexA@[sid]),
353                        E.Field(1, [sid]@expindexB )
354                        ]))
355          }          }

fun fs x=Int.toString(x)
fun f x=fs(length(x))

(* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
fun innerProductField(shape1,dim,i::beta) = let
val alpha= List.take(shape1,length(shape1)-1)
val expindexA= specialize(alpha,0)
val expindexB= specialize(beta,(length(alpha)))
val s'=E.V(length(alpha)+ length(beta))
val s''=[(s',0,i-1)]
in E.EIN{
params = [E.FLD(dim) ,E.FLD(dim)],              (* T and T' *)
index = alpha@beta,(* \alpha \beta, i *)
body = E.Sum(s'', E.Prod[
E.Field(0, expindexA@[s']),   (* F_{\alpha i} *)
E.Field(1, [s']@expindexB )  (* F'_{i \beta} *)
])}
356          end          end
| innerProductField _ = raise Fail "Wrong shape for innerProductField"
357
358      (*Field Cross Product*)      fun normalizeFF(dim,[i]) = let
359      val crossProductField2d = E.EIN{          val sx=[(E.V 0,0,i-1)]
360              params = [E.FLD(2), E.FLD(2)],          val f=E.Field(0, [E.V 0])
361              index= [],          in E.EIN{
362              body=E.Sum([(E. V 0,0,1),(E.V 1,0,1)],              params = [E.FLD(dim) ,E.FLD(dim)],index = [dim],
363              E.Prod[ E.Eps2(0, 1), E.Field(0, [E.V 0]),  E.Field(1, [E.V 1]) ])              body = E.Prod[f,
364                    E.Div(E.Const 1,E.Sqrt(E.Sum(sx, E.Prod[f,f])))]
365           }           }
366            end
367            | normalizeFF(dim,_) =raise Fail"unsupported normalize"
368
369          (*Field Cross Product*)      (************************* trace *************************)
370      val crossProductField3d = E.EIN{      (* Trace: <M_{i, i}>  This one Sx represents both i's*)
371           params = [E.FLD(3), E.FLD(3)],      fun traceT dim = E.EIN{
372           index= [3],          params = [E.TEN(1,[dim,dim])],index = [],
373           body=E.Sum([(E. V 1,0,2),(E.V 2,0,2)],          body = E.Sum([(E.V 0,0,dim-1)],E.Tensor(0, [E.V 0, E.V 0]))
E.Prod[ E.Epsilon(0, 1, 2), E.Field(0, [E.V 1]),  E.Field(1, [E.V 2 ]) ])
374           }           }
375
376      (* 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*)
377      fun traceField(dim,alpha) =let      fun traceF(dim,alpha) =let
378          val expindex= specialize(alpha,0)          val expindex= specialize(alpha,0)
379          val s=E.V(length(alpha))          val s=E.V(length(alpha))
380          in          in
# Line 474  Line 385
385               }               }
386          end          end
387
388        (************************* tranpose *************************)
389        fun transposeT alpha =E.EIN{
390            params = [E.TEN(1,alpha)],
391            index= List.rev alpha,
392            body= E.Tensor(0, [E.V 1,E.V 0])
393        }
394
395      (*Transpose Field F_{ji}*)      (*Transpose Field F_{ji}*)
396      fun transposeField(dim,i,j) =E.EIN{      fun transposeF(dim,i,j) =E.EIN{
397              params = [E.FLD(dim)], index= [i,j],              params = [E.FLD(dim)], index= [i,j],
398              body= E.Field(0, [E.V 1,E.V 0])              body= E.Field(0, [E.V 1,E.V 0])
399          }          }
400
401      (*<F_{\alpha i j} * G{i j \beta }>_\alpha \beta*)      (************************* other tensor ops *************************)
402      fun doubleDotField(shape1,i::j::beta) = let      fun modulate dim =E.EIN{
403          val alpha= List.take(shape1,length(shape1)-2)          params = [E.TEN(1,[dim]), E.TEN(1,[dim])],
404          val expindexA= specialize(alpha,0)          index = [dim],
405          val expindexB= specialize(beta,(length(alpha)))          body = E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 0])]
val sumi=length(alpha)+ length(beta)
val s'=[E.V sumi,E.V(sumi+1)]
val s''=[(E.V sumi,0,i-1),(E.V(sumi+1),0,j-1)]
in
E.EIN{
params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],
index = alpha@beta,
body = E.Sum(s'',E.Prod[E.Field(0, expindexA@s'), E.Field(1,s'@expindexB)])
406              }              }
end
| doubleDotField _ = raise Fail "Wrong shape for double dot "
407
408        fun identity dim =E.EIN{
409            params = [],index = [dim,dim], body = E.Delta(E.V(0), E.V(1))
410        }
411
413          fun iter ([],_,cnt)=[]          fun iter ([],_,cnt)=[]
# Line 504  Line 415
415            |iter(false::es,cs,cnt)=[E.V cnt]@iter(es,cs,cnt+1)            |iter(false::es,cs,cnt)=[E.V cnt]@iter(es,cs,cnt+1)
417          in          in
418              E.EIN{              E.EIN{  params = [E.TEN(1,argTy)],index = rstTy,body = E.Tensor(0, ix)}
params = [E.TEN(1,argTy)],
index = rstTy,
body = E.Tensor(0, ix)
}
419          end          end
420
421        (******************** other field ops  ********************************)
422        (*FLD here is bounded to image field, and dimension of h*)
423      fun magnitudeTenVec(i::beta) = let      fun conv(dim,shape) =let
424              val shape1=i::beta           val expindex= specialize(shape,0)
val n=length(shape1)
val alpha= List.take(shape1,n-1)
val expindexA= specialize(alpha,0)
val expindexB= specialize(beta,(length(alpha)))
val s'=E.V(length(alpha)+ length(beta))
val s''=[(s',0,i-1)]
425          in E.EIN{          in E.EIN{
426              params = [E.TEN(1,shape1),E.TEN(1,shape1)],              params = [E.IMG(dim,shape),E.KRN],
427              index = alpha@beta,              index = shape,
428              body = E.Sqrt(E.Sum(s'', E.Prod[              body= E.Conv(0,expindex,1,[])
E.Tensor(0, expindexA@[s']),
E.Tensor(0, [s']@expindexB )
]))
429              }              }
430             end
431
432        (* Probe: <F(x)>_{\alpha}   *)
433        fun probe(alpha,dim) = let
434            val  expindex= specialize(alpha,0)
435            in E.EIN{
436                 params = [E.FLD(dim),E.TEN(0,[])], index= alpha,
437                 body= E.Probe(E.Field(0, expindex), E.Tensor(1,[]))
438                }
439          end          end
440      fun magnitudeFldVec(dim,[]) =          (***************************** derivative ****************************)
441          E.EIN{      (*\EinExp{\sum_{ij}\mathcal{E}_{ij} \frac{ F_j}{\partial x_i}*)
442              params = [E.FLD(dim)],      val curl2d=E.EIN{
443                 params = [E.FLD 2],
444              index = [],              index = [],
445              body =  E.Field(0, [])               body = E.Sum([(E.V 0,0,1), (E.V 1,0,1)],
446                    E.Prod[E.Eps2(0, 1),
447                    E.Apply( E.Partial([E.V 0]), E.Field(0,[E.V 1]))])
448              }              }
449          | magnitudeFldVec(dim,i::beta) = let
450          val shape1=i::beta      val curl3d=E.EIN{
451          val alpha= List.take(shape1,length(shape1)-1)               params = [E.TEN(1,[3])],
452          val expindexA= specialize(alpha,0)               index = [3],
453          val expindexB= specialize(beta,(length(alpha)))               body = E.Sum([(E.V 1,0,2), (E.V 2,0,2)],E.Prod[E.Epsilon(0, 1, 2),
454          val s'=E.V(length(alpha)+ length(beta))               E.Apply( E.Partial([E.V 1]), E.Field(0,[E.V 2]))])
455          val s''=[(s',0,i-1)]          }
456
457        (*< d F /  d_i>_i  *)
459            val a=List.hd(alpha)
460            val  expindex= specialize(alpha,0)
461          in E.EIN{          in E.EIN{
462              params = [E.FLD(dim) ,E.FLD(dim)],              (* T and T' *)              params = [E.FLD(a)],
463              index = alpha@beta,(* \alpha \beta, i *)              index =alpha,
464              body = E.Sqrt(E.Sum(s'', E.Prod[              body = E.Apply(E.Partial(expindex),E.Field(0,[]))
E.Field(0, expindexA@[s']),   (* F_{\alpha i} *)
E.Field(1, [s']@expindexB )  (* F'_{i \beta} *)
]))
465              }              }
466          end          end
467
468          fun normalizeFldVec(dim,[]) =raise Fail"normalize of a scalar"      (*< Sigma d F_alpha /  d x_i>ALpha  i CHANGE HERE *)
469            | normalizeFldVec(dim,[i]) = let      fun dotimes(dim,alpha)= let
470              val sx=[(E.V 0,0,i-1)]          val n=length(alpha)
471              val f=E.Field(0, [E.V 0])          fun expIndex(n,inc)=List.tabulate(n, (fn(x)=>E.V (x+inc)))
472            val i'=expIndex(n,0)
473              in E.EIN{              in E.EIN{
474                  params = [E.FLD(dim) ,E.FLD(dim)],              params = [E.FLD(dim)], index =alpha@[dim],
475                  index = [dim],              body = E.Apply(E.Partial [E.V n] ,E.Field(0,i'))
body = E.Prod[f,
E.Div(E.Const 1,
E.Sqrt(E.Sum(sx, E.Prod[f,f]))
)]
476              }              }
477              end              end
478
479        (*  <d F_i /d_i> *)
480          fun sqrt dim=      fun divergence(dim,alpha)=let
481              E.EIN{          val  expindex= specialize(alpha,0)
482            val sumI=length(alpha)
483            val sumIndex=E.V(sumI)
484            val sumIndexL=[sumIndex]
485            val S=expindex@sumIndexL
486            in E.EIN{
487                  params = [E.FLD(dim)],                  params = [E.FLD(dim)],
488                  index = [],              index = alpha,
489                  body = E.Sqrt(E.Field(0, []))              body = E.Sum([(sumIndex,0,dim-1)],
490                    E.Apply(E.Partial(sumIndexL),E.Field(0,S)))
491              }              }
492            end

493
494    end; (* local *)    end; (* local *)
495

Legend:
 Removed from v.2905 changed lines Added in v.2906