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

trunk/src/compiler/translate/translate-basis.sml revision 1910, Tue Jun 5 12:02:36 2012 UTC branches/charisee/src/compiler/translate/translate-basis.sml revision 2389, Sun Jun 16 18:45:16 2013 UTC
# Line 26  Line 26 
26      structure MV = MetaVar      structure MV = MetaVar
27      structure VTbl = Var.Tbl      structure VTbl = Var.Tbl
28    
29      fun pruneTy ty = (case TU.prune ty      structure EinOp= Operators
30             of (Ty.T_Var _) => raise Fail("unresolved type " ^ TU.toString ty)      structure R=Rewrite
31        structure N=Normalize
32    
33        fun pruneTy tv = (case TU.prune(MV.toType tv)
34               of (ty as Ty.T_Var _) => raise Fail("unresolved type " ^ TU.toString ty)
35              | ty => TranslateTy.tr ty              | ty => TranslateTy.tr ty
36            (* end case *))            (* end case *))
37    
# Line 41  Line 45 
45              | shp => raise Fail("unresolved shape " ^ TU.shapeToString shp)              | shp => raise Fail("unresolved shape " ^ TU.shapeToString shp)
46            (* end case *))            (* end case *))
47    
48      fun dimVarToTensor dv = DstTy.tensorTy[pruneDim(MV.toDim dv)]      fun dimVarToInt dv = pruneDim(MV.toDim dv)
49        fun dimVarToTensor dv = DstTy.tensorTy[dimVarToInt dv]
50      fun dimVarToMatrix dv = let      fun dimVarToMatrix dv = let
51            val d = pruneDim(MV.toDim dv)            val d = dimVarToInt dv
52            in            in
53              DstTy.tensorTy[d, d]        (* square matrix type *)              DstTy.tensorTy[d, d]        (* square matrix type *)
54            end            end
# Line 81  Line 86 
86                  end                  end
87            end            end
88    
89        fun createTenEin (operator, sv) = let
90              val shape=shapeVarToTensor
91              in
92                S.transform(operator,[len(shape), shape])
93              end
94        fun createFldEin(operator, f)=S.transform(operator,[])
95    
96    
97        fun assignEin (y, rator, xs) = [IL.ASSGN(y, IL.EINAPP(R.evalEinApp(rator, xs)))]
98        fun simpleEinOp rator (y, [], xs) = assignEin (y, S.transform(rator,[]), xs)
99        fun tensorEinOp rator (y, [sv], xs) = assignEin(y, createTenEin(rator, sv), xs)
100    
101    (* build a table that maps Basis variables to their translation functions *)    (* build a table that maps Basis variables to their translation functions *)
102      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
103            val tbl = VTbl.mkTable (128, Fail "Translate table")            val tbl = VTbl.mkTable (128, Fail "Translate table")
104              val insert = VTbl.insert tbl
105            in            in
106              List.app (VTbl.insert tbl) [              List.app insert [
107                  (BV.lt_ii,              simpleOp(Op.LT DstTy.IntTy)),                  (BV.lt_ii,              simpleOp(Op.LT DstTy.IntTy)),
108                  (BV.lt_rr,              simpleOp(Op.LT DstTy.realTy)),                  (BV.lt_rr,              simpleOp(Op.LT DstTy.realTy)),
109                  (BV.lte_ii,             simpleOp(Op.LTE DstTy.IntTy)),                  (BV.lte_ii,             simpleOp(Op.LTE DstTy.IntTy)),
# Line 102  Line 120 
120                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),
121                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),
122                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),
123                  (BV.add_ii,             simpleOp(Op.Add DstTy.IntTy)),  
124                  (BV.add_tt,             tensorOp Op.Add),                      (* Changed*)
125                  (BV.add_ff,             fn (y, _, [f, g]) => assign(y, Op.AddField, [f, g])),  
126                  (BV.sub_ii,             simpleOp(Op.Sub DstTy.IntTy)),                  (BV.add_ii,             simpleEinOp(EinOp.addScalars)),
127                  (BV.sub_tt,             tensorOp Op.Sub),                  (BV.add_tt,             tensorEinOp(EinOp.addTensors)),
128                  (BV.sub_ff,             fn (y, _, [f, g]) => assign(y, Op.SubField, [f, g])),  
129                  (BV.mul_ii,             simpleOp(Op.Mul DstTy.IntTy)),  
130                  (BV.mul_rr,             simpleOp(Op.Mul(DstTy.realTy))),                  (BV.add_ff,             fn (y, _, [f, g])
131                  (BV.mul_rt,             tensorOp Op.Scale),                                              =>assignEin(y, createFldEin(EinOp.addField,f ), [f, g])),
132                  (BV.mul_tr,             fn (y, sv, [t, r]) => tensorOp Op.Scale (y, sv, [r, t])),                  (BV.add_fr,             fn (y, _, [f, s])
133                  (BV.mul_rf,             fn (y, _, [s, f]) => assign(y, Op.ScaleField, [s, f])),                                              => assignEin(y, createFldEin(EinOp.addTenField,f ), [f, s])),
134                  (BV.mul_fr,             fn (y, _, [f, s]) => assign(y, Op.ScaleField, [s, f])),                  (BV.add_rf,             fn (y, _, [s, f])
135                                                => assignEin(y, createFldEin(EinOp.addTenField,f ), [f, s])),
136    
137                    (BV.sub_ii,             simpleEinOp(EinOp.subScalars)),
138                    (BV.sub_tt,             tensorEinOp(EinOp.subTensor)),
139                    (BV.sub_ff,             fn (y, _, [f, g])
140                                                => assignEin(y, createFldEin(EinOp.subField,f), [f, g])),
141    
142                    (* UnChanged*)
143                    (BV.sub_fr,             fn (y, _, [f, s]) => let
144                                              val s' = IL.Var.copy s
145                                              in [
146                                                IL.ASSGN(s', IL.OP(Op.Neg DstTy.realTy, [s])),
147                                                IL.ASSGN(y, IL.OP(Op.OffsetField, [f, s']))
148                                              ] end),
149    
150                    (BV.sub_rf,             fn (y, _, [s, f]) => let
151                                              val f' = IL.Var.copy f
152                                              in [
153                                                IL.ASSGN(f', IL.OP(Op.NegField, [f])),
154                                                IL.ASSGN(y, IL.OP(Op.OffsetField, [f', s]))
155                                              ] end),
156                             (* Changed*)
157                    (BV.mul_ii,             simpleEinOp(EinOp.scalarxscalar)),
158                    (BV.mul_rr,             simpleEinOp(EinOp.scalarxscalar)),
159                    (BV.mul_rt,             tensorEinOp(EinOp.scaleTensor)),
160    
161                    (BV.mul_tr,             fn (y, sv, [t, r])
162                                                =>assignEin(y,createTenEin(EinOp.scaleTensor, sv), [r,t])),
163    
164    
165                    (BV.mul_rf,             fn (y, _, [s, f])
166                                                => assignEin(y, createFldEin(EinOp.scaleField,f), [s, f])),
167                    (BV.mul_fr,             fn (y, _, [f, s])
168                                                => assignEin(y, createFldEin(EinOp.scaleField,f), [s, f])),
169    
170                             (* UnChanged*)
171    
172                  (BV.div_ii,             simpleOp(Op.Div DstTy.IntTy)),                  (BV.div_ii,             simpleOp(Op.Div DstTy.IntTy)),
173                  (BV.div_rr,             simpleOp(Op.Div DstTy.realTy)),                  (BV.div_rr,             simpleOp(Op.Div DstTy.realTy)),
174                  (BV.div_tr,             fn (y, [sv], [x, s]) => let                  (BV.div_tr,             fn (y, [sv], [x, s]) => let
# Line 133  Line 188 
188                                              IL.ASSGN(y, IL.OP(Op.ScaleField, [s', f]))                                              IL.ASSGN(y, IL.OP(Op.ScaleField, [s', f]))
189                                            ] end),                                            ] end),
190                  (BV.exp_ri,             simpleOp(Op.Power)),                  (BV.exp_ri,             simpleOp(Op.Power)),
191                  (BV.exp_rr,             basisFn ILBasis.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
192    
193                            (* Changed*)
194                    (*Note curl is in Ein and does not need to normalize.*)
195                    (BV.curl2D,             fn (y, _, xs) => assignEin(y, EinOp.Curl2d, xs)),
196                    (BV.curl3D,             fn (y, _, xs) => assignEin(y, EinOp.Curl3d, xs)),
197    
198    
199                             (* UnChanged*)
200                  (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>                  (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>
201                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), xs)),                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), xs)),
202                  (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>                  (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>
203                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), [v, k])),                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), [v, k])),
204    
205    
206                  (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),                  (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),
207                  (BV.neg_t,              tensorOp Op.Neg),                  (BV.neg_t,              tensorOp Op.Neg),
208                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),
209                  (BV.op_at,              fn (y, [_, dv, sv], xs) =>                  (BV.op_probe,           fn (y, [_, dv, sv], xs) =>
210                                            assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),                                            assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),
211                  (BV.op_D,               fn (y, _, xs) => assign(y, Op.DiffField, xs)),  
212                  (BV.op_Dotimes,         fn (y, _, xs) => assign(y, Op.DiffField, xs)),                           (* Changed*)
213                    (*Um what do I give as the argument to Normalize?*)
214                    (BV.op_D,               fn (y, _, xs) => assignEin(y, createFldEin(EinOp.Grad,xs), xs)),
215                    (BV.op_Dotimes,         fn (y, _, xs) => assignEin(y, createFldEin(EinOp.Divergence,xs), xs)),
216    
217                             (* UnChanged*)
218                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv
219                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)
220                                              | ty => assign(y, Op.Norm ty, xs)                                              | ty => assign(y, Op.Norm ty, xs)
221                                            (* end case *))),                                            (* end case *))),
222                  (BV.op_not,             simpleOp Op.Not),                  (BV.op_not,             simpleOp Op.Not),
223                  (BV.fn_atan2,           basisFn ILBasis.atan2),  
224                  (BV.fn_cos,             basisFn ILBasis.cos),                           (* Changed*)
225                  (BV.op_cross,           simpleOp Op.Cross),                  (BV.op_cross,           fn(y, _ , xs )=> assignEin(y,EinOp.crossProductE ,xs))
226                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let
227                                            val d1 = pruneDim(MV.toDim dv1)                                            val d1 = pruneDim(MV.toDim dv1)
228                                            val d2 = pruneDim(MV.toDim dv2)                                            val d2 = pruneDim(MV.toDim dv2)
229                                            in                                            in assignEin( y, S.transform(EinOp.outerProduct,[(length(d1),d1), (length(d2),d2)]),xs)
230                                              assign (y, Op.Outer(DstTy.tensorTy[d1, d2]), xs)                                            end)
231                                            end),                                              (*Here, d1, d2 is an int, but we want a list.*)
232    
233                    (* Assuming dd1, ddd2 are lists of dimensions*)
234                  (BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let                  (BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let
235                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
236                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2
237                                            val rator = (case (dd1, dd2)                                            val ilist=  [(length(dd1)-1, List.take(dd1, length(dd1)-1) ) ,
238                                                   of ([d], [d']) => Op.Dot ty1                                                  ( length(dd2)-1, tl(dd2)),
239                                                    | ([d1], [d1', d2]) => Op.MulVecMat ty2                                                  ( 0, [hd(dd2)]) ]
240                                                    | ([d1, d2], [d2']) => Op.MulMatVec ty1                                            in assignEin(y, S.tranform(EinOp.innerProduct, ilist),xs) end),
241                                                    | ([d1, d2], [d2', d3]) => Op.MulMatMat(ty1, ty2)  
242                                                    | _ => raise Fail "unsupported inner-product type"  
243                                                  (* end case *))                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) => let
244                                            in                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
245                                              assign (y, rator, xs)                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2
246                                            end),                                            val ilist=    [ (length(dd1)-2 ,  List.take(q, length(q)-2)) ,
247                                                    ( length(dd2)-2 , tl(tl(dd2))),
248                                                    (0, List.take(dd2,2))]
249                                             in  assignEin(y, S.transform(EinOp.doubleDot, ilist),xs) end),
250    
251    
252                                (* UnChanged*)
253                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>
254                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),
255                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
# Line 191  Line 269 
269                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
270                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),
271                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),
                 (BV.fn_fmod,            basisFn ILBasis.fmod),  
                 (BV.fn_log10,           basisFn ILBasis.log10),  
                 (BV.fn_ln,              basisFn ILBasis.ln),  
272                  (BV.fn_max,             simpleOp Op.Max),                  (BV.fn_max,             simpleOp Op.Max),
273                  (BV.fn_min,             simpleOp Op.Min),                  (BV.fn_min,             simpleOp Op.Min),
274                  (BV.fn_modulate,        vectorOp Op.Mul),                  (BV.fn_modulate,        vectorOp Op.Mul),
275                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (BV.fn_normalize,       vectorOp Op.Normalize),
276                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
277                  (BV.fn_sin,             basisFn ILBasis.sin),  
278                  (BV.fn_sqrt,            basisFn ILBasis.sqrt),                          (* Changed*)
279                  (BV.fn_tan,             basisFn ILBasis.tan),                  (BV.fn_trace,           fn (y, [dv], xs) => (let
280                  (BV.fn_trace,           fn (y, [dv], xs) => assign(y, Op.Trace(dimVarToMatrix dv), xs)),                           val i=pruneDim(MV.toDim dv)  (* (dimVarToMatrix dv)*)
281                            (*we need i to be the dimension n of an n xn matrix*)
282                            in  assignEin(y,S.transform(EinOp.trace, [1,i]),xs)  end))
283    
284                            (* UnChanged*)
285                    (BV.fn_transpose,       fn (y, [dv1, dv2], xs) =>
286                                              assign(y, Op.Transpose(dimVarToInt dv1, dimVarToInt dv2), xs)),
287                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
288                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
289                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
290                  (BV.kn_c2ctmr,          kernel Kernel.ctmr),                  (BV.kn_c2ctmr,          kernel Kernel.ctmr),
291                    (BV.kn_c4hexic,         kernel Kernel.c4hexic),
292                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
293                  (BV.kn_c1tent,          kernel Kernel.tent),                  (BV.kn_c1tent,          kernel Kernel.tent),
294                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
295                  (BV.identity,           fn (y, [dv], []) =>  
296                                            assign(y, Op.Identity(pruneDim(MV.toDim dv)), [])),                          (* Changed*)
297                    (BV.identity,           fn (y, [dv], []) =>(let
298                                            val i=pruneDim(MV.toDim dv)
299                                            (*we need i to be the dimension n of an n xn matrix*)
300                                            in  assignEin(y, S.transform(EinOp.identity,[(1,i),(1,i)]),[]) end)),
301    
302                            (* UnChanged*)
303                  (BV.zero,               fn (y, [sv], []) =>                  (BV.zero,               fn (y, [sv], []) =>
304                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),
305                  (BV.subscript,          fn (y, [tv, dv], args) =>                  (BV.subscript,          fn (y, [tv, dv], args) =>
306                                            assign(y,                                            assign(y,
307                                              Op.SeqSub(DstTy.SeqTy(pruneTy(MV.toType tv), pruneDim(MV.toDim dv))),                                              Op.SeqSub(DstTy.SeqTy(pruneTy tv, pruneDim(MV.toDim dv))),
308                                              args))                                              args))
309                ];                ];
310    
311              (* add C math functions *)
312                List.app (fn (n, x) => insert(x, basisFn n)) BV.mathFns;
313              tbl              tbl
314            end            end
315    

Legend:
Removed from v.1910  
changed lines
  Added in v.2389

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