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 3484, Sat Dec 5 15:33:56 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.exp_ri,             simpleOp Op.Power),                  (BV.mul_fs,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [s, f]) =>
157                  (BV.exp_rr,             basisFn MathFuns.pow),                                            [assignEin(y, Mk.mulSF(d, dd), [f, s])]),
158                  (BV.curl2D,             fn (y, _, xs) => assign(y, Op.CurlField 2, xs)),                  (BV.mul_st,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
159                  (BV.curl3D,             fn (y, _, xs) => assign(y, Op.CurlField 3, xs)),                                            [assignEin(y, Mk.mulST(d, dd), List.rev xs)]),
160                  (BV.convolve_vk,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>                  (BV.mul_ts,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
161                                            assign(y, Op.Field(DstTy.TensorTy[d], DstTy.TensorTy dd), xs)),                                            [assignEin(y, Mk.mulST(d, dd), xs)]),
162                  (BV.convolve_kv,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [k, v]) =>                  (BV.div_rr,             fn (y, _, args) => [assignEin(y, Mk.divRR, args)]),
163                                            assign(y, Op.Field(DstTy.TensorTy[d], DstTy.TensorTy dd), [v, k])),                  (BV.div_tr,             fn (y, [shp], xs) => let
164                  (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
165                  (BV.neg_t,              tensorOp Op.Neg),                                            val rator = Mk.divTR dd1
166                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),                                            in
167                  (BV.op_probe,           fn (y, [_, dv, sv], xs) =>                                              [assignEin(y, rator, xs)]
168                                            assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),                                            end),
169                  (BV.op_D,               fn (y, _, xs) => assign(y, Op.DiffField, xs)),                  (BV.div_fr,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
170                  (BV.op_Dotimes,         fn (y, _, xs) => assign(y, Op.DiffField, xs)),                                            [assignEin(y, Mk.divFR(d, dd), xs)]),
171                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                  (BV.div_fs,             fn (y, [_, _, Ty.DIM d, Ty.SHAPE dd], xs) =>
172                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                            [assignEin(y, Mk.divFS(d, dd), xs)]),
173                                              | ty => assign(y, Op.Norm ty, xs)                  (BV.div_ss,             fn (y, [_, Ty.DIM d], xs) =>
174                                            (* end case *))),                                            [assignEin(y, Mk.divSS d, xs)]),
175                  (BV.op_not,             simpleOp Op.Not),                  (BV.pow_ri,             simpleOp Op.Power),
176                  (BV.op_cross,           simpleOp Op.Cross),  (* FIXME: BV.pos_rr *)
177                  (BV.op_outer,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>                  (BV.pow_si,             fn (y, [_, Ty.DIM d1], [f, n]) => let
178                                            assign (y, Op.Outer(DstTy.tensorTy[d1, d2]), xs)),                                            fun getN x  = (case IR.Var.binding x
179                  (BV.op_inner,           fn (y, [Ty.SHAPE dd1, Ty.SHAPE dd2, _], xs) => let                                                   of IR.VB_RHS(IR.LIT(Literal.Int n)) => IntInf.toInt n
180                                            val ty1 = DstTy.TensorTy dd1                                                    | vb => raise Fail (String.concat[
181                                            val ty2 = DstTy.TensorTy dd2  (* FIXME: should catch this earlier, where we can generate an error message! *)
182                                            val rator = (case (dd1, dd2)                                                          "Not a constant integer, ", IR.Var.toString x,
183                                                   of ([d], [d']) => Op.Dot ty1                                                          " found ", IR.vbToString vb, "\n"
                                                   | ([d1], [d1', d2]) => Op.MulVecMat ty2  
                                                   | ([d1, d2], [d2']) => Op.MulMatVec ty1  
                                                   | ([d1, d2], [d2', d3]) => Op.MulMatMat(ty1, ty2)  
                                                   | ([d1], [d1', d2, d3]) => Op.MulVecTen3 ty2  
                                                   | ([d1, d2, d3], [d3']) => Op.MulTen3Vec ty1  
                                                   | _ => raise Fail(concat[  
                                                         "unsupported inner-product: ",  
                                                         DstTy.toString ty1, " * ", DstTy.toString ty2  
184                                                        ])                                                        ])
185                                                  (* end case *))                                                  (* end case *))
186                                            in                                            in
187                                              assign (y, rator, xs)                                              [assignEin(y, Mk.powF(d1, getN n), [f])]
188                                              end),
189                    (BV.curl2D,             simpleEOp Mk.curl2d),
190                    (BV.curl3D,             simpleEOp Mk.curl3d),
191                    (BV.convolve_vk,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
192                                              [assignEin(y, Mk.conv(d, dd), xs)]),
193                    (BV.convolve_kv,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
194                                              [assignEin(y, Mk.conv(d, dd), xs)]),
195                    (BV.neg_t,              fn (y, [shp], xs) => let
196                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
197                                              val rator = Mk.negTT dd1
198                                              in
199                                                [assignEin(y, rator, xs)]
200                                              end),
201                    (BV.neg_f,              fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
202                                              [assignEin(y, Mk.negFF(d, dd), xs)]),
203                    (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
204                                              [assignEin(y, (Mk.probe(dd, d)), xs)]),
205                    (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>
206                                              if (d = 2) orelse (d = 3)
207                                                then [assignEin(y, Mk.grad [d], xs)]
208                                                else raise Fail "unsupported gradient"),
209                    (BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) =>
210                                              [assignEin(y, Mk.dotimes(d1, dd@[d2]), xs)]),
211                    (BV.op_Ddot,            fn (y, [_, Ty.DIM d1,  Ty.SHAPE dd, Ty.DIM d2], xs) =>
212                                              [assignEin(y, Mk.divergence(d1, dd), xs)] ),
213    (* FIXME: should scalar norm be an op or an EIN?
214                    (BV.op_norm_t,          fn (y, [sv], xs) =>  assign(y, Op.Norm(shapeVarToTensor sv), xs)),
215    *)
216                    (BV.op_norm_f,          fn (y, [ _, Ty.DIM d1, Ty.SHAPE dd], xs) =>
217                                              [assignEin(y, Mk.magnitudeFF(d1, dd), xs@xs)]),
218                    (BV.op_not,             simpleOp Op.Not),
219                    (BV.op_cross3_tt,       simpleEOp Mk.cross3TT),
220                    (BV.op_cross2_tt,       simpleEOp Mk.cross2TT),
221                    (BV.op_cross2_ff,       simpleEOp Mk.cross2FF),
222                    (BV.op_cross3_ff,       simpleEOp Mk.cross3FF),
223                    (BV.op_outer_tt,        fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
224                                              [assignEin(y, (Mk.outerTT(d1, d2)), xs)]),
225                    (BV.op_outer_mt,        fn (y, [Ty.DIM d1, Ty.DIM d2, Ty.DIM d3], xs) =>
226                                              [assignEin(y, (Mk.outerMT([d1, d2], d3)), xs)]),
227                    (BV.op_outer_tm,        fn (y, [Ty.DIM d1, Ty.DIM d2, Ty.DIM d3], xs) =>
228                                              [assignEin(y, (Mk.outerTM(d1, [ d2, d3])), xs)]),
229                    (BV.op_outer_ff,        fn (y, [_, Ty.DIM d1, Ty.DIM i, Ty.DIM j], xs)=>
230                                              [assignEin(y, Mk.outerFF(d1, i, j), xs)]),
231                    (BV.op_inner_tt,        fn (y, [sh1, sh2, _], xs) => let
232                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
233                                              val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
234                                              in
235                                                [assignEin(y, (Mk.innerTT(dd1, dd2)), xs)]
236                                            end),                                            end),
237                  (BV.op_colon,           fn (y, [sh1, sh2, _], xs) => let                  (BV.op_inner_tf,        fn (y, [_, Ty.DIM d, sh1, Ty.SHAPE dd2, _], xs) =>let
238                                            val ty1 = shapeVarToTensor sh1                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
                                           val ty2 = shapeVarToTensor sh2  
239                                            in                                            in
240                                              assign (y, Op.ColonMul(ty1, ty2), xs)                                              [assignEin(y, Mk.innerTF(dd1, d, dd2), xs)]
241                                            end),                                            end),
242                  (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) =>                  (BV.op_inner_ft,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd1, sh2, _], xs) =>let
243                                            assign(y, Op.Inside d, xs)),                                            val ty1 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
244                                              in
245                                                [assignEin(y, Mk.innerFT(dd1, d, dd2), xs)]
246                                              end),
247                    (BV.op_inner_ff,        fn (y,  [_, _, Ty.DIM d, Ty.SHAPE dd1, Ty.SHAPE dd2, _], xs) =>
248                                              [assignEin(y, Mk.innerFF(dd1, d, dd2), xs)]),
249                    (BV.op_colon_tt,        fn (y, [sh1, sh2, _], xs) => let
250                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
251                                              val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
252                                              in
253                                                [assignEin(y, Mk.colonTT(dd1, dd2), xs)]
254                                              end),
255                    (BV.op_colon_ft,        fn (y, [_, Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE dd2, _], xs) =>
256                                              [assignEin(y, Mk.colonFT(d, dd1, dd2), xs)]),
257                    (BV.op_colon_tf,        fn (y, [_, Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE dd2, _], xs) =>
258                                              [assignEin(y, Mk.colonTF(d, dd1, dd2), xs)]),
259                    (BV.op_colon_ff,        fn (y, [_, Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE dd2, _], xs) =>
260                                              [assignEin(y, Mk.colonFF(d, dd1, dd2), xs)]),
261                    (*  modulate is vector * vector pointwise multiplication *)
262                    (BV.fn_modulate,        fn (y, [Ty.DIM dd1], xs) =>
263                                              [assignEin(y, (Mk.modulate dd1), xs)]),
264    (* FIXME: should scalar normormalize be an op or an EIN?
265                    (BV.fn_normalize_t,     fn (y, [shp], xs) => let
266                                              val DstTy.TensorTy dd1 = shapeVarToTensor shp
267                                              in
268                                                case dd1
269                                                 of [_] => assign(y, Op.Normalize(DstTy.TensorTy dd1), xs)
270    (* FIXME: looks right but causes precision error for regresstion tests. change later *)
271                                                  | _ => [assignEin(y, Mk.normalizeTT dd1, xs@xs)]
272                                                (* end case *)
273                                              end),
274    *)
275                    (BV.fn_normalize_f,     fn (y, [ _, Ty.DIM d1, Ty.SHAPE dd], xs) => (case dd
276                                               of [] => [assignEin(y, Mk.normalizeFF(d1, []), xs)]
277                                                | _ => [assignEin(y, Mk.normalizeFF(d1, dd), xs@xs)]
278                                              (* end case *))),
279                    (BV.fn_trace_t,         fn (y, [Ty.DIM d], xs) =>
280                                              [assignEin(y, (Mk.traceT d), xs)]),
281                    (BV.fn_trace_f,         fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
282                                              [assignEin(y, Mk.traceF(d, dd), xs)]),
283                    (BV.fn_transpose_t,     fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
284                                              [assignEin(y, (Mk.transposeT [d1, d2]), xs)]),
285                    (BV.fn_transpose_f,     fn (y, [_, Ty.DIM d1, Ty.DIM d2, Ty.DIM d3], xs) =>
286                                              [assignEin(y, (Mk.transposeF (d1, d2, d3)), xs)]),
287                    (BV.fn_det2_t,          simpleEOp (Mk.det2T)),
288                    (BV.fn_det3_t,          simpleEOp (Mk.det3T)),
289                    (BV.fn_det2_f,          simpleEOp (Mk.det2F)),
290                    (BV.fn_det3_f,          simpleEOp (Mk.det3F)),
291    (* FIXME: BV.fn_sqrt_r *)
292                    (BV.fn_sqrt_s,          fn (y, [_, Ty.DIM d1], xs) =>
293                                              [assignEin(y, Mk.sqrtF d1, xs)]),
294    (* FIXME: BV.fn_cos_r *)
295                    (BV.fn_cos_s,           fn (y, [_, Ty.DIM d1], xs) =>
296                                              [assignEin(y, Mk.cosF d1, xs)]),
297    (* FIXME: BV.fn_acos_r *)
298                    (BV.fn_acos_s,          fn (y, [_, Ty.DIM d1], xs) =>
299                                              [assignEin(y, Mk.acosF d1, xs)]),
300    (* FIXME: BV.fn_sin_r *)
301                    (BV.fn_sin_s,           fn (y, [_, Ty.DIM d1], xs) =>
302                                              [assignEin(y, Mk.sinF d1, xs)]),
303    (* FIXME: BV.fn_asin_r *)
304                    (BV.fn_asin_s,          fn (y, [_, Ty.DIM d1], xs) =>
305                                              [assignEin(y, Mk.asinF d1, xs)]),
306    (* FIXME: BV.fn_tan_r *)
307                    (BV.fn_tan_s,           fn (y, [_, Ty.DIM d1], xs) =>
308                                              [assignEin(y, Mk.tanF d1, xs)]),
309    (* FIXME: BV.fn_atan_r *)
310                    (BV.fn_atan_s,          fn (y, [_, Ty.DIM d1], xs) =>
311                                              [assignEin(y, Mk.atanF d1, xs)]),
312                    (BV.fn_exp_r,           fn (y, _, xs) =>
313                                              [assignEin(y, Mk.expT, xs)]),
314                    (BV.fn_exp_s,           fn (y, [_, Ty.DIM d1], xs) =>
315                                              [assignEin(y, Mk.expF d1, xs)]),
316                    (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
317                    (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, xs)),
318                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
319                  (BV.clamp_vvv,          vectorOp Op.Clamp),                  (BV.clamp_vvv,          vectorOp Op.Clamp),
320                  (BV.lerp3,              tensorOp Op.Lerp),                  (BV.lerp3,              tensorOp Op.Lerp),
321                  (BV.lerp5,              fn (y, [sv], [a, b, x0, x, x1]) => let                  (BV.lerp5,              fn (y, [sv], [a, b, x0, x, x1]) => let
322                                            val t1 = IL.Var.new("t1", DstTy.realTy)                                            val t1 = IR.Var.new("t1", DstTy.realTy)
323                                            val t2 = IL.Var.new("t2", DstTy.realTy)                                            val t2 = IR.Var.new("t2", DstTy.realTy)
324                                            val t3 = IL.Var.new("t3", DstTy.realTy)                                            val t3 = IR.Var.new("t3", DstTy.realTy)
325                                            in [                                            in [
326                                              IL.ASSGN(t1, IL.OP(Op.Sub DstTy.realTy, [x, x0])),                                              assignEin(t1, Mk.subRR, [x, x0]),
327                                              IL.ASSGN(t2, IL.OP(Op.Sub DstTy.realTy, [x1, x0])),                                              assignEin(t2, Mk.subRR, [x1, x0]),
328                                              IL.ASSGN(t3, IL.OP(Op.Div DstTy.realTy, [t1, t2])),                                              assignEin(t3, Mk.divRR, [t1, t2]),
329                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))                                              IR.ASSGN(y, IR.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))
330                                            ] end),                                            ] end),
331                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),
332                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
333                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),
334                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),
335                  (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])),
336                  (BV.fn_max,             simpleOp Op.Max),                  (BV.fn_abs_i,           simpleOp (Op.Abs DstTy.IntTy)),
337                  (BV.fn_min,             simpleOp Op.Min),                  (BV.fn_abs_r,           simpleOp (Op.Abs DstTy.realTy)),
338                  (BV.fn_modulate,        vectorOp Op.Mul),                  (BV.fn_max_i,           simpleOp (Op.Max DstTy.IntTy)),
339                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (BV.fn_max_r,           simpleOp (Op.Max DstTy.realTy)),
340                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_min_i,           simpleOp (Op.Min DstTy.IntTy)),
341                  (BV.fn_trace,           fn (y, [dv], xs) => assign(y, Op.Trace(dimVarToMatrix dv), xs)),                  (BV.fn_min_r,           simpleOp (Op.Min DstTy.realTy)),
                 (BV.fn_transpose,       fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>  
                                           assign(y, Op.Transpose(d1, d2), xs)),  
