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 2844, Tue Dec 9 18:05:29 2014 UTC revision 2845, Fri Dec 12 06:46:23 2014 UTC
# Line 13  Line 13
13      in      in
14
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)))
17
18      (* Adding tensors : < X{\alpha} + Y_{\alpha}>_{\alpha} *)      (* Adding tensors : < X{\alpha} + Y_{\alpha}>_{\alpha} *)
20          val expindex= specialize(alpha,0)          val expindex= specialize(alpha,0)
21          in          in
22              E.EIN{              E.EIN{
23              params = [E.TEN(1,alpha), E.TEN(1,alpha)], index = alpha,                  params = [E.TEN(1,alpha), E.TEN(1,alpha)],
24                    index = alpha,
25              body = E.Add[E.Tensor(0, expindex), E.Tensor(1, expindex)]              body = E.Add[E.Tensor(0, expindex), E.Tensor(1, expindex)]
26              }              }
27          end          end
28
29      fun createVec dim=E.EIN{      fun createVec dim=
30          params = [E.TEN(1,[dim])], index = [dim],          E.EIN{params = [E.TEN(1,[dim])], index = [dim], body = E.Tensor(0, [E.V 0])}
body = E.Tensor(0, [E.V 0])
}

val zero=E.EIN{
params = [], index = [],
body = E.Const(0)
}
31
32         val zero=
33            E.EIN{params = [], index = [], body = E.Const(0)}
34
35       fun subTen alpha=let       fun subTen alpha=let
36          val expindex= specialize(alpha,0)          val expindex= specialize(alpha,0)
37          in          in
38              E.EIN{              E.EIN{
39              params = [E.TEN(1,alpha), E.TEN(1,alpha)], index = alpha,                  params = [E.TEN(1,alpha), E.TEN(1,alpha)],
40              body = E.Sub(E.Tensor(0, expindex), E.Tensor(1, expindex))}                  index = alpha,
41                    body = E.Sub(E.Tensor(0, expindex), E.Tensor(1, expindex))
42                }
43          end          end
44
45      fun divTen alpha =let      fun divTen alpha =let
46          val expindex= specialize(alpha,0)          val expindex= specialize(alpha,0)
47          in  E.EIN{          in
48              params = [E.TEN(1,alpha), E.TEN(1,[])], index = alpha,              E.EIN{
49                    params = [E.TEN(1,alpha), E.TEN(1,[])],
50                    index = alpha,
51              body = E.Div(E.Tensor(0, expindex), E.Tensor(1,[]))              body = E.Div(E.Tensor(0, expindex), E.Tensor(1,[]))
52          }          }
53          end          end
# Line 60  Line 61
61
62      fun negTen alpha=let      fun negTen alpha=let
63          val  expindex= specialize(alpha,0)          val  expindex= specialize(alpha,0)
64          in E.EIN{          in
65                E.EIN{
66              params = [E.TEN(1,alpha)],              params = [E.TEN(1,alpha)],
67              index = alpha,              index = alpha,
68              body = E.Neg(E.Tensor(0, expindex))              body = E.Neg(E.Tensor(0, expindex))
# Line 70  Line 72
72      (* scalar times tensor product: <s * T_{\alpha}>_{\alpha} *)      (* scalar times tensor product: <s * T_{\alpha}>_{\alpha} *)
73      fun scaleTen alpha = let      fun scaleTen alpha = let
74          val expindex= specialize(alpha,0)          val expindex= specialize(alpha,0)
75          in E.EIN{          in
76              params = [E.TEN(1,[]), E.TEN(1,alpha)],    (* s and T *)              E.EIN{
77              index = alpha,           (* \alpha *)                  params = [E.TEN(1,[]), E.TEN(1,alpha)],
78                    index = alpha,
79              body = E.Prod[ E.Tensor(0, []),  E.Tensor(1, expindex)]              body = E.Prod[ E.Tensor(0, []),  E.Tensor(1, expindex)]
80          }          }
81          end          end
82
83        fun dot i =
84            E.EIN{
85                    params = [E.TEN(1,[i]) ,E.TEN(1,[i])],
86                    index = [],
87                    body = E.Sum([(E.V 0,0,i-1)], E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 0])])
88                }
89
90
91      (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)      (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)
92      fun innerProduct(shape1,i::beta) = let      fun innerProduct(shape1,i::beta) = let
93          val alpha= List.take(shape1,length(shape1)-1)          val alpha= List.take(shape1,length(shape1)-1)
# Line 84  Line 95
95          val expindexB= specialize(beta,(length(alpha)))          val expindexB= specialize(beta,(length(alpha)))
96          val s'=E.V(length(alpha)+ length(beta))          val s'=E.V(length(alpha)+ length(beta))
97          val s''=[(s',0,i-1)]          val s''=[(s',0,i-1)]
98          in E.EIN{          in
99               params = [E.TEN(1,shape1) ,E.TEN(1,i::beta)],              (* T and T' *)              E.EIN{
100              index = alpha@beta,   (* \alpha \beta, i *)                  params = [E.TEN(1,shape1) ,E.TEN(1,i::beta)],
101                    index = alpha@beta,
102              body = E.Sum(s'', E.Prod[              body = E.Sum(s'', E.Prod[
103                  E.Tensor(0, expindexA@[s']),   (* T_{\alpha i} *)                  E.Tensor(0, expindexA@[s']),   (* T_{\alpha i} *)
104                  E.Tensor(1, [s']@expindexB )  (* T'_{i \beta} *)                      E.Tensor(1, [s']@expindexB )  (* T'_{i \beta} *)])
])
105          }          }
106          end          end
107          | innerProduct _ = raise Fail "Wrong shape for inner product"          | innerProduct _ = raise Fail "Wrong shape for inner product"
# Line 103  Line 114
114          val sumi=length(alpha)+ length(beta)          val sumi=length(alpha)+ length(beta)
115          val s'=[E.V sumi,E.V(sumi+1)]          val s'=[E.V sumi,E.V(sumi+1)]
116          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)]
117          in E.EIN{          in
118                E.EIN{
119              params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],              params = [E.TEN(1,shape1),E.TEN(1,i::j::beta)],
120              index = alpha@beta,              index = alpha@beta,
121              body = E.Sum(s'',E.Prod[                  body = E.Sum(s'',E.Prod[ E.Tensor(0, expindexA@s'), E.Tensor(1,s'@expindexB)])
E.Tensor(0, expindexA@s'),
E.Tensor(1,s'@expindexB)
])
122          }          }
123          end          end
124          | doubleDot _ = raise Fail "Wrong shape for double dot "          | doubleDot _ = raise Fail "Wrong shape for double dot "
125
126      (*Vector Examples : <T_i * T_j>_ij..t0⊗t1*)      (*Vector Examples : <T_i * T_j>_ij..t0⊗t1*)
127      fun outerProduct(dimA,dimB) =E.EIN{      fun outerProduct(dimA,dimB) =
128            E.EIN{
129          params = [E.TEN(1,[dimA]), E.TEN(1,[dimB])],          params = [E.TEN(1,[dimA]), E.TEN(1,[dimB])],
130          index= [dimA,dimB],          index= [dimA,dimB],
131          body= E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])]          body= E.Prod[E.Tensor(0, [E.V 0]), E.Tensor(1, [E.V 1])]
132      }      }
133
134
135      fun transpose([i,j]) =E.EIN{      fun transpose alpha =E.EIN{
136          params = [E.TEN(1,[i,j])], index= [j,i],              params = [E.TEN(1,alpha)],
137                index= List.rev alpha,
138          body= E.Tensor(0, [E.V 1,E.V 0])          body= E.Tensor(0, [E.V 1,E.V 0])
139        }        }
| transpose _= raise Fail "too many indices for transpose"

