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 2608, Fri May 2 18:04:54 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
26    
27      fun pruneTy ty = (case TU.prune ty      structure mk= mkOperators
            of (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"
33        fun dimVarToTensor dv = DstTy.tensorTy[dimVarToInt dv]
     fun dimVarToTensor dv = DstTy.tensorTy[pruneDim(MV.toDim dv)]  
34      fun dimVarToMatrix dv = let      fun dimVarToMatrix dv = let
35            val d = pruneDim(MV.toDim 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 81  Line 71 
71                  end                  end
72            end            end
73    
74        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    
80    
81    
82    (* shape is an int list, DIM is in int|variable, k-level of differntiation *)
83    
84    (* build a table that maps Basis variables to their translation functions *)    (* build a table that maps Basis variables to their translation functions *)
85      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
86            val tbl = VTbl.mkTable (128, Fail "Translate table")            val tbl = VTbl.mkTable (128, Fail "Translate table")
87              val insert = VTbl.insert tbl
88            in            in
89              List.app (VTbl.insert tbl) [              List.app insert [
90                  (BV.lt_ii,              simpleOp(Op.LT DstTy.IntTy)),                  (BV.lt_ii,              simpleOp(Op.LT DstTy.IntTy)),
91                  (BV.lt_rr,              simpleOp(Op.LT DstTy.realTy)),                  (BV.lt_rr,              simpleOp(Op.LT DstTy.realTy)),
92                  (BV.lte_ii,             simpleOp(Op.LTE DstTy.IntTy)),                  (BV.lte_ii,             simpleOp(Op.LTE DstTy.IntTy)),
# Line 102  Line 103 
103                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),
104                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),
105                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),
106                  (BV.add_ii,             simpleOp(Op.Add DstTy.IntTy)),                  (BV.add_ii,             simpleOp Op.IAdd),
107                  (BV.add_tt,             tensorOp Op.Add),                  (BV.add_tt,             fn (y, [shp], xs) => let
108                  (BV.add_ff,             fn (y, _, [f, g]) => assign(y, Op.AddField, [f, g])),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
109                  (BV.sub_ii,             simpleOp(Op.Sub DstTy.IntTy)),                                          val rator =mk.addTen(dd1)
110                  (BV.sub_tt,             tensorOp Op.Sub),                                          in
111                  (BV.sub_ff,             fn (y, _, [f, g]) => assign(y, Op.SubField, [f, g])),                                              [assignEin(y, rator,xs)]
112                  (BV.mul_ii,             simpleOp(Op.Mul DstTy.IntTy)),                                          end),
113                  (BV.mul_rr,             simpleOp(Op.Mul(DstTy.realTy))),                  (BV.add_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
114                  (BV.mul_rt,             tensorOp Op.Scale),                                              [assignEin(y, mk.addField(d, dd),xs)]),
115                  (BV.mul_tr,             fn (y, sv, [t, r]) => tensorOp Op.Scale (y, sv, [r, t])),  
116                  (BV.mul_rf,             fn (y, _, [s, f]) => assign(y, Op.ScaleField, [s, f])),                  (BV.add_fr,             fn (y, [_,Ty.DIM d], [f,s]) =>
117                  (BV.mul_fr,             fn (y, _, [f, s]) => assign(y, Op.ScaleField, [s, f])),                                              [assignEin(y, mk.addTenField(d),[s,f])]),
118                  (BV.div_ii,             simpleOp(Op.Div DstTy.IntTy)),  
119                  (BV.div_rr,             simpleOp(Op.Div DstTy.realTy)),                  (BV.add_rf,             fn (y, [_,Ty.DIM d], xs) =>
120                  (BV.div_tr,             fn (y, [sv], [x, s]) => let                                              [assignEin(y, mk.addTenField(d),xs)]),
121                                            val one = IL.Var.new("one", DstTy.realTy)  
122                                            val s' = IL.Var.new("sInv", DstTy.realTy)  
123                                            in [                  (BV.sub_ii,             simpleOp Op.ISub),
124                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),                  (BV.sub_tt,             fn (y, [shp], xs) => let
125                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
126                                              IL.ASSGN(y, IL.OP(Op.Scale(shapeVarToTensor sv), [s', x]))                                          val rator =mk.subTen(dd1)
127                                            ] end),                                          in
128                  (BV.div_fr,             fn (y, _, [f, s]) => let                                              [assignEin(y, rator,xs)]
129                                            val one = IL.Var.new("one", DstTy.realTy)                                          end),
130                                            val s' = IL.Var.new("sInv", DstTy.realTy)                  (BV.sub_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
131                                            in [                                                [assignEin(y, mk.subField(d, dd),xs)]),
132                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),  
133                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),  
134                                              IL.ASSGN(y, IL.OP(Op.ScaleField, [s', f]))                  (BV.sub_fr,             fn (y, [_,Ty.DIM d], xs) =>
135                                            ] end),                                              [assignEin(y, mk.subFieldTen(d),xs)]),
136    
137                    (BV.sub_rf,             fn (y, [_,Ty.DIM d], xs) =>
138                                              [assignEin(y, mk.subTenField(d),xs)]),
139    
140                    (BV.mul_ii,             simpleOp Op.IMul),
141                    (BV.mul_rr,             fn (y,_,args) => [assignEin(y, mk.prodScalar,args)]),
142                    (BV.mul_rt,             fn (y, [shp], xs) => let
143                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
144                                            val rator =mk.scaleTen(dd1)
145                                            in
146                                                [assignEin(y, rator,xs)]
147                                            end),
148                    (BV.mul_tr,             fn (y, [shp], [t, r]) => let
149                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
150                                              val rator = mk.scaleTen dd1
151                                              in
152                                                [assignEin(y, rator,[r,t])]
153                                              end),
154                    (BV.mul_rf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
155                                                [assignEin(y, mk.scaleField(d, dd),xs)]),
156                    (BV.mul_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f, s]) =>
157                                                [assignEin(y, mk.scaleField(d, dd),[s,f])]),
158    (*MARK-mul_ff*)
159                    (BV.mul_ss,             fn (y, [_,Ty.DIM d], xs) =>
160                                            [assignEin(y, mk.mulFieldss d,xs)]),
161                    (BV.mul_sf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
162                                                [assignEin(y, mk.mulFieldsf(d,dd),xs)]),
163                    (BV.mul_fs,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f,s]) =>
164                                            [assignEin(y, mk.mulFieldsf(d,dd),[s,f])]),
165    
166                    (BV.div_ii,             simpleOp Op.IDiv),
167                    (BV.div_rr,             fn (y,_,args) => [assignEin(y, mk.divScalar,args)]),
168                    (BV.div_tr,             fn (y, [shp], xs) => let
169                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
170                                            val rator =mk.divTen(dd1)
171                                            in
172                                                [assignEin(y, rator,xs)]
173                                            end),
174                    (BV.div_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
175                                                [assignEin(y, mk.divideField(d, dd),xs)]),
176                    (BV.div_ss,             fn (y, [_,Ty.DIM d], xs) =>
177                                                [assignEin(y, mk.divFieldss d,xs)]),
178    
179                  (BV.exp_ri,             simpleOp(Op.Power)),                  (BV.exp_ri,             simpleOp(Op.Power)),
180                  (BV.exp_rr,             basisFn ILBasis.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
181                  (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>                  (BV.curl2D,              simpleEOp mk.curl2d),
182                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), xs)),                  (BV.curl3D,              simpleEOp mk.curl3d),
183                  (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>                  (BV.convolve_vk,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], xs) =>
184                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), [v, k])),                                             [assignEin(y, mk.conv(d, dd),xs)]),
185                  (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),                  (BV.convolve_kv,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], [k, v]) =>
186                  (BV.neg_t,              tensorOp Op.Neg),                                               [assignEin(y, mk.conv(d, dd),[v,k])]),
187                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),                  (BV.neg_i,              simpleOp Op.INeg),
188                  (BV.op_at,              fn (y, [_, dv, sv], xs) =>                  (BV.neg_t,              fn (y, [shp], xs) => let
189                                            assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
190                  (BV.op_D,               fn (y, _, xs) => assign(y, Op.DiffField, xs)),                                          val rator =mk.negTen(dd1)
191                  (BV.op_Dotimes,         fn (y, _, xs) => assign(y, Op.DiffField, xs)),                                          in
192                                                [assignEin(y, rator,xs)]
193                                            end),
194                    (BV.neg_f,              fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
195                                            [assignEin(y, mk.negField(d, dd),xs)]),
196                    (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
197                                                [assignEin(y, (mk.probe(dd,d)),xs)]),
198                    (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>  [assignEin(y, mk.grad([d]),xs)]),
199    
200                    (BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) => let
201                                        val x= print (String.concat[" d1:",Int.toString(d1)," d2:",Int.toString(d2),
202                                            " shape:",Int.toString(length(dd)), "\n"])
203                                            val g=print "*******\n"
204                                            val gg2=print(Int.toString(length(xs)))
205                            in
206                                        [assignEin(y, mk.dotimes(d1, dd@[d2]),xs)] end ),
207                    (BV.op_Ddot,         fn (y, [_, Ty.DIM d1,  Ty.SHAPE dd, Ty.DIM d2], xs) =>
208                                            [assignEin(y, mk.divergence(d1, dd),xs)] ),
209    
210    
211                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv
212                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)
213                                              | ty => assign(y, Op.Norm ty, xs)                                              | ty => assign(y, Op.Norm ty, xs)
214                                            (* end case *))),                                            (* end case *))),
215                  (BV.op_not,             simpleOp Op.Not),                  (BV.op_not,             simpleOp Op.Not),
216                  (BV.fn_atan2,           basisFn ILBasis.atan2),                  (BV.op_cross,            simpleEOp mk.crossProduct),
217                  (BV.fn_cos,             basisFn ILBasis.cos),                  (BV.op_crossField,       simpleEOp mk.crossProductField),
218                  (BV.op_cross,           simpleOp Op.Cross),                  (BV.op_outer,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
219                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let                                              [assignEin(y, (mk.outerProduct(d1, d2)), xs)]),
220                                            val d1 = pruneDim(MV.toDim dv1)  (* Any Shape fields
221                                            val d2 = pruneDim(MV.toDim dv2)                   (BV.op_outerField,      fn (y, [_, Ty.DIM d1, Ty.SHAPE dd1, Ty.SHAPE dd2], xs)=>
222                                            [assignEin(y, mk.outerField(d1, dd1, dd2),   xs)]),
223    *)
224                    (BV.op_outerField,      fn (y, [_, Ty.DIM d1], xs)=>
225                                                [assignEin(y, mk.outerField(d1),   xs)]),
226    
227    
228                    (BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let
229                                                val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
230                                                val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
231                                            in                                            in
232                                              assign (y, Op.Outer(DstTy.tensorTy[d1, d2]), xs)                                              [assignEin(y, (mk.innerProduct(dd1,dd2)),xs)]
233                                            end),                                            end),
234                  (BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let  
235                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                  (BV.op_innerField,           fn (y,  [_,Ty.SHAPE dd1,Ty.DIM d,Ty.SHAPE dd2,_], xs) =>
236                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                                      let
237                                            val rator = (case (dd1, dd2)                                                      val  _=print(String.concat["Translate Inner product Field. "])
                                                  of ([d], [d']) => Op.Dot ty1  
                                                   | ([d1], [d1', d2]) => Op.MulVecMat ty2  
                                                   | ([d1, d2], [d2']) => Op.MulMatVec ty1  
                                                   | ([d1, d2], [d2', d3]) => Op.MulMatMat(ty1, ty2)  
                                                   | _ => raise Fail "unsupported inner-product type"  
                                                 (* end case *))  
238                                            in                                            in
239                                              assign (y, rator, xs)                                                  [assignEin(y, mk.innerProductField(dd1,d,dd2),xs)] end ),
240    
241                    (BV.op_colon,           fn (y, [sh1, sh2, _], xs) => let
242                                                val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
243                                                val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
244                                            in
245                                                [assignEin(y, (mk.doubleDot(dd1,dd2)),xs)]
246                                            end),                                            end),
247                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>                  (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, xs)),
                                           assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),  
248                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
249                  (BV.clamp_vvv,          vectorOp Op.Clamp),                  (BV.clamp_vvv,          vectorOp Op.Clamp),
250                  (BV.lerp3,              tensorOp Op.Lerp),                  (BV.lerp3,              tensorOp Op.Lerp),
# Line 182  Line 253 
253                                            val t2 = IL.Var.new("t2", DstTy.realTy)                                            val t2 = IL.Var.new("t2", DstTy.realTy)
254                                            val t3 = IL.Var.new("t3", DstTy.realTy)                                            val t3 = IL.Var.new("t3", DstTy.realTy)
255                                            in [                                            in [
256                                              IL.ASSGN(t1, IL.OP(Op.Sub DstTy.realTy, [x, x0])),                                              assignEin(t1, mk.subScalar,[x,x0]),
257                                              IL.ASSGN(t2, IL.OP(Op.Sub DstTy.realTy, [x1, x0])),                                              assignEin(t2, mk.subScalar,[x1,x0]),
258                                              IL.ASSGN(t3, IL.OP(Op.Div DstTy.realTy, [t1, t2])),                                              assignEin(t3, mk.divScalar,[t1,t2]),
259                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))
260                                            ] end),                                            ] end),
261                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),
262                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
263                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),
264                  (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),  
265                  (BV.fn_max,             simpleOp Op.Max),                  (BV.fn_max,             simpleOp Op.Max),
266                  (BV.fn_min,             simpleOp Op.Min),                  (BV.fn_min,             simpleOp Op.Min),
267                  (BV.fn_modulate,        vectorOp Op.Mul),  
268                    (*  modulate is vector * vector pointwise multiplication *)
269                    (BV.fn_modulate,        fn (y,[Ty.DIM dd1], xs) =>
270                                    [assignEin(y, (mk.modulate dd1),xs)]),
271                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (BV.fn_normalize,       vectorOp Op.Normalize),
272                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
273                  (BV.fn_sin,             basisFn ILBasis.sin),                  (BV.fn_trace,           fn (y, [Ty.DIM d], xs) =>
274                  (BV.fn_sqrt,            basisFn ILBasis.sqrt),                                            [assignEin(y,(mk.trace d), xs)]),
275                  (BV.fn_tan,             basisFn ILBasis.tan),                  (BV.fn_traceField,           fn (y, [_,Ty.DIM d,Ty.SHAPE dd], xs) =>
276                  (BV.fn_trace,           fn (y, [dv], xs) => assign(y, Op.Trace(dimVarToMatrix dv), xs)),                          [assignEin(y,mk.traceField(d,dd), xs)]),
277    
278                    (BV.fn_transpose,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
279                                              [assignEin(y, (mk.transpose [d1,d2]), xs)]),
280    
281                    (BV.fn_transposeField,  fn (y, [_,Ty.DIM d1, Ty.DIM d2,Ty.DIM d3], xs) =>
282                        [assignEin(y, (mk.transposeField (d1,d2,d3)), xs)]),
283    
284                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
285                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
286                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
287                  (BV.kn_c2ctmr,          kernel Kernel.ctmr),                  (BV.kn_c2ctmr,          kernel Kernel.ctmr),
288                    (BV.kn_c4hexic,         kernel Kernel.c4hexic),
289                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
290                  (BV.kn_c1tent,          kernel Kernel.tent),                  (BV.kn_c1tent,          kernel Kernel.tent),
291                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
292                  (BV.identity,           fn (y, [dv], []) =>                  (BV.identity,           fn (y, [Ty.DIM d], xs) =>
293                                            assign(y, Op.Identity(pruneDim(MV.toDim dv)), [])),                                            [assignEin(y, (mk.identity d), xs)]),
294                  (BV.zero,               fn (y, [sv], []) =>               (*   (BV.zero,               fn (y, [sv], []) =>
295                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),*)
296                  (BV.subscript,          fn (y, [tv, dv], args) =>                  (BV.subscript,          fn (y, [ty, Ty.DIM d], xs) =>
297                                            assign(y,                                            assign (y, Op.SeqSub(DstTy.SeqTy(trType ty, d)), xs))
298                                              Op.SeqSub(DstTy.SeqTy(pruneTy(MV.toType tv), pruneDim(MV.toDim dv))),  (*,
299                                              args))                    (BV.dynSubscript,     fn (y, [tv], args) =>
300                                              assign(y, Op.SeqSub(DstTy.DynSeqTy(pruneTy tv)), args))
301    *)
302                ];                ];
303              (* add C math functions *)
304                List.app (fn (n, x) => insert(x, basisFn n)) BV.mathFns;
305              tbl              tbl
306            end            end
307    

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

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