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 2380, Fri Jun 7 22:28:15 2013 UTC revision 2843, Mon Dec 8 01:27:25 2014 UTC
# Line 12  Line 12 
12     * to the instantiated meta variables mvs) to a list of SSA assignments in     * to the instantiated meta variables mvs) to a list of SSA assignments in
13     * reverse order.     * reverse order.
14     *)     *)
15      val translate : (HighIL.var * Var.var * Types.meta_var list * HighIL.var list)      val translate : (HighIL.var * Var.var * SimpleTypes.meta_arg list * HighIL.var list)
16            -> HighIL.assignment list            -> HighIL.assignment list
17    
18    end = struct    end = struct
# Line 21  Line 21 
21      structure IL = HighIL      structure IL = HighIL
22      structure DstTy = HighILTypes      structure DstTy = HighILTypes
23      structure Op = HighOps      structure Op = HighOps
24      structure Ty = Types      structure Ty = SimpleTypes
     structure TU = TypeUtil  
     structure MV = MetaVar  
25      structure VTbl = Var.Tbl      structure VTbl = Var.Tbl
     structure EinOp= Examples  
26    
27      fun pruneTy tv = (case TU.prune(MV.toType tv)      structure mk= mkOperators
            of (ty as Ty.T_Var _) => raise Fail("unresolved type " ^ TU.toString ty)  
             | ty => TranslateTy.tr ty  
           (* end case *))  
   
     fun pruneDim d = (case TU.pruneDim d  
            of (Ty.DimConst n) => n  
             | d => raise Fail("unresolved dimension " ^ TU.dimToString d)  
           (* end case *))  
28    
29      fun pruneShape sv = (case TU.pruneShape(MV.toShape sv)      fun trType (Ty.TY ty) = TranslateTy.tr ty
30             of Ty.Shape dd => DstTy.tensorTy(List.map pruneDim dd)        | trType _ = raise Fail "expected type"
31              | shp => raise Fail("unresolved shape " ^ TU.shapeToString shp)      fun dimVarToInt (Ty.DIM d) = d
32            (* end case *))        | dimVarToInt _ = raise Fail "expected dim"
   
     fun dimVarToInt dv = pruneDim(MV.toDim dv)  
33      fun dimVarToTensor dv = DstTy.tensorTy[dimVarToInt dv]      fun dimVarToTensor dv = DstTy.tensorTy[dimVarToInt dv]
34      fun dimVarToMatrix dv = let      fun dimVarToMatrix dv = let
35            val d = dimVarToInt dv            val d = dimVarToInt dv
36            in            in
37              DstTy.tensorTy[d, d]        (* square matrix type *)              DstTy.tensorTy[d, d]        (* square matrix type *)
38            end            end
39      fun shapeVarToTensor sv = pruneShape sv      fun shapeVarToTensor (Ty.SHAPE shp) = DstTy.tensorTy shp
40          | shapeVarToTensor _ = raise Fail "expected shape"
41    
42      fun assign (y, rator, xs) = [IL.ASSGN(y, IL.OP(rator, xs))]      fun assign (y, rator, xs) = [IL.ASSGN(y, IL.OP(rator, xs))]
43    
# Line 83  Line 71 
71                  end                  end
72            end            end
73    
74      fun assignEin(*hmm*)      fun assignEin (y, rator, xs) = IL.ASSGN(y, IL.EINAPP(rator, xs))
75    
76        fun  simpleEOp rator (y, _,xs) = [assignEin(y, rator, xs)]
77    
78    
79      fun ScaGenToEin  rator(y, [],xs)= assignEin (y,S.transform(rator,[]), xs) (*rator should be Ein not generic*)      fun mkNorm (shape,A) =let
80            val RTy=DstTy.TensorTy []
81            val b=IL.Var.new("dot" ,RTy)
82            val c=IL.Var.new("sqrt" ,RTy)
83            val rator=(case shape
84                of [_]=>mk.innerProduct(shape,shape)
85                | [_,_]=>mk.doubleDot(shape,shape)
86                | _ => raise Fail "unsupported norm"
87                (*end case*))
88            val dot=assignEin(b,rator, [A,A])
89            val rator= IL.OP(Op.Sqrt, [b])
90            in (c,rator,dot)
91            end
92    
93    
     fun GenToEin rator(y,[sv],xs)= assignEin(y, S.transform(rator, [len(sv), sv] ),xs)  
