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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/translate/translate-basis.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/translate/translate-basis.sml

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

revision 2444, Thu Sep 26 17:32:54 2013 UTC revision 2445, Thu Sep 26 17:40:17 2013 UTC
# Line 27  Line 27 
27      structure VTbl = Var.Tbl      structure VTbl = Var.Tbl
28    
29      structure EinOp= Operators      structure EinOp= Operators
30      structure R=Rewrite      structure R=RewriteEin
31      structure N=Normalize      structure N=Normalize
32    
33      fun pruneTy tv = (case TU.prune(MV.toType tv)      fun pruneTy tv = (case TU.prune(MV.toType tv)
# Line 52  Line 52 
52            in            in
53              DstTy.tensorTy[d, d]        (* square matrix type *)              DstTy.tensorTy[d, d]        (* square matrix type *)
54            end            end
55      fun shapeVarToTensor sv = pruneShape sv  
56    
57      fun assign (y, rator, xs) = [IL.ASSGN(y, IL.OP(rator, xs))]      fun assign (y, rator, xs) = [IL.ASSGN(y, IL.OP(rator, xs))]
58    
# Line 92  Line 92 
92    
93      fun assignEin (y, rator, xs) = [IL.ASSGN(y, IL.EINAPP(R.evalEinApp(rator, xs)))]      fun assignEin (y, rator, xs) = [IL.ASSGN(y, IL.EINAPP(R.evalEinApp(rator, xs)))]
94    
95        fun simpleEinOp rator (y, _,xs) = assignEin(y, rator, xs)
96    
97        fun shapeVarToTensor sv = pruneShape sv
98    
99        fun tensorEinOp einop (y, [SK], xs) =
100            let val ty1 as DstTy.TensorTy dd1 = pruneShape SK
101                val rator =S.transform(einop,[dd1],[])
102            in
103                    assignEin(y, rator,xs)
104            end
105    
106    
107      fun singleScalarField(rator,y,NK,xs)=      fun scalarField(einop,paramarg,y,xs)=
108              let val rator=S.transform(rator, [],[NK])              let val rator=S.transform(einop, [[]],paramarg)
109              in              in
110                  assignEin(y, rator, xs)                  assignEin(y, rator, xs)
111              end              end
112    
113      fun singleField(rator, y, SK, NK, xs)=      fun singlefield(SK,einop,paramarg, y, xs)=
114              let              let
115                  val einShape=FieldD(SK)              val s=peelFieldShape SK
116                  val rator=S.transform(rator, einShape,[NK])              val rator= S.transform(einop, s,paramarg)
117              in assignEin(y, rator, xs)              in assignEin(y, rator, xs)
118              end              end
119    
120    
121    
122    
123  (****MV.toDim returns int, and DstTy.TensorTy returns intlist *)  (****MV.toDim returns int, and DstTy.TensorTy returns intlist *)
124    
125  (*DK- SK-shape,NK-dim *)  (*DK- SK-shape,NK-dim *)
# Line 138  Line 149 
149                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),
150                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),
151                  (BV.add_ii,             simpleOp(Op.IAdd DstTy.IntTy)),                  (BV.add_ii,             simpleOp(Op.IAdd DstTy.IntTy)),
152                  (BV.add_tt,             fn (y, [SK], xs) =>                  (BV.add_tt,             tensorEinOp EinOp.addTensor),
153                                              let                  (BV.add_ff,             fn (y, [_,NK,SK], xs)=> singlefield(SK,EinOp.addField, [NK,NK], y, xs)),
154                    (BV.add_fr,             fn (y, [_,NK], xs)=>    scalarField(EinOp.addTenField,[NK],y, xs)),
155                    (BV.add_rf,             fn (y, [_,NK], [s, f])=>scalarField(EinOp.addTenField,[NK],y,[f,s])),
156                    (BV.sub_ii,              simpleOp(Op.ISub DstTy.IntTy)),
157                    (BV.sub_tt,             tensorEinOp EinOp.subTensor),
158                    (BV.sub_ff,             fn (y, [_,NK,SK], xs)=>singlefield(SK,EinOp.subField, [NK,NK],y,xs)),
159                    (BV.sub_fr,             fn (y, [_,NK], xs) =>     scalarField(EinOp.subField,[NK], y,xs)),
160                    (BV.sub_rf,             fn (y, [_,NK], [s, f]) => scalarField(EinOp.subField,[NK], y,[f, s])),
161                    (BV.mul_ii,             simpleOp(Op.IMul DstTy.IntTy)),
162                    (BV.mul_rr,             simpleOp(Op.IMul DstTy.IntTy)),
163                    (BV.mul_rt,             tensorEinOp EinOp.scaleTensor),
164                    (BV.mul_tr,             fn (y, [SK], [t, r])=>let
165                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape SK                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape SK
166                                                  val rator=S.tranform(EinOp.addTensors, [dd1],[])                                              val rator =S.transform(EinOp.scaleTensor,[dd1],[])
167                                              in                                              in
168                                                  assignEin(y,rator,xs)                                              assignEin(y, rator,[r,t])
169                                              end),                                              end),
                 (BV.add_ff,             fn (y, [_,NK,SK], [f, g])=>  
                                         let  
170    
                                             val rator= S.transform(EinOp.addField, [SK],[NK,NK])  
                                             in assignEin(y, rator, [f, g])  
                                             end),  