140
141      fun modulate dim =E.EIN{      fun modulate dim =E.EIN{
142          params = [E.TEN(1,[dim]), E.TEN(1,[dim])],          params = [E.TEN(1,[dim]), E.TEN(1,[dim])],
# Line 135  Line 144
144          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])]
145          }          }
146
147        (*get norm, but without the sqrt
148        * implemented as a summation over a modulate
149        *)
150        fun norm alpha =let
151            val i=List.hd alpha
152            val expindex= specialize(alpha,0)
153            val sx= sumIds(length(alpha),i-1)
154            in E.EIN{
155                params = [E.TEN(1,alpha), E.TEN(1,alpha)],
156                index = [],
157                body = E.Sum(sx,
158                    E.Prod[E.Tensor(0, expindex), E.Tensor(1, expindex)])
159                }
160            end
161
162        fun norm2 dim =let
163            in E.EIN{
164            params = [ E.TEN(1,[]),E.TEN(1,[dim])],
165            index = [dim],
166            body =E.Prod[ E.Div(E.Const 1,E.Tensor(0, [])),E.Tensor(1, [E.V 0])]
167            }
168            end
169
170
171      (*crossProduct is on 3D vectors ..vec3 t8=t0 × t1; *)      (*crossProduct is on 3D vectors ..vec3 t8=t0 × t1; *)
172      val crossProduct = E.EIN{      val crossProduct = E.EIN{
# Line 155  Line 187
187
188      (* Identiy: <\delta_{i j}>_{i j}  *)      (* Identiy: <\delta_{i j}>_{i j}  *)
189      fun identity dim =E.EIN{      fun identity dim =E.EIN{
190          params = [],              params = [],index = [dim,dim], body = E.Delta(E.V(0), E.V(1))
index = [dim,dim],
body = E.Delta(E.V(0), E.V(1))
191      }      }
192
193      (*Tensor and Fields*)      (*Tensor and Fields*)
# Line 277  Line 307
307      (* Probe: <F(x)>_{\alpha}   *)      (* Probe: <F(x)>_{\alpha}   *)
308      fun probe(alpha,dim) = let      fun probe(alpha,dim) = let
309          val  expindex= specialize(alpha,0)          val  expindex= specialize(alpha,0)

310          in E.EIN{          in E.EIN{
311              params = [E.FLD(dim),E.TEN(0,[])],              params = [E.FLD(dim),E.TEN(0,[])],
312              index= alpha,              index= alpha,
# Line 298  Line 327
327          params = [E.FLD 2],          params = [E.FLD 2],
328          index = [],          index = [],
329          body = E.Sum([(E.V 0,0,1), (E.V 1,0,1)],          body = E.Sum([(E.V 0,0,1), (E.V 1,0,1)],
330                  E.Prod[E.Eps2(0, 1),                  E.Prod[E.Eps2(0, 1),E.Apply( E.Partial([E.V 0]), E.Field(0,[E.V 1]))])
E.Apply( E.Partial([E.V 0]), E.Field(0,[E.V 1]))])

331          }          }
332
333      val curl3d=E.EIN{      val curl3d=E.EIN{
334          params = [E.TEN(1,[3])],          params = [E.TEN(1,[3])],
335          index = [3],          index = [3],
336          body = E.Sum([(E.V 1,0,2), (E.V 2,0,2)],E.Prod[E.Epsilon(0, 1, 2),E.Apply( E.Partial([E.V 1]), E.Field(0,[E.V 2]))])              body = E.Sum([(E.V 1,0,2), (E.V 2,0,2)],E.Prod[E.Epsilon(0, 1, 2),
337                    E.Apply( E.Partial([E.V 1]), E.Field(0,[E.V 2]))])
338      }      }
339
340      (*Scalars*)      (*Scalars*)
# Line 331  Line 359
359          body = E.Div( E.Tensor(0, []), E.Tensor(1, []))          body = E.Div( E.Tensor(0, []), E.Tensor(1, []))
360      }      }
361