94    
95      fun createTenEin(operator, sv)=S.transform(operator,[len(sv), sv])  
96      fun createFldEin(operator, f)=S.transform(operator,[  ])  (* shape is an int list, DIM is in int|variable, k-level of differntiation *)
97    
98    (* build a table that maps Basis variables to their translation functions *)    (* build a table that maps Basis variables to their translation functions *)
99      val tbl : ((IL.var * Ty.meta_var list * IL.var list) -> IL.assignment list) VTbl.hash_table = let      val tbl : ((IL.var * Ty.meta_arg list * IL.var list) -> IL.assignment list) VTbl.hash_table = let
100            val tbl = VTbl.mkTable (128, Fail "Translate table")            val tbl = VTbl.mkTable (128, Fail "Translate table")
101            val insert = VTbl.insert tbl            val insert = VTbl.insert tbl
102            in            in
# Line 115  Line 117 
117                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),
118                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),
119                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),
120                    (BV.add_ii,             simpleOp Op.IAdd),
121                    (BV.add_tt,             fn (y, [shp], xs) => let
122                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
123                                            val rator =mk.addTen(dd1)
124                                            in
125                                                [assignEin(y, rator,xs)]
126                                            end),
127                    (BV.add_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
128                                                [assignEin(y, mk.addField(d, dd),xs)]),
129    
130                    (BV.add_fr,             fn (y, [_,Ty.DIM d], [f,s]) =>
131                                                [assignEin(y, mk.addTenField(d),[s,f])]),
132    
133                    (BV.add_rf,             fn (y, [_,Ty.DIM d], xs) =>
134                                                [assignEin(y, mk.addTenField(d),xs)]),
135    
136    
137                    (BV.sub_ii,             simpleOp Op.ISub),
138                    (BV.sub_tt,             fn (y, [shp], xs) => let
139                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
140                                            val rator =mk.subTen(dd1)
141                                            in
142                                                [assignEin(y, rator,xs)]
143                                            end),
144                    (BV.sub_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
145                                                  [assignEin(y, mk.subField(d, dd),xs)]),
146    
147    
148                    (BV.sub_fr,             fn (y, [_,Ty.DIM d], xs) =>
149                                                [assignEin(y, mk.subFieldTen(d),xs)]),
150    
151                    (BV.sub_rf,             fn (y, [_,Ty.DIM d], xs) =>
152                                              [assignEin(y, mk.subTenField(d),xs)]),
153    
154                    (BV.mul_ii,             simpleOp Op.IMul),
155                    (BV.mul_rr,             fn (y,_,args) => [assignEin(y, mk.prodScalar,args)]),
156                    (BV.mul_rt,             fn (y, [shp], xs) => let
157                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
158                                            val rator =mk.scaleTen(dd1)
159                                            in
160                                                [assignEin(y, rator,xs)]
161                                            end),
162                    (BV.mul_tr,             fn (y, [shp], [t, r]) => let
163                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
164                                              val rator = mk.scaleTen dd1
165                                              in
166                                                [assignEin(y, rator,[r,t])]
167                                              end),
168                    (BV.mul_rf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
169                                                [assignEin(y, mk.scaleField(d, dd),xs)]),
170                    (BV.mul_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f, s]) =>
171                                                [assignEin(y, mk.scaleField(d, dd),[s,f])]),
172                    (BV.mul_ss,             fn (y, [_,Ty.DIM d], xs) =>
173                                            [assignEin(y, mk.mulFieldss d,xs)]),
174                    (BV.mul_sf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
175                                                [assignEin(y, mk.mulFieldsf(d,dd),xs)]),
176                    (BV.mul_fs,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f,s]) =>
177                                            [assignEin(y, mk.mulFieldsf(d,dd),[s,f])]),
178    
179                    (BV.div_ii,             simpleOp Op.IDiv),
180                    (BV.div_rr,             fn (y,_,args) => [assignEin(y, mk.divScalar,args)]),
181                    (BV.div_tr,             fn (y, [shp], xs) => let
182                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
183                                            val rator =mk.divTen(dd1)
184                                            in
185                                                [assignEin(y, rator,xs)]
186                                            end),
187                    (BV.div_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
188                                                [assignEin(y, mk.divideField(d, dd),xs)]),
189                    (BV.div_ss,             fn (y, [_,Ty.DIM d], xs) =>
190                                                [assignEin(y, mk.divFieldss d,xs)]),
191    
                     (* Changed*)  
   
                 (BV.add_ii,             ScaGenToEin(EinOp.addScalars)), (* DstTy.IntTy*)  
                 (BV.add_tt,             GenToEin(EinOp.addTensors)),  
   
                     (*Ein*)  
                 (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])),  
   
                 (BV.sub_ii,             ScaGenToEin(EinOp.subScalars)), (*DstTy.IntTy*)  
                 (BV.sub_tt,             GenToEin(EinOp.subTensor)),  
                 (BV.sub_ff,             fn (y, _, [f, g])  
                                             => assignEin(y, createFldEin(EinOp.subField,f), [f, g])),  
   
                 (* 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),  
                          (* Changed*)  
                 (BV.mul_ii,             ScaGenToEin(EinOp.scalarxscalar)), (* DstTy.IntTy)),*)  
                 (BV.mul_rr,             ScaGenToEin(EinOp.scalarxscalar)), (*(DstTy.realTy))),*)  
                 (BV.mul_rt,             GenToEin(EinOp.scaleTensor)),    (*tensorOp Op.Scale),*)  
   
                 (BV.mul_tr,             fn (y, sv, [t, r])  
                                             =>assignEin(y,createEin(EinOp.scaleTensor, sv), [r,t])  
   
   
                 (BV.mul_rf,             fn (y, _, [s, f]) => assignEin(y, createFldEin(EinOp.scaleField,f), [s, f])),  
                 (BV.mul_fr,             fn (y, _, [f, s]) => assignEin(y, createFldEin(EinOp.scaleField,f), [s, f])),  
   
                          (* UnChanged*)  
   
                 (BV.div_ii,             simpleOp(Op.Div DstTy.IntTy)),  
                 (BV.div_rr,             simpleOp(Op.Div DstTy.realTy)),  
                 (BV.div_tr,             fn (y, [sv], [x, s]) => let  
                                           val one = IL.Var.new("one", DstTy.realTy)  
                                           val s' = IL.Var.new("sInv", DstTy.realTy)  
                                           in [  
                                             IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),  
                                             IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),  
                                             IL.ASSGN(y, IL.OP(Op.Scale(shapeVarToTensor sv), [s', x]))  
                                           ] end),  
                 (BV.div_fr,             fn (y, _, [f, s]) => let  
                                           val one = IL.Var.new("one", DstTy.realTy)  
                                           val s' = IL.Var.new("sInv", DstTy.realTy)  
                                           in [  
                                             IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),  
                                             IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),  
                                             IL.ASSGN(y, IL.OP(Op.ScaleField, [s', f]))  
                                           ] end),  
192                  (BV.exp_ri,             simpleOp(Op.Power)),                  (BV.exp_ri,             simpleOp(Op.Power)),
193                  (BV.exp_rr,             basisFn MathFuns.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
194                    (BV.curl2D,              simpleEOp mk.curl2d),
195                    (BV.curl3D,              simpleEOp mk.curl3d),
196                    (BV.convolve_vk,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], xs) =>
197                                               [assignEin(y, mk.conv(d, dd),xs)]),
198                    (BV.convolve_kv,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], [k, v]) =>
199                                                 [assignEin(y, mk.conv(d, dd),[v,k])]),
200                    (BV.neg_i,              simpleOp Op.INeg),
201                    (BV.neg_t,              fn (y, [shp], xs) => let
202                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
203                                            val rator =mk.negTen(dd1)
204                                            in
205                                                [assignEin(y, rator,xs)]
206                                            end),
207                    (BV.neg_f,              fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
208                                            [assignEin(y, mk.negField(d, dd),xs)]),
209                    (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
210                                                [assignEin(y, (mk.probe(dd,d)),xs)]),
211                    (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>  [assignEin(y, mk.grad([d]),xs)]),
212    
213                    (BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) =>                                    [assignEin(y, mk.dotimes(d1, dd@[d2]),xs)]),
214                    (BV.op_Ddot,         fn (y, [_, Ty.DIM d1,  Ty.SHAPE dd, Ty.DIM d2], xs) =>
215                                            [assignEin(y, mk.divergence(d1, dd),xs)] ),
216    
217    
218                    (BV.op_norm,            fn (y, [sv], [x]) => (case shapeVarToTensor sv
219                                               of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, [x])
220                                                | DstTy.TensorTy dd=> let
221                                                    val RTy=DstTy.TensorTy []
222                                                    val (_,sqrtop,dot)= mkNorm (dd,x)
223                                                    in
224                                                        [dot ,IL.ASSGN (y,sqrtop)]
225                                                    end
226    
227    
228                          (* Changed*)                                              | ty => assign(y, Op.Norm ty, [x])
                 (BV.curl2D,             fn (y, _, xs) => assignEin(y, EinOp.Curl2d, xs)),  
                 (BV.curl3D,             fn (y, _, xs) => assignEin(y, EinOp.Curl3d, xs)),  
   
   
                          (* 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])),  
   
   
                 (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),  
                 (BV.neg_t,              tensorOp Op.Neg),  
                 (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),  
                 (BV.op_probe,           fn (y, [_, dv, sv], xs) =>  
                                           assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),  
   
                          (* Changed****)  
                 (BV.op_D,               fn (y, _, xs) => assignEin(y, EinOp.Grad, xs)),  
                 (BV.op_Dotimes,         fn (y, _, xs) => assignEin(y, EinOp.Divergence, xs)),  
   
                          (* UnChanged*)  
                 (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv  
                                            of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)  
                                             | ty => assign(y, Op.Norm ty, xs)  
