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 2395, Sun Jun 23 18:51:44 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 86  Line 86 
86                  end                  end
87            end            end
88    
89      fun createTenEin (operator, sv) = let  
90            val shape=shapeVarToTensor  
91    
92    
93        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            in
103              S.transform(operator,[len(shape), shape])                  assignEin(y, rator,xs)
104            end            end
     fun createFldEin(operator, f)=S.transform(operator,[])  
105    
106    
107      fun assignEin (y, rator, xs) = [IL.ASSGN(y, IL.EINAPP(R.evalEinApp(rator, xs)))]      fun scalarField(einop,paramarg,y,xs)=
108      fun simpleEinOp rator (y, [], xs) = assignEin (y, S.transform(rator,[]), xs)              let val rator=S.transform(einop, [[]],paramarg)
109      fun tensorEinOp rator (y, [sv], xs) = assignEin(y, createTenEin(rator, sv), xs)              in
110                    assignEin(y, rator, xs)
111                end
112    
113        fun singlefield(SK,einop,paramarg, y, xs)=
114            let
115                val s=peelFieldShape SK
116                val rator= S.transform(einop, s,paramarg)
117            in assignEin(y, rator, xs)
118            end
119    
120    
121    
122    
123    (****MV.toDim returns int, and DstTy.TensorTy returns intlist *)
124    
125    (*DK- SK-shape,NK-dim *)
126    
127    (* shape is an int list, DIM is in int|variable, k-level of differntiation *)
128    
129    (* build a table that maps Basis variables to their translation functions *)    (* build a table that maps Basis variables to their translation functions *)
130      val tbl : ((IL.var * Ty.meta_var list * IL.var list) -> IL.assignment list) VTbl.hash_table = let      val tbl : ((IL.var * Ty.meta_var list * IL.var list) -> IL.assignment list) VTbl.hash_table = let
# Line 120  Line 148 
148                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),
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                    (* Changed*)                  (BV.add_tt,             tensorEinOp EinOp.addTensor),
153                  (BV.add_tt,             tensorEinOp(EinOp.addTensors)),                  (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])),
                 (BV.add_ff,             fn (y, _, [f, g])  
                                             =>assignEin(y, createFldEin(EinOp.addField,f ), [f, g])),  
                 (BV.add_fr,             fn (y, _, [f, s])  
                                             => assignEin(y, createFldEin(EinOp.addTenField,f ), [f, s])),  
                 (BV.add_rf,             fn (y, _, [s, f])  
                                             => assignEin(y, createFldEin(EinOp.addTenField,f ), [f, s])),  
   
