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 2668, Thu Jun 12 03:29:04 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 *))  
   
     fun pruneShape sv = (case TU.pruneShape(MV.toShape sv)  
            of Ty.Shape dd => DstTy.tensorTy(List.map pruneDim dd)  
             | shp => raise Fail("unresolved shape " ^ TU.shapeToString shp)  
           (* end case *))  
28    
29      fun dimVarToTensor dv = DstTy.tensorTy[pruneDim(MV.toDim dv)]      fun trType (Ty.TY ty) = TranslateTy.tr ty
30          | trType _ = raise Fail "expected type"
31        fun dimVarToInt (Ty.DIM d) = d
32          | dimVarToInt _ = raise Fail "expected dim"
33        fun dimVarToTensor dv = DstTy.tensorTy[dimVarToInt 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        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    
94    
95    
96    (* 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
102            in            in
103              List.app (VTbl.insert tbl) [              List.app insert [
104                  (BV.lt_ii,              simpleOp(Op.LT DstTy.IntTy)),                  (BV.lt_ii,              simpleOp(Op.LT DstTy.IntTy)),
105                  (BV.lt_rr,              simpleOp(Op.LT DstTy.realTy)),                  (BV.lt_rr,              simpleOp(Op.LT DstTy.realTy)),
106                  (BV.lte_ii,             simpleOp(Op.LTE DstTy.IntTy)),                  (BV.lte_ii,             simpleOp(Op.LTE DstTy.IntTy)),
# Line 102  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.Add DstTy.IntTy)),                  (BV.add_ii,             simpleOp Op.IAdd),
121                  (BV.add_tt,             tensorOp Op.Add),                  (BV.add_tt,             fn (y, [shp], xs) => let
122                  (BV.add_ff,             fn (y, _, [f, g]) => assign(y, Op.AddField, [f, g])),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
123                  (BV.sub_ii,             simpleOp(Op.Sub DstTy.IntTy)),                                          val rator =mk.addTen(dd1)
124                  (BV.sub_tt,             tensorOp Op.Sub),                                          in
125                  (BV.sub_ff,             fn (y, _, [f, g]) => assign(y, Op.SubField, [f, g])),                                              [assignEin(y, rator,xs)]
126                  (BV.mul_ii,             simpleOp(Op.Mul DstTy.IntTy)),                                          end),
127                  (BV.mul_rr,             simpleOp(Op.Mul(DstTy.realTy))),                  (BV.add_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
128                  (BV.mul_rt,             tensorOp Op.Scale),                                              [assignEin(y, mk.addField(d, dd),xs)]),
129                  (BV.mul_tr,             fn (y, sv, [t, r]) => tensorOp Op.Scale (y, sv, [r, t])),  
130                  (BV.mul_rf,             fn (y, _, [s, f]) => assign(y, Op.ScaleField, [s, f])),                  (BV.add_fr,             fn (y, [_,Ty.DIM d], [f,s]) =>
131                  (BV.mul_fr,             fn (y, _, [f, s]) => assign(y, Op.ScaleField, [s, f])),                                              [assignEin(y, mk.addTenField(d),[s,f])]),
132                  (BV.div_ii,             simpleOp(Op.Div DstTy.IntTy)),  
133                  (BV.div_rr,             simpleOp(Op.Div DstTy.realTy)),                  (BV.add_rf,             fn (y, [_,Ty.DIM d], xs) =>
134                  (BV.div_tr,             fn (y, [sv], [x, s]) => let                                              [assignEin(y, mk.addTenField(d),xs)]),
135                                            val one = IL.Var.new("one", DstTy.realTy)  
136                                            val s' = IL.Var.new("sInv", DstTy.realTy)  
137                                            in [                  (BV.sub_ii,             simpleOp Op.ISub),
138                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),                  (BV.sub_tt,             fn (y, [shp], xs) => let
139                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
140                                              IL.ASSGN(y, IL.OP(Op.Scale(shapeVarToTensor sv), [s', x]))                                          val rator =mk.subTen(dd1)
141                                            ] end),                                          in
142                  (BV.div_fr,             fn (y, _, [f, s]) => let                                              [assignEin(y, rator,xs)]
143                                            val one = IL.Var.new("one", DstTy.realTy)                                          end),
144                                            val s' = IL.Var.new("sInv", DstTy.realTy)                  (BV.sub_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
145                                            in [                                                [assignEin(y, mk.subField(d, dd),xs)]),
146                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),  
147                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),  
148                                              IL.ASSGN(y, IL.OP(Op.ScaleField, [s', f]))                  (BV.sub_fr,             fn (y, [_,Ty.DIM d], xs) =>
149                                            ] end),                                              [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    (*MARK-mul_ff*)
173                    (BV.mul_ss,             fn (y, [_,Ty.DIM d], xs) =>
174                                            [assignEin(y, mk.mulFieldss d,xs)]),
175                    (BV.mul_sf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
176                                                [assignEin(y, mk.mulFieldsf(d,dd),xs)]),
177                    (BV.mul_fs,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f,s]) =>
178                                            [assignEin(y, mk.mulFieldsf(d,dd),[s,f])]),
179    
180                    (BV.div_ii,             simpleOp Op.IDiv),
181                    (BV.div_rr,             fn (y,_,args) => [assignEin(y, mk.divScalar,args)]),
182                    (BV.div_tr,             fn (y, [shp], xs) => let
183                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
184                                            val rator =mk.divTen(dd1)
185                                            in
186                                                [assignEin(y, rator,xs)]
187                                            end),
188                    (BV.div_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
189                                                [assignEin(y, mk.divideField(d, dd),xs)]),
190                    (BV.div_ss,             fn (y, [_,Ty.DIM d], xs) =>
191                                                [assignEin(y, mk.divFieldss d,xs)]),
192    
193                  (BV.exp_ri,             simpleOp(Op.Power)),                  (BV.exp_ri,             simpleOp(Op.Power)),
194                  (BV.exp_rr,             basisFn ILBasis.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
195                  (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>                  (BV.curl2D,              simpleEOp mk.curl2d),
196                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), xs)),                  (BV.curl3D,              simpleEOp mk.curl3d),
197                  (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>                  (BV.convolve_vk,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], xs) =>
198                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), [v, k])),                                             [assignEin(y, mk.conv(d, dd),xs)]),
199                  (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),                  (BV.convolve_kv,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], [k, v]) =>
200                  (BV.neg_t,              tensorOp Op.Neg),                                               [assignEin(y, mk.conv(d, dd),[v,k])]),
201                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),                  (BV.neg_i,              simpleOp Op.INeg),
202                  (BV.op_at,              fn (y, [_, dv, sv], xs) =>                  (BV.neg_t,              fn (y, [shp], xs) => let
203                                            assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
204                  (BV.op_D,               fn (y, _, xs) => assign(y, Op.DiffField, xs)),                                          val rator =mk.negTen(dd1)
205                  (BV.op_Dotimes,         fn (y, _, xs) => assign(y, Op.DiffField, xs)),                                          in
206                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                                              [assignEin(y, rator,xs)]
207                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                          end),
208                                              | ty => assign(y, Op.Norm ty, xs)                  (BV.neg_f,              fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
209                                            [assignEin(y, mk.negField(d, dd),xs)]),
210                    (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
211                                                [assignEin(y, (mk.probe(dd,d)),xs)]),
212                    (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>  [assignEin(y, mk.grad([d]),xs)]),
213    
214                    (BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) => let
215                                        val x= print (String.concat[" d1:",Int.toString(d1)," d2:",Int.toString(d2),
216                                            " shape:",Int.toString(length(dd)), "\n"])
217                                            val g=print "*******\n"
218                                            val gg2=print(Int.toString(length(xs)))
219                            in
220                                        [assignEin(y, mk.dotimes(d1, dd@[d2]),xs)] end ),
221                    (BV.op_Ddot,         fn (y, [_, Ty.DIM d1,  Ty.SHAPE dd, Ty.DIM d2], xs) =>
222                                            [assignEin(y, mk.divergence(d1, dd),xs)] ),
223    
224    
225                    (BV.op_norm,            fn (y, [sv], [x]) => (case shapeVarToTensor sv
226                                               of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, [x])
227                                                | DstTy.TensorTy dd=> let
228                                                    val RTy=DstTy.TensorTy []
229                                                    val (_,sqrtop,dot)= mkNorm (dd,x)
230                                                    in
231                                                        [dot ,IL.ASSGN (y,sqrtop)]
232                                                    end
233    
234    
235                                                | ty => assign(y, Op.Norm ty, [x])
236                                            (* end case *))),                                            (* end case *))),
237                  (BV.op_not,             simpleOp Op.Not),                  (BV.op_not,             simpleOp Op.Not),
238                  (BV.fn_atan2,           basisFn ILBasis.atan2),                  (BV.op_cross,            simpleEOp mk.crossProduct),
239                  (BV.fn_cos,             basisFn ILBasis.cos),                  (BV.op_crossField,       simpleEOp mk.crossProductField),
240                  (BV.op_cross,           simpleOp Op.Cross),                  (BV.op_outer,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
241                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let                                              [assignEin(y, (mk.outerProduct(d1, d2)), xs)]),
242                                            val d1 = pruneDim(MV.toDim dv1)  (* Any Shape fields
243                                            val d2 = pruneDim(MV.toDim dv2)                   (BV.op_outerField,      fn (y, [_, Ty.DIM d1, Ty.SHAPE dd1, Ty.SHAPE dd2], xs)=>
244                                            [assignEin(y, mk.outerField(d1, dd1, dd2),   xs)]),
245    *)
246                    (BV.op_outerField,      fn (y, [_, Ty.DIM d1], xs)=>
247                                                [assignEin(y, mk.outerField(d1),   xs)]),
248    
249    
250                    (BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let
251                                                val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
252                                                val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
253                                            in                                            in
254                                              assign (y, Op.Outer(DstTy.tensorTy[d1, d2]), xs)                                              [assignEin(y, (mk.innerProduct(dd1,dd2)),xs)]
255                                            end),                                            end),
256                  (BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let  
257                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                  (BV.op_innerField,      fn (y,  [_,Ty.SHAPE dd1,Ty.DIM d,Ty.SHAPE dd2,_], xs) =>
258                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                              [assignEin(y, mk.innerProductField(dd1,d,dd2),xs)]),
259                                            val rator = (case (dd1, dd2)                  (BV.op_colon,           fn (y, [sh1, sh2, _], xs) => let
260                                                   of ([d], [d']) => Op.Dot ty1                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
261                                                    | ([d1], [d1', d2]) => Op.MulVecMat ty2                                              val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
                                                   | ([d1, d2], [d2']) => Op.MulMatVec ty1  
                                                   | ([d1, d2], [d2', d3]) => Op.MulMatMat(ty1, ty2)  
                                                   | _ => raise Fail "unsupported inner-product type"  
                                                 (* end case *))  
262                                            in                                            in
263                                              assign (y, rator, xs)                                              [assignEin(y, (mk.doubleDot(dd1,dd2)),xs)]
264                                            end),                                            end),
265                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>                  (BV.op_colonField,       fn (y, [_,Ty.SHAPE dd1,_,Ty.SHAPE dd2, _], xs) =>
266                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),                                              [assignEin(y, (mk.doubleDotField(dd1,dd2)),xs)]),
267                    (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, xs)),
268                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
269                  (BV.clamp_vvv,          vectorOp Op.Clamp),                  (BV.clamp_vvv,          vectorOp Op.Clamp),
270                  (BV.lerp3,              tensorOp Op.Lerp),                  (BV.lerp3,              tensorOp Op.Lerp),
# Line 182  Line 273 
273                                            val t2 = IL.Var.new("t2", DstTy.realTy)                                            val t2 = IL.Var.new("t2", DstTy.realTy)
274                                            val t3 = IL.Var.new("t3", DstTy.realTy)                                            val t3 = IL.Var.new("t3", DstTy.realTy)
275                                            in [                                            in [
276                                              IL.ASSGN(t1, IL.OP(Op.Sub DstTy.realTy, [x, x0])),                                              assignEin(t1, mk.subScalar,[x,x0]),
277                                              IL.ASSGN(t2, IL.OP(Op.Sub DstTy.realTy, [x1, x0])),                                              assignEin(t2, mk.subScalar,[x1,x0]),
278                                              IL.ASSGN(t3, IL.OP(Op.Div DstTy.realTy, [t1, t2])),                                              assignEin(t3, mk.divScalar,[t1,t2]),
279                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))
280                                            ] end),                                            ] end),
281                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),
282                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
283                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),
284                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),
285                  (BV.fn_fmod,            basisFn ILBasis.fmod),  
286                  (BV.fn_log10,           basisFn ILBasis.log10),  
                 (BV.fn_ln,              basisFn ILBasis.ln),  