229                                            (* end case *))),                                            (* end case *))),
230                  (BV.op_not,             simpleOp Op.Not),                  (BV.op_not,             simpleOp Op.Not),
231                    (BV.op_cross,            simpleEOp mk.crossProduct),
232                           (* Changed*)                  (BV.op_cross2,            simpleEOp mk.crossProduct2),
233                  (BV.op_cross,           createScalarEin EinOp.crossProduct),                  (BV.op_crossField,       simpleEOp mk.crossProductField),
234                  (BV.op_outer,            assignEin (y, EinOp.outerProduct, xs)                  (BV.op_outer,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
235                                              (*  fn (y, [dv1, dv2], xs) => let                                              [assignEin(y, (mk.outerProduct(d1, d2)), xs)]),
236                                            val d1 = pruneDim(MV.toDim dv1)  (* Any Shape fields
237                                            val d2 = pruneDim(MV.toDim dv2)                   (BV.op_outerField,      fn (y, [_, Ty.DIM d1, Ty.SHAPE dd1, Ty.SHAPE dd2], xs)=>
238                                            in                                          [assignEin(y, mk.outerField(d1, dd1, dd2),   xs)]),
239                                              (DstTy.tensorTy[d1, d2]), xs)  *)
240                                            end),*)                  (BV.op_outerField,      fn (y, [_, Ty.DIM d1], xs)=>
241                                                [assignEin(y, mk.outerField(d1),   xs)]),
242    
243    
244                  (BV.op_inner,        fn (y, [sh1, sh2, _], xs) => let                  (BV.op_inner,        fn (y, [sh1, sh2, _], xs) => let
245                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
246                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                              val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
247                                            val ilist=  [(length(dd1)-1, List.take(dd1, length(dd1)-1) ) ,                                          in
248                                                      ( length(dd2)-1, tl(dd2)),                                              [assignEin(y, (mk.innerProduct(dd1,dd2)),xs)]
249                                                      ( 0, [hd(dd2)]) ]                                          end),
   
                                           in assignEin(y, S.tranform(EinOp.innerProduct, ilist),xs) end),  
   