156                  (BV.sub_ii,              simpleOp(Op.ISub DstTy.IntTy)),                  (BV.sub_ii,              simpleOp(Op.ISub DstTy.IntTy)),
157                  (BV.sub_tt,             tensorEinOp(EinOp.subTensor)),                  (BV.sub_tt,             tensorEinOp EinOp.subTensor),
158                  (BV.sub_ff,             fn (y, _, [f, g])                  (BV.sub_ff,             fn (y, [_,NK,SK], xs)=>singlefield(SK,EinOp.subField, [NK,NK],y,xs)),
159                                              => assignEin(y, createFldEin(EinOp.subField,f), [f, g])),                  (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])),
                 (* UnChanged*)  
                 (BV.sub_fr,             fn (y, _, [f, s]) => let  
                                           val s' = IL.Var.copy s  
                                           in [  
                                             IL.ASSGN(s', IL.OP(Op.Neg DstTy.realTy, [s])),  
                                             IL.ASSGN(y, IL.OP(Op.OffsetField, [f, s']))  
                                           ] end),  
   
                 (BV.sub_rf,             fn (y, _, [s, f]) => let  
                                           val f' = IL.Var.copy f  
                                           in [  
                                             IL.ASSGN(f', IL.OP(Op.NegField, [f])),  
                                             IL.ASSGN(y, IL.OP(Op.OffsetField, [f', s]))  
                                           ] end),  
   
161                  (BV.mul_ii,              simpleOp(Op.IMul DstTy.IntTy)),                  (BV.mul_ii,              simpleOp(Op.IMul DstTy.IntTy)),
162                  (BV.mul_rr,              simpleOp(Op.IMul DstTy.IntTy)),                  (BV.mul_rr,              simpleOp(Op.IMul DstTy.IntTy)),
163                       (* Changed*)                  (BV.mul_rt,             tensorEinOp EinOp.scaleTensor),
164                  (BV.mul_rt,             tensorEinOp(EinOp.scaleTensor)),                  (BV.mul_tr,             fn (y, [SK], [t, r])=>let
165                                             val ty1 as DstTy.TensorTy dd1 = pruneShape SK
166                                                val rator =S.transform(EinOp.scaleTensor,[dd1],[])
167                                            in
168                                                assignEin(y, rator,[r,t])
169                                            end),
170    
                 (BV.mul_tr,             fn (y, sv, [t, r])  
                                             =>assignEin(y,createTenEin(EinOp.scaleTensor, sv), [r,t])),  
171    
172    
173                  (BV.mul_rf,             fn (y, _, [s, f])                (BV.mul_rf,             fn (y,[_,NK,SK], xs)=> singlefield(SK,EinOp.scaleField,[NK],y, xs)),
                                             => assignEin(y, createFldEin(EinOp.scaleField,f), [s, f])),  
                 (BV.mul_fr,             fn (y, _, [f, s])  
                                             => assignEin(y, createFldEin(EinOp.scaleField,f), [s, f])),  
174    
                          (* UnChanged*)  
175    
                 (BV.div_ii,             simpleOp(Op.IDiv DstTy.IntTy)),  
                 (BV.div_rr,             simpleOp(Op.IDiv DstTy.realTy)),  
                         (* Changed *)  
                 (BV.div_tr,             fn (y, [sv], [x, s]) =>  
                                          assignEin(y, createTenEin(EinOp.divideTensor,sv), [x,s])),  
                 (BV.div_fr,             fn (y, _, [f, s]) =>  
                                           assignEin(y, createFldEin(EinOp.divideField,sv), [x,s])),  
                          (*UnChanged*)  
                 (BV.exp_ri,             simpleOp(Op.Power)),  
                 (BV.exp_rr,             basisFn MathFuns.pow),  
176    
177                          (* Changed*)                  (BV.mul_fr,             fn (y, [_,NK,SK], [f, s])=> singleField(SK,EinOp.scaleField, [NK],y,[s,f])),
                 (*Note curl is in Ein and does not need to normalize.*)  
                 (BV.curl2D,             fn (y, _, xs) => assignEin(y, EinOp.Curl2d, xs)),  
                 (BV.curl3D,             fn (y, _, xs) => assignEin(y, EinOp.Curl3d, xs)),  
178    
179                    (BV.div_ii,             simpleOp(Op.IDiv DstTy.IntTy)),
180                    (BV.div_rr,             simpleOp(Op.IDiv DstTy.realTy)),
181    
                          (* UnChanged*)  
                 (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>  
                                           assign(y, Op.Field(pruneDim(MV.toDim dv)), xs)),  
                 (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>  
                                           assign(y, Op.Field(pruneDim(MV.toDim dv)), [v, k])),  
182    
183                   (BV.div_tr,             tensorEinOp EinOp.divideTensor),
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)),
                 (BV.op_probe,           fn (y, [_, dv, sv], xs) =>  
                                           assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),  
   
                          (* Changed*)  
                 (*Um what do I give as the argument to Normalize?*)  
                 (BV.op_D,               fn (y, _, xs) => assignEin(y, createFldEin(EinOp.Grad,xs), xs)),  
                 (BV.op_Dotimes,         fn (y, _, xs) => assignEin(y, createFldEin(EinOp.Divergence,xs), xs)),  
195    
196                           (* UnChanged*)                  (BV.op_probe,           fn (y, [_, NK, SK], xs) =>
197                                            let
198                                                val dv'=dimVarToTensor NK  (*Field*)
199                                                val sv'=shapeVarToTensor SK (*Position*)
200                                                val einop= S.transform(EinOp.probe,[sv',dv'],[dv'])
201                                            in assignEin(y, einop,xs)
202                                            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)),
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                           (* Changed*)                 (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 assignEin( y, S.transform(EinOp.outerProduct,[(length(d1),d1), (length(d2),d2)]),xs)                                            in
216                                                assignEin( y, S.transform(EinOp.outerProduct,[d1,d2],[]),xs)
217                                            end)                                            end)
218                                              (*Here, d1, d2 is an int, but we want a list.*)                  (BV.op_inner,        fn (y, [sh1, sh2, _], xs) =>
219                                                let
                 (* Assuming dd1, ddd2 are lists of dimensions*)  
                 (BV.op_inner,        fn (y, [sh1, sh2, _], xs) => let  
220                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
221                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2
222                                            val ilist=  [(length(dd1)-1, List.take(dd1, length(dd1)-1) ) ,                                                  val alpha= List.take(dd1, length(dd1)-1)
223                                                  ( length(dd2)-1, tl(dd2)),                                                  val beta=  tl(dd2)
224                                                  ( 0, [hd(dd2)]) ]                                                  val i =hd(dd2)
225                                            in assignEin(y, S.tranform(EinOp.innerProduct, ilist),xs) end),                                                  val ilist=  [alpha, beta, i]
226                                              in
227                                                assignEin(y, S.tranform(EinOp.innerProduct, ilist,[]),xs)
228                                            end),
229    
230                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) => let                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) =>
231                                                let
232                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
233                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2
234                                            val ilist=    [ (length(dd1)-2 ,  List.take(q, length(q)-2)) ,                                                  val m= List.take(dd2,2)
235                                                  ( length(dd2)-2 , tl(tl(dd2))),                                                  val i=hd(m)
236                                                  (0, List.take(dd2,2))]                                                  val j=tl(m)
237                                           in  assignEin(y, S.transform(EinOp.doubleDot, ilist),xs) end),                                                  val alpha= List.take(dd1, length(dd1)-2)
238                                                    val beta=tl(tl(dd2))
239                                                    val ilist=[alpha, beta, i, j]
240                                                in
241                                                    assignEin(y, S.transform(EinOp.doubleDot, ilist,[]),xs)
242                                                end),
243    
                             (* UnChanged*)  
244                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>
245                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),
246                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
# Line 267  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                          (* Changed*)                 (BV.fn_trace,           fn (y, [dv], xs) =>let
270                  (BV.fn_trace,           fn (y, [dv], xs) => (let                                              val d=dimVarToInt dv
271                           val i=pruneDim(MV.toDim dv)  (* (dimVarToMatrix dv)*)                                          in
272                          (*we need i to be the dimension n of an n xn matrix*)                                              assignEin(y,S.transform(EinOp.trace, [d],[]),xs)
273                          in  assignEin(y,S.transform(EinOp.trace, [1,i]),xs)  end))                                          end),
   