171    
                 (BV.add_fr,             fn (y, [_,NK], xs)=> singleScalarField(EinOp.addTenField,y, NK, xs)),  
                 (BV.add_rf,             fn (y, [_,NK], [s, f])  
                                         =>singleScalarField(EinOp.addTenField,y, NK, [f,s])),  
172    
173                  (BV.mul_rf,             fn (y,[_,NK,SK], xs)=> singlefield(SK,EinOp.scaleField,[NK],y, xs)),
174    
175    
176    
177                  (BV.sub_ii,              simpleOp(Op.ISub DstTy.IntTy)),                  (BV.mul_fr,             fn (y, [_,NK,SK], [f, s])=> singleField(SK,EinOp.scaleField, [NK],y,[s,f])),
                 (BV.sub_tt,             fn(y, [SK],xs)=>  
                                             let val ty1 as DstTy.TensorTy dd1 = pruneShape SK  
                                                 val rator =S.transform(EinOp.subTensor,[dd1],[])  
                                             in  
                                                 assignEin(y, rator,xs)  
                                             end),  
                 (BV.sub_ff,             fn (y, [_,NK,SK], [f, g])=>  
                                             let  
                                             val einShape=FieldD(SK)  
                                             val rator=S.transform(EinOp.subField, einShape,[NK,NK])  
                                             in assignEin(y, rator, [f, g])  
                                             end),  
178    
                 (BV.sub_fr,             fn (y, [_,NK], xs) =>  singleScalarField(EinOp.subField, y,NK, xs)),  
                 (BV.sub_rf,             fn (y, [_,NK], [s, f]) => singleScalarField(EinOp.subField, y,NK, [f, s])),  
                 (BV.mul_ii,              simpleOp(Op.IMul DstTy.IntTy)),  
                 (BV.mul_rr,              simpleOp(Op.IMul DstTy.IntTy)),  
                 (BV.mul_rt,              fn (y, [SK], [r,t])=>  
                                         let  
                                             val rator =S.transform(EinOp.scaleTensor, [SK],[])  
                                         in assignEin(y,rator, [r,t]),  
                                         end)  
                 (BV.mul_tr,             fn (y, [SK], [t, r])=>  
                                             let  
                                             val rator =S.transform(EinOp.scaleTensor, [SK],[])  
                                             in assignEin(y,rator, [r,t]),  
                                             end)  
                 (BV.mul_rf,             fn (y, [_,NK,SK], xs)  
                                     => singleField(EinOp.scaleField, y, SK, NK, xs)),  
                 (BV.mul_fr,             fn (y, [_,NK,SK], [f, s])  
                                     => singleField(EinOp.scaleField, y, SK, NK, [s,f])),  