250    
251                    (BV.op_innerField,      fn (y,  [_,Ty.SHAPE dd1,Ty.DIM d,Ty.SHAPE dd2,_], xs) =>
252                                                [assignEin(y, mk.innerProductField(dd1,d,dd2),xs)]),
253                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) => let                  (BV.op_colon,         fn (y, [sh1, sh2, _], xs) => let
254                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
255                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                              val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
256                                            val ilist=    [ (length(dd1)-2 ,  List.take(q, length(q)-2)) ,                                          in
257                                              ( length(dd2)-2 , tl(tl(dd2))),(_, List.take(dd2,2))]                                              [assignEin(y, (mk.doubleDot(dd1,dd2)),xs)]
258                                           in  assignEin(y, S.transform(EinOp.doubleDot, ilist),xs) end),                                          end),
259                    (BV.op_colonField,       fn (y, [_,Ty.SHAPE dd1,_,Ty.SHAPE dd2, _], xs) =>
260                                                [assignEin(y, (mk.doubleDotField(dd1,dd2)),xs)]),
261                              (* UnChanged*)                  (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, xs)),
                 (BV.fn_inside,          fn (y, [_, dv, _], xs) =>  
                                           assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),  
262                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
263                  (BV.clamp_vvv,          vectorOp Op.Clamp),                  (BV.clamp_vvv,          vectorOp Op.Clamp),
264                  (BV.lerp3,              tensorOp Op.Lerp),                  (BV.lerp3,              tensorOp Op.Lerp),
# Line 252  Line 267 
267                                            val t2 = IL.Var.new("t2", DstTy.realTy)                                            val t2 = IL.Var.new("t2", DstTy.realTy)
268                                            val t3 = IL.Var.new("t3", DstTy.realTy)                                            val t3 = IL.Var.new("t3", DstTy.realTy)
269                                            in [                                            in [
270                                              IL.ASSGN(t1, IL.OP(Op.Sub DstTy.realTy, [x, x0])),                                              assignEin(t1, mk.subScalar,[x,x0]),
271                                              IL.ASSGN(t2, IL.OP(Op.Sub DstTy.realTy, [x1, x0])),                                              assignEin(t2, mk.subScalar,[x1,x0]),
272                                              IL.ASSGN(t3, IL.OP(Op.Div DstTy.realTy, [t1, t2])),                                              assignEin(t3, mk.divScalar,[t1,t2]),
273                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))
274                                            ] end),                                            ] end),
275                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),
276                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
277                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),
278                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),
279    
280    
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),  
284                    (*  modulate is vector * vector pointwise multiplication *)
285                    (BV.fn_modulate,        fn (y,[Ty.DIM dd1], xs) =>
286                                    [assignEin(y, (mk.modulate dd1),xs)]),
287    (*
288    vectorOp Op.Normalize),*)
289    
290                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (BV.fn_normalize,       vectorOp Op.Normalize),
291    
292                        (* fn (y, [Ty.DIM i], [x]) =>let
293                                val (c,sqrtop,dot)= mkNorm ([i],x)
294                                val d = IL.Var.new ("int", DstTy.intTy)
295                                val e=IL.Var.new("divide" ,DstTy.TensorTy [])
296                        in     [dot ,IL.ASSGN (c,sqrtop),
297                                IL.ASSGN (d, IL.LIT(Literal.Int 1)),
298                                assignEin(e,mk.divScalar,[d,c]),
299                                assignEin(y,mk.scaleTen [i],[e,x])]
300                        end)*)
301    
302                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
303                    (BV.fn_trace,           fn (y, [Ty.DIM d], xs) =>
304                                              [assignEin(y,(mk.trace d), xs)]),
305                    (BV.fn_traceField,           fn (y, [_,Ty.DIM d,Ty.SHAPE dd], xs) =>
306                            [assignEin(y,mk.traceField(d,dd), xs)]),
307    
308                    (BV.fn_transpose,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
309                                              [assignEin(y, (mk.transpose [d1,d2]), xs)]),
310    
311                    (BV.fn_transposeField,  fn (y, [_,Ty.DIM d1, Ty.DIM d2,Ty.DIM d3], xs) =>
312                        [assignEin(y, (mk.transposeField (d1,d2,d3)), xs)]),
313    
                         (* Changed*)  
                 (BV.fn_trace,           fn (y, [dv], xs) => assignEin(y, EinOp.Trace,xs)),  
                         (*(dimVarToMatrix dv), xs)),*)  
   
                         (* UnChanged*)  
                 (BV.fn_transpose,       fn (y, [dv1, dv2], xs) =>  
                                           assign(y, Op.Transpose(dimVarToInt dv1, dimVarToInt dv2), xs)),  
