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 2378, Thu Jun 6 21:02:40 2013 UTC revision 2379, Fri Jun 7 16:21:39 2013 UTC
# Line 87  Line 87 
87    
88      fun createScalarEin rator(y, [],xs)= assignEin (y,rator, xs)      fun createScalarEin rator(y, [],xs)= assignEin (y,rator, xs)
89    
90      fun createEin rator(y, [sv], xs)= assignEin(y, rator, xs)      fun createTenEin rator(y, [sv], xs)= assignEin(y, rator(shapeVarToTensor sv), xs)
91    
92    
93    
# Line 118  Line 118 
118                      (* Changed*)                      (* Changed*)
119    
120                  (BV.add_ii,             createScalarEin(EinOp.addScalars)), (* DstTy.IntTy*)                  (BV.add_ii,             createScalarEin(EinOp.addScalars)), (* DstTy.IntTy*)
121                  (BV.add_tt,             createEin(Ein.Op.addTensors)),                  (BV.add_tt,             createTenEin(EinOp.addTensors)),
122                    (BV.add_ff,             fn (y, _, [f, g]) => assignEin(y, EinOp.addField, [f, g])),
123                    (BV.add_fr,             fn (y, _, [f, s]) => assignEin(y, EinOp.addTenField, [f, s])),
124                    (BV.add_rf,             fn (y, _, [s, f]) => assignEin(y, EinOp.addTenField, [f, s])),
125    
                      (* UnChanged*)  
                 (BV.add_ff,             fn (y, _, [f, g]) => assign(y, Op.AddField, [f, g])),  
                 (BV.add_fr,             fn (y, _, [f, s]) => assign(y, Op.OffsetField, [f, s])),  
                 (BV.add_rf,             fn (y, _, [s, f]) => assign(y, Op.OffsetField, [f, s])),  
                       (* Changed*)  
126                  (BV.sub_ii,             createScalarEin(EinOp.subScalars)), (*DstTy.IntTy*)                  (BV.sub_ii,             createScalarEin(EinOp.subScalars)), (*DstTy.IntTy*)
127                  (BV.sub_tt,             createEin(EinOp.subTensor)),                  (BV.sub_tt,             createTenEin(EinOp.subTensor)),
128                    (BV.sub_ff,             fn (y, _, [f, g]) => assignEin(y, EinOp.subField, [f, g])),
129    
130                          (* UnChanged*)                          (* UnChanged*)
                 (BV.sub_ff,             fn (y, _, [f, g]) => assign(y, Op.SubField, [f, g])),  
131                  (BV.sub_fr,             fn (y, _, [f, s]) => let                  (BV.sub_fr,             fn (y, _, [f, s]) => let
132                                            val s' = IL.Var.copy s                                            val s' = IL.Var.copy s
133                                            in [                                            in [
# Line 146  Line 144 
144                           (* Changed*)                           (* Changed*)
145                  (BV.mul_ii,             createScalarEin(EinOp.scalarxscalar)), (* DstTy.IntTy)),*)                  (BV.mul_ii,             createScalarEin(EinOp.scalarxscalar)), (* DstTy.IntTy)),*)
146                  (BV.mul_rr,             createScalarEin(EinOp.scalarxscalar)), (*(DstTy.realTy))),*)                  (BV.mul_rr,             createScalarEin(EinOp.scalarxscalar)), (*(DstTy.realTy))),*)
147                  (BV.mul_rt,             createEin(EinOp.scaleTensor)),    (*tensorOp Op.Scale),*)                  (BV.mul_rt,             createTenEin(EinOp.scaleTensor)),    (*tensorOp Op.Scale),*)
148                  (BV.mul_tr,             fn (y, sv, [t, r]) => createEin EinOp.scaleTensor (y, sv, [r, t])),                  (BV.mul_tr,             fn (y, sv, [t, r]) => createTenEin EinOp.scaleTensor (y, sv, [r, t])),
149                    (BV.mul_rf,             fn (y, _, [s, f]) => assignEin(y, EinOp.scaleField, [s, f])),
150                    (BV.mul_fr,             fn (y, _, [f, s]) => assignEin(y, EinOp.scaleField, [s, f])),
   
151    
152                           (* UnChanged*)                           (* UnChanged*)
                 (BV.mul_rf,             fn (y, _, [s, f]) => assign(y, Op.ScaleField, [s, f])),  
                 (BV.mul_fr,             fn (y, _, [f, s]) => assign(y, Op.ScaleField, [s, f])),  
   
   