362      (* Product Scalars*)      (* Product Scalars*)
363      val prodScalar = E.EIN{      val prodScalar = E.EIN{
364          params =[E.TEN(1,[]), E.TEN(1,[])],          params =[E.TEN(1,[]), E.TEN(1,[])],
# Line 343  Line 370
370      fun transform(i, j) = E.EIN{      fun transform(i, j) = E.EIN{
371          params = [E.TEN(1,[i,j]), E.TEN(1,[j]), E.TEN(1,[j])],          params = [E.TEN(1,[i,j]), E.TEN(1,[j]), E.TEN(1,[j])],
372          index = [i],          index = [i],
373          body = E.Add              body = E.Add[E.Sum([(E.V 1, 0,j-1)],E.Prod[E.Tensor(0, [E.V 0, E.V 1]),
374              [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])]),                  E.Tensor(1, [E.V 1])]), E.Tensor(2,[E.V 0])]
E.Tensor(2,[E.V 0])]
375          }          }
376

377      fun transformA(i, j) = E.EIN{      fun transformA(i, j) = E.EIN{
378          params = [E.TEN(1,[i,j]), E.TEN(1,[j])],          params = [E.TEN(1,[i,j]), E.TEN(1,[j])],
379          index = [i],          index = [i],
380          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])])          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])])
381          }          }
382

383      fun transformB i = E.EIN{      fun transformB i = E.EIN{
384          params = [E.TEN(1,[i]), E.TEN(1,[i])],          params = [E.TEN(1,[i]), E.TEN(1,[i])],
385          index = [i],          index = [i],
# Line 363  Line 387
387      }      }
388
389
390        (*multiply scalar fields *)
(*New OPs*)
391      fun mulFieldss dim = E.EIN{      fun mulFieldss dim = E.EIN{
392          params = [E.FLD(dim),E.FLD(dim)],          params = [E.FLD(dim),E.FLD(dim)],
393          index = [],          index = [],
# Line 386  Line 409
409          body = E.Div(E.Field(0, []),E.Field(1, []))          body = E.Div(E.Field(0, []),E.Field(1, []))
410          }          }
411

412      (*Assumes same dimension vector field *)      (*Assumes same dimension vector field *)
413      fun outerField dim =      fun outerField dim =
414          E.EIN{          E.EIN{
# Line 399  Line 421
421          fun f x=fs(length(x))          fun f x=fs(length(x))
422
423       (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)       (* generic inner product: <T_{\alpha i} * T_{i \beta}>_{\alpha \beta} *)

424      fun innerProductField(shape1,dim,i::beta) = let      fun innerProductField(shape1,dim,i::beta) = let
425          val alpha= List.take(shape1,length(shape1)-1)          val alpha= List.take(shape1,length(shape1)-1)
426          val expindexA= specialize(alpha,0)          val expindexA= specialize(alpha,0)
427          val expindexB= specialize(beta,(length(alpha)))          val expindexB= specialize(beta,(length(alpha)))
428          val s'=E.V(length(alpha)+ length(beta))          val s'=E.V(length(alpha)+ length(beta))
429          val s''=[(s',0,i-1)]          val s''=[(s',0,i-1)]

430          val _=print(String.concat["Inner product Field. ",f(alpha)])          val _=print(String.concat["Inner product Field. ",f(alpha)])
431          in E.EIN{          in E.EIN{
432              params = [E.FLD(dim) ,E.FLD(dim)],              (* T and T' *)              params = [E.FLD(dim) ,E.FLD(dim)],              (* T and T' *)

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