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 1923, Sat Jun 23 12:02:18 2012 UTC branches/charisee/src/compiler/translate/translate-basis.sml revision 2955, Wed Mar 4 23:06:28 2015 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        structure mk= mkOperators
27    
28      fun pruneTy ty = (case TU.prune ty      fun trType (Ty.TY ty) = TranslateTy.tr ty
29             of (Ty.T_Var _) => raise Fail("unresolved type " ^ TU.toString ty)        | trType _ = raise Fail "expected type"
30              | ty => TranslateTy.tr ty      fun dimVarToInt (Ty.DIM d) = d
31            (* end case *))        | dimVarToInt _ = raise Fail "expected dim"
32        fun dimVarToTensor dv = DstTy.tensorTy[dimVarToInt dv]
     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 *))  
   
     fun dimVarToTensor dv = DstTy.tensorTy[pruneDim(MV.toDim dv)]  
33      fun dimVarToMatrix dv = let      fun dimVarToMatrix dv = let
34            val d = pruneDim(MV.toDim dv)            val d = dimVarToInt dv
35            in            in
36              DstTy.tensorTy[d, d]        (* square matrix type *)              DstTy.tensorTy[d, d]        (* square matrix type *)
37            end            end
38      fun shapeVarToTensor sv = pruneShape sv      fun shapeVarToTensor (Ty.SHAPE shp) = DstTy.tensorTy shp
39          | shapeVarToTensor _ = raise Fail "expected shape"
40    
41      fun assign (y, rator, xs) = [IL.ASSGN(y, IL.OP(rator, xs))]      fun assign (y, rator, xs) = [IL.ASSGN(y, IL.OP(rator, xs))]
42    
# Line 61  Line 50 
50    
51      fun kernel h (y, [], []) = assign(y, Op.Kernel(h, 0), [])      fun kernel h (y, [], []) = assign(y, Op.Kernel(h, 0), [])
52    
53        val cnt = ref 0
54        fun genName prefix = let
55            val n = !cnt
56            in
57                cnt := n+1;
58                String.concat[prefix, "_", Int.toString n]
59            end
60    (* utility functions for synthesizing eigenvector/eigenvalue code *)    (* utility functions for synthesizing eigenvector/eigenvalue code *)
61      fun eigenVec (rator, dim) = let      fun eigenVec (rator, dim) = let
62            val ty = DstTy.SeqTy(DstTy.realTy, dim)            val ty = DstTy.SeqTy(DstTy.realTy, dim)
# Line 81  Line 77 
77                  end                  end
78            end            end
79    
80        fun assignEin (y, rator, xs) = IL.ASSGN(y, IL.EINAPP(rator, xs))
81    
82        fun  simpleEOp rator (y, _,xs) = [assignEin(y, rator, xs)]
83    
84    (* shape is an int list, DIM is in int|variable, k-level of differntiation *)
85    
86    (* build a table that maps Basis variables to their translation functions *)    (* build a table that maps Basis variables to their translation functions *)
87      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
88            val tbl = VTbl.mkTable (128, Fail "Translate table")            val tbl = VTbl.mkTable (128, Fail "Translate table")
89            val insert = VTbl.insert tbl            val insert = VTbl.insert tbl
90            in            in
# Line 103  Line 105 
105                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),                  (BV.neq_ii,             simpleOp(Op.NEQ DstTy.IntTy)),
106                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),                  (BV.neq_ss,             simpleOp(Op.NEQ DstTy.StringTy)),
107                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),                  (BV.neq_rr,             simpleOp(Op.NEQ(DstTy.realTy))),
108                  (BV.add_ii,             simpleOp(Op.Add DstTy.IntTy)),                  (BV.add_ii,             simpleOp Op.IAdd),
109                  (BV.add_tt,             tensorOp Op.Add),                  (BV.add_tt,             fn (y, [shp], xs) => let
110                  (BV.add_ff,             fn (y, _, [f, g]) => assign(y, Op.AddField, [f, g])),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
111                  (BV.sub_ii,             simpleOp(Op.Sub DstTy.IntTy)),                                          val rator =mk.addTT(dd1)
112                  (BV.sub_tt,             tensorOp Op.Sub),                                          in
113                  (BV.sub_ff,             fn (y, _, [f, g]) => assign(y, Op.SubField, [f, g])),                                              [assignEin(y, rator,xs)]
114                  (BV.mul_ii,             simpleOp(Op.Mul DstTy.IntTy)),                                          end),
115                  (BV.mul_rr,             simpleOp(Op.Mul(DstTy.realTy))),                  (BV.add_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
116                  (BV.mul_rt,             tensorOp Op.Scale),                                              [assignEin(y, mk.addFF(d, dd),xs)]),
117                  (BV.mul_tr,             fn (y, sv, [t, r]) => tensorOp Op.Scale (y, sv, [r, t])),  
118                  (BV.mul_rf,             fn (y, _, [s, f]) => assign(y, Op.ScaleField, [s, f])),                  (BV.add_ft,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f,s]) =>
119                  (BV.mul_fr,             fn (y, _, [f, s]) => assign(y, Op.ScaleField, [s, f])),                                              [assignEin(y, mk.addTF(d,dd),[s,f])]),
120                  (BV.div_ii,             simpleOp(Op.Div DstTy.IntTy)),  
121                  (BV.div_rr,             simpleOp(Op.Div DstTy.realTy)),                  (BV.add_tf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
122                  (BV.div_tr,             fn (y, [sv], [x, s]) => let                                              [assignEin(y, mk.addTF(d,dd),xs)]),
123                                            val one = IL.Var.new("one", DstTy.realTy)                  (BV.sub_ii,             simpleOp Op.ISub),
124                                            val s' = IL.Var.new("sInv", DstTy.realTy)                  (BV.sub_tt,             fn (y, [shp], xs) => let
125                                            in [                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
126                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),                                          val rator =mk.subTT dd1
127                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),                                          in
128                                              IL.ASSGN(y, IL.OP(Op.Scale(shapeVarToTensor sv), [s', x]))                                              [assignEin(y, rator,xs)]
129                                            ] end),                                          end),
130                  (BV.div_fr,             fn (y, _, [f, s]) => let                  (BV.sub_ff,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
131                                            val one = IL.Var.new("one", DstTy.realTy)                                                [assignEin(y, mk.subFF(d, dd),xs)]),
132                                            val s' = IL.Var.new("sInv", DstTy.realTy)                  (BV.sub_ft,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [x1,x2]) =>
133                                            in [                                              [assignEin(y, mk.subFT(d,dd),[x2,x1])]),
134                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),                  (BV.sub_tf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
135                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),                                                  [assignEin(y, mk.subTF(d,dd),xs)]),
136                                              IL.ASSGN(y, IL.OP(Op.ScaleField, [s', f]))                  (BV.mul_ii,             simpleOp Op.IMul),
137                                            ] end),                  (BV.mul_rr,             fn (y,_,args) => [assignEin(y, mk.mulRR,args)]),
138                    (BV.mul_rt,             fn (y, [shp], xs) => let
139                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
140                                            val rator =mk.mulRT(dd1)
141                                            in
142                                                [assignEin(y, rator,xs)]
143                                            end),
144                    (BV.mul_tr,             fn (y, [shp], [t, r]) => let
145                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
146                                              val rator = mk.mulRT dd1
147                                              in
148                                                [assignEin(y, rator,[r,t])]
149                                              end),
150                    (BV.mul_rf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
151                                                [assignEin(y, mk.mulRF(d, dd),xs)]),
152                    (BV.mul_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [f, s]) =>
153                                                [assignEin(y, mk.mulRF(d, dd),[s,f])]),
154                    (BV.mul_ss,             fn (y, [_,Ty.DIM d], xs) =>
155                                            [assignEin(y, mk.mulSS d,xs)]),
156                    (BV.mul_sf,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
157                                                [assignEin(y, mk.mulSF(d,dd),xs)]),
158                    (BV.mul_fs,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], [s,f]) =>
159                                            [assignEin(y, mk.mulSF(d,dd),[f,s])]),
160                    (BV.div_ii,             simpleOp Op.IDiv),
161                    (BV.div_rr,             fn (y,_,args) => [assignEin(y, mk.divRR,args)]),
162                    (BV.div_tr,             fn (y, [shp], xs) => let
163                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
164                                            val rator =mk.divTR dd1
165                                            in
166                                                [assignEin(y, rator,xs)]
167                                            end),
168                    (BV.div_fr,             fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
169                                                [assignEin(y, mk.divFR(d, dd),xs)]),
170                    (BV.div_fs,             fn (y, [_,_,Ty.DIM d, Ty.SHAPE dd], xs) =>
171                                            [assignEin(y, mk.divFS(d, dd),xs)]),
172                    (BV.div_ss,             fn (y, [_,Ty.DIM d], xs) =>
173                                                [assignEin(y, mk.divSS d,xs)]),
174                  (BV.exp_ri,             simpleOp(Op.Power)),                  (BV.exp_ri,             simpleOp(Op.Power)),
175                  (BV.exp_rr,             basisFn MathFuns.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
176                  (BV.convolve_vk,        fn (y, [_, dv, _], xs) =>                  (BV.curl2D,              simpleEOp mk.curl2d),
177                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), xs)),                  (BV.curl3D,              simpleEOp mk.curl3d),
178                  (BV.convolve_kv,        fn (y, [_, dv, _], [k, v]) =>                  (BV.convolve_vk,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], xs) =>
179                                            assign(y, Op.Field(pruneDim(MV.toDim dv)), [v, k])),                                             [assignEin(y, mk.conv(d, dd),xs)]),
180                  (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),                  (BV.convolve_kv,        fn (y, [_, Ty.DIM d,  Ty.SHAPE dd], [k, v]) =>
181                  (BV.neg_t,              tensorOp Op.Neg),                                               [assignEin(y, mk.conv(d, dd),[v,k])]),
182                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),                  (BV.neg_i,              simpleOp Op.INeg),
183                  (BV.op_probe,           fn (y, [_, dv, sv], xs) =>                  (BV.neg_t,              fn (y, [shp], xs) => let
184                                            assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),                                          val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
185                  (BV.op_D,               fn (y, _, xs) => assign(y, Op.DiffField, xs)),                                          val rator =mk.negTT dd1
186                  (BV.op_Dotimes,         fn (y, _, xs) => assign(y, Op.DiffField, xs)),                                          in
187                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                                              [assignEin(y, rator,xs)]
188                                            end),
189                    (BV.neg_f,              fn (y, [_,Ty.DIM d, Ty.SHAPE dd], xs) =>
190                                            [assignEin(y, mk.negFF(d, dd),xs)]),
191                    (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
192                                                [assignEin(y, (mk.probe(dd,d)),xs)]),
193                    (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>  (case d
194                                                of 2=>[assignEin(y, mk.grad([d]),xs)]
195                                                |  3=>[assignEin(y, mk.grad([d]),xs)]
196                                                | _ => raise Fail "unsupported gradient"
197                                                (*end case*))),
198                    (BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) =>
199                                                [assignEin(y, mk.dotimes(d1, dd@[d2]),xs)]),
200                    (BV.op_Ddot,         fn (y, [_, Ty.DIM d1,  Ty.SHAPE dd, Ty.DIM d2], xs) =>
201                                            [assignEin(y, mk.divergence(d1, dd),xs)] ),
202                    (BV.op_norm_t,            fn (y, [sv], xs) => let
203                                                val ty=shapeVarToTensor sv
204                                                in (case shapeVarToTensor sv
205                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)
206                                              | ty => assign(y, Op.Norm ty, xs)                                                  | DstTy.TensorTy [_]    => assign(y, Op.Norm ty, xs)
207                                                    | DstTy.TensorTy[_,_]   => assign(y, Op.Norm ty, xs)
208                                                    | DstTy.TensorTy[_,_,_] => assign(y, Op.Norm ty, xs)
209                                                    | _ => raise Fail"unsupported norm of TensorTy"
210                                                    (* end case *))
211                                                end),
212                    (BV.op_norm_f,            fn (y, [ _,Ty.DIM d1, Ty.SHAPE dd], xs) => (case dd
213                                                of []  =>  [assignEin(y, mk.magnitudeFF(d1, dd),xs)]
214                                                | [i]  =>  [assignEin(y, mk.magnitudeFF(d1, dd),xs@xs)]
215                                                | _ => raise Fail"unsupported norm of fieldTy"
216                                            (* end case *))),                                            (* end case *))),
217                  (BV.op_not,             simpleOp Op.Not),                  (BV.op_not,             simpleOp Op.Not),
218                  (BV.op_cross,           simpleOp Op.Cross),                  (BV.op_cross3_tt,           simpleEOp mk.cross3TT),
219                  (BV.op_outer,           fn (y, [dv1, dv2], xs) => let                  (BV.op_cross2_tt,          simpleEOp mk.cross2TT),
220                                            val d1 = pruneDim(MV.toDim dv1)                  (BV.op_cross2_ff,       simpleEOp mk.cross2FF),
221                                            val d2 = pruneDim(MV.toDim dv2)                  (BV.op_cross3_ff,       simpleEOp mk.cross3FF),
222                                            in                  (BV.op_outer_tt,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
223                                              assign (y, Op.Outer(DstTy.tensorTy[d1, d2]), xs)                                              [assignEin(y, (mk.outerTT(d1, d2)), xs)]),
224                                            end),                  (BV.op_outer_ff,      fn (y, [_, Ty.DIM d1], xs)=>
225                  (BV.op_inner,           fn (y, [sh1, sh2, _], xs) => let                                              [assignEin(y, mk.outerFF d1,   xs)]),
226                                            val ty1 as DstTy.TensorTy dd1 = pruneShape sh1                  (BV.op_inner_tt,           fn (y, [sh1, sh2, _], xs) => let
227                                            val ty2 as DstTy.TensorTy dd2 = pruneShape sh2                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
228                                            val rator = (case (dd1, dd2)                                              val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
229                                                   of ([d], [d']) => Op.Dot ty1                                          in
230                                                    | ([d1], [d1', d2]) => Op.MulVecMat ty2                                              [assignEin(y, (mk.innerTT(dd1,dd2)),xs)]
231                                                    | ([d1, d2], [d2']) => Op.MulMatVec ty1                                          end),
232                                                    | ([d1, d2], [d2', d3]) => Op.MulMatMat(ty1, ty2)  
233                                                    | _ => raise Fail "unsupported inner-product type"                  (BV.op_inner_tf,      fn (y,  [_,Ty.DIM d,sh1,Ty.SHAPE dd2,_], xs) =>let
234                                                  (* end case *))                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
235                                            in                                            in
236                                              assign (y, rator, xs)                                                  [assignEin(y, mk.innerTF(dd1,d,dd2),xs)]
237                                            end),                                            end),
238                  (BV.fn_inside,          fn (y, [_, dv, _], xs) =>                  (BV.op_inner_ft,      fn (y,  [_,Ty.DIM d,Ty.SHAPE dd1,sh2,_], xs) =>let
239                                            assign(y, Op.Inside(pruneDim(MV.toDim dv)), xs)),                                              val ty1 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
240                                            in
241                                                    [assignEin(y, mk.innerFT(dd1,d,dd2),xs)]
242                                            end ),
243    
244                    (BV.op_inner_ff,      fn (y,  [_,_,Ty.DIM d,Ty.SHAPE dd1,Ty.SHAPE dd2,_], xs) =>
245                                                [assignEin(y, mk.innerFF(dd1,d,dd2),xs)]),
246    
247                    (BV.op_colon_tt,           fn (y, [sh1, sh2, _], xs) => let
248                                                val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
249                                                val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
250                                            in
251                                                [assignEin(y, (mk.colonTT(dd1,dd2)),xs)]
252                                            end),
253                    (BV.op_colon_ff,       fn (y, [_,Ty.SHAPE dd1,_,Ty.SHAPE dd2, _], xs) =>
254                                                [assignEin(y, (mk.colonFF(dd1,dd2)),xs)]),
255                    (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, xs)),
256                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
257                  (BV.clamp_vvv,          vectorOp Op.Clamp),                  (BV.clamp_vvv,          vectorOp Op.Clamp),
258                  (BV.lerp3,              tensorOp Op.Lerp),                  (BV.lerp3,              tensorOp Op.Lerp),
# Line 181  Line 261 
261                                            val t2 = IL.Var.new("t2", DstTy.realTy)                                            val t2 = IL.Var.new("t2", DstTy.realTy)
262                                            val t3 = IL.Var.new("t3", DstTy.realTy)                                            val t3 = IL.Var.new("t3", DstTy.realTy)
263                                            in [                                            in [
264                                              IL.ASSGN(t1, IL.OP(Op.Sub DstTy.realTy, [x, x0])),                                              assignEin(t1, mk.subRR,[x,x0]),
265                                              IL.ASSGN(t2, IL.OP(Op.Sub DstTy.realTy, [x1, x0])),                                              assignEin(t2, mk.subRR,[x1,x0]),
266                                              IL.ASSGN(t3, IL.OP(Op.Div DstTy.realTy, [t1, t2])),                                              assignEin(t3, mk.divRR,[t1,t2]),
267                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))
268                                            ] end),                                            ] end),
269                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),
270                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
271                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),
272                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),
273    
274    
275                  (BV.fn_max,             simpleOp Op.Max),                  (BV.fn_max,             simpleOp Op.Max),
276                  (BV.fn_min,             simpleOp Op.Min),                  (BV.fn_min,             simpleOp Op.Min),
277                  (BV.fn_modulate,        vectorOp Op.Mul),  
278                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (*  modulate is vector * vector pointwise multiplication *)
279                    (BV.fn_modulate,        fn (y,[Ty.DIM dd1], xs) =>
280                                    [assignEin(y, (mk.modulate dd1),xs)]),
281                    (BV.fn_normalize_t,   vectorOp Op.Normalize),
282                    (BV.fn_normalize_f,             fn (y, [ _,Ty.DIM d1, Ty.SHAPE dd], xs) =>
283                        (case dd
284                            of [] => [assignEin(y, mk.normalizeFF(d1, []),xs)]
285                            | [i] => [assignEin(y, mk.normalizeFF(d1, [i]),xs@xs)]
286                            | _ => raise Fail"unsupported normalized of fieldTy"
287                        (* end case *))),
288                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
289                  (BV.fn_trace,           fn (y, [dv], xs) => assign(y, Op.Trace(dimVarToMatrix dv), xs)),                  (BV.fn_trace_t,           fn (y, [Ty.DIM d], xs) =>
290                                              [assignEin(y,(mk.traceT d), xs)]),
291                    (BV.fn_trace_f,           fn (y, [_,Ty.DIM d,Ty.SHAPE dd], xs) =>
292                            [assignEin(y,mk.traceF(d,dd), xs)]),
293                    (BV.fn_transpose_t,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
294                                              [assignEin(y, (mk.transposeT [d1,d2]), xs)]),
295                    (BV.fn_transpose_f,  fn (y, [_,Ty.DIM d1, Ty.DIM d2,Ty.DIM d3], xs) =>
296                        [assignEin(y, (mk.transposeF (d1,d2,d3)), xs)]),
297                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
298                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
299                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
300                  (BV.kn_c2ctmr,          kernel Kernel.ctmr),                  (BV.kn_c2ctmr,          kernel Kernel.ctmr),
301                    (BV.kn_c4hexic,         kernel Kernel.c4hexic),
302                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
303                  (BV.kn_c1tent,          kernel Kernel.tent),                  (BV.kn_c1tent,          kernel Kernel.tent),
304                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
305                  (BV.identity,           fn (y, [dv], []) =>                  (BV.identity,           fn (y, [Ty.DIM d], xs) =>
306                                            assign(y, Op.Identity(pruneDim(MV.toDim dv)), [])),                                            [assignEin(y, (mk.identity d), xs)]),
307                  (BV.zero,               fn (y, [sv], []) =>                  (BV.zero,               fn (y, [sv], []) =>
308                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),
309                  (BV.subscript,          fn (y, [tv, dv], args) =>                  (BV.subscript,          fn (y, [ty, Ty.DIM d], xs) =>
310                                            assign(y,                                            assign (y, Op.SeqSub(DstTy.SeqTy(trType ty, d)), xs))
311                                              Op.SeqSub(DstTy.SeqTy(pruneTy(MV.toType tv), pruneDim(MV.toDim dv))),  (*,
312                                              args))                    (BV.dynSubscript,     fn (y, [tv], args) =>
313                                              assign(y, Op.SeqSub(DstTy.DynSeqTy(pruneTy tv)), args))
314    *)
315                ];                ];
316            (* add C math functions *)            (* add C math functions *)
317              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.1923  
changed lines
  Added in v.2955

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