287                  (BV.fn_max,             simpleOp Op.Max),                  (BV.fn_max,             simpleOp Op.Max),
288                  (BV.fn_min,             simpleOp Op.Min),                  (BV.fn_min,             simpleOp Op.Min),
289                  (BV.fn_modulate,        vectorOp Op.Mul),  
290                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (*  modulate is vector * vector pointwise multiplication *)
291                    (BV.fn_modulate,        fn (y,[Ty.DIM dd1], xs) =>
292                                    [assignEin(y, (mk.modulate dd1),xs)]),
293    (*
294    vectorOp Op.Normalize),*)
295                    (*only supports vectors *)
296                    (BV.fn_normalize, fn (y, [Ty.DIM i], [x]) =>let
297                                val (c,sqrtop,dot)= mkNorm ([i],x)
298                                val d = IL.Var.new ("int", DstTy.intTy)
299                                val e=IL.Var.new("divide" ,DstTy.TensorTy [])
300                        in     [dot ,IL.ASSGN (c,sqrtop),
301                                IL.ASSGN (d, IL.LIT(Literal.Int 1)),
302                                assignEin(e,mk.divScalar,[d,c]),
303                                assignEin(y,mk.scaleTen [i],[e,x])]
304                        end),
305    
306                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
307                  (BV.fn_sin,             basisFn ILBasis.sin),                  (BV.fn_trace,           fn (y, [Ty.DIM d], xs) =>
308                  (BV.fn_sqrt,            basisFn ILBasis.sqrt),                                            [assignEin(y,(mk.trace d), xs)]),
309                  (BV.fn_tan,             basisFn ILBasis.tan),                  (BV.fn_traceField,           fn (y, [_,Ty.DIM d,Ty.SHAPE dd], xs) =>
310                  (BV.fn_trace,           fn (y, [dv], xs) => assign(y, Op.Trace(dimVarToMatrix dv), xs)),                          [assignEin(y,mk.traceField(d,dd), xs)]),
311    
312                    (BV.fn_transpose,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
313                                              [assignEin(y, (mk.transpose [d1,d2]), xs)]),
314    
315                    (BV.fn_transposeField,  fn (y, [_,Ty.DIM d1, Ty.DIM d2,Ty.DIM d3], xs) =>
316                        [assignEin(y, (mk.transposeField (d1,d2,d3)), xs)]),
317    
318                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
319                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
320                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
321                  (BV.kn_c2ctmr,          kernel Kernel.ctmr),                  (BV.kn_c2ctmr,          kernel Kernel.ctmr),
322                    (BV.kn_c4hexic,         kernel Kernel.c4hexic),
323                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
324                  (BV.kn_c1tent,          kernel Kernel.tent),                  (BV.kn_c1tent,          kernel Kernel.tent),
325                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
326                  (BV.identity,           fn (y, [dv], []) =>                  (BV.identity,           fn (y, [Ty.DIM d], xs) =>
327                                            assign(y, Op.Identity(pruneDim(MV.toDim dv)), [])),                                            [assignEin(y, (mk.identity d), xs)]),
328                  (BV.zero,               fn (y, [sv], []) =>                  (BV.zero,               fn (y, [sv], []) =>
329                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),
330                  (BV.subscript,          fn (y, [tv, dv], args) =>                  (BV.subscript,          fn (y, [ty, Ty.DIM d], xs) =>
331                                            assign(y,                                            assign (y, Op.SeqSub(DstTy.SeqTy(trType ty, d)), xs))
332                                              Op.SeqSub(DstTy.SeqTy(pruneTy(MV.toType tv), pruneDim(MV.toDim dv))),  (*,
333                                              args))                    (BV.dynSubscript,     fn (y, [tv], args) =>
334                                              assign(y, Op.SeqSub(DstTy.DynSeqTy(pruneTy tv)), args))
335    *)
336                ];                ];
337              (* add C math functions *)
338                List.app (fn (n, x) => insert(x, basisFn n)) BV.mathFns;
339              tbl              tbl
340            end            end
341    

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

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