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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

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    
19        (******************************* Add *****************************************)
20        val addRR = E.EIN{
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} *)
27      fun addTen alpha =let      fun addTT alpha =let
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} *)
39        fun addFF(dim,shape) =let
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*)  
     fun addTenField dim = E.EIN{  
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 = [],  
             body = E.Add[E.Lift(E.Tensor(0, [])),E.Neg(E.Field(1, []))]  
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} *)  
     fun addField(dim,shape) =let  
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  *)  
     fun grad alpha=let  
         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*)  
     (* Add Scalars*)  
     val addScalar = E.EIN{  
             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    
412      fun slice (argTy,mask,const,rstTy) =let      fun slice (argTy,mask,const,rstTy) =let
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)
416          val ix=iter(mask,const,0)          val ix=iter(mask,const,0)
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  *)
458        fun grad alpha=let
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

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