274    
275                  (BV.fn_transpose,       fn (y, [dv1, dv2], xs) =>                  (BV.fn_transpose,       fn (y, [dv1, dv2], xs) =>
276                          let val d1=dimVarToInt dv1 val d2= dimVarToInt dv2                                          let
277                                                val d1=dimVarToInt dv1
278                                                val d2=dimVarToInt dv2
279                          in                          in
280                           assignEin(y,S.transform(EinOp.transpose, [(length(d1),d1),(length d2, d2)]),xs)                                              assignEin(y,S.transform(EinOp.transpose, [[d1],[d2]],[]),xs)
281                          end                                          end),
282                                           (* assign(y, Op.Transpose(dimVarToInt dv1, dimVarToInt dv2), xs))*)  
                    ) ,  
                      (* UnChanged*)  
283                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
284                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
285                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
# Line 291  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                          (* Changed*)                  (BV.identity,           fn (y, [dv], []) =>let
293                  (BV.identity,           fn (y, [dv], []) =>(let                                              val d=dimVarToInt dv
294                                          val i=pruneDim(MV.toDim dv)                                          in assignEin(y, S.transform(EinOp.identity,[[d],[d]],[]),xs)
295                                          (*we need i to be the dimension n of an n xn matrix*)                                          end),
                                         in  assignEin(y, S.transform(EinOp.identity,[(1,i),(1,i)]),[]) end)),  
296    
                         (* UnChanged*)  
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], args) =>                 (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                                              args))                                              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.2395  
changed lines
  Added in v.2445

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