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

SCM Repository

[diderot] Diff of /branches/vis12/src/compiler/simplify/eval.sml
ViewVC logotype

Diff of /branches/vis12/src/compiler/simplify/eval.sml

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

revision 234, Thu Aug 5 21:34:29 2010 UTC revision 245, Fri Aug 6 15:31:55 2010 UTC
# Line 6  Line 6 
6   * Evaluation of "static" expressions.   * Evaluation of "static" expressions.
7   *)   *)
8    
9  structure Eval =  structure Eval : sig
10    struct  
11        datatype value
12          = BV of bool
13          | SV of string
14          | IV of IntInf.int
15          | TV of (int list * real list)    (* tensors *)
16          | FV of FieldDef.field_def
17          | Img of ImageInfo.info
18          | KV of Kernel.kernel
19    
20        val evalStatics : Simple.block -> value Var.Map.map
21    
22      end = struct
23    
24      structure Ty = Types      structure Ty = Types
25      structure BV = BasisVars      structure BV = BasisVars
# Line 40  Line 52 
52            fun tensorBinOp rator [TV(s1, v1), TV(s2, v2)] =            fun tensorBinOp rator [TV(s1, v1), TV(s2, v2)] =
53                  TV(s1, ListPair.mapEq rator (v1, v2))                  TV(s1, ListPair.mapEq rator (v1, v2))
54            fun realBinOp rator [TV([], [a]), TV([], [b])] = RV(rator(a, b))            fun realBinOp rator [TV([], [a]), TV([], [b])] = RV(rator(a, b))
55              fun realUnOp rator [TV([], [a])] = RV(rator a)
56            fun intCmp rator [IV a, IV b] = BV(rator(a, b))            fun intCmp rator [IV a, IV b] = BV(rator(a, b))
57            fun realCmp rator [TV([], [a]), TV([], [b])] = BV(rator(a, b))            fun realCmp rator [TV([], [a]), TV([], [b])] = BV(rator(a, b))
58            fun boolCmp rator [BV a, BV b] = BV(rator(a, b))            fun boolCmp rator [BV a, BV b] = BV(rator(a, b))
# Line 78  Line 91 
91                  (BV.neq_ii,             intCmp (op <>)),                  (BV.neq_ii,             intCmp (op <>)),
92                  (BV.neq_ss,             stringCmp (op <>)),                  (BV.neq_ss,             stringCmp (op <>)),
93                  (BV.neq_rr,             realCmp Real.!=),                  (BV.neq_rr,             realCmp Real.!=),
94                    (BV.neg_i,              fn [IV i] => IV(~i)),
95  (*  (*
                 (BV.neg_i,              simpleOp(Op.Neg Op.IntTy)),  
96                  (BV.neg_t,              tensorOp Op.Neg),                  (BV.neg_t,              tensorOp Op.Neg),
97                  (BV.neg_f,              fn (y, _, xs) => assign(y, Op.NegField, xs)),  *)
98                    (BV.neg_f,              fn [FV fld] => FV(FieldDef.neg fld)),
99    (*
100                  (BV.op_at,              fn (y, _, xs) => assign(y, Op.Probe, xs)),                  (BV.op_at,              fn (y, _, xs) => assign(y, Op.Probe, xs)),
101                  (BV.op_D,               fn (y, _, xs) => assign(y, Op.DiffField, xs)),  *)
102                  (BV.op_norm,            tensorOp Op.Norm),                  (BV.op_D,               fn [FV fld] => FV(FieldDef.diff fld)),
                 (BV.op_not,             simpleOp Op.Not),  
103  (*  (*
104                  (BV.op_subscript,       fn (y, [SK, NK], xs) => ??), (*FIXME*)                  (BV.op_norm,            tensorOp Op.Norm),
105  *)  *)
106                    (BV.op_not,             fn [BV b] => BV(not b)),
107    (*
108                    (BV.op_subscript,       fn (y, [SK, NK], xs) => ??),
109                  (BV.fn_CL,              fn (y, _, xs) => assign(y, Op.CL, xs)),                  (BV.fn_CL,              fn (y, _, xs) => assign(y, Op.CL, xs)),
110                  (BV.fn_convolve,        fn (y, _, xs) => assign(y, Op.Convolve, xs)),  *)
111                  (BV.fn_cos,             simpleOp Op.Cos),                  (BV.fn_convolve,        fn [KV h, Img info] => FV(FieldDef.CONV(info, h))),
112                    (BV.fn_cos,             realUnOp Math.cos),
113    (*
114                  (BV.fn_dot,             vectorOp Op.Dot),                  (BV.fn_dot,             vectorOp Op.Dot),
115                  (BV.fn_inside,          fn (y, _, xs) => assign(y, Op.Inside, xs)),                  (BV.fn_inside,          fn (y, _, xs) => assign(y, Op.Inside, xs)),
116  *)  *)
# Line 101  Line 120 
120                  (BV.fn_pow,             realBinOp Real.Math.pow),                  (BV.fn_pow,             realBinOp Real.Math.pow),
121  (*  (*
122                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),                  (BV.fn_principleEvec,   vectorOp Op.PrincipleEvec),
                 (BV.fn_sin,             simpleOp Op.Sin),  
123  *)  *)
124                    (BV.fn_sin,             realUnOp Math.sin),
125                  (BV.kn_bspln3,          kernel Kernel.bspln3),                  (BV.kn_bspln3,          kernel Kernel.bspln3),
126                  (BV.kn_bspln5,          kernel Kernel.bspln5),                  (BV.kn_bspln5,          kernel Kernel.bspln5),
127                  (BV.kn_ctmr,            kernel Kernel.ctmr),                  (BV.kn_ctmr,            kernel Kernel.ctmr),
128                  (BV.kn_tent,            kernel Kernel.tent),                  (BV.kn_tent,            kernel Kernel.tent),
129                  (BV.i2r,                fn [IV i] => RV(real(IntInf.toInt i)))(*,                  (BV.i2r,                fn [IV i] => RV(real(IntInf.toInt i)))
                 (BV.input,              fn (y, [TK], xs) => ??), (*FIXME*)  
                 (BV.optInput,           fn (y, [TK], xs) => ??) (*FIXME*)  
 *)  