179                  (BV.div_ii,             simpleOp(Op.IDiv DstTy.IntTy)),                  (BV.div_ii,             simpleOp(Op.IDiv DstTy.IntTy)),
180                  (BV.div_rr,             simpleOp(Op.IDiv DstTy.realTy)),                  (BV.div_rr,             simpleOp(Op.IDiv DstTy.realTy)),
                 (BV.div_tr,             fn (y, [SK], xs) =>  
                                           let  
                                             val rator=S.transform(EinOp.divideTensor,[SK],[])  
                                          in  assignEin(y, rator, xs)  
                                           end),  
                 (BV.div_fr,             fn (y, [DK,NK,SK], xs) =>singleField(EinOp.divideField, y, SK, NK, xs)),  
                 (BV.exp_ri,             simpleOp(Op.Power)),  
                 (BV.exp_rr,             basisFn MathFuns.pow),  
   
   
                 (BV.curl2D,             fn (y, [DK], xs) =>  
                                             let  
                                                 val rator=S.transform(EinOp.Curl,[[0],[2],[2]],[2])  
                                             in  
                                                 assignEin(y, rator, xs)  
                                             end),  
                 (BV.curl3D,             fn (y, [DK], xs) =>  
                                     let  
                                         val rator=S.transform(EinOp.Curl,[[3],[3],[3]],[3])  
                                     in  
                                         assignEin(y, rator, xs)  
                                     end),  
181    
182    
183                  (BV.convolve_vk,        fn (y, [DK, NK, SK], xs) =>                 (BV.div_tr,             tensorEinOp EinOp.divideTensor),
                                     let  
                                         val shape=pruneDim(MV.toDim NK)  
                                         val rator=S.transform(EinOp.conv,[shape],[])  
                                     in  
                                         assignEin (y, rator, xs)  
                                     end),  
                 (BV.convolve_kv,        fn (y, [DK, NK, SK], [k, v]) =>  
                                     let  
                                         val shape=pruneDim(MV.toDim NK)  
                                         val rator= S.transform(EinOp.conv,[shape],[])  
                                     in  
                                         assignEin (y, rator, [v,k])  
                                     end),  
184    
185                    (BV.div_fr,             fn (y, [_,NK,SK], xs) =>singleField(SK,EinOp.divideField, [NK],y, xs)),
186                    (BV.exp_ri,             simpleOp(Op.Power)),
187                    (BV.exp_rr,             basisFn MathFuns.pow),
188                    (BV.curl2D,             simpleEinOp EinOp.Curl2d),
189                    (BV.curl3D,             simpleEinOp EinOp.Curl3d),
190                    (BV.convolve_vk,        fn (y, [_, NK, SK], xs) => singlefield(SK,EinOp.conv, [NK],y,xs)),
191                    (BV.convolve_kv,        fn (y, [_, NK, SK], [k, v]) =>singlefield(SK,EinOp.conv, [NK],y,[v,k])),
192                  (BV.neg_i,              simpleOp(Op.INeg DstTy.IntTy)),                  (BV.neg_i,              simpleOp(Op.INeg DstTy.IntTy)),
193                  (BV.neg_t,              tensorOp Op.INeg),                  (BV.neg_t,              tensorOp Op.INeg),
194                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),                  (BV.neg_f,              fn (y, [_,NK,SK], xs) => singlefield(SK,EinOp.negField, [NK],y,xs)),
195    
196                    (BV.op_probe,           fn (y, [_, NK, SK], xs) =>
                 (BV.op_probe,           fn (y, [_, dv, sv], xs) =>  
197                                          let                                          let
198                                              val dv'=dimVarToTensor dv  (*Field*)                                              val dv'=dimVarToTensor NK  (*Field*)
199                                              val sv'=shapeVarToTensor sv (*Position*)                                              val sv'=shapeVarToTensor SK (*Position*)
200                                          val il= S.transform(EinOp.probe,[dv',sv'],[dv'])                                              val einop= S.transform(EinOp.probe,[sv',dv'],[dv'])
201                                          in assignEin(y, il,xs)                                          in assignEin(y, einop,xs)
202                                          end ),                                          end ),
203                    (BV.op_D,               fn (y, [_, NK], xs) => scalarField(EinOp.Grad,[NK], y,xs)),
204                    (BV.op_Dotimes,         fn (y, [_, NK, SK, NK2], xs) => singleField(SK,EinOp.Divergence,[NK], y,xs)),
                 (BV.op_D,               fn (y, [DK, NK], xs) =>  
                                         let  
                                             val rator=S.transform(EinOp.Grad,[DK],[NK])  
                                         in  
                                                 assignEin(y, rator, xs)  
                                         end),  
                 (BV.op_Dotimes,         fn (y, [DK, NK, SK, NK], xs) =>  
                                             singleField(EinOp.Divergence, y, SK, NK, xs)  
205                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv
206                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)
207                                              | ty => assign(y, Op.Norm ty, xs)                                              | ty => assign(y, Op.Norm ty, xs)
208                                            (* end case *))),                                            (* end case *))),
                 (BV.op_not,             simpleOp Op.Not),  
   
