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 3495, Fri Dec 11 20:34:26 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        fun dist(y,dd1,xs)= let
78                val t0 = IL.Var.new("t0", DstTy.TensorTy(dd1))
79                in [assignEin(t0, Mk.subTT(dd1),xs),assignEin(y, Mk.normTT(dd1),[t0])] end
80    
81    
82    (* build a table that maps Basis variables to their translation functions *)    (* build a table that maps Basis variables to their translation functions *)
83      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
84            val tbl = VTbl.mkTable (128, Fail "Translate table")            val tbl = VTbl.mkTable (128, Fail "Translate table")
85            val insert = VTbl.insert tbl            fun insert (id, def) = (case VTbl.find tbl id
86                     of NONE => VTbl.insert tbl (id, def)
87                      | SOME _ => raise Fail("duplicate definition of " ^ Var.nameOf id)
88                    (* end case *))
89            in            in
90              List.app insert [              List.app insert [
91                  (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 112 
112                  (BV.mul_ii,             simpleOp Op.IMul),                  (BV.mul_ii,             simpleOp Op.IMul),
113                  (BV.div_ii,             simpleOp Op.IDiv),                  (BV.div_ii,             simpleOp Op.IDiv),
114                  (BV.op_mod,             simpleOp Op.IMod),                  (BV.op_mod,             simpleOp Op.IMod),
115                    (BV.neg_i,              simpleOp Op.INeg),
116                  (BV.add_ii,             simpleOp(Op.Add DstTy.IntTy)),                  (BV.add_tt,             fn (y, [shp], xs) => let
117                  (BV.add_tt,             tensorOp Op.Add),                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
118                  (BV.add_ff,             fn (y, _, [f, g]) => assign(y, Op.AddField, [f, g])),                                            val rator = Mk.addTT(dd1)
119                  (BV.add_fr,             fn (y, _, [f, s]) => assign(y, Op.OffsetField, [f, s])),                                            in
120                  (BV.add_rf,             fn (y, _, [s, f]) => assign(y, Op.OffsetField, [f, s])),                                              [assignEin(y, rator, xs)]
121                  (BV.sub_ii,             simpleOp(Op.Sub DstTy.IntTy)),                                            end),
122                  (BV.sub_tt,             tensorOp Op.Sub),                  (BV.add_ff,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
123                  (BV.sub_ff,             fn (y, _, [f, g]) => assign(y, Op.SubField, [f, g])),                                            [assignEin(y, Mk.addFF(d, dd), xs)]),
124                  (BV.sub_fr,             fn (y, _, [f, s]) => let                  (BV.add_ft,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [f, s]) =>
125                                            val s' = IL.Var.copy s                                            [assignEin(y, Mk.addTF(d, dd), [s, f])]),
126                                            in [                  (BV.add_tf,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
127                                              IL.ASSGN(s', IL.OP(Op.Neg DstTy.realTy, [s])),                                            [assignEin(y, Mk.addTF(d, dd), xs)]),
128                                              IL.ASSGN(y, IL.OP(Op.OffsetField, [f, s']))                  (BV.sub_tt,             fn (y, [shp], xs) => let
129                                            ] end),                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
130                  (BV.sub_rf,             fn (y, _, [s, f]) => let                                            val rator = Mk.subTT dd1
131                                            val f' = IL.Var.copy f                                            in
132                                            in [                                              [assignEin(y, rator, xs)]
133                                              IL.ASSGN(f', IL.OP(Op.NegField, [f])),                                            end),
134                                              IL.ASSGN(y, IL.OP(Op.OffsetField, [f', s]))                  (BV.sub_ff,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
135                                            ] end),                                            [assignEin(y, Mk.subFF(d, dd), xs)]),
136                  (BV.mul_ii,             simpleOp(Op.Mul DstTy.IntTy)),                  (BV.sub_ft,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [x1, x2]) =>
137                  (BV.mul_rr,             simpleOp(Op.Mul(DstTy.realTy))),                                            [assignEin(y, Mk.subFT(d, dd), [x2, x1])]),
138                  (BV.mul_rt,             tensorOp Op.Scale),                  (BV.sub_tf,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
139                  (BV.mul_tr,             fn (y, sv, [t, r]) => tensorOp Op.Scale (y, sv, [r, t])),                                            [assignEin(y, Mk.subTF(d, dd), xs)]),
140                  (BV.mul_rf,             fn (y, _, [s, f]) => assign(y, Op.ScaleField, [s, f])),                  (BV.mul_rr,             fn (y, _, args) => [assignEin(y, Mk.mulRR, args)]),
141                  (BV.mul_fr,             fn (y, _, [f, s]) => assign(y, Op.ScaleField, [s, f])),                  (BV.mul_rt,             fn (y, [shp], xs) => let
142                  (BV.div_ii,             simpleOp(Op.Div DstTy.IntTy)),                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
143                  (BV.div_rr,             simpleOp(Op.Div DstTy.realTy)),                                            val rator = Mk.mulRT(dd1)
144                  (BV.div_tr,             fn (y, [sv], [x, s]) => let                                            in
145                                            val one = IL.Var.new("one", DstTy.realTy)                                              [assignEin(y, rator, xs)]
146                                            val s' = IL.Var.new("sInv", DstTy.realTy)                                            end),
147                                            in [                  (BV.mul_tr,             fn (y, [shp], [t, r]) => let
148                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
149                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),                                            val rator = Mk.mulRT dd1
150                                              IL.ASSGN(y, IL.OP(Op.Scale(shapeVarToTensor sv), [s', x]))                                            in
151                                            ] end),                                              [assignEin(y, rator, [r, t])]
152                  (BV.div_fr,             fn (y, _, [f, s]) => let                                            end),
153                                            val one = IL.Var.new("one", DstTy.realTy)                  (BV.mul_rf,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
154                                            val s' = IL.Var.new("sInv", DstTy.realTy)                                            [assignEin(y, Mk.mulRF(d, dd), xs)]),
155                                            in [                  (BV.mul_fr,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [f, s]) =>
156                                              IL.ASSGN(one, IL.LIT(Literal.Float(FloatLit.one))),                                            [assignEin(y, Mk.mulRF(d, dd), [s, f])]),
157                                              IL.ASSGN(s', IL.OP(Op.Div DstTy.realTy, [one, s])),                  (BV.mul_ss,             fn (y, [_, Ty.DIM d], xs) =>
158                                              IL.ASSGN(y, IL.OP(Op.ScaleField, [s', f]))                                            [assignEin(y, Mk.mulSS d, xs)]),
159                                            ] end),                  (BV.mul_sf,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
160                  (BV.op_mod,             simpleOp Op.Mod),                                            [assignEin(y, Mk.mulSF(d, dd), xs)]),
161                  (BV.exp_ri,             simpleOp Op.Power),                  (BV.mul_fs,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [s, f]) =>
162                  (BV.exp_rr,             basisFn MathFuns.pow),                                            [assignEin(y, Mk.mulSF(d, dd), [f, s])]),
163                  (BV.curl2D,             fn (y, _, xs) => assign(y, Op.CurlField 2, xs)),                  (BV.mul_st,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
164                  (BV.curl3D,             fn (y, _, xs) => assign(y, Op.CurlField 3, xs)),                                            [assignEin(y, Mk.mulST(d, dd), List.rev xs)]),
165                  (BV.convolve_vk,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>                  (BV.mul_ts,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
166                                            assign(y, Op.Field(DstTy.TensorTy[d], DstTy.TensorTy dd), xs)),                                            [assignEin(y, Mk.mulST(d, dd), xs)]),
167                  (BV.convolve_kv,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], [k, v]) =>                  (BV.div_rr,             fn (y, _, args) => [assignEin(y, Mk.divRR, args)]),
168                                            assign(y, Op.Field(DstTy.TensorTy[d], DstTy.TensorTy dd), [v, k])),                  (BV.div_tr,             fn (y, [shp], xs) => let
169                  (BV.neg_i,              simpleOp(Op.Neg DstTy.IntTy)),                                            val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
170                  (BV.neg_t,              tensorOp Op.Neg),                                            val rator = Mk.divTR dd1
171                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),                                            in
172                  (BV.op_probe,           fn (y, [_, dv, sv], xs) =>                                              [assignEin(y, rator, xs)]
173                                            assign(y, Op.Probe(dimVarToTensor dv, shapeVarToTensor sv), xs)),                                            end),
174                  (BV.op_D,               fn (y, _, xs) => assign(y, Op.DiffField, xs)),                  (BV.div_fr,             fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
175                  (BV.op_Dotimes,         fn (y, _, xs) => assign(y, Op.DiffField, xs)),                                            [assignEin(y, Mk.divFR(d, dd), xs)]),
176                  (BV.op_norm,            fn (y, [sv], xs) => (case shapeVarToTensor sv                  (BV.div_fs,             fn (y, [_, _, Ty.DIM d, Ty.SHAPE dd], xs) =>
177                                             of DstTy.TensorTy[] => assign(y, Op.Abs DstTy.realTy, xs)                                            [assignEin(y, Mk.divFS(d, dd), xs)]),
178                                              | ty => assign(y, Op.Norm ty, xs)                  (BV.div_ss,             fn (y, [_, Ty.DIM d], xs) =>
179                                            (* end case *))),                                            [assignEin(y, Mk.divSS d, xs)]),
180                  (BV.op_not,             simpleOp Op.Not),                  (BV.pow_ri,             simpleOp Op.Power),
181                  (BV.op_cross,           simpleOp Op.Cross),  (* FIXME: BV.pos_rr *)
182                  (BV.op_outer,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>                  (BV.pow_si,             fn (y, [_, Ty.DIM d1], [f, n]) => let
183                                            assign (y, Op.Outer(DstTy.tensorTy[d1, d2]), xs)),                                            fun getN x  = (case IR.Var.binding x
184                  (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
185                                            val ty1 = DstTy.TensorTy dd1                                                    | vb => raise Fail (String.concat[
186                                            val ty2 = DstTy.TensorTy dd2  (* FIXME: should catch this earlier, where we can generate an error message! *)
187                                            val rator = (case (dd1, dd2)                                                          "Not a constant integer, ", IR.Var.toString x,
188                                                   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  
189                                                        ])                                                        ])
190                                                  (* end case *))                                                  (* end case *))
191                                            in                                            in
192                                              assign (y, rator, xs)                                              [assignEin(y, Mk.powF(d1, getN n), [f])]
193                                              end),
194                    (BV.curl2D,             simpleEOp Mk.curl2d),
195                    (BV.curl3D,             simpleEOp Mk.curl3d),
196                    (BV.convolve_vk,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
197                                              [assignEin(y, Mk.conv(d, dd), xs)]),
198                    (BV.convolve_kv,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
199                                              [assignEin(y, Mk.conv(d, dd), xs)]),
200                    (BV.neg_t,              fn (y, [shp], xs) => let
201                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor shp
202                                              val rator = Mk.negTT dd1
203                                              in
204                                                [assignEin(y, rator, xs)]
205                                              end),
206                    (BV.neg_f,              fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
207                                              [assignEin(y, Mk.negFF(d, dd), xs)]),
208                    (BV.op_probe,           fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
209                                              [assignEin(y, (Mk.probe(dd, d)), xs)]),
210                    (BV.op_D,               fn (y, [_, Ty.DIM d], xs) =>
211                                              if (d = 2) orelse (d = 3)
212                                                then [assignEin(y, Mk.grad [d], xs)]
213                                                else raise Fail "unsupported gradient"),
214                    (BV.op_Dotimes,         fn (y, [_, Ty.DIM d1, Ty.SHAPE dd, Ty.DIM d2], xs) =>
215                                              [assignEin(y, Mk.dotimes(d1, dd@[d2]), xs)]),
216                    (BV.op_Ddot,            fn (y, [_, Ty.DIM d1,  Ty.SHAPE dd, Ty.DIM d2], xs) =>
217                                              [assignEin(y, Mk.divergence(d1, dd), xs)] ),
218                    (BV.op_norm_t,            fn (y, [sv], xs) =>let
219                                            val DstTy.TensorTy dd1 = shapeVarToTensor sv
220                                            in (case (dd1,xs)
221                                                of ([],[arg0])=> [IL.ASSGN(y,IL.VAR arg0)]
222                                                | _ => [assignEin(y, Mk.normT(dd1),xs)])
223                                            end),
224                    (BV.op_norm_f,            fn (y, [ _,Ty.DIM d1, Ty.SHAPE dd1], xs) =>
225                                                (case (dd1,xs)
226                                                of ([],[arg0])=> [IL.ASSGN(y,IL.VAR arg0)]
227                                                | _ => [assignEin(y, Mk.normF(d1, dd1),xs)])),
228                    (BV.op_not,             simpleOp Op.Not),
229                    (BV.op_cross3_tt,       simpleEOp Mk.cross3TT),
230                    (BV.op_cross2_tt,       simpleEOp Mk.cross2TT),
231                    (BV.op_cross2_ff,       simpleEOp Mk.cross2FF),
232                    (BV.op_cross3_ff,       simpleEOp Mk.cross3FF),
233                    (BV.op_outer_tt,           fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
234                                                [assignEin(y, Mk.outerTT([d1],[d2]),xs)] ),
235                    (BV.op_outer_mt,           fn (y, [Ty.DIM d1, Ty.DIM d2,Ty.DIM d3], xs) =>
236                                                [assignEin(y, Mk.outerTT([d1,d2],[d3]),xs)] ),
237                    (BV.op_outer_tm,           fn (y, [Ty.DIM d1, Ty.DIM d2,Ty.DIM d3], xs) =>
238                                                [assignEin(y, Mk.outerTT([d1],[d2,d3]),xs)] ),
239                    (BV.op_outer_ff,      fn (y, [_, Ty.DIM d1,Ty.DIM i,Ty.DIM j], xs)=>
240                                                [assignEin(y, Mk.outerFF(d1,[i],[j]), xs)]),
241                    (BV.op_inner_tt,        fn (y, [sh1, sh2, _], xs) => let
242                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
243                                              val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
244                                              in
245                                                [assignEin(y, (Mk.innerTT(dd1, dd2)), xs)]
246                                              end),
247                    (BV.op_inner_tf,        fn (y, [_, Ty.DIM d, sh1, Ty.SHAPE dd2, _], xs) =>let
248                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
249                                              in
250                                                [assignEin(y, Mk.innerTF(dd1, d, dd2), xs)]
251                                              end),
252                    (BV.op_inner_ft,        fn (y, [_, Ty.DIM d, Ty.SHAPE dd1, sh2, _], xs) =>let
253                                              val ty1 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
254                                              in
255                                                [assignEin(y, Mk.innerFT(dd1, d, dd2), xs)]
256                                            end),                                            end),
257                  (BV.op_colon,           fn (y, [sh1, sh2, _], xs) => let                  (BV.op_inner_ff,        fn (y,  [_, _, Ty.DIM d, Ty.SHAPE dd1, Ty.SHAPE dd2, _], xs) =>
258                                            val ty1 = shapeVarToTensor sh1                                            [assignEin(y, Mk.innerFF(dd1, d, dd2), xs)]),
259                                            val ty2 = shapeVarToTensor sh2                  (BV.op_colon_tt,        fn (y, [sh1, sh2, _], xs) => let
260                                              val ty1 as DstTy.TensorTy dd1 = shapeVarToTensor sh1
261                                              val ty2 as DstTy.TensorTy dd2 = shapeVarToTensor sh2
262                                            in                                            in
263                                              assign (y, Op.ColonMul(ty1, ty2), xs)                                              [assignEin(y, Mk.colonTT(dd1, dd2), xs)]
264                                            end),                                            end),
265                  (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) =>                  (BV.op_colon_ft,        fn (y, [_, Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE dd2, _], xs) =>
266                                            assign(y, Op.Inside d, xs)),                                            [assignEin(y, Mk.colonFT(d, dd1, dd2), xs)]),
267                    (BV.op_colon_tf,        fn (y, [_, Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE dd2, _], xs) =>
268                                              [assignEin(y, Mk.colonTF(d, dd1, dd2), xs)]),
269                    (BV.op_colon_ff,        fn (y, [_, Ty.SHAPE dd1, Ty.DIM d, Ty.SHAPE dd2, _], xs) =>
270                                              [assignEin(y, Mk.colonFF(d, dd1, dd2), xs)]),
271                    (*  modulate is vector * vector pointwise multiplication *)
272                    (BV.fn_modulate,        fn (y, [Ty.DIM dd1], xs) =>
273                                              [assignEin(y, (Mk.modulate dd1), xs)]),
274                    (BV.fn_normalize_t,   fn (y, [shp], xs) =>let
275                                            val DstTy.TensorTy dd1 = shapeVarToTensor shp
276                                            in (case (dd1,xs)
277                                                of ([],[arg0])=> [IL.ASSGN(y,IL.VAR arg0)]
278                                                | (_,[arg0]) => [assignEin(y, Mk.normalizeTT(dd1),xs)]
279                                            (*end case*))
280                                            end),
281                    (BV.fn_normalize_f,   fn (y, [ _,Ty.DIM d1, Ty.SHAPE dd1], xs) =>
282                                            (case (dd1,xs)
283                                                of ([],[arg0])=> [IL.ASSGN(y,IL.VAR arg0)]
284                                                | (_,[arg0]) => [assignEin(y, Mk.normalizeFF(d1, dd1),xs@xs)]
285                                            end)),
286                    (BV.fn_trace_t,         fn (y, [Ty.DIM d], xs) =>
287                                              [assignEin(y, (Mk.traceT d), xs)]),
288                    (BV.fn_trace_f,         fn (y, [_, Ty.DIM d, Ty.SHAPE dd], xs) =>
289                                              [assignEin(y, Mk.traceF(d, dd), xs)]),
290                    (BV.fn_transpose_t,     fn (y, [Ty.DIM d1, Ty.DIM d2], xs) =>
291                                              [assignEin(y, (Mk.transposeT [d1, d2]), xs)]),
292                    (BV.fn_transpose_f,     fn (y, [_, Ty.DIM d1, Ty.DIM d2, Ty.DIM d3], xs) =>
293                                              [assignEin(y, (Mk.transposeF (d1, d2, d3)), xs)]),
294                    (BV.fn_det2_t,          simpleEOp (Mk.det2T)),
295                    (BV.fn_det3_t,          simpleEOp (Mk.det3T)),
296                    (BV.fn_det2_f,          simpleEOp (Mk.det2F)),
297                    (BV.fn_det3_f,          simpleEOp (Mk.det3F)),
298                    (BV.fn_sqrt_s,          fn (y, [_, Ty.DIM d1], xs) =>
299                                              [assignEin(y, Mk.sqrtF d1, xs)]),
300                    (BV.fn_sqrt_t,    fn (y, _, xs) =>
301                                                [assignEin(y, Mk.sqrtR, xs)]),
302    (*
303                    (BV.fn_cos_r,           fn (y, _, xs) =>
304                                                [assignEin(y, Mk.cosR, xs)]),
305    *)
306                    (BV.fn_cos_s,           fn (y, [_, Ty.DIM d1], xs) =>
307                                              [assignEin(y, Mk.cosF d1, xs)]),
308    (*
309                    (BV.fn_acos_r,           fn (y, _, xs) =>
310                                              [assignEin(y, Mk.acosR, xs)]),
311    *)
312                    (BV.fn_acos_s,          fn (y, [_, Ty.DIM d1], xs) =>
313                                              [assignEin(y, Mk.acosF d1, xs)]),
314    (*
315                    (BV.fn_sin_r,           fn (y, _, xs) =>
316                                                [assignEin(y, Mk.sinR, xs)]),
317    *)
318                    (BV.fn_sin_s,           fn (y, [_, Ty.DIM d1], xs) =>
319                                              [assignEin(y, Mk.sinF d1, xs)]),
320    (*
321                    (BV.fn_asin_r,           fn (y, _, xs) =>
322                                                [assignEin(y, Mk.asinR, xs)]),
323    *)
324                    (BV.fn_asin_s,          fn (y, [_, Ty.DIM d1], xs) =>
325                                              [assignEin(y, Mk.asinF d1, xs)]),
326    (*
327                    (BV.fn_tan_r,           fn (y, _, xs) =>
328                                                [assignEin(y, Mk.tanR, xs)]),
329    *)
330                    (BV.fn_tan_s,           fn (y, [_, Ty.DIM d1], xs) =>
331                                              [assignEin(y, Mk.tanF d1, xs)]),
332    (*
333                    (BV.fn_atan_r,           fn (y, _, xs) =>
334                                               [assignEin(y, Mk.atanR, xs)]),
335    *)
336                    (BV.fn_atan_s,          fn (y, [_, Ty.DIM d1], xs) =>
337                                              [assignEin(y, Mk.atanF d1, xs)]),
338                    (BV.fn_exp_r,           fn (y, _, xs) =>
339                                              [assignEin(y, Mk.expT, xs)]),
340                    (BV.fn_exp_s,           fn (y, [_, Ty.DIM d1], xs) =>
341                                              [assignEin(y, Mk.expF d1, xs)]),
342                    (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
343                    (BV.fn_inside,          fn (y, [_, Ty.DIM d, _], xs) => assign(y, Op.Inside d, xs)),
344                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),                  (BV.clamp_rrr,          simpleOp (Op.Clamp DstTy.realTy)),
345                  (BV.clamp_vvv,          vectorOp Op.Clamp),                  (BV.clamp_vvv,          vectorOp Op.Clamp),
346                  (BV.lerp3,              tensorOp Op.Lerp),                  (BV.lerp3,              tensorOp Op.Lerp),
347                  (BV.lerp5,              fn (y, [sv], [a, b, x0, x, x1]) => let                  (BV.lerp5,              fn (y, [sv], [a, b, x0, x, x1]) => let
348                                            val t1 = IL.Var.new("t1", DstTy.realTy)                                            val t1 = IR.Var.new("t1", DstTy.realTy)
349                                            val t2 = IL.Var.new("t2", DstTy.realTy)                                            val t2 = IR.Var.new("t2", DstTy.realTy)
350                                            val t3 = IL.Var.new("t3", DstTy.realTy)                                            val t3 = IR.Var.new("t3", DstTy.realTy)
351                                            in [                                            in [
352                                              IL.ASSGN(t1, IL.OP(Op.Sub DstTy.realTy, [x, x0])),                                              assignEin(t1, Mk.subRR, [x, x0]),
353                                              IL.ASSGN(t2, IL.OP(Op.Sub DstTy.realTy, [x1, x0])),                                              assignEin(t2, Mk.subRR, [x1, x0]),
354                                              IL.ASSGN(t3, IL.OP(Op.Div DstTy.realTy, [t1, t2])),                                              assignEin(t3, Mk.divRR, [t1, t2]),
355                                              IL.ASSGN(y,  IL.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))                                              IR.ASSGN(y, IR.OP(Op.Lerp(shapeVarToTensor sv), [a, b, t3]))
356                                            ] end),                                            ] end),
357                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),                  (BV.evals2x2,           eigenVal (Op.Eigen2x2, 2)),
358                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),                  (BV.evals3x3,           eigenVal (Op.Eigen3x3, 3)),
359                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),                  (BV.evecs2x2,           eigenVec (Op.Eigen2x2, 2)),
360                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),                  (BV.evecs3x3,           eigenVec (Op.Eigen3x3, 3)),
361                  (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])),
362                  (BV.fn_max,             simpleOp Op.Max),                  (BV.fn_abs_i,           simpleOp (Op.Abs DstTy.IntTy)),
363                  (BV.fn_min,             simpleOp Op.Min),                  (BV.fn_abs_r,           simpleOp (Op.Abs DstTy.realTy)),
364                  (BV.fn_modulate,        vectorOp Op.Mul),                  (BV.fn_max_i,           simpleOp (Op.Max DstTy.IntTy)),
365                  (BV.fn_normalize,       vectorOp Op.Normalize),                  (BV.fn_max_r,           simpleOp (Op.Max DstTy.realTy)),
366                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_min_i,           simpleOp (Op.Min DstTy.IntTy)),
367                  (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)),  
368                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
369                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
370                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
                 (BV.kn_c2ctmr,          kernel Kernel.ctmr),  
371                  (BV.kn_c4hexic,         kernel Kernel.c4hexic),                  (BV.kn_c4hexic,         kernel Kernel.c4hexic),
372                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
                 (BV.kn_c1tent,          kernel Kernel.tent),  
                 (BV.kn_c2tent,          kernel Kernel.tent),  
373                  (BV.i2r,                simpleOp Op.IntToReal),                  (BV.i2r,                simpleOp Op.IntToReal),
374                  (BV.identity,           fn (y, [Ty.DIM d], []) =>                  (BV.identity,           fn (y, [Ty.DIM d], xs) =>
375                                            assign(y, Op.Identity d, [])),                                            [assignEin(y, Mk.identity d, xs)]),
376    (* FIXME: eventually zero should be implemented by Ein
377                    (BV.zero,               fn (y, [Ty.SHAPE dd], []) =>
378                                              [assignEin(y, Mk.zeros dd, [])]),
379    *)
380                  (BV.zero,               fn (y, [sv], []) =>                  (BV.zero,               fn (y, [sv], []) =>
381                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),                                            assign(y, Op.Zero(shapeVarToTensor sv), [])),
382                  (BV.nan,                fn (y, [Ty.SHAPE dd], []) => let                  (BV.nan,                fn (y, [Ty.SHAPE dd], []) => let
383                                              val nan = IL.LIT(Literal.Float(FloatLit.nan))                                              val nan = IR.LIT(Literal.Real(RealLit.nan))
384                                              fun mk (y, [], stms) = IL.ASSGN(y, nan) :: stms                                              fun mk (y, [], stms) = IR.ASSGN(y, nan) :: stms
385                                                | mk (y, d::dd, stms) = let                                                | mk (y, d::dd, stms) = let
386                                                    val ty = shapeVarToTensor(Ty.SHAPE dd)                                                    val ty = shapeVarToTensor(Ty.SHAPE dd)
387                                                    val zs = List.tabulate(d, fn _ => IL.Var.new("_nan", ty))                                                    val zs = List.tabulate(d, fn _ => IR.Var.new("_nan", ty))
388                                                    in                                                    in
389                                                      IL.ASSGN(y, IL.CONS(IL.Var.ty y, zs)) ::                                                      IR.ASSGN(y, IR.CONS(zs, IR.Var.ty y)) ::
390                                                        List.foldl (fn (z, stms) => mk(z, dd, stms)) stms zs                                                        List.foldl (fn (z, stms) => mk(z, dd, stms)) stms zs
391                                                    end                                                    end
392                                              in                                              in
# Line 250  Line 394 
394                                              end),                                              end),
395                  (BV.subscript,          fn (y, [tv, Ty.DIM d], args) =>                  (BV.subscript,          fn (y, [tv, Ty.DIM d], args) =>
396                                            assign(y,                                            assign(y,
397                                              Op.SeqSub(DstTy.SeqTy(trType tv, d)),                                              Op.SeqSub(DstTy.SeqTy(trType tv, SOME d)),
398                                              args)),                                              args)),
399                  (BV.dynSubscript,       fn (y, [tv], args) =>                  (BV.dynSubscript,       fn (y, [tv], args) =>
400                                            assign(y, Op.SeqSub(DstTy.DynSeqTy(trType tv)), args)),                                            assign(y, Op.SeqSub(DstTy.SeqTy(trType tv, NONE)), args)),
401                (* image operations *)                (* image operations *)
402                  (BV.fn_size,            fn (y, [Ty.DIM d, _], [img]) => let                  (BV.fn_size,            fn (y, [Ty.DIM d, _], [img]) => let
403                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
404                                          (* we extract each dimension separately and then build the sequence value *)                                          (* we extract each dimension separately and then build the sequence value *)
405                                            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))
406                                            fun mkStms ([], _, stms) = stms (* in reverse order! *)                                            fun mkStms ([], _, stms) = stms (* in reverse order! *)
407                                              | mkStms (d::dr, i, stms) = mkStms (dr, i+1,                                              | mkStms (d::dr, i, stms) = mkStms (dr, i+1,
408                                                  IL.ASSGN(d, IL.OP(Op.ImageDim(info, i), [img])) :: stms)                                                  IR.ASSGN(d, IR.OP(Op.ImageDim(info, i), [img])) :: stms)
409                                            in                                            in
410                                              List.revAppend (mkStms (dims, 0, []), [                                              List.revAppend (mkStms (dims, 0, []), [
411                                                  IL.ASSGN(y, IL.CONS(DstTy.SeqTy(DstTy.intTy, d), dims))                                                  IR.ASSGN(y, IR.SEQ(dims, DstTy.SeqTy(DstTy.intTy, SOME d)))
412                                                ])                                                ])
413                                            end),                                            end),
414                  (BV.image_border,       fn (y, _, args as [img, _]) => let                  (BV.image_border,       fn (y, _, args as [img, _]) => let
415                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
416                                            in                                            in
417                                              assign(y, Op.BorderCtlDefault info, args)                                              assign(y, Op.BorderCtlDefault info, args)
418                                            end),                                            end),
419                  (BV.image_clamp,        fn (y, _, args as [img]) => let                  (BV.image_clamp,        fn (y, _, args as [img]) => let
420                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
421                                            in                                            in
422                                              assign(y, Op.BorderCtlClamp info, args)                                              assign(y, Op.BorderCtlClamp info, args)
423                                            end),                                            end),
424                  (BV.image_mirror,       fn (y, _, args as [img]) => let                  (BV.image_mirror,       fn (y, _, args as [img]) => let
425                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
426                                            in                                            in
427                                              assign(y, Op.BorderCtlMirror info, args)                                              assign(y, Op.BorderCtlMirror info, args)
428                                            end),                                            end),
429                  (BV.image_wrap,         fn (y, _, args as [img]) => let                  (BV.image_wrap,         fn (y, _, args as [img]) => let
430                                            val DstTy.ImageTy info = IL.Var.ty img                                            val DstTy.ImageTy info = IR.Var.ty img
431                                            in                                            in
432                                              assign(y, Op.BorderCtlWrap info, args)                                              assign(y, Op.BorderCtlWrap info, args)
433                                            end)                                            end),
434                    (BV.dist2_t,           fn (y,_,xs)=>dist(y,[2],args)),
435                    (BV.dist3_t,           fn (y,_,xs)=>dist(y,[3],args)),
436                    (BV.red_all,            fn (y, _, args as [e, v, k]) =>
437                                              assign(y, Op.R_All(IR.Var.ty v), args)),
438                    (BV.red_exists,         fn (y, _, args as [e, v, k]) =>
439                                              assign(y, Op.R_Exists(IR.Var.ty v), args)),
440                    (BV.red_max,            fn (y, _, args as [e, v, k]) =>
441                                              assign(y, Op.R_Max(IR.Var.ty v), args)),
442                    (BV.red_mean,           fn (y, _, args as [e, v, k]) =>
443                                              assign(y, Op.R_Mean(IR.Var.ty v), args)),
444                    (BV.red_min,            fn (y, _, args as [e, v, k]) =>
445                                              assign(y, Op.R_Min(IR.Var.ty v), args)),
446                    (BV.red_product,        fn (y, _, args as [e, v, k]) =>
447                                              assign(y, Op.R_Product(IR.Var.ty v),args)),
448                    (BV.red_sum,            fn (y, _, args as [e, v, k]) =>
449                                              assign(y, Op.R_Sum(IR.Var.ty v), args)),
450                    (BV.red_variance,       fn (y, _, args as [e, v, k]) =>
451                                              assign(y, Op.R_Variance(IR.Var.ty v), args)),
452                    (BV.fn_sphere_im,       fn (y, [tv], args as [p, s]) =>
453                                              assign(y, Op.SphereQuery(IR.Var.ty p, trType tv), args)),
454                    (BV.fn_sphere1_r,       fn (y, [tv], args as [p, s]) =>
455                                              assign(y, Op.SphereQuery(IR.Var.ty p, trType tv), args)),
456                    (BV.fn_sphere2_t,       fn (y, [tv], args as [p, s]) =>
457                                              assign(y, Op.SphereQuery(IR.Var.ty p, trType tv), args)),
458                    (BV.fn_sphere3_t,       fn (y, [tv], args as [p, s]) =>
459                                              assign(y, Op.SphereQuery(IR.Var.ty p, trType tv), args))
460                ];                ];
           (* add C math functions *)  
             List.app (fn (n, x) => insert(x, basisFn n)) BV.mathFns;  
461              tbl              tbl
462            end            end
463    
# Line 297  Line 465 
465             of SOME transFn => transFn(y, mvs, xs)             of SOME transFn => transFn(y, mvs, xs)
466              | NONE => raise Fail("TranslateBasis.translate: unknown basis function " ^ Var.uniqueNameOf f)              | NONE => raise Fail("TranslateBasis.translate: unknown basis function " ^ Var.uniqueNameOf f)
467            (* end case *))            (* end case *))
468  handle ex => (print(concat["translate (", IL.Var.toString y, ", ",  handle ex => (print(concat["translate (", IR.Var.toString y, ", ",
469  Var.uniqueNameOf f, ", ...)\n"]); raise ex)  Var.uniqueNameOf f, ", ...)\n"]); raise ex)
470    
471    end    end

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

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