342                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
343                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
344                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
                 (BV.kn_c2ctmr,          kernel Kernel.ctmr),  
345                  (BV.kn_c4hexic,         kernel Kernel.c4hexic),                  (BV.kn_c4hexic,         kernel Kernel.c4hexic),
346                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
                 (BV.kn_c1tent,          kernel Kernel.tent),  
                 (BV.kn_c2tent,          kernel Kernel.tent),  
347                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
348                  (BV.identity,           fn (y, [Ty.DIM d], []) =>                  (BV.identity,           fn (y, [Ty.DIM d], xs) =>
349                                            assign(y, Op.Identity d, [])),                                            [assignEin(y, Mk.identity d, xs)]),
350                  (BV.zero,               fn (y, [sv], []) =>                  (BV.zero,               fn (y, [Ty.SHAPE dd], []) =>
351                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            [assignEin(y, Mk.zeros dd, [])]),
352                  (BV.nan,                fn (y, [Ty.SHAPE dd], []) => let                  (BV.nan,                fn (y, [Ty.SHAPE dd], []) => let
353                                              val nan = IL.LIT(Literal.Float(FloatLit.nan))                                              val nan = IR.LIT(Literal.Real(RealLit.nan))
354                                              fun mk (y, [], stms) = IL.ASSGN(y, nan) :: stms                                              fun mk (y, [], stms) = IR.ASSGN(y, nan) :: stms
355                                                | mk (y, d::dd, stms) = let                                                | mk (y, d::dd, stms) = let
356                                                    val ty = shapeVarToTensor(Ty.SHAPE dd)                                                    val ty = shapeVarToTensor(Ty.SHAPE dd)
357                                                    val zs = List.tabulate(d, fn _ => IL.Var.new("_nan", ty))                                                    val zs = List.tabulate(d, fn _ => IR.Var.new("_nan", ty))
358                                                    in                                                    in
359                                                      IL.ASSGN(y, IL.CONS(IL.Var.ty y, zs)) ::                                                      IR.ASSGN(y, IR.CONS(zs, IR.Var.ty y)) ::
360                                                        List.foldl (fn (z, stms) => mk(z, dd, stms)) stms zs                                                        List.foldl (fn (z, stms) => mk(z, dd, stms)) stms zs
361                                                    end                                                    end
362                                              in                                              in
# Line 250  Line 364 
364                                              end),                                              end),
365                  (BV.subscript,          fn (y, [tv, Ty.DIM d], args) =>                  (BV.subscript,          fn (y, [tv, Ty.DIM d], args) =>
366                                            assign(y,                                            assign(y,
367                                              Op.SeqSub(DstTy.SeqTy(trType tv, d)),                                              Op.SeqSub(DstTy.SeqTy(trType tv, SOME d)),
368                                              args)),                                              args)),
369                  (BV.dynSubscript,       fn (y, [tv], args) =>                  (BV.dynSubscript,       fn (y, [tv], args) =>
370                                            assign(y, Op.SeqSub(DstTy.DynSeqTy(trType tv)), args)),                                            assign(y, Op.SeqSub(DstTy.SeqTy(trType tv, NONE)), args)),
371                (* image operations *)                (* image operations *)
372                  (BV.fn_size,            fn (y, [Ty.DIM d, _], [img]) => let                  (BV.fn_size,            fn (y, [Ty.DIM d, _], [img]) => let
373                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
374                                          (* we extract each dimension separately and then build the sequence value *)                                          (* we extract each dimension separately and then build the sequence value *)
375                                            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))
376                                            fun mkStms ([], _, stms) = stms (* in reverse order! *)                                            fun mkStms ([], _, stms) = stms (* in reverse order! *)
377                                              | mkStms (d::dr, i, stms) = mkStms (dr, i+1,                                              | mkStms (d::dr, i, stms) = mkStms (dr, i+1,
378                                                  IL.ASSGN(d, IL.OP(Op.ImageDim(info, i), [img])) :: stms)                                                  IR.ASSGN(d, IR.OP(Op.ImageDim(info, i), [img])) :: stms)
379                                            in                                            in
380                                              List.revAppend (mkStms (dims, 0, []), [                                              List.revAppend (mkStms (dims, 0, []), [
381                                                  IL.ASSGN(y, IL.CONS(DstTy.SeqTy(DstTy.intTy, d), dims))                                                  IR.ASSGN(y, IR.SEQ(dims, DstTy.SeqTy(DstTy.intTy, SOME d)))
382                                                ])                                                ])
383                                            end),                                            end),
384                  (BV.image_border,       fn (y, _, args as [img, _]) => let                  (BV.image_border,       fn (y, _, args as [img, _]) => let
385                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
386                                            in                                            in
387                                              assign(y, Op.BorderCtlDefault info, args)                                              assign(y, Op.BorderCtlDefault info, args)
388                                            end),                                            end),
389                  (BV.image_clamp,        fn (y, _, args as [img]) => let                  (BV.image_clamp,        fn (y, _, args as [img]) => let
390                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
391                                            in                                            in
392                                              assign(y, Op.BorderCtlClamp info, args)                                              assign(y, Op.BorderCtlClamp info, args)
393                                            end),                                            end),
394                  (BV.image_mirror,       fn (y, _, args as [img]) => let                  (BV.image_mirror,       fn (y, _, args as [img]) => let
395                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
396                                            in                                            in
397                                              assign(y, Op.BorderCtlMirror info, args)                                              assign(y, Op.BorderCtlMirror info, args)
398                                            end),                                            end),
399                  (BV.image_wrap,         fn (y, _, args as [img]) => let                  (BV.image_wrap,         fn (y, _, args as [img]) => let
400                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
401                                            in                                            in
402                                              assign(y, Op.BorderCtlWrap info, args)                                              assign(y, Op.BorderCtlWrap info, args)
403                                            end)                                            end),
404                    (BV.dist2_t,            simpleOp (Op.Dist(DstTy.TensorTy[2]))),
405                    (BV.dist3_t,            simpleOp (Op.Dist(DstTy.TensorTy[3]))),
406                    (BV.red_all,            fn (y, _, args as [e, v, k]) =>
407                                              assign(y, Op.R_All(IR.Var.ty v), args)),
408                    (BV.red_exists,         fn (y, _, args as [e, v, k]) =>
409                                              assign(y, Op.R_Exists(IR.Var.ty v), args)),
410                    (BV.red_max,            fn (y, _, args as [e, v, k]) =>
411                                              assign(y, Op.R_Max(IR.Var.ty v), args)),
412                    (BV.red_mean,           fn (y, _, args as [e, v, k]) =>
413                                              assign(y, Op.R_Mean(IR.Var.ty v), args)),
414                    (BV.red_min,            fn (y, _, args as [e, v, k]) =>
415                                              assign(y, Op.R_Min(IR.Var.ty v), args)),
416                    (BV.red_product,        fn (y, _, args as [e, v, k]) =>
417                                              assign(y, Op.R_Product(IR.Var.ty v),args)),
418                    (BV.red_sum,            fn (y, _, args as [e, v, k]) =>
419                                              assign(y, Op.R_Sum(IR.Var.ty v), args)),
420                    (BV.red_variance,       fn (y, _, args as [e, v, k]) =>
421                                              assign(y, Op.R_Variance(IR.Var.ty v), args)),
422                    (BV.fn_sphere_im,       fn (y, [tv], args as [p, s]) =>
423                                              assign(y, Op.SphereQuery(IR.Var.ty p, trType tv), args)),
424                    (BV.fn_sphere1_r,       fn (y, [tv], args as [p, s]) =>
425                                              assign(y, Op.SphereQuery(IR.Var.ty p, trType tv), args)),
426                    (BV.fn_sphere2_t,       fn (y, [tv], args as [p, s]) =>
427                                              assign(y, Op.SphereQuery(IR.Var.ty p, trType tv), args)),
428                    (BV.fn_sphere3_t,       fn (y, [tv], args as [p, s]) =>
429                                              assign(y, Op.SphereQuery(IR.Var.ty p, trType tv), args))
430                ];                ];
           (* add C math functions *)  
             List.app (fn (n, x) => insert(x, basisFn n)) BV.mathFns;  
431              tbl              tbl
432            end            end
433    
# Line 297  Line 435 
435             of SOME transFn => transFn(y, mvs, xs)             of SOME transFn => transFn(y, mvs, xs)
436              | NONE => raise Fail("TranslateBasis.translate: unknown basis function " ^ Var.uniqueNameOf f)              | NONE => raise Fail("TranslateBasis.translate: unknown basis function " ^ Var.uniqueNameOf f)
437            (* end case *))            (* end case *))
438  handle ex => (print(concat["translate (", IL.Var.toString y, ", ",  handle ex => (print(concat["translate (", IR.Var.toString y, ", ",
439  Var.uniqueNameOf f, ", ...)\n"]); raise ex)  Var.uniqueNameOf f, ", ...)\n"]); raise ex)
440    
441    end    end

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

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