209    
210                   (BV.op_not,             simpleOp Op.Not),
211                  (BV.op_cross,           fn(y, _ , xs )=> assignEin(y,EinOp.crossProductE ,xs)),                  (BV.op_cross,           simpleEinOp EinOp.crossProduct),
212                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let
213                                              val d1 = [pruneDim(MV.toDim dv1)]                                              val d1 = [pruneDim(MV.toDim dv1)]
214                                              val d2 = [pruneDim(MV.toDim dv2)]                                              val d2 = [pruneDim(MV.toDim dv2)]
215                                            in                                            in
216                                              assignEin( y, S.transform(EinOp.outerProduct,[d1,d2],[]),xs)                                              assignEin( y, S.transform(EinOp.outerProduct,[d1,d2],[]),xs)
217                                            end),                                            end)
   
218                  (BV.op_inner,        fn (y, [sh1, sh2, _], xs) =>                  (BV.op_inner,        fn (y, [sh1, sh2, _], xs) =>
219                                              let                                              let
220                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
# Line 291  Line 236 
236                                                  val j=tl(m)                                                  val j=tl(m)
237                                                  val alpha= List.take(dd1, length(dd1)-2)                                                  val alpha= List.take(dd1, length(dd1)-2)
238                                                  val beta=tl(tl(dd2))                                                  val beta=tl(tl(dd2))
   
239                                                  val ilist=[alpha, beta, i, j]                                                  val ilist=[alpha, beta, i, j]
240                                              in                                              in
241                                                  assignEin(y, S.transform(EinOp.doubleDot, ilist,[]),xs)                                                  assignEin(y, S.transform(EinOp.doubleDot, ilist,[]),xs)
# Line 322  Line 266 
266                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (BV.fn_normalize,       vectorOp Op.Normalize),
267                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
268    
269                  (BV.fn_trace,           fn (y, [dv], xs) =>                 (BV.fn_trace,           fn (y, [dv], xs) =>let
270                                          let                                              val d=dimVarToInt dv
                                                 val i=pruneDim(MV.toDim dv)  
271                                          in                                          in
272                                              assignEin(y,S.transform(EinOp.trace, [i],[]),xs)                                              assignEin(y,S.transform(EinOp.trace, [d],[]),xs)
273                                              end),                                              end),
274    
275                  (BV.fn_transpose,           fn (y, [dv1, dv2], xs) =>                  (BV.fn_transpose,           fn (y, [dv1, dv2], xs) =>
# Line 346  Line 289 
289                  (BV.kn_c1tent,          kernel Kernel.tent),                  (BV.kn_c1tent,          kernel Kernel.tent),
290                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
291    
292                  (BV.identity,           fn (y, [dv], []) =>                  (BV.identity,           fn (y, [dv], []) =>let
293                                              let                                              val d=dimVarToInt dv
294                                                  val i=pruneDim(MV.toDim dv)                                          in assignEin(y, S.transform(EinOp.identity,[[d],[d]],[]),xs)
                                             in assignEin(y, S.transform(EinOp.identity,[[i],[i]],[]))  
295                                              end),                                              end),
296    
297                  (BV.zero,               fn (y, [sv], []) =>                  (BV.zero,               fn (y, [sv], []) =>
298                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),
299                  (BV.subscript,          fn (y, [tv, dv], xs) =>s                 (BV.subscript,          fn (y, [tv, dv], xs) =>
300                                            assign(y,                                            assign(y,
301                                              Op.SeqSub(DstTy.SeqTy(pruneTy tv, pruneDim(MV.toDim dv))),                                              Op.SeqSub(DstTy.SeqTy(pruneTy tv, pruneDim(MV.toDim dv))),
302                                              xs))                                              xs)),
303    
304                    (BV.dynSubscript,       fn (y, [tv], args) =>
305                                            assign(y, Op.SeqSub(DstTy.DynSeqTy(pruneTy tv)), args))
306                  ];                  ];
307    
308            (* add C math functions *)            (* add C math functions *)

Legend:
Removed from v.2444  
changed lines
  Added in v.2445

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