153    
154                  (BV.div_ii,             simpleOp(Op.Div DstTy.IntTy)),                  (BV.div_ii,             simpleOp(Op.Div DstTy.IntTy)),
155                  (BV.div_rr,             simpleOp(Op.Div DstTy.realTy)),                  (BV.div_rr,             simpleOp(Op.Div DstTy.realTy)),
# Line 179  Line 172 
172                  (BV.exp_ri,             simpleOp(Op.Power)),                  (BV.exp_ri,             simpleOp(Op.Power)),
173                  (BV.exp_rr,             basisFn MathFuns.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
174    
175                            (* Changed*)
176                    (BV.curl2D,             fn (y, _, xs) => assignEin(y, EinOp.Curl2d, xs)),
177                    (BV.curl3D,             fn (y, _, xs) => assignEin(y, EinOp.Curl3d, xs)),
178    
179    
180                  (BV.curl2D,             fn (y, _, xs) => assign(y, Op.CurlField 2, xs)),                           (* UnChanged*)
                 (BV.curl3D,             fn (y, _, xs) => assign(y, Op.CurlField 3, xs)),  
   
   
   
181                  (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>                  (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>
182                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), xs)),                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), xs)),
183                  (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>                  (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>
184                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), [v, k])),                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), [v, k])),
185    
186    
187                  (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),                  (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),
188                  (BV.neg_t,              tensorOp Op.Neg),                  (BV.neg_t,              tensorOp Op.Neg),
189                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),
190                  (BV.op_probe,           fn (y, [_, dv, sv], xs) =>                  (BV.op_probe,           fn (y, [_, dv, sv], xs) =>
191                                            assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),                                            assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),
192                  (BV.op_D,               fn (y, _, xs) => assign(y, Op.DiffField, xs)),  
193                  (BV.op_Dotimes,         fn (y, _, xs) => assign(y, Op.DiffField, xs)),                           (* Changed*)
194                    (BV.op_D,               fn (y, _, xs) => assignEin(y, EinOp.Grad, xs)),
195                    (BV.op_Dotimes,         fn (y, _, xs) => assignEin(y, EinOp.Divergence, xs)),
196    
197                             (* UnChanged*)
198                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv
199                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)
200                                              | ty => assign(y, Op.Norm ty, xs)                                              | ty => assign(y, Op.Norm ty, xs)
201                                            (* end case *))),                                            (* end case *))),
202                  (BV.op_not,             simpleOp Op.Not),                  (BV.op_not,             simpleOp Op.Not),
203                  (BV.op_cross,           simpleOp Op.Cross),  
204                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let                           (* Changed*)
205                    (BV.op_cross,           createScalarEin EinOp.crossProduct),
206                    (BV.op_outer,            assignEin (y, EinOp.outerProduct, xs)
207                                                (*  fn (y, [dv1, dv2], xs) => let
208                                            val d1 = pruneDim(MV.toDim dv1)                                            val d1 = pruneDim(MV.toDim dv1)
209                                            val d2 = pruneDim(MV.toDim dv2)                                            val d2 = pruneDim(MV.toDim dv2)
210                                            in                                            in
211                                              assign (y, Op.Outer(DstTy.tensorTy[d1, d2]), xs)                                              (DstTy.tensorTy[d1, d2]), xs)
212                                            end),                                            end),*)
213                  (BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let  
214    
215                    (BV.op_inner,        fn (y,_,xs)=assignEin(y,EinOp.innerProduct ,xs)),
216    
217                                        (* fn (y, [sh1, sh2, _], xs) => let
218                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
219                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2
220                                            val rator = (case (dd1, dd2)                                            val rator = (case (dd1, dd2)
# Line 227  Line 232 
232                                            in                                            in
233                                              assign (y, rator, xs)                                              assign (y, rator, xs)
234                                            end),                                            end),
235                  (BV.op_colon,           fn (y, [sh1, sh2, _], xs) => let                                          *)
236                    (BV.op_colon,           fn (y,_, xs)=>assignEin (EinOp.doubleDot, xs)),
237    
238                                            (*fn (y, [sh1, sh2, _], xs) => let
239                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1
240                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2
241                                            in                                            in
242                                              assign (y, Op.ColonMul(ty1, ty2), xs)                                              assign (y, Op.ColonMul(ty1, ty2), xs)
243                                            end),                                            end),*)
244                                (* UnChanged*)
245                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>
246                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),
247                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
# Line 257  Line 266 
266                  (BV.fn_modulate,        vectorOp Op.Mul),                  (BV.fn_modulate,        vectorOp Op.Mul),
267                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (BV.fn_normalize,       vectorOp Op.Normalize),
268                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
269                  (BV.fn_trace,           fn (y, [dv], xs) => assign(y, Op.Trace(dimVarToMatrix dv), xs)),  
270                            (* Changed*)
271                    (BV.fn_trace,           fn (y, [dv], xs) => assignEin(y, EinOp.Trace,xs)),
272                            (*(dimVarToMatrix dv), xs)),*)
273    
274                            (* UnChanged*)
275                  (BV.fn_transpose,       fn (y, [dv1, dv2], xs) =>                  (BV.fn_transpose,       fn (y, [dv1, dv2], xs) =>
276                                            assign(y, Op.Transpose(dimVarToInt dv1, dimVarToInt dv2), xs)),                                            assign(y, Op.Transpose(dimVarToInt dv1, dimVarToInt dv2), xs)),
277                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
# Line 268  Line 282 
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)), [])),                          (* Changed*)
287                    (BV.identity,           fn (y, [dv], []) =>assignEin(y, EinOp.identity,[])),
288                                          (*  assign(y, Op.Identity(pruneDim(MV.toDim dv)), [])),*)
289                            (* UnChanged*)
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) =>

Legend:
Removed from v.2378  
changed lines
  Added in v.2379

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