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 2445, Thu Sep 26 17:40:17 2013 UTC revision 2447, Sat Sep 28 18:10:51 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=RewriteEin      structure S=Specialize
     structure N=Normalize  
31    
32      fun pruneTy tv = (case TU.prune(MV.toType tv)      fun pruneTy tv = (case TU.prune(MV.toType tv)
33             of (ty as Ty.T_Var _) => raise Fail("unresolved type " ^ TU.toString ty)             of (ty as Ty.T_Var _) => raise Fail("unresolved type " ^ TU.toString ty)
# Line 40  Line 39 
39              | d => raise Fail("unresolved dimension " ^ TU.dimToString d)              | d => raise Fail("unresolved dimension " ^ TU.dimToString d)
40            (* end case *))            (* end case *))
41    
42    
43    
44      fun pruneShape sv = (case TU.pruneShape(MV.toShape sv)      fun pruneShape sv = (case TU.pruneShape(MV.toShape sv)
45             of Ty.Shape dd => DstTy.tensorTy(List.map pruneDim dd)             of Ty.Shape dd => DstTy.tensorTy(List.map pruneDim dd)
46              | shp => raise Fail("unresolved shape " ^ TU.shapeToString shp)              | shp => raise Fail("unresolved shape " ^ TU.shapeToString shp)
47            (* end case *))            (* end case *))
48    
49    
50      fun dimVarToInt dv = pruneDim(MV.toDim dv)      fun dimVarToInt dv = pruneDim(MV.toDim dv)
51      fun dimVarToTensor dv = DstTy.tensorTy[dimVarToInt dv]      fun dimVarToTensor dv = DstTy.tensorTy[dimVarToInt dv]
52      fun dimVarToMatrix dv = let      fun dimVarToMatrix dv = let
# Line 59  Line 61 
61      fun basisFn name (y, [], xs) = [IL.ASSGN(y, IL.APPLY(name, xs))]      fun basisFn name (y, [], xs) = [IL.ASSGN(y, IL.APPLY(name, xs))]
62    
63      fun simpleOp rator (y, [], xs) = assign (y, rator, xs)      fun simpleOp rator (y, [], xs) = assign (y, rator, xs)
64            fun shapeVarToTensor sv = pruneShape sv
65    
66    
67      fun tensorOp rator (y, [sv], xs) = assign (y, rator(shapeVarToTensor sv), xs)      fun tensorOp rator (y, [sv], xs) = assign (y, rator(shapeVarToTensor sv), xs)
68    
# Line 90  Line 94 
94    
95    
96    
97      fun assignEin (y, rator, xs) = [IL.ASSGN(y, IL.EINAPP(R.evalEinApp(rator, xs)))]      fun assignEin (y, rator, xs) = [IL.ASSGN(y, IL.EINAPP(rator, xs))]
98    
99      fun simpleEinOp rator (y, _,xs) = assignEin(y, rator, xs)      fun simpleEinOp rator (y, _,xs) = assignEin(y, rator, xs)
100    
101      fun shapeVarToTensor sv = pruneShape sv      fun peelFieldSK SK=[2]  (*(case TU.pruneShape(MV.toShape SK)
102                of Ty.Shape dd =>  List.map pruneDim dd
103                | shp => raise Fail("unresolved shape " ^ TU.shapeToString shp)
104                (* end case *))*)
105    
106    
107    
108      fun tensorEinOp einop (y, [SK], xs) =      fun tensorEinOp einop (y, [SK], xs) =
109          let val ty1 as DstTy.TensorTy dd1 = pruneShape SK          let val ty1 as DstTy.TensorTy dd1 = pruneShape SK
# Line 104  Line 113 
113          end          end
114    
115    
116    
117      fun scalarField(einop,paramarg,y,xs)=      fun scalarField(einop,paramarg,y,xs)=
118              let val rator=S.transform(einop, [[]],paramarg)              let val paramarg'=List.map dimVarToInt  paramarg(*[2]*)
119                    val rator=S.transform(einop, [[]],paramarg')
120    
121              in              in
122                  assignEin(y, rator, xs)                  assignEin(y, rator, xs)
123              end              end
124    
125      fun singlefield(SK,einop,paramarg, y, xs)=      fun singleField(SK,einop,paramarg, y, xs)=
126          let          let
127              val s=peelFieldShape SK              val s=peelFieldSK SK
128              val rator= S.transform(einop, s,paramarg)              val paramarg'= List.map dimVarToInt paramarg (*[2]*)
129                val rator= S.transform(einop, [s],paramarg')
130          in assignEin(y, rator, xs)          in assignEin(y, rator, xs)
131          end          end
132    
# Line 148  Line 161 
161                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),
162                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),
163                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),
164                  (BV.add_ii,             simpleOp(Op.IAdd DstTy.IntTy)),                  (BV.add_ii,             simpleOp Op.IAdd ),
165                  (BV.add_tt,             tensorEinOp EinOp.addTensor),                  (BV.add_tt,             tensorEinOp EinOp.addTensor),
166                  (BV.add_ff,             fn (y, [_,NK,SK], xs)=> singlefield(SK,EinOp.addField, [NK,NK], y, xs)),                  (BV.add_ff,             fn (y, [_,NK,SK], xs)=> singleField(SK,EinOp.addField, [NK,NK], y, xs)),
167                  (BV.add_fr,             fn (y, [_,NK], xs)=>    scalarField(EinOp.addTenField,[NK],y, xs)),                  (BV.add_fr,             fn (y, [_,NK], xs)=>    scalarField(EinOp.addTenField,[NK],y, xs)),
168                  (BV.add_rf,             fn (y, [_,NK], [s, f])=>scalarField(EinOp.addTenField,[NK],y,[f,s])),                  (BV.add_rf,             fn (y, [_,NK], [s, f])=>scalarField(EinOp.addTenField,[NK],y,[f,s])),
169                  (BV.sub_ii,              simpleOp(Op.ISub DstTy.IntTy)),                  (BV.sub_ii,              simpleOp Op.ISub ),
170                  (BV.sub_tt,             tensorEinOp EinOp.subTensor),                  (BV.sub_tt,             tensorEinOp EinOp.subTensor),
171                  (BV.sub_ff,             fn (y, [_,NK,SK], xs)=>singlefield(SK,EinOp.subField, [NK,NK],y,xs)),                  (BV.sub_ff,             fn (y, [_,NK,SK], xs)=>singleField(SK,EinOp.subField, [NK,NK],y,xs)),
172                  (BV.sub_fr,             fn (y, [_,NK], xs) =>     scalarField(EinOp.subField,[NK], y,xs)),                  (BV.sub_fr,             fn (y, [_,NK], xs) =>     scalarField(EinOp.subField,[NK], y,xs)),
173                  (BV.sub_rf,             fn (y, [_,NK], [s, f]) => scalarField(EinOp.subField,[NK], y,[f, s])),                  (BV.sub_rf,             fn (y, [_,NK], [s, f]) => scalarField(EinOp.subField,[NK], y,[f, s])),
174                  (BV.mul_ii,             simpleOp(Op.IMul DstTy.IntTy)),  (* CHANEG create negative subtraction*)
175                  (BV.mul_rr,             simpleOp(Op.IMul DstTy.IntTy)),                  (BV.mul_ii,             simpleOp Op.IMul),
176                    (BV.mul_rr,             simpleOp Op.IMul),
177                  (BV.mul_rt,             tensorEinOp EinOp.scaleTensor),                  (BV.mul_rt,             tensorEinOp EinOp.scaleTensor),
178                  (BV.mul_tr,             fn (y, [SK], [t, r])=>let                  (BV.mul_tr,             fn (y, [SK], [t, r])=>let
179                                           val ty1 as DstTy.TensorTy dd1 = pruneShape SK                                           val ty1 as DstTy.TensorTy dd1 = pruneShape SK
# Line 170  Line 184 
184    
185    
186    
187                (BV.mul_rf,             fn (y,[_,NK,SK], xs)=> singlefield(SK,EinOp.scaleField,[NK],y, xs)),                (BV.mul_rf,             fn (y,[_,NK,SK], xs)=> singleField(SK,EinOp.scaleField,[NK],y, xs)),
188    
189    
190    
191                  (BV.mul_fr,             fn (y, [_,NK,SK], [f, s])=> singleField(SK,EinOp.scaleField, [NK],y,[s,f])),                  (BV.mul_fr,             fn (y, [_,NK,SK], [f, s])=> singleField(SK,EinOp.scaleField, [NK],y,[s,f])),
192    
193                  (BV.div_ii,             simpleOp(Op.IDiv DstTy.IntTy)),                  (BV.div_ii,             simpleOp Op.IDiv),
194                  (BV.div_rr,             simpleOp(Op.IDiv DstTy.realTy)),                  (BV.div_rr,             simpleOp Op.IDiv),
195    
196    
197                 (BV.div_tr,             tensorEinOp EinOp.divideTensor),                 (BV.div_tr,             tensorEinOp EinOp.divideTensor),
# Line 187  Line 201 
201                  (BV.exp_rr,             basisFn MathFuns.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
202                  (BV.curl2D,             simpleEinOp EinOp.Curl2d),                  (BV.curl2D,             simpleEinOp EinOp.Curl2d),
203                  (BV.curl3D,             simpleEinOp EinOp.Curl3d),                  (BV.curl3D,             simpleEinOp EinOp.Curl3d),
204                  (BV.convolve_vk,        fn (y, [_, NK, SK], xs) => singlefield(SK,EinOp.conv, [NK],y,xs)),                  (BV.convolve_vk,        fn (y, [_, NK, SK], xs) => singleField(SK,EinOp.conv, [NK],y,xs)),
205                  (BV.convolve_kv,        fn (y, [_, NK, SK], [k, v]) =>singlefield(SK,EinOp.conv, [NK],y,[v,k])),                  (BV.convolve_kv,        fn (y, [_, NK, SK], [k, v]) =>singleField(SK,EinOp.conv, [NK],y,[v,k])),
206                  (BV.neg_i,              simpleOp(Op.INeg DstTy.IntTy)),                  (BV.neg_i,              simpleOp Op.INeg),
207                  (BV.neg_t,              tensorOp Op.INeg),                  (BV.neg_t,              tensorEinOp EinOp.negTensor),
208                  (BV.neg_f,              fn (y, [_,NK,SK], xs) => singlefield(SK,EinOp.negField, [NK],y,xs)),  
209    
210                    (BV.neg_f,              fn (y, [_,NK,SK], xs) => singleField(SK,EinOp.negField, [NK],y,xs)),
211    
212                  (BV.op_probe,           fn (y, [_, NK, SK], xs) =>                  (BV.op_probe,           fn (y, [_, NK, SK], xs) =>
213                                          let                                          let
214                                              val dv'=dimVarToTensor NK  (*Field*)                                              val dv=dimVarToTensor NK  (*Field*)
215                                              val sv'=shapeVarToTensor SK (*Position*)                                              val sv=shapeVarToTensor SK (*Position*)
216                                              val einop= S.transform(EinOp.probe,[sv',dv'],[dv'])                                              val dv'=peelFieldSK dv
217                                                val sv'=peelFieldSK sv
218                                                val einop= S.transform(EinOp.probe,[sv',dv'],[2])
219                                          in assignEin(y, einop,xs)                                          in assignEin(y, einop,xs)
220                                          end),                                          end),
221                  (BV.op_D,               fn (y, [_, NK], xs) => scalarField(EinOp.Grad,[NK], y,xs)),                  (BV.op_D,               fn (y, [_, NK], xs) => scalarField(EinOp.Grad,[NK], y,xs)),
# Line 214  Line 232 
232                                              val d2 = [pruneDim(MV.toDim dv2)]                                              val d2 = [pruneDim(MV.toDim dv2)]
233                                            in                                            in
234                                              assignEin( y, S.transform(EinOp.outerProduct,[d1,d2],[]),xs)                                              assignEin( y, S.transform(EinOp.outerProduct,[d1,d2],[]),xs)
235                                            end)                                            end),
236                  (BV.op_inner,        fn (y, [sh1, sh2, _], xs) =>                  (BV.op_inner,        fn (y, [sh1, sh2, _], xs) =>
237                                              let                                              let
238                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                                  val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
# Line 222  Line 240 
240                                                  val alpha= List.take(dd1, length(dd1)-1)                                                  val alpha= List.take(dd1, length(dd1)-1)
241                                                  val beta=  tl(dd2)                                                  val beta=  tl(dd2)
242                                                  val i =hd(dd2)                                                  val i =hd(dd2)
243                                                  val ilist=  [alpha, beta, i]                                                  val ilist=  [alpha, beta, [i]]
244                                            in                                            in
245                                              assignEin(y, S.tranform(EinOp.innerProduct, ilist,[]),xs)                                              assignEin(y, S.transform(EinOp.innerProduct, ilist,[]),xs)
246                                          end),                                          end),
247    
248                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) =>                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) =>
# Line 236  Line 254 
254                                                  val j=tl(m)                                                  val j=tl(m)
255                                                  val alpha= List.take(dd1, length(dd1)-2)                                                  val alpha= List.take(dd1, length(dd1)-2)
256                                                  val beta=tl(tl(dd2))                                                  val beta=tl(tl(dd2))
257                                                  val ilist=[alpha, beta, i, j]                                                  val ilist=[alpha, beta, [i], j]
258                                              in                                              in
259                                                  assignEin(y, S.transform(EinOp.doubleDot, ilist,[]),xs)                                                  assignEin(y, S.transform(EinOp.doubleDot, ilist,[]),xs)
260                                              end),                                              end),
# Line 251  Line 269 
269                                            val t2 = IL.Var.new("t2", DstTy.realTy)                                            val t2 = IL.Var.new("t2", DstTy.realTy)
270                                            val t3 = IL.Var.new("t3", DstTy.realTy)                                            val t3 = IL.Var.new("t3", DstTy.realTy)
271                                            in [                                            in [
272                                              IL.ASSGN(t1, IL.OP(Op.Sub DstTy.realTy, [x, x0])),                                              IL.ASSGN(t1, IL.OP(Op.ISub, [x, x0])),
273                                              IL.ASSGN(t2, IL.OP(Op.Sub DstTy.realTy, [x1, x0])),                                              IL.ASSGN(t2, IL.OP(Op.ISub, [x1, x0])),
274                                              IL.ASSGN(t3, IL.OP(Op.Div DstTy.realTy, [t1, t2])),                                              IL.ASSGN(t3, IL.OP(Op.IDiv, [t1, t2])),
275                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))
276                                            ] end),                                            ] end),
277                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),
# Line 262  Line 280 
280                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),
281                  (BV.fn_max,             simpleOp Op.Max),                  (BV.fn_max,             simpleOp Op.Max),
282                  (BV.fn_min,             simpleOp Op.Min),                  (BV.fn_min,             simpleOp Op.Min),
283                  (BV.fn_modulate,        vectorOp Op.Mul),                  (BV.fn_modulate,         fn (y, _, xs) => assign (y, Op.IMul, xs)),
284                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (BV.fn_normalize,       vectorOp Op.Normalize),
285                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
286    
287                 (BV.fn_trace,           fn (y, [dv], xs) =>let                 (BV.fn_trace,           fn (y, [dv], xs) =>let
288                                              val d=dimVarToInt dv                                              val d=dimVarToInt dv
289                                          in                                          in
290                                              assignEin(y,S.transform(EinOp.trace, [d],[]),xs)                                              assignEin(y,S.transform(EinOp.trace, [[d]],[]),xs)
291                                          end),                                          end),
292    
293                  (BV.fn_transpose,           fn (y, [dv1, dv2], xs) =>                  (BV.fn_transpose,           fn (y, [dv1, dv2], xs) =>
# Line 289  Line 307 
307                  (BV.kn_c1tent,          kernel Kernel.tent),                  (BV.kn_c1tent,          kernel Kernel.tent),
308                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
309    
310                  (BV.identity,           fn (y, [dv], []) =>let                  (BV.identity,           fn (y, [dv], xs) =>let
311                                              val d=dimVarToInt dv                                              val d=dimVarToInt dv
312                                          in assignEin(y, S.transform(EinOp.identity,[[d],[d]],[]),xs)                                          in assignEin(y, S.transform(EinOp.identity,[[d],[d]],[]),xs)
313                                          end),                                          end),
314    
315                  (BV.zero,               fn (y, [sv], []) =>               (*   (BV.zero,               fn (y, [sv], []) =>
316                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),*)
317                 (BV.subscript,          fn (y, [tv, dv], xs) =>                 (BV.subscript,          fn (y, [tv, dv], xs) =>
318                                            assign(y,                                            assign(y,
319                                              Op.SeqSub(DstTy.SeqTy(pruneTy tv, pruneDim(MV.toDim dv))),                                              Op.SeqSub(DstTy.SeqTy(pruneTy tv, pruneDim(MV.toDim dv))),
320                                              xs)),                                              xs))
321    
322    
323                (*,
324    
325                  (BV.dynSubscript,       fn (y, [tv], args) =>                  (BV.dynSubscript,       fn (y, [tv], args) =>
326                                          assign(y, Op.SeqSub(DstTy.DynSeqTy(pruneTy tv)), args))                                          assign(y, Op.SeqSub(DstTy.DynSeqTy(pruneTy tv)), args))*)
327                  ];                  ];
328    
329            (* add C math functions *)            (* add C math functions *)

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

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