130                ];                ];
131              tbl              tbl
132            end            end
133    
134      fun loadImage (mvs, [SV filename]) = let      fun loadImage ([Ty.DIM dim, Ty.SHAPE shp], [SV filename]) = let
135            val info = ImageInfo.getInfo filename            val Ty.DimConst d = TypeUtil.resolveDim dim
136              val Ty.Shape dd = TypeUtil.resolveShape shp
137              val info as ImageInfo.ImgInfo{dim, ...} = ImageInfo.getInfo filename
138            in            in
139  (* FIXME: check image info details against mvs *)            (* check that the expected dimension and actual dimension match *)
140                if (d <> dim)
141                  then raise Fail(concat["image file \"", filename, "\" has wrong dimension"])
142                  else ();
143              (* check that the expected shape and actual shape match *)
144    (* FIXME *)
145              Img info              Img info
146            end            end
147    
# Line 142  Line 165 
165                       of SOME evalFn => evalFn (List.map (evalVar env) xs)                       of SOME evalFn => evalFn (List.map (evalVar env) xs)
166                        | NONE => raise Fail("Eval.exvalExp: unknown function " ^ Var.nameOf f)                        | NONE => raise Fail("Eval.exvalExp: unknown function " ^ Var.nameOf f)
167                      (* end case *))                      (* end case *))
168                  ) handle ex => raise Fail (concat [                  ) handle ex => (
169                      TextIO.output (TextIO.stdErr, concat [
170                      Var.uniqueNameOf f, "(",                      Var.uniqueNameOf f, "(",
171                      String.concatWith "," (List.map Var.uniqueNameOf xs),                      String.concatWith "," (List.map Var.uniqueNameOf xs),
172                      ") fails with exception ", exnName ex                        ") fails with exception ", exnName ex, "\n"
173                    ]))                      ]);
174                      raise ex))
175              | S.E_Cons xs => raise Fail "TODO: E_Cons"              | S.E_Cons xs => raise Fail "TODO: E_Cons"
176              | S.E_Input(ty, name, optDefault) => let              | S.E_Input(ty, name, optDefault) => let
177                  val optDefault = Option.map (evalVar env) optDefault                  val optDefault = Option.map (evalVar env) optDefault
# Line 170  Line 195 
195              | S.E_LoadImage info => Img info              | S.E_LoadImage info => Img info
196            (* end case *))            (* end case *))
197    
198        fun evalBlock (env, S.Block stms) = let
199              fun evalStm (stm, env) = (case stm
200                     of S.S_Assign(x, e) => VMap.insert(env, x, evalExp(env, e))
201                      | S.S_IfThenElse(x, b1, b2) => (case evalVar env x
202                           of BV true => evalBlock(env, b1)
203                            | BV false => evalBlock(env, b2)
204                            | _ => raise Fail "type error"
205                          (* end case *))
206                      | S.S_New _ => raise Fail "unexpected new actor"
207                      | S.S_Die => raise Fail "unexpected die"
208                      | S.S_Stabilize => raise Fail "unexpected stabilize"
209                    (* end case *))
210              in
211                List.foldl evalStm env stms
212              end
213    
214        fun evalStatics staticInit = evalBlock (VMap.empty, staticInit)
215    
216    end    end

Legend:
Removed from v.234  
changed lines
  Added in v.245

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