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

SCM Repository

[diderot] Diff of /trunk/src/compiler/mid-to-low/mid-to-low.sml
ViewVC logotype

Diff of /trunk/src/compiler/mid-to-low/mid-to-low.sml

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

revision 463, Wed Oct 27 22:48:59 2010 UTC revision 464, Thu Oct 28 12:57:20 2010 UTC
# Line 12  Line 12 
12    
13    end = struct    end = struct
14    
   
15      structure SrcIL = MidIL      structure SrcIL = MidIL
16      structure SrcOp = MidOps      structure SrcOp = MidOps
17      structure VTbl = SrcIL.Var.Tbl      structure VTbl = SrcIL.Var.Tbl
18      structure DstIL = LowIL      structure DstIL = LowIL
19      structure DstTy = LowTypes      structure DstTy = LowILTypes
20      structure DstOp = LowOps      structure DstOp = LowOps
21    
22      type var_env = DstIL.var VTbl.hash_table      type var_env = DstIL.var VTbl.hash_table
# Line 37  Line 36 
36     * with a cutoff when we get to 12 digits.     * with a cutoff when we get to 12 digits.
37     *)     *)
38      fun ratToFloat r = (case Rational.explode r      fun ratToFloat r = (case Rational.explode r
39             of {sign=0, ...} => FloatList.zero             of {sign=0, ...} => FloatLit.zero false
40              | {sign, num, denom=1} => FloatLit.fromInt(sign * IntInf.toInt num)              | {sign, num, denom=1} => FloatLit.fromInt(sign * IntInf.toInt num)
41              | {sign, num, denom} => let              | {sign, num, denom} => let
42                (* normalize so that num <= denom *)                (* normalize so that num <= denom *)
43                  val (denom, exp) = let                  val (denom, exp) = let
44                        fun lp (n, denom) = if (denom < num)                        fun lp (n, denom) = if (denom < num)
45                              then lp(n+1, denom*10)                              then lp(n+1, denom*10)
46                              else (n, denom)                              else (denom, n)
47                        in                        in
48                          lp (0, denom)                          lp (1, denom)
49                        end                        end
50                (* normalize so that num <= denom < 10*num *)                (* normalize so that num <= denom < 10*num *)
51  (* FIXME *)                  val (num, exp) = let
52                          fun lp (n, num) = if (10*num < denom)
53                                then lp(n-1, 10*num)
54                                else (num, n)
55                          in
56                            lp (exp, num)
57                          end
58                (* divide num/denom, computing the resulting digits *)                (* divide num/denom, computing the resulting digits *)
59                  fun divLp (n, a) = let                  fun divLp (n, a) = let
60                        val (q, r) = IntInf.divMod(a, denom)                        val (q, r) = IntInf.divMod(a, denom)
# Line 58  Line 63 
63                          else if (n < 12) then let                          else if (n < 12) then let
64                            val (d, dd) = divLp(n+1, 10*r)                            val (d, dd) = divLp(n+1, 10*r)
65                            in                            in
66                              if (d < 10) then (q, d::dd) else (q+1, 0::dd)                              if (d < 10)
67                                  then (q, (IntInf.toInt d)::dd)
68                                  else (q+1, 0::dd)
69                            end                            end
70                          else if (IntInf.div(10*r, denom) < 5)                          else if (IntInf.div(10*r, denom) < 5)
71                            then (q, [])                            then (q, [])
72                            else (q+1, []) (* round up *)                            else (q+1, []) (* round up *)
73                        end                        end
74                  val digits = divLp (0, a)                  val digits = let
75                          val (d, dd) = divLp (0, num)
76                          in
77                            (IntInf.toInt d)::dd
78                          end
79                  in                  in
80  (* FIXME *)                    FloatLit.fromDigits{isNeg=(sign < 0), digits=digits, exp=exp}
81                  end                  end
82              (* end case *))
83    
   (* variable names for kernel coefficients *)  
84    (* expand the EvalKernel operations into vector operations.  The parameters are    (* expand the EvalKernel operations into vector operations.  The parameters are
85     *    result  -- the lhs variable to store the result     *    result  -- the lhs variable to store the result
86     *    d       -- the vector width of the operation, which should be equal to twice the     *    d       -- the vector width of the operation, which should be equal to twice the
# Line 79  Line 90 
90     *)     *)
91      fun expandEvalKernel (result, d, h, k, [x]) = let      fun expandEvalKernel (result, d, h, k, [x]) = let
92            val {isCont, segs} = Kernel.curve (h, k)            val {isCont, segs} = Kernel.curve (h, k)
93            val deg = List.length segs - i            val deg = List.length segs - 1
94          (* convert to a vector of vectors to give fast access *)          (* convert to a vector of vectors to give fast access *)
95            val segs = Vector.fromList (List.map Vector.fromList segs)            val segs = Vector.fromList (List.map Vector.fromList segs)
96          (* get the kernel coefficient value for the d'th term of the i'th          (* get the kernel coefficient value for the d'th term of the i'th
97           * segment.           * segment.
98           *)           *)
99            fun coefficient d i = ratToFloat (Vector.sub (Vector.sub(segs, i), d))            fun coefficient d i = Literal.Float(ratToFloat (Vector.sub (Vector.sub(segs, i), d)))
100            val ty = DstTy.VecTy d            val ty = DstTy.VecTy d
101            val coeffs = List.tabulate (deg+1,            val coeffs = List.tabulate (deg+1,
102                  fn i => DstIL.Var.new(str(chr(ord #"a" + (deg - i)))), ty)                  fn i => DstIL.Var.new(str(chr(ord #"a" + (deg - i))), ty))
103          (* define coefficient vectors *)          (* code to define the coefficient vectors *)
104            val coeffVecs = ???            val coeffVecs = let
105                    fun mk (x, (i, code)) = let
106                          val lits = List.tabulate(d, coefficient i)
107                          val vars = List.tabulate(d, fn _ => DstIL.Var.new("_f", DstTy.realTy))
108                          val code =
109                                ListPair.map (fn (x, lit) => (x, DstIL.LIT lit)) (vars, lits) @
110                                  (x, DstIL.CONS vars) :: code
111                          in
112                            (i-1, code)
113                          end
114                    in
115                      #2 (List.foldr mk (deg, []) coeffs)
116                    end
117          (* build the evaluation of the polynomials in reverse order *)          (* build the evaluation of the polynomials in reverse order *)
118            fun eval [coeff] = (coeff, coeffVecs)            fun eval [coeff] = (coeff, [])
119              | eval (coeff::r) = let              | eval (coeff::r) = let
120                  val (t1, stms) = eval r                  val (t1, stms) = eval r
121                  val t2 = DstIL.Var.new ("_t", ty)                  val t2 = DstIL.Var.new ("_t", ty)
# Line 104  Line 127 
127                  in                  in
128                    (t3, stms)                    (t3, stms)
129                  end                  end
130    (* FIXME: need to get result into "result" variable! *)
131              val (t, evalCode) = eval coeffs
132            in            in
133              List.rev (eval coeffs)              coeffVecs @ evalCode
134            end            end
135    
136    (* compute the load address for a given set of voxels indices *)    (* compute the load address for a given set of voxels indices *)
# Line 152  Line 177 
177                | SrcOp.LoadVoxels(rty, d) => assign (DstOp.LoadVoxels(rty, d))                | SrcOp.LoadVoxels(rty, d) => assign (DstOp.LoadVoxels(rty, d))
178                | SrcOp.PosToImgSpace info => assign (DstOp.PosToImgSpace info)                | SrcOp.PosToImgSpace info => assign (DstOp.PosToImgSpace info)
179                | SrcOp.GradToWorldSpace info => assign (DstOp.GradToWorldSpace info)                | SrcOp.GradToWorldSpace info => assign (DstOp.GradToWorldSpace info)
180                | SrcOp.EvalKernel(d, h, k) => expandEvalKernel(y, d, h, k)                | SrcOp.EvalKernel(d, h, k) => expandEvalKernel(y, d, h, k, renameList(env, args))
181                | SrcOp.LoadImage info => assign (DstOp.LoadImage info)                | SrcOp.LoadImage info => assign (DstOp.LoadImage info)
182                | SrcOp.Inside info => assign (DstOp.Inside info)                | SrcOp.Inside info => assign (DstOp.Inside info)
183                | SrcOp.Input(ty, name) => assign (DstOp.Input(ty, name))                | SrcOp.Input(ty, name) => assign (DstOp.Input(ty, name))

Legend:
Removed from v.463  
changed lines
  Added in v.464

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