314                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
315                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
316                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
# Line 282  Line 319 
319                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
320                  (BV.kn_c1tent,          kernel Kernel.tent),                  (BV.kn_c1tent,          kernel Kernel.tent),
321                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
322                    (BV.identity,           fn (y, [Ty.DIM d], xs) =>
323                          (* Changed*)                                            [assignEin(y, (mk.identity d), xs)]),
                 (BV.identity,           fn (y, [dv], []) =>(let val i=pruneDim(MV.toDim dv)  
                                            in  assignEin(y, S.transform(EinOp.identity,[(1,i),(1,i)]  ),[]) end)),  
   
                         (* UnChanged*)  
324                  (BV.zero,               fn (y, [sv], []) =>                  (BV.zero,               fn (y, [sv], []) =>
325                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),
326                  (BV.subscript,          fn (y, [tv, dv], args) =>                  (BV.subscript,          fn (y, [ty, Ty.DIM d], xs) =>
327                                            assign(y,                                            assign (y, Op.SeqSub(DstTy.SeqTy(trType ty, d)), xs))
328                                              Op.SeqSub(DstTy.SeqTy(pruneTy tv, pruneDim(MV.toDim dv))),  (*,
329                                              args))                    (BV.dynSubscript,     fn (y, [tv], args) =>
330                                              assign(y, Op.SeqSub(DstTy.DynSeqTy(pruneTy tv)), args))
331    *)
332                ];                ];
333            (* add C math functions *)            (* add C math functions *)
334              List.app (fn (n, x) => insert(x, basisFn n)) BV.mathFns;              List.app (fn (n, x) => insert(x, basisFn n)) BV.mathFns;

Legend:
Removed from v.2380  
changed lines
  Added in v.2843

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