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 2400, Sun Jul 7 13:29:54 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 sv
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)),                  (BV.add_ii,             simpleOp(Op.IAdd DstTy.IntTy)),
124                  (BV.add_tt,             tensorOp Op.Add),                  (BV.add_tt,             tensorEinOp(EinOp.addTensors)),
125                  (BV.add_ff,             fn (y, _, [f, g]) => assign(y, Op.AddField, [f, g])),  
126                  (BV.sub_ii,             simpleOp(Op.Sub DstTy.IntTy)),   (*SrcOp.Field d*)
127                  (BV.sub_tt,             tensorOp Op.Sub),                  (BV.add_ff,             fn (y, _, [f, g])
128                  (BV.sub_ff,             fn (y, _, [f, g]) => assign(y, Op.SubField, [f, g])),                                              =>assignEin(y, createFldEin(EinOp.addField,f ), [f, g])),
129                  (BV.mul_ii,             simpleOp(Op.Mul DstTy.IntTy)),                  (BV.add_fr,             fn (y, _, [f, s])
130                  (BV.mul_rr,             simpleOp(Op.Mul(DstTy.realTy))),                                              => assignEin(y, createFldEin(EinOp.addTenField,f ), [f, s])),
131                  (BV.mul_rt,             tensorOp Op.Scale),                  (BV.add_rf,             fn (y, _, [s, f])
132                  (BV.mul_tr,             fn (y, sv, [t, r]) => tensorOp Op.Scale (y, sv, [r, t])),                                              => assignEin(y, createFldEin(EinOp.addTenField,f ), [f, s])),
133                  (BV.mul_rf,             fn (y, _, [s, f]) => assign(y, Op.ScaleField, [s, f])),  
134                  (BV.mul_fr,             fn (y, _, [f, s]) => assign(y, Op.ScaleField, [s, f])),                  (BV.sub_ii,              simpleOp(Op.ISub DstTy.IntTy)),
135                  (BV.div_ii,             simpleOp(Op.Div DstTy.IntTy)),                  (BV.sub_tt,             tensorEinOp(EinOp.subTensor)),
136                  (BV.div_rr,             simpleOp(Op.Div DstTy.realTy)),                  (BV.sub_ff,             fn (y, _, [f, g])
137                  (BV.div_tr,             fn (y, [sv], [x, s]) => let                                              => assignEin(y, createFldEin(EinOp.subField,f), [f, g])),
138                                            val one = IL.Var.new("one", DstTy.realTy)  
139                                            val s' = IL.Var.new("sInv", DstTy.realTy)  (***********Examine subfr, and subrf*)
140                    (BV.sub_fr,             fn (y, _, [f, s]) => let
141                                              val s' = IL.Var.copy s
142                                            in [                                            in [
143                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),                                              IL.ASSGN(s', IL.OP(Op.Neg DstTy.realTy, [s])),
144                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),                                              IL.ASSGN(y, IL.OP(Op.OffsetField, [f, s']))
                                             IL.ASSGN(y, IL.OP(Op.Scale(shapeVarToTensor sv), [s', x]))  
145                                            ] end),                                            ] end),
146                  (BV.div_fr,             fn (y, _, [f, s]) => let  
147                                            val one = IL.Var.new("one", DstTy.realTy)                  (BV.sub_rf,             fn (y, _, [s, f]) => let
148                                            val s' = IL.Var.new("sInv", DstTy.realTy)                                            val f' = IL.Var.copy f
149                                            in [                                            in [
150                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),                                              IL.ASSGN(f', IL.OP(Op.NegField, [f])),
151                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),                                              IL.ASSGN(y, IL.OP(Op.OffsetField, [f', s]))
                                             IL.ASSGN(y, IL.OP(Op.ScaleField, [s', f]))  
152                                            ] end),                                            ] end),
153    
154                    (BV.mul_ii,              simpleOp(Op.IMul DstTy.IntTy)),
155                    (BV.mul_rr,              simpleOp(Op.IMul DstTy.IntTy)),
156                    (BV.mul_rt,             tensorEinOp(EinOp.scaleTensor)),
157                    (BV.mul_tr,             fn (y, sv, [t, r])
158                                                =>assignEin(y,createTenEin(EinOp.scaleTensor, sv), [r,t])),
159                    (BV.mul_rf,             fn (y, _, [s, f])
160                                                => assignEin(y, createFldEin(EinOp.scaleField,f), [s, f])),
161                    (BV.mul_fr,             fn (y, _, [f, s])
162                                                => assignEin(y, createFldEin(EinOp.scaleField,f), [s, f])),
163    
164                    (BV.div_ii,             simpleOp(Op.IDiv DstTy.IntTy)),
165                    (BV.div_rr,             simpleOp(Op.IDiv DstTy.realTy)),
166                    (BV.div_tr,             fn (y, [sv], [x, s]) =>
167                                             assignEin(y, createTenEin(EinOp.divideTensor,sv), [x,s])),
168                    (BV.div_fr,             fn (y, _, [f, s]) =>
169                                              assignEin(y, createFldEin(EinOp.divideField,sv), [x,s])),
170    
171                  (BV.exp_ri,             simpleOp(Op.Power)),                  (BV.exp_ri,             simpleOp(Op.Power)),
172                  (BV.exp_rr,             basisFn ILBasis.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
173                  (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>  
174                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), xs)),                  (*Note curl is in Ein and does not need to be specialized.*)
175                  (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>                  (BV.curl2D,             fn (y, _, xs) => assignEin(y, EinOp.Curl2d, xs)),
176                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), [v, k])),                  (BV.curl3D,             fn (y, _, xs) => assignEin(y, EinOp.Curl3d, xs)),
177                  (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),  
178                  (BV.neg_t,              tensorOp Op.Neg),  
179                    (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>let
180                            val shape=pruneDim(MV.toDim dv)
181                            val operator=EinOp.conv
182                        in
183                            S.transform(operator,[(len(shape), shape)])
184                            assignEin (y, rator, xs)
185                        end),
186                    (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>let
187                            val shape=pruneDim(MV.toDim dv)
188                            val operator=EinOp.conv
189                        in
190                            S.transform(operator,[(len(shape), shape)])
191                            assignEin (y, rator, [v,k])
192                        end),
193    
194                    (BV.neg_i,              simpleOp(Op.INeg DstTy.IntTy)),
195                    (BV.neg_t,              tensorOp Op.INeg),
196                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),
197                  (BV.op_at,              fn (y, [_, dv, sv], xs) =>                  (BV.op_probe,           fn (y, [_, dv, sv], xs) =>
198                                            assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),                            (*  assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs),*)
199                  (BV.op_D,               fn (y, _, xs) => assign(y, Op.DiffField, xs)),  
200                  (BV.op_Dotimes,         fn (y, _, xs) => assign(y, Op.DiffField, xs)),                                          let
201                                            val dv'=dimVarToTensor dv
202                                            val sv'=shapeVarToTensor sv
203                                            val operator=EinOp.probe
204                                            (*field-0 sv', position-1 dv'*)
205                                            (*F(x)_alpha   <F(x_1)>_0*)
206                                            val il= S.transform(operator,[(len(sv'), sv'),(len(dv'),dv')])
207                                            in assignEin(y, il,xs) end ),
208    
209    (*Should I not include shape in field operations? *)
210    (***********  What do I give as the arguments to Specialize*)
211                    (BV.op_D,               fn (y, _, xs) => assignEin(y, createFldEin(EinOp.Grad,xs), xs)),
212                    (BV.op_Dotimes,         fn (y, _, xs) => assignEin(y, createFldEin(EinOp.Divergence,xs), xs)),
213    
214                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv
215                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)
216                                              | ty => assign(y, Op.Norm ty, xs)                                              | ty => assign(y, Op.Norm ty, xs)
217                                            (* end case *))),                                            (* end case *))),
218                  (BV.op_not,             simpleOp Op.Not),                  (BV.op_not,             simpleOp Op.Not),
219                  (BV.fn_atan2,           basisFn ILBasis.atan2),  
220                  (BV.fn_cos,             basisFn ILBasis.cos),  (****MV.toDim returns int, and DstTy.TensorTy returns intlist *)
221                  (BV.op_cross,           simpleOp Op.Cross),  
222                    (BV.op_cross,           fn(y, _ , xs )=> assignEin(y,EinOp.crossProductE ,xs)),
223                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let
224                                            val d1 = pruneDim(MV.toDim dv1)                                            val d1 = [pruneDim(MV.toDim dv1)]
225                                            val d2 = pruneDim(MV.toDim dv2)                                            val d2 = [pruneDim(MV.toDim dv2)]
226                                            in                                            in assignEin( y, S.transform(EinOp.outerProduct,[(length(d1),d1), (length(d2),d2)]),xs)
                                             assign (y, Op.Outer(DstTy.tensorTy[d1, d2]), xs)  
227                                            end),                                            end),
228                  (BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let                  (BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let
229                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
230                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2
231                                            val rator = (case (dd1, dd2)                                            val ilist=  [(length(dd1)-1, List.take(dd1, length(dd1)-1) ) ,
232                                                   of ([d], [d']) => Op.Dot ty1                                                  ( length(dd2)-1, tl(dd2)),
233                                                    | ([d1], [d1', d2]) => Op.MulVecMat ty2                                                  ( 0, [hd(dd2)]) ]
234                                                    | ([d1, d2], [d2']) => Op.MulMatVec ty1                                            in assignEin(y, S.tranform(EinOp.innerProduct, ilist),xs) end),
235                                                    | ([d1, d2], [d2', d3]) => Op.MulMatMat(ty1, ty2)  
236                                                    | _ => raise Fail "unsupported inner-product type"                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) => let
237                                                  (* end case *))                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
238                                            in                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2
239                                              assign (y, rator, xs)                                            val ilist=    [ (length(dd1)-2 ,  List.take(q, length(q)-2)) ,
240                                            end),                                                  ( length(dd2)-2 , tl(tl(dd2))),
241                                                    (0, List.take(dd2,2))]
242                                             in assignEin(y, S.transform(EinOp.doubleDot, ilist),xs) end),
243    
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 191  Line 260 
260                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
261                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),
262                  (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),  
263                  (BV.fn_max,             simpleOp Op.Max),                  (BV.fn_max,             simpleOp Op.Max),
264                  (BV.fn_min,             simpleOp Op.Min),                  (BV.fn_min,             simpleOp Op.Min),
265                  (BV.fn_modulate,        vectorOp Op.Mul),                  (BV.fn_modulate,        vectorOp Op.Mul),
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                  (BV.fn_sin,             basisFn ILBasis.sin),  
269                  (BV.fn_sqrt,            basisFn ILBasis.sqrt),                  (BV.fn_trace,           fn (y, [dv], xs) =>let
270                  (BV.fn_tan,             basisFn ILBasis.tan),                                              val i=pruneDim(MV.toDim dv)
271                  (BV.fn_trace,           fn (y, [dv], xs) => assign(y, Op.Trace(dimVarToMatrix dv), xs)),                                          in assignEin(y,S.transform(EinOp.trace, [1,i]),xs)  end),
272    
273                    (BV.fn_transpose,       fn (y, [dv1, dv2], xs) =>let
274                                                val d1=dimVarToInt dv1 val d2= dimVarToInt dv2
275                                            in assignEin(y,S.transform(EinOp.transpose, [(length(d1),d1),(length d2, d2)]),xs) end) ,
276    
277                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
278                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
279                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
280                  (BV.kn_c2ctmr,          kernel Kernel.ctmr),                  (BV.kn_c2ctmr,          kernel Kernel.ctmr),
281                    (BV.kn_c4hexic,         kernel Kernel.c4hexic),
282                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
283                  (BV.kn_c1tent,          kernel Kernel.tent),                  (BV.kn_c1tent,          kernel Kernel.tent),
284                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
285                  (BV.identity,           fn (y, [dv], []) =>  
286                                            assign(y, Op.Identity(pruneDim(MV.toDim dv)), [])),                  (BV.identity,           fn (y, [dv], []) =>let
287                                                    val i=pruneDim(MV.toDim dv)
288                                                in assignEin(y, S.transform(EinOp.identity,[(1,i),(1,i)]),[]) end),
289    
290                  (BV.zero,               fn (y, [sv], []) =>                  (BV.zero,               fn (y, [sv], []) =>
291                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),
292                  (BV.subscript,          fn (y, [tv, dv], args) =>                  (BV.subscript,          fn (y, [tv, dv], args) =>
293                                            assign(y,                                            assign(y,
294                                              Op.SeqSub(DstTy.SeqTy(pruneTy(MV.toType tv), pruneDim(MV.toDim dv))),                                              Op.SeqSub(DstTy.SeqTy(pruneTy tv, pruneDim(MV.toDim dv))),
295                                              args))                                              args))
296                ];                ];
297    
298              (* add C math functions *)
299                List.app (fn (n, x) => insert(x, basisFn n)) BV.mathFns;
300              tbl              tbl
301            end            end
302    

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

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