Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/translate/translate-basis.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/translate/translate-basis.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3476, Wed Dec 2 20:44:59 2015 UTC revision 3478, Thu Dec 3 17:26:24 2015 UTC
# Line 5  Line 5 
5   * COPYRIGHT (c) 2015 The University of Chicago   * COPYRIGHT (c) 2015 The University of Chicago
6   * All rights reserved.   * All rights reserved.
7   *   *
8   * Translation for basis operations in Simple AST to HighIL code   * Translation for basis operations in Simple AST to HighIR code
9   *)   *)
10    
11  structure TranslateBasis : sig  structure TranslateBasis : sig
# Line 14  Line 14 
14     * 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
15     * reverse order.     * reverse order.
16     *)     *)
17      val translate : (HighIL.var * Var.var * SimpleTypes.meta_arg list * HighIL.var list)      val translate : (HighIR.var * Var.t * SimpleTypes.meta_arg list * HighIR.var list)
18            -> HighIL.assignment list            -> HighIR.assignment list
19    
20    end = struct    end = struct
21    
22      structure BV = BasisVars      structure BV = BasisVars
23      structure IL = HighIL      structure IR = HighIR
24      structure DstTy = HighILTypes      structure DstTy = HighTypes
25      structure Op = HighOps      structure Op = HighOps
26      structure Ty = SimpleTypes      structure Ty = SimpleTypes
27      structure VTbl = Var.Tbl      structure VTbl = Var.Tbl
28        structure Mk = MkOperators
29    
30      fun trType (Ty.TY ty) = TranslateTy.tr ty      fun trType (Ty.TY ty) = TranslateTy.tr ty
31        | trType _ = raise Fail "expected type"        | trType _ = raise Fail "expected type"
# Line 39  Line 40 
40      fun shapeVarToTensor (Ty.SHAPE shp) = DstTy.tensorTy shp      fun shapeVarToTensor (Ty.SHAPE shp) = DstTy.tensorTy shp
41        | shapeVarToTensor _ = raise Fail "expected shape"        | shapeVarToTensor _ = raise Fail "expected shape"
42    
43      fun assign (y, rator, xs) = [IL.ASSGN(y, IL.OP(rator, xs))]      fun assign (y, rator, xs) = [IR.ASSGN(y, IR.OP(rator, xs))]
   
     fun basisFn name (y, [], xs) = [IL.ASSGN(y, IL.APPLY(name, xs))]  
