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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/mid-to-low/evalKrn-set.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/mid-to-low/evalKrn-set.sml

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

revision 3448, Fri Nov 20 20:33:38 2015 UTC revision 3542, Mon Jan 4 19:47:38 2016 UTC
# Line 12  Line 12 
12    
13      in      in
14    
15      val testing=0  
16      fun lookup e =H.lookup e      fun lookup e =H.lookup e
17      fun insert e=H.insert e      fun insert e=H.insert e
18      fun find e=H.find e      fun find e=H.find e
# Line 23  Line 23 
23      fun mkSubSca e= H.mkSubSca e      fun mkSubSca e= H.mkSubSca e
24      fun mkProdVec e =H.mkProdVec e      fun mkProdVec e =H.mkProdVec e
25      fun mkDotVec(setO,a,b,last)=H.mkDotVec(setO,last,[a,b])      fun mkDotVec(setO,a,b,last)=H.mkDotVec(setO,last,[a,b])
   
26      fun iTos n=Int.toString n      fun iTos n=Int.toString n
27      fun err str=raise Fail(str)      fun err str=raise Fail(str)
28      val realTy=DstTy.TensorTy []      val realTy=DstTy.TensorTy []
29      val intTy=DstTy.IntTy      val intTy=DstTy.IntTy
30      fun testp n =(case testing      val testing=false
31           of 0 => 1      fun testp n =if (testing) then (print(String.concat n);1) else 1
          | _  => (print(String.concat n);1)  
          (*end case *))  
32    
33       (* convert a rational to a FloatLit.float value.  We do this by long division       (* convert a rational to a FloatLit.float value.  We do this by long division
34       * with a cutoff when we get to 12 digits.       * with a cutoff when we get to 12 digits.
# Line 112  Line 109 
109      * Note that the coeffient vectors are flipped (cf high-to-low/probe.sml).      * Note that the coeffient vectors are flipped (cf high-to-low/probe.sml).
110      *)      *)
111      fun expandEvalKernel (setOrig,pre,d, h, k, x) = let      fun expandEvalKernel (setOrig,pre,d, h, k, x) = let
     val _="\n*********************\n"  
112           val {isCont, segs} = Kernel.curve (h, k)           val {isCont, segs} = Kernel.curve (h, k)
113           (* degree of polynomial *)           (* degree of polynomial *)
114           val deg = List.length(hd segs) - 1           val deg = List.length(hd segs) - 1
# Line 122  Line 118 
118                   Literal.Float(ratToFloat (Vector.sub (Vector.sub(segs, i), d)))                   Literal.Float(ratToFloat (Vector.sub (Vector.sub(segs, i), d)))
119           val ty = DstTy.vecTy d           val ty = DstTy.vecTy d
120           val coeffs = List.tabulate (deg+1,fn i => Var.new("P"^Int.toString i, ty))           val coeffs = List.tabulate (deg+1,fn i => Var.new("P"^Int.toString i, ty))
   
         (* code to define the coefficient vectors *)  
         (*  
         val coeffVecs = let  
             fun mk (x, (i, code)) = let  
                 val lits = List.tabulate(d, coefficient i)  
                 val vars = List.tabulate(d, fn _ => Var.new("_f", DstTy.realTy))  
               (*  val code =  
                     ListPair.map (fn (x, lit) => (x, DstIL.LIT lit)) (vars, lits) @(x, DstIL.CONS(Var.ty x, vars)) :: code  
                     *)  
   
                     val code0 =ListPair.map (fn (x, lit) => (x, DstIL.LIT lit)) (vars, lits)  
                     val code =code0@(x, DstIL.CONS(Var.ty x, vars)) :: code  
                     val _ = List.map (fn e=>print(LowToString.toStringAll(LowILTypes.realTy, DstIL.ASSGN e))) [(x,DstIL.CONS(Var.ty x, vars))]  
                 in  
                     (i-1, code)  
                 end  
             in  
                 #2 (List.foldr mk (deg, []) coeffs)  
             end  
   
   
          *)  
   
121           fun filterLit([],vars,code,opset)=(vars,code,opset)           fun filterLit([],vars,code,opset)=(vars,code,opset)
122           | filterLit((lhs,rhs)::es,vars,code,opset)=let           | filterLit((lhs,rhs)::es,vars,code,opset)=let
   
123             val (opset,var) = lowSet.filter(opset,(lhs,rhs))             val (opset,var) = lowSet.filter(opset,(lhs,rhs))
124             in (case var             in (case var
125                  of NONE=> filterLit(es,vars@[lhs], code@[(lhs, rhs)],opset)                  of NONE=> filterLit(es,vars@[lhs], code@[(lhs, rhs)],opset)
126                  | SOME v =>filterLit(es,vars@[v],code,opset)                  | SOME v =>filterLit(es,vars@[v],code,opset)
127              (*end case*))              (*end case*))
128            end            end
   
129           val (coeffVecs,setOrig) = let           val (coeffVecs,setOrig) = let
130           fun mk (x, (i::xs, code,opset)) = let           fun mk (x, (i::xs, code,opset)) = let
131                  val lits = List.tabulate(d, coefficient i)                  val lits = List.tabulate(d, coefficient i)
132                  val vars = List.tabulate(d, fn _ => Var.new("_f", DstTy.realTy))                  val vars = List.tabulate(d, fn _ => Var.new("_f", DstTy.realTy))
   
   
133                  val code0 =ListPair.map (fn (x, lit) => (x, DstIL.LIT lit)) (vars, lits)                  val code0 =ListPair.map (fn (x, lit) => (x, DstIL.LIT lit)) (vars, lits)
134                  val (vars,code0,opset)=filterLit(code0,[],[],opset)                  val (vars,code0,opset)=filterLit(code0,[],[],opset)
   
135                  val code =code@code0@[(x, DstIL.CONS(Var.ty x, vars))]                  val code =code@code0@[(x, DstIL.CONS(Var.ty x, vars))]
   
   
   
                 val _ = List.map (fn e=>(LowToString.toStringAll(LowILTypes.realTy, DstIL.ASSGN e))) [(x,DstIL.CONS(Var.ty x, vars))]  
136                  in                  in
137                      (xs, code,opset)                      (xs, code,opset)
138                  end                  end
# Line 178  Line 141 
141              in              in
142                  (b,c)                  (b,c)
143              end              end
   
   
   
   
144           val coeffVecsCode=List.map (fn(x,y)=>DstIL.ASSGN (x,y)) coeffVecs           val coeffVecsCode=List.map (fn(x,y)=>DstIL.ASSGN (x,y)) coeffVecs
   
   
145           fun getSet([],done,opset,cnt)=(done,opset,cnt)           fun getSet([],done,opset,cnt)=(done,opset,cnt)
146             | getSet( DstIL.ASSGN(lhs,rhs)::es,done,opset,cnt)=let             | getSet( DstIL.ASSGN(lhs,rhs)::es,done,opset,cnt)=let
147              val (opset,var) = lowSet.filter(opset,(lhs,rhs))              val (opset,var) = lowSet.filter(opset,(lhs,rhs))
# Line 194  Line 151 
151                              (*end case*))                              (*end case*))
152                  end                  end
153             | getSet (e1::es, done, opset,cnt)=getSet(es,done@[e1],opset,cnt)             | getSet (e1::es, done, opset,cnt)=getSet(es,done@[e1],opset,cnt)
          (*  
          val (coeffVecsCode,setOrig,cnt)=getSet(coeffVecsCode, [],setOrig,0)  
   
          val _ =("\nTASHreplaced"^Int.toString(cnt))  
          *)  
   
   
   
      val _ = List.map (fn e=>(LowToString.toStringAll(LowILTypes.realTy,e))) coeffVecsCode  
   
   
154          (*get dot product and addition of list of coeffs*)          (*get dot product and addition of list of coeffs*)
155           fun mkdot(setO,[e2,e1],code)=let           fun mkdot(setO,[e2,e1],code)=let
156              val (setA,vA,A)= mkProdVec(setO,d,[x,e2])              val (setA,vA,A)= mkProdVec(setO,d,[x,e2])

Legend:
Removed from v.3448  
changed lines
  Added in v.3542

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