44    
45      fun simpleOp rator (y, [], xs) = assign (y, rator, xs)      fun simpleOp rator (y, [], xs) = assign (y, rator, xs)
46    
# Line 53  Line 52 
52    
53    (* utility functions for synthesizing eigenvector/eigenvalue code *)    (* utility functions for synthesizing eigenvector/eigenvalue code *)
54      fun eigenVec (rator, dim) = let      fun eigenVec (rator, dim) = let
55            val ty = DstTy.SeqTy(DstTy.realTy, dim)            val ty = DstTy.SeqTy(DstTy.realTy, SOME dim)
56            in            in
57              fn (y, _, [m]) => let              fn (y, _, [m]) => let
58                  val v = IL.Var.new("evals", ty)                  val v = IR.Var.new("evals", ty)
59                  in                  in
60                    [IL.MASSGN([v, y], rator, [m])]                    [IR.MASSGN([v, y], rator, [m])]
61                  end                  end
62            end            end
63      fun eigenVal (rator, dim) = let      fun eigenVal (rator, dim) = let
64            val ty = DstTy.SeqTy(DstTy.vecTy dim, dim)            val ty = DstTy.SeqTy(DstTy.vecTy dim, SOME dim)
65            in            in
66              fn (y, _, [m]) => let              fn (y, _, [m]) => let
67                  val v = IL.Var.new("evecs", ty)                  val v = IR.Var.new("evecs", ty)
68                  in                  in
69                    [IL.MASSGN([y, v], rator, [m])]                    [IR.MASSGN([y, v], rator, [m])]
70                  end                  end
71            end            end
72    
73        fun assignEin (y, rator, xs) = IR.ASSGN(y, IR.EINAPP(rator, xs))
74    
75        fun simpleEOp rator (y, _, xs) = [assignEin(y, rator, xs)]
76    
77    (* build a table that maps Basis variables to their translation functions *)    (* build a table that maps Basis variables to their translation functions *)
78      val tbl : ((IL.var * Ty.meta_arg list * IL.var list) -> IL.assignment list) VTbl.hash_table = let      val tbl : ((IR.var * Ty.meta_arg list * IR.var list) -> IR.assignment list) VTbl.hash_table = let
79            val tbl = VTbl.mkTable (128, Fail "Translate table")            val tbl = VTbl.mkTable (128, Fail "Translate table")
80            val insert = VTbl.insert tbl            fun insert (id, def) = (case VTbl.find tbl id
81                     of NONE => VTbl.insert tbl (id, def)
82                      | SOME _ => raise Fail("duplicate definition of " ^ Var.nameOf id)
83                    (* end case *))
84            in            in
85              List.app insert [              List.app insert [
86                  (BV.at_Td,              fn (y, [tv], args) => assign(y, Op.Prepend(trType tv), args)),                  (BV.at_Td,              fn (y, [tv], args) => assign(y, Op.Prepend(trType tv), args)),
# Line 101  Line 107 
107                  (BV.mul_ii,             simpleOp Op.IMul),                  (BV.mul_ii,             simpleOp Op.IMul),
108                  (BV.div_ii,             simpleOp Op.IDiv),                  (BV.div_ii,             simpleOp Op.IDiv),
109                  (BV.op_mod,             simpleOp Op.IMod),                  (BV.op_mod,             simpleOp Op.IMod),
110                    (BV.neg_i,              simpleOp Op.INeg),
111                  (BV.add_ii,             simpleOp(Op.Add DstTy.IntTy)),                  (BV.add_tt,             fn (y, [shp], xs) => let
112                  (BV.add_tt,             tensorOp Op.Add),                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
113                  (BV.add_ff,             fn (y, _, [f, g]) => assign(y, Op.AddField, [f, g])),                                            val rator = Mk.addTT(dd1)
114                  (BV.add_fr,             fn (y, _, [f, s]) => assign(y, Op.OffsetField, [f, s])),                                            in
115                  (BV.add_rf,             fn (y, _, [s, f]) => assign(y, Op.OffsetField, [f, s])),                                              [assignEin(y, rator, xs)]
116                  (BV.sub_ii,             simpleOp(Op.Sub DstTy.IntTy)),                                            end),
117                  (BV.sub_tt,             tensorOp Op.Sub),                  (BV.add_ff,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
118                  (BV.sub_ff,             fn (y, _, [f, g]) => assign(y, Op.SubField, [f, g])),                                            [assignEin(y, Mk.addFF(d, dd), xs)]),
119                  (BV.sub_fr,             fn (y, _, [f, s]) => let                  (BV.add_ft,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [f, s]) =>
120                                            val s' = IL.Var.copy s                                            [assignEin(y, Mk.addTF(d, dd), [s, f])]),
121                                            in [                  (BV.add_tf,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
122                                              IL.ASSGN(s', IL.OP(Op.Neg DstTy.realTy, [s])),                                            [assignEin(y, Mk.addTF(d, dd), xs)]),
123                                              IL.ASSGN(y, IL.OP(Op.OffsetField, [f, s']))                  (BV.sub_tt,             fn (y, [shp], xs) => let
124                                            ] end),                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
125                  (BV.sub_rf,             fn (y, _, [s, f]) => let                                            val rator = Mk.subTT dd1
126                                            val f' = IL.Var.copy f                                            in
127                                            in [                                              [assignEin(y, rator, xs)]
128                                              IL.ASSGN(f', IL.OP(Op.NegField, [f])),                                            end),
129                                              IL.ASSGN(y, IL.OP(Op.OffsetField, [f', s]))                  (BV.sub_ff,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
130                                            ] end),                                            [assignEin(y, Mk.subFF(d, dd), xs)]),
131                  (BV.mul_ii,             simpleOp(Op.Mul DstTy.IntTy)),                  (BV.sub_ft,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [x1, x2]) =>
132                  (BV.mul_rr,             simpleOp(Op.Mul(DstTy.realTy))),                                            [assignEin(y, Mk.subFT(d, dd), [x2, x1])]),
133                  (BV.mul_rt,             tensorOp Op.Scale),                  (BV.sub_tf,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
134                  (BV.mul_tr,             fn (y, sv, [t, r]) => tensorOp Op.Scale (y, sv, [r, t])),                                            [assignEin(y, Mk.subTF(d, dd), xs)]),
135                  (BV.mul_rf,             fn (y, _, [s, f]) => assign(y, Op.ScaleField, [s, f])),                  (BV.mul_rr,             fn (y, _, args) => [assignEin(y, Mk.mulRR, args)]),
136                  (BV.mul_fr,             fn (y, _, [f, s]) => assign(y, Op.ScaleField, [s, f])),                  (BV.mul_rt,             fn (y, [shp], xs) => let
137                  (BV.div_ii,             simpleOp(Op.Div DstTy.IntTy)),                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
138                  (BV.div_rr,             simpleOp(Op.Div DstTy.realTy)),                                            val rator = Mk.mulRT(dd1)
139                  (BV.div_tr,             fn (y, [sv], [x, s]) => let                                            in
140                                            val one = IL.Var.new("one", DstTy.realTy)                                              [assignEin(y, rator, xs)]
141                                            val s' = IL.Var.new("sInv", DstTy.realTy)                                            end),
142                                            in [                  (BV.mul_tr,             fn (y, [shp], [t, r]) => let
143                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
144                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),                                            val rator = Mk.mulRT dd1
145                                              IL.ASSGN(y, IL.OP(Op.Scale(shapeVarToTensor sv), [s', x]))                                            in
146                                            ] end),                                              [assignEin(y, rator, [r, t])]
147                  (BV.div_fr,             fn (y, _, [f, s]) => let                                            end),
148                                            val one = IL.Var.new("one", DstTy.realTy)                  (BV.mul_rf,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
149                                            val s' = IL.Var.new("sInv", DstTy.realTy)                                            [assignEin(y, Mk.mulRF(d, dd), xs)]),
150                                            in [                  (BV.mul_fr,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [f, s]) =>
151                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),                                            [assignEin(y, Mk.mulRF(d, dd), [s, f])]),
152                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),                  (BV.mul_ss,             fn (y, [_, Ty.DIM d], xs) =>
153                                              IL.ASSGN(y, IL.OP(Op.ScaleField, [s', f]))                                            [assignEin(y, Mk.mulSS d, xs)]),
154                                            ] end),                  (BV.mul_sf,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
155                  (BV.op_mod,             simpleOp Op.Mod),                                            [assignEin(y, Mk.mulSF(d, dd), xs)]),
156                    (BV.mul_fs,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [s, f]) =>
157                                              [assignEin(y, Mk.mulSF(d, dd), [f, s])]),
158                    (BV.mul_st,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
159                                              [assignEin(y, Mk.mulST(d, dd), List.rev xs)]),
160                    (BV.mul_ts,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
161                                              [assignEin(y, Mk.mulST(d, dd), xs)]),
162                    (BV.div_rr,             fn (y, _, args) => [assignEin(y, Mk.divRR, args)]),
163                    (BV.div_tr,             fn (y, [shp], xs) => let
164                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
165                                              val rator = Mk.divTR dd1
166                                              in
167                                                [assignEin(y, rator, xs)]
168                                              end),
169                    (BV.div_fr,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
170                                              [assignEin(y, Mk.divFR(d, dd), xs)]),
171                    (BV.div_fs,             fn (y, [_, _, Ty.DIM d, Ty.SHAPE dd], xs) =>
172                                              [assignEin(y, Mk.divFS(d, dd), xs)]),
173                    (BV.div_ss,             fn (y, [_, Ty.DIM d], xs) =>
174                                              [assignEin(y, Mk.divSS d, xs)]),
175                  (BV.exp_ri,             simpleOp Op.Power),                  (BV.exp_ri,             simpleOp Op.Power),
176                  (BV.exp_rr,             basisFn MathFuns.pow),                  (BV.exp_rr,             basisFn MathFuns.pow),
177                  (BV.curl2D,             fn (y, _, xs) => assign(y, Op.CurlField 2, xs)),                  (BV.curl2D,             simpleEOp Mk.curl2d),
178                  (BV.curl3D,             fn (y, _, xs) => assign(y, Op.CurlField 3, xs)),                  (BV.curl3D,             simpleEOp Mk.curl3d),
179                  (BV.convolve_vk,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>                  (BV.convolve_vk,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
180                                            assign(y, Op.Field(DstTy.TensorTy[d], DstTy.TensorTy dd), xs)),                                            [assignEin(y, Mk.conv(d, dd), xs)]),
181                  (BV.convolve_kv,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [k, v]) =>                  (BV.convolve_kv,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
182                                            assign(y, Op.Field(DstTy.TensorTy[d], DstTy.TensorTy dd), [v, k])),                                            [assignEin(y, Mk.conv(d, dd), xs)]),
183                  (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),                  (BV.neg_t,              fn (y, [shp], xs) => let
184                  (BV.neg_t,              tensorOp Op.Neg),                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
185                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),                                            val rator = Mk.negTT dd1
186                  (BV.op_probe,           fn (y, [_, dv, sv], xs) =>                                            in
187                                            assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),                                              [assignEin(y, rator, xs)]
188                  (BV.op_D,               fn (y, _, xs) => assign(y, Op.DiffField, xs)),                                            end),
189                  (BV.op_Dotimes,         fn (y, _, xs) => assign(y, Op.DiffField, xs)),                  (BV.neg_f,              fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
190                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                                            [assignEin(y, Mk.negFF(d, dd), xs)]),
191                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                  (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
192                                              | ty => assign(y, Op.Norm ty, xs)                                            [assignEin(y, (Mk.probe(dd, d)), xs)]),
193                                            (* end case *))),                  (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>
194                                              if (d = 2) orelse (d = 3)
195                                                then [assignEin(y, Mk.grad [d], xs)]
196                                                else raise Fail "unsupported gradient"),
197                    (BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) =>
198                                              [assignEin(y, Mk.dotimes(d1, dd@[d2]), xs)]),
199                    (BV.op_Ddot,            fn (y, [_, Ty.DIM d1,  Ty.SHAPE dd, Ty.DIM d2], xs) =>
200                                              [assignEin(y, Mk.divergence(d1, dd), xs)] ),
201                    (BV.op_norm_t,          fn (y, [sv], xs) =>  assign(y, Op.Norm(shapeVarToTensor sv), xs)),
202                    (BV.op_norm_f,          fn (y, [ _, Ty.DIM d1, Ty.SHAPE dd], xs) =>
203                                              [assignEin(y, Mk.magnitudeFF(d1, dd), xs@xs)]),
204                  (BV.op_not,             simpleOp Op.Not),                  (BV.op_not,             simpleOp Op.Not),
205                  (BV.op_cross,           simpleOp Op.Cross),                  (BV.op_cross3_tt,       simpleEOp Mk.cross3TT),
206                  (BV.op_outer,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>                  (BV.op_cross2_tt,       simpleEOp Mk.cross2TT),
207                                            assign (y, Op.Outer(DstTy.tensorTy[d1, d2]), xs)),                  (BV.op_cross2_ff,       simpleEOp Mk.cross2FF),
208                  (BV.op_inner,           fn (y, [Ty.SHAPE dd1, Ty.SHAPE dd2, _], xs) => let                  (BV.op_cross3_ff,       simpleEOp Mk.cross3FF),
209                                            val ty1 = DstTy.TensorTy dd1                  (BV.op_outer_tt,        fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
210                                            val ty2 = DstTy.TensorTy dd2                                            [assignEin(y, (Mk.outerTT(d1, d2)), xs)]),
211                                            val rator = (case (dd1, dd2)                  (BV.op_outer_mt,        fn (y, [Ty.DIM d1, Ty.DIM d2, Ty.DIM d3], xs) =>
212                                                   of ([d], [d']) => Op.Dot ty1                                            [assignEin(y, (Mk.outerMT([d1, d2], d3)), xs)]),
213                                                    | ([d1], [d1', d2]) => Op.MulVecMat ty2                  (BV.op_outer_tm,        fn (y, [Ty.DIM d1, Ty.DIM d2, Ty.DIM d3], xs) =>
214                                                    | ([d1, d2], [d2']) => Op.MulMatVec ty1                                            [assignEin(y, (Mk.outerTM(d1, [ d2, d3])), xs)]),
215                                                    | ([d1, d2], [d2', d3]) => Op.MulMatMat(ty1, ty2)                  (BV.op_outer_ff,        fn (y, [_, Ty.DIM d1, Ty.DIM i, Ty.DIM j], xs)=>
216                                                    | ([d1], [d1', d2, d3]) => Op.MulVecTen3 ty2                                            [assignEin(y, Mk.outerFF(d1, i, j), xs)]),
217                                                    | ([d1, d2, d3], [d3']) => Op.MulTen3Vec ty1                  (BV.op_inner_tt,        fn (y, [sh1, sh2, _], xs) => let
218                                                    | _ => raise Fail(concat[                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
219                                                          "unsupported inner-product: ",                                            val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
220                                                          DstTy.toString ty1, " * ", DstTy.toString ty2                                            in
221                                                        ])                                              [assignEin(y, (Mk.innerTT(dd1, dd2)), xs)]
222                                                  (* end case *))                                            end),
223                    (BV.op_inner_tf,        fn (y, [_, Ty.DIM d, sh1, Ty.SHAPE dd2, _], xs) =>let
224                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
225                                            in                                            in
226                                              assign (y, rator, xs)                                              [assignEin(y, Mk.innerTF(dd1, d, dd2), xs)]
227                                            end),                                            end),
228                  (BV.op_colon,           fn (y, [sh1, sh2, _], xs) => let                  (BV.op_inner_ft,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd1, sh2, _], xs) =>let
229                                            val ty1 = shapeVarToTensor sh1                                            val ty1 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
                                           val ty2 = shapeVarToTensor sh2  
230                                            in                                            in
231                                              assign (y, Op.ColonMul(ty1, ty2), xs)                                              [assignEin(y, Mk.innerFT(dd1, d, dd2), xs)]
232                                            end),                                            end),
233                  (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) =>                  (BV.op_inner_ff,        fn (y,  [_, _, Ty.DIM d, Ty.SHAPE dd1, Ty.SHAPE dd2, _], xs) =>
234                                            assign(y, Op.Inside d, xs)),                                            [assignEin(y, Mk.innerFF(dd1, d, dd2), xs)]),
235                    (BV.op_colon_tt,        fn (y, [sh1, sh2, _], xs) => let
236                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
237                                              val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
238                                              in
239                                                [assignEin(y, Mk.colonTT(dd1, dd2), xs)]
240                                              end),
241                    (BV.op_colon_ft,        fn (y, [_, Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE dd2, _], xs) =>
242                                              [assignEin(y, Mk.colonFT(d, dd1, dd2), xs)]),
243                    (BV.op_colon_tf,        fn (y, [_, Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE dd2, _], xs) =>
244                                              [assignEin(y, Mk.colonTF(d, dd1, dd2), xs)]),
245                    (BV.op_colon_ff,        fn (y, [_, Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE dd2, _], xs) =>
246                                              [assignEin(y, Mk.colonFF(d, dd1, dd2), xs)]),
247                    (*  modulate is vector * vector pointwise multiplication *)
248                    (BV.fn_modulate,        fn (y, [Ty.DIM dd1], xs) =>
249                                              [assignEin(y, (Mk.modulate dd1), xs)]),
250                    (BV.fn_normalize_t,     fn (y, [shp], xs) => let
251                                              val DstTy.TensorTy dd1 = shapeVarToTensor shp
252                                              in
253                                                case dd1
254                                                 of [_] => assign(y, Op.Normalize(DstTy.TensorTy dd1), xs)
255    (* FIXME: looks right but causes precision error for regresstion tests. change later *)
256                                                  | _ => [assignEin(y, Mk.normalizeTT dd1, xs@xs)]
257                                                (* end case *)
258                                              end),
259                    (BV.fn_normalize_f,     fn (y, [ _, Ty.DIM d1, Ty.SHAPE dd], xs) => (case dd
260                                               of [] => [assignEin(y, Mk.normalizeFF(d1, []), xs)]
261                                                | _ => [assignEin(y, Mk.normalizeFF(d1, dd), xs@xs)]
262                                              (* end case *))),
263                    (BV.fn_trace_t,         fn (y, [Ty.DIM d], xs) =>
264                                              [assignEin(y, (Mk.traceT d), xs)]),
265                    (BV.fn_trace_f,         fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
266                                              [assignEin(y, Mk.traceF(d, dd), xs)]),
267                    (BV.fn_transpose_t,     fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
268                                              [assignEin(y, (Mk.transposeT [d1, d2]), xs)]),
269                    (BV.fn_transpose_f,     fn (y, [_, Ty.DIM d1, Ty.DIM d2, Ty.DIM d3], xs) =>
270                                              [assignEin(y, (Mk.transposeF (d1, d2, d3)), xs)]),
271                    (BV.fn_det2_t,          simpleEOp (Mk.det2T)),
272                    (BV.fn_det3_t,          simpleEOp (Mk.det3T)),
273                    (BV.fn_det2_f,          simpleEOp (Mk.det2F)),
274                    (BV.fn_det3_f,          simpleEOp (Mk.det3F)),
275                    (BV.fn_sqrt_f,          fn (y, [_, Ty.DIM d1], xs) =>
276                                              [assignEin(y, Mk.sqrtF d1, xs)]),
277                    (BV.fn_sqrt_t,          fn (y, _, xs) =>
278                                              assign(y, Op.Sqrt, xs)),
279                    (BV.fn_cos_f,           fn (y, [_, Ty.DIM d1], xs) =>
280                                              [assignEin(y, Mk.cosF d1, xs)]),
281                    (BV.fn_acos_f,          fn (y, [_, Ty.DIM d1], xs) =>
282                                              [assignEin(y, Mk.acosF d1, xs)]),
283                    (BV.fn_sin_f,           fn (y, [_, Ty.DIM d1], xs) =>
284                                              [assignEin(y, Mk.sinF d1, xs)]),
285                    (BV.fn_asin_f,          fn (y, [_, Ty.DIM d1], xs) =>
286                                              [assignEin(y, Mk.asinF d1, xs)]),
287                    (BV.fn_tan_f,           fn (y, [_, Ty.DIM d1], xs) =>
288                                              [assignEin(y, Mk.tanF d1, xs)]),
289                    (BV.fn_atan_f,          fn (y, [_, Ty.DIM d1], xs) =>
290                                              [assignEin(y, Mk.atanF d1, xs)]),
291                    (BV.fn_exp_f,           fn (y, [_, Ty.DIM d1], xs) =>
292                                              [assignEin(y, Mk.expF d1, xs)]),
293                    (BV.fn_exp_t,           fn (y, _, xs) =>
294                                              [assignEin(y, Mk.expT, xs)]),
295                    (BV.fn_pow_f,           fn (y, [_, Ty.DIM d1], [f, n]) => let
296                                              fun getN x  = (case IR.Var.binding x
297                                                     of IR.VB_RHS(IR.LIT(Literal.Int n)) => IntInf.toInt n
298                                                      | vb => raise Fail (String.concat[
299    (* FIXME: should catch this earlier, where we can generate an error message! *)
300                                                            "Not an Int, ", IR.Var.toString x,
301                                                            " found ", IR.vbToString vb, "\n"
302                                                          ])
303                                                    (* end case *))
304                                              in
305                                                [assignEin(y, Mk.powF(d1, getN n), [f])]
306                                              end),
307                    (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
308                    (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, xs)),
309                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
310                  (BV.clamp_vvv,          vectorOp Op.Clamp),                  (BV.clamp_vvv,          vectorOp Op.Clamp),
311                  (BV.lerp3,              tensorOp Op.Lerp),                  (BV.lerp3,              tensorOp Op.Lerp),
312                  (BV.lerp5,              fn (y, [sv], [a, b, x0, x, x1]) => let                  (BV.lerp5,              fn (y, [sv], [a, b, x0, x, x1]) => let
313                                            val t1 = IL.Var.new("t1", DstTy.realTy)                                            val t1 = IR.Var.new("t1", DstTy.realTy)
314                                            val t2 = IL.Var.new("t2", DstTy.realTy)                                            val t2 = IR.Var.new("t2", DstTy.realTy)
315                                            val t3 = IL.Var.new("t3", DstTy.realTy)                                            val t3 = IR.Var.new("t3", DstTy.realTy)
316                                            in [                                            in [
317                                              IL.ASSGN(t1, IL.OP(Op.Sub DstTy.realTy, [x, x0])),                                              assignEin(t1, Mk.subRR, [x, x0]),
318                                              IL.ASSGN(t2, IL.OP(Op.Sub DstTy.realTy, [x1, x0])),                                              assignEin(t2, Mk.subRR, [x1, x0]),
319                                              IL.ASSGN(t3, IL.OP(Op.Div DstTy.realTy, [t1, t2])),                                              assignEin(t3, Mk.divRR, [t1, t2]),
320                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))                                              IR.ASSGN(y, IR.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))
321                                            ] end),                                            ] end),
322                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),
323                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
# Line 216  Line 326 
326                  (BV.fn_length,          fn (y, [tv], [s]) => assign(y, Op.Length(trType tv), [s])),                  (BV.fn_length,          fn (y, [tv], [s]) => assign(y, Op.Length(trType tv), [s])),
327                  (BV.fn_max,             simpleOp Op.Max),                  (BV.fn_max,             simpleOp Op.Max),
328                  (BV.fn_min,             simpleOp Op.Min),                  (BV.fn_min,             simpleOp Op.Min),
                 (BV.fn_modulate,        vectorOp Op.Mul),  
                 (BV.fn_normalize,       vectorOp Op.Normalize),  
                 (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),  
                 (BV.fn_trace,           fn (y, [dv], xs) => assign(y, Op.Trace(dimVarToMatrix dv), xs)),  
                 (BV.fn_transpose,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>  
                                           assign(y, Op.Transpose(d1, d2), xs)),  
329                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
330                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
331                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
                 (BV.kn_c2ctmr,          kernel Kernel.ctmr),  
332                  (BV.kn_c4hexic,         kernel Kernel.c4hexic),                  (BV.kn_c4hexic,         kernel Kernel.c4hexic),
333                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
                 (BV.kn_c1tent,          kernel Kernel.tent),  
                 (BV.kn_c2tent,          kernel Kernel.tent),  
334                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
335                  (BV.identity,           fn (y, [Ty.DIM d], []) =>                  (BV.identity,           fn (y, [Ty.DIM d], xs) =>
336                                            assign(y, Op.Identity d, [])),                                            [assignEin(y, Mk.identity d, xs)]),
337                  (BV.zero,               fn (y, [sv], []) =>                  (BV.zero,               fn (y, [Ty.SHAPE dd], []) =>
338                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            [assignEin(y, Mk.zeros dd, [])]),
339                  (BV.nan,                fn (y, [Ty.SHAPE dd], []) => let                  (BV.nan,                fn (y, [Ty.SHAPE dd], []) => let
340                                              val nan = IL.LIT(Literal.Float(FloatLit.nan))                                              val nan = IR.LIT(Literal.Real(RealLit.nan))
341                                              fun mk (y, [], stms) = IL.ASSGN(y, nan) :: stms                                              fun mk (y, [], stms) = IR.ASSGN(y, nan) :: stms
342                                                | mk (y, d::dd, stms) = let                                                | mk (y, d::dd, stms) = let
343                                                    val ty = shapeVarToTensor(Ty.SHAPE dd)                                                    val ty = shapeVarToTensor(Ty.SHAPE dd)
344                                                    val zs = List.tabulate(d, fn _ => IL.Var.new("_nan", ty))                                                    val zs = List.tabulate(d, fn _ => IR.Var.new("_nan", ty))
345                                                    in                                                    in
346                                                      IL.ASSGN(y, IL.CONS(IL.Var.ty y, zs)) ::                                                      IR.ASSGN(y, IR.CONS(zs, IR.Var.ty y)) ::
347                                                        List.foldl (fn (z, stms) => mk(z, dd, stms)) stms zs                                                        List.foldl (fn (z, stms) => mk(z, dd, stms)) stms zs
348                                                    end                                                    end
349                                              in                                              in
# Line 250  Line 351 
351                                              end),                                              end),
352                  (BV.subscript,          fn (y, [tv, Ty.DIM d], args) =>                  (BV.subscript,          fn (y, [tv, Ty.DIM d], args) =>
353                                            assign(y,                                            assign(y,
354                                              Op.SeqSub(DstTy.SeqTy(trType tv, d)),                                              Op.SeqSub(DstTy.SeqTy(trType tv, SOME d)),
355                                              args)),                                              args)),
356                  (BV.dynSubscript,       fn (y, [tv], args) =>                  (BV.dynSubscript,       fn (y, [tv], args) =>
357                                            assign(y, Op.SeqSub(DstTy.DynSeqTy(trType tv)), args)),                                            assign(y, Op.SeqSub(DstTy.SeqTy(trType tv, NONE)), args)),
358                (* image operations *)                (* image operations *)
359                  (BV.fn_size,            fn (y, [Ty.DIM d, _], [img]) => let                  (BV.fn_size,            fn (y, [Ty.DIM d, _], [img]) => let
360                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
361                                          (* we extract each dimension separately and then build the sequence value *)                                          (* we extract each dimension separately and then build the sequence value *)
362                                            val dims = List.tabulate(d, fn i => IL.Var.new("i"^Int.toString i, DstTy.IntTy))                                            val dims = List.tabulate(d, fn i => IR.Var.new("i"^Int.toString i, DstTy.IntTy))
363                                            fun mkStms ([], _, stms) = stms (* in reverse order! *)                                            fun mkStms ([], _, stms) = stms (* in reverse order! *)
364                                              | mkStms (d::dr, i, stms) = mkStms (dr, i+1,                                              | mkStms (d::dr, i, stms) = mkStms (dr, i+1,
365                                                  IL.ASSGN(d, IL.OP(Op.ImageDim(info, i), [img])) :: stms)                                                  IR.ASSGN(d, IR.OP(Op.ImageDim(info, i), [img])) :: stms)
366                                            in                                            in
367                                              List.revAppend (mkStms (dims, 0, []), [                                              List.revAppend (mkStms (dims, 0, []), [
368                                                  IL.ASSGN(y, IL.CONS(DstTy.SeqTy(DstTy.intTy, d), dims))                                                  IR.ASSGN(y, IR.SEQ(dims, DstTy.SeqTy(DstTy.intTy, SOME d)))
369                                                ])                                                ])
370                                            end),                                            end),
371                  (BV.image_border,       fn (y, _, args as [img, _]) => let                  (BV.image_border,       fn (y, _, args as [img, _]) => let
372                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
373                                            in                                            in
374                                              assign(y, Op.BorderCtlDefault info, args)                                              assign(y, Op.BorderCtlDefault info, args)
375                                            end),                                            end),
376                  (BV.image_clamp,        fn (y, _, args as [img]) => let                  (BV.image_clamp,        fn (y, _, args as [img]) => let
377                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
378                                            in                                            in
379                                              assign(y, Op.BorderCtlClamp info, args)                                              assign(y, Op.BorderCtlClamp info, args)
380                                            end),                                            end),
381                  (BV.image_mirror,       fn (y, _, args as [img]) => let                  (BV.image_mirror,       fn (y, _, args as [img]) => let
382                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
383                                            in                                            in
384                                              assign(y, Op.BorderCtlMirror info, args)                                              assign(y, Op.BorderCtlMirror info, args)
385                                            end),                                            end),
386                  (BV.image_wrap,         fn (y, _, args as [img]) => let                  (BV.image_wrap,         fn (y, _, args as [img]) => let
387                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
388                                            in                                            in
389                                              assign(y, Op.BorderCtlWrap info, args)                                              assign(y, Op.BorderCtlWrap info, args)
390                                            end)                                            end)
# Line 297  Line 398 
398             of SOME transFn => transFn(y, mvs, xs)             of SOME transFn => transFn(y, mvs, xs)
399              | NONE => raise Fail("TranslateBasis.translate: unknown basis function " ^ Var.uniqueNameOf f)              | NONE => raise Fail("TranslateBasis.translate: unknown basis function " ^ Var.uniqueNameOf f)
400            (* end case *))            (* end case *))
401  handle ex => (print(concat["translate (", IL.Var.toString y, ", ",  handle ex => (print(concat["translate (", IR.Var.toString y, ", ",
402  Var.uniqueNameOf f, ", ...)\n"]); raise ex)  Var.uniqueNameOf f, ", ...)\n"]); raise ex)
403    
404    end    end

Legend:
Removed from v.3476  
changed lines
  Added in v.3478

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