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

SCM Repository

[diderot] Diff of /branches/charisee_dev/src/compiler/high-il/normalize-ein.sml
ViewVC logotype

Diff of /branches/charisee_dev/src/compiler/high-il/normalize-ein.sml

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

revision 2603, Thu Apr 24 03:58:37 2014 UTC revision 2613, Wed May 7 04:35:38 2014 UTC
# Line 7  Line 7 
7      structure P=Printer      structure P=Printer
8      structure F=Filter      structure F=Filter
9      structure G=EpsHelpers      structure G=EpsHelpers
10    
11      in      in
12    
13  fun err str=raise Fail (String.concat["Ill-formed EIN Operator",str])  fun err str=raise Fail (String.concat["Ill-formed EIN Operator",str])
14    val testing=0
15    
16    fun flatProd [e]=e
17    | flatProd e=E.Prod e
18    
19    
20    fun prodAppPartial(es,p1)=(case es
21  fun prodAppPartial ([e1],p1)= E.Apply(E.Partial p1,e1)      of []      => raise Fail "Empty App Partial"
22    | prodAppPartial((e1::e2),p1)=let      | [e1]     => E.Apply(E.Partial p1,e1)
23        | (e1::e2) => let
24      val l= prodAppPartial(e2,p1)      val l= prodAppPartial(e2,p1)
25      val (_,e2')= F.mkProd[e1,l]      val (_,e2')= F.mkProd[e1,l]
26      val (_,e1')=F.mkProd(e2@ [E.Apply(E.Partial p1, e1)])      val (_,e1')=F.mkProd(e2@ [E.Apply(E.Partial p1, e1)])
27      in      in
28          E.Add[e1',e2']          E.Add[e1',e2']
29      end      end
30        (* end case *))
31    
32  (*rewritten Sum*)  (*rewritten Sum*)
33  fun mkSum(c1,e1)=(case e1  fun mkSum(c1,e1)=(case e1
# Line 34  Line 39 
39      | E.Epsilon _ => (0,E.Sum(c1,e1))      | E.Epsilon _ => (0,E.Sum(c1,e1))
40      | E.Tensor _  => (0,E.Sum(c1,e1))      | E.Tensor _  => (0,E.Sum(c1,e1))
41      | E.Neg e2    => (1,E.Neg(E.Sum(c1,e2)))      | E.Neg e2    => (1,E.Neg(E.Sum(c1,e2)))
     | E.Lift e    => (1,E.Lift(E.Sum(c1,e)))  
     | E.Sum(c2,e2)=> (1,E.Sum(c1@c2,e2))  
42      | E.Sub (a,b) => (1,E.Sub(E.Sum(c1,a),E.Sum(c1,b)))      | E.Sub (a,b) => (1,E.Sub(E.Sum(c1,a),E.Sum(c1,b)))
     | E.Div (a,b) => (1,E.Div(E.Sum(c1,a),E.Sum(c1,b)))  
43      | E.Add e     => (1,E.Add (List.map (fn(a)=>E.Sum(c1,a)) e))      | E.Add e     => (1,E.Add (List.map (fn(a)=>E.Sum(c1,a)) e))
44        | E.Div (a,b) => (1,E.Div(E.Sum(c1,a),E.Sum(c1,b)))
45        | E.Lift e    => (1,E.Lift(E.Sum(c1,e)))
46        | E.Sum(c2,e2)=> (1,E.Sum(c1@c2,e2))
47      | E.Prod p     =>F.filterSca(c1,p)      | E.Prod p     =>F.filterSca(c1,p)
48      | E.Const _   => err("Sum of Const")      | E.Const _   => err("Sum of Const")
49      | E.Partial _ => err("Sum of Partial")      | E.Partial _ => err("Sum of Partial")
# Line 60  Line 65 
65      | E.Apply(E.Partial d2,e2)  => let      | E.Apply(E.Partial d2,e2)  => let
66                          val E.Partial d3=d1                          val E.Partial d3=d1
67                          in (1,E.Apply(E.Partial(d3@d2),e2)) end                          in (1,E.Apply(E.Partial(d3@d2),e2)) end
68      | E.Neg e2    => (1,E.Neg(E.Apply(d1,e2)))      | E.Apply _   => err" Apply of non-Partial expression"
69      | E.Sum(c2,e2)=> (1,E.Sum(c2,E.Apply(d1,e2)))      | E.Sum(c2,e2)=> (1,E.Sum(c2,E.Apply(d1,e2)))
70        | E.Neg e2    => (1,E.Neg(E.Apply(d1,e2)))
71      | E.Add e     => (1,E.Add (List.map (fn(a)=>E.Apply(d1,a)) e))      | E.Add e     => (1,E.Add (List.map (fn(a)=>E.Apply(d1,a)) e))
72      | E.Sub (a,b) => (1,E.Sub(E.Apply(d1,a),E.Apply(d1,b)))      | E.Sub (a,b) => (1,E.Sub(E.Apply(d1,a),E.Apply(d1,b)))
73      | E.Div (a,b) => (1,E.Div(E.Apply(d1,a),E.Apply(d1,b)))      | E.Div (g,b) => let
74            in
75            (case F.filterField[b]
76            of (_,[]) => (1,E.Div(E.Apply(d1,g),b)) (*Division by a real*)
77            | (pre,h) => let
78                val g'=E.Apply(d1,g)
79                val h'=E.Apply(d1,flatProd(h))
80                val num=E.Sub(E.Prod([g']@h),E.Prod[g,h'])
81                val denom=E.Prod(pre@h@h)
82                in (1,E.Div(num,denom))
83                end
84            (*end case*))
85            end
86    
87      | E.Prod p =>let      | E.Prod p =>let
88          val (pre, post)= F.filterField p          val (pre, post)= F.filterField p
89          val E.Partial d3=d1          val E.Partial d3=d1
# Line 89  Line 108 
108      | E.Apply _   => (0,E.Probe(e1,x))      | E.Apply _   => (0,E.Probe(e1,x))
109      | E.Conv _    => (0,E.Probe(e1,x))      | E.Conv _    => (0,E.Probe(e1,x))
110      | E.Field _   => (0,E.Probe(e1,x))      | E.Field _   => (0,E.Probe(e1,x))
     | E.Add e     => (1,E.Add (List.map (fn(a)=>E.Probe(a,x)) e))  
111      | E.Sum(c,e') => (1,E.Sum(c,E.Probe(e',x)))      | E.Sum(c,e') => (1,E.Sum(c,E.Probe(e',x)))
112      | E.Div (a,b) => (1,E.Div(E.Probe(a,x),E.Probe(b,x)))      | E.Add e     => (1,E.Add (List.map (fn(a)=>E.Probe(a,x)) e))
113      | E.Sub (a,b) => (1,E.Sub(E.Probe(a,x),E.Probe(b,x)))      | E.Sub (a,b) => (1,E.Sub(E.Probe(a,x),E.Probe(b,x)))
114      | E.Neg e'    => (1,E.Neg(E.Probe(e',x)))      | E.Neg e'    => (1,E.Neg(E.Probe(e',x)))
115        | E.Div (a,b) => (1,E.Div(E.Probe(a,x),E.Probe(b,x)))
116      | E.Const _   => err("Const without Lift")      | E.Const _   => err("Const without Lift")
117      | E.Tensor _  => err("Tensor without Lift")      | E.Tensor _  => err("Tensor without Lift")
118      | E.Delta _   => err("Probe of Delta")      | E.Delta _   => err("Probe of Delta")
# Line 107  Line 126 
126    
127    
128    
  (*print summation range*)  
 fun handleIndex e= (case e  
     of E.C(cx)=> String.concat["'",Int.toString(cx),"'"]  
     |  E.V(ix)=> Int.toString(ix)  
     (*end case *))  
   
 fun handleSumRange (mu,lb,ub)= print(String.concat[(handleIndex mu),"[",Int.toString(lb),"-",Int.toString(ub),"]"])  
 fun printSx e=(print "\n $";List.map handleSumRange e; print "$")  
   
 fun K gg=String.concatWith "," (List.map (fn (E.V e1,_,_)=> (Int.toString(e1))) gg)  
 fun Kt gg=List.map (fn e1=> print(String.concat["[", (K e1),"]"])) gg  
129    
130  (*Apply normalize to each term in product list  (*Apply normalize to each term in product list
131  or Apply normalize to tail of each list*)  or Apply normalize to tail of each list*)
132  fun normalize (Ein.EIN{params, index, body}) = let  fun normalize (Ein.EIN{params, index, body}) = let
                 (* val _ = print(String.concat["\n IN NORMALIZE@", P.printbody(body),"@\n"])*)  
133        val changed = ref false        val changed = ref false
       val sumIndex=ref []  
134    
135        fun rewriteBody body =        fun rewriteBody body =(case body
             (case body  
136               of E.Const _=> body               of E.Const _=> body
137                | E.Tensor _ =>body                | E.Tensor _ =>body
138                | E.Field _=> body                | E.Field _=> body
# Line 157  Line 162 
162    
163                  (**************Apply, Sum, Probe**************)                  (**************Apply, Sum, Probe**************)
164                | E.Apply(E.Partial [],e)=> e                | E.Apply(E.Partial [],e)=> e
165                | E.Apply(E.Partial d1, e1)=>let              | E.Apply(E.Partial d1, e1) =>
166                    let
167                  val e2 = rewriteBody e1                  val e2 = rewriteBody e1
168                  val (c,e3)=mkapply(E.Partial d1,e2)                  val (c,e3)=mkapply(E.Partial d1,e2)
169                  in (case c of 1=>(changed:=true;e3)| _ =>e3 (*end case*))                  in (case c of 1=>(changed:=true;e3)| _ =>e3 (*end case*))
170                  end                  end
171                | E.Apply(E.Prod e1,e2)=>E.Apply(E.Partial(F.filterPartial e1), rewriteBody e2)              | E.Apply _                 => raise Fail" Not well-formed Apply expression"
172                | E.Sum([],e)=> (changed:=true;rewriteBody e)                | E.Sum([],e)=> (changed:=true;rewriteBody e)
173                | E.Sum(c,e)=>let                | E.Sum(c,e)=>let
174                  val ref x=sumIndex                  val (c,e')=mkSum(c,rewriteBody e)
175                  val c'=[c]@x                  in (case c of 0 => e'|_ => (changed:=true;e'))
                 val e'=(sumIndex:=c';rewriteBody e)  
                 val ref s=sumIndex  
                 val z=hd(s)  
                 val (cng,e2)=(sumIndex:=tl(s);mkSum(z,e'))  
                 in (case cng  
                     of 1=> (changed:=true;e2)  
                     |_=> e2  
                     (*end case*))  
176                  end                  end
177                | E.Probe(u,v)=>  let              | E.Probe(u,v)              =>
178                    let
179                  val (c',b')=mkprobe(rewriteBody u,rewriteBody v)                  val (c',b')=mkprobe(rewriteBody u,rewriteBody v)
180                  in (case c'                  in (case c'
181                      of 1=> (changed:=true;b')                      of 1=> (changed:=true;b')
182                      |_=> b'                      |_=> b'
183                      (*end case*))                      (*end case*))
184                  end                  end
   
185                  (*************Product**************)                  (*************Product**************)
186                  | E.Prod [] => raise Fail"missing elements in product"
187                | E.Prod [e1] => rewriteBody e1                | E.Prod [e1] => rewriteBody e1
               | E.Prod((E.Div(e2,e3))::e4)=>  
                 (changed :=true; E.Div(E.Prod([e2]@e4), e3 ))  
188                | E.Prod((E.Add(e2))::e3)=>                | E.Prod((E.Add(e2))::e3)=>
189                     (changed := true; E.Add(List.map (fn e=> E.Prod([e]@e3)) e2))                     (changed := true; E.Add(List.map (fn e=> E.Prod([e]@e3)) e2))
               | E.Prod(e1::E.Add(e2)::e3)=>  
                 (changed := true; E.Add(List.map (fn e=> E.Prod([e1,e]@e3)) e2))  
190                | E.Prod((E.Sub(e2,e3))::e4)=>                | E.Prod((E.Sub(e2,e3))::e4)=>
191                  (changed :=true; E.Sub(E.Prod([e2]@e4), E.Prod([e3]@e4 )))                  (changed :=true; E.Sub(E.Prod([e2]@e4), E.Prod([e3]@e4 )))
192                  | E.Prod((E.Div(e2,e3))::e4)=> (changed :=true; E.Div(E.Prod([e2]@e4), e3 ))
193                  | E.Prod(e1::E.Add(e2)::e3)=>
194                    (changed := true; E.Add(List.map (fn e=> E.Prod([e1,e]@e3)) e2))
195                | E.Prod(e1::E.Sub(e2,e3)::e4)=>                | E.Prod(e1::E.Sub(e2,e3)::e4)=>
196                  (changed :=true; E.Sub(E.Prod([e1,e2]@e4), E.Prod([e1,e3]@e4 )))                  (changed :=true; E.Sub(E.Prod([e1,e2]@e4), E.Prod([e1,e3]@e4 )))
197    
198    
   
199                  (*************Product EPS **************)                  (*************Product EPS **************)
200    
                 (* Apply (d, e) shoudl be convereted to Conv operator *)  
201                | E.Prod(E.Epsilon(i,j,k)::E.Apply(E.Partial d,e)::es)=>let                | E.Prod(E.Epsilon(i,j,k)::E.Apply(E.Partial d,e)::es)=>let
202                   val change= G.matchEps(0,d,[],[i,j,k])                   val change= G.matchEps(0,d,[],[i,j,k])
203                   in case (change,es)                   in case (change,es)
# Line 213  Line 209 
209                          in b end                          in b end
210                  end                  end
211                | E.Prod(E.Epsilon(i,j,k)::E.Conv(V,alpha, h, d)::es)=>let                | E.Prod(E.Epsilon(i,j,k)::E.Conv(V,alpha, h, d)::es)=>let
   
212                  val change= G.matchEps(0,d,[],[i,j,k])                  val change= G.matchEps(0,d,[],[i,j,k])
213                  in case (change,es)                  in case (change,es)
214                      of (1,_) =>(changed:=true; E.Const 0)                      of (1,_) =>(changed:=true; E.Const 0)
# Line 224  Line 219 
219                          in b end                          in b end
220                  end                  end
221    
   
222                | E.Prod[(E.Epsilon(e1,e2,e3)), E.Tensor(_,[E.V i1,E.V i2])]=>                | E.Prod[(E.Epsilon(e1,e2,e3)), E.Tensor(_,[E.V i1,E.V i2])]=>
223                      if(e2=i1 andalso e3=i2) then (changed :=true;E.Const(0))                      if(e2=i1 andalso e3=i2) then (changed :=true;E.Const(0))
224                      else body                      else body
225    
226                | E.Prod(E.Epsilon eps1::ps)=> (case (G.epsToDels(E.Epsilon eps1::ps))
227              | E.Prod(E.Epsilon eps1::ps)=>                  of (1,e,[],_,_)      =>(changed:=true;e)(* Changed to Deltas *)
228                  let                  | (1,e,sx,_,_)      =>(changed:=true;E.Sum(sx,e))(* Changed to Deltas *)
229                    | (0,_,_,_,[])   =>  body
230                  val ref x=sumIndex                  | (0,_,_,epsAll,rest) => let
                 val (i,s',e,rest)=G.epsToDels(x,body)  
                 in (case (i, e,rest)  
                 of (1,[e1],_) =>(changed:=true;sumIndex:=s';e1)  
                     |(0,eps,[])=>body  
                     | _ => let  
231                          val p'=rewriteBody(E.Prod rest)                          val p'=rewriteBody(E.Prod rest)
232                          val p''= (case p' of E.Prod p=>p |e=>[e])                          val(_,b)= F.mkProd(epsAll@[p'])
                         val(_,b)= F.mkProd (e@p'')  
233                          in b end                          in b end
234                          (*end case*))                          (*end case*))
                  end  
             | E.Prod(E.Sum(c1,E.Prod(E.Epsilon e1::es1))::E.Sum(c2,E.Prod(E.Epsilon e2::es2))::es)=>let  
                 val ref x=sumIndex  
   
   
                 val m= Kt x  
   
                 val c'= [c1@c2]@x  
                 val (i,s',e,rest)=G.epsToDels(c', E.Prod([E.Epsilon e1, E.Epsilon e2]@es1@es2@es))  
                  val gsg=Kt s'  
   
235    
236                  in (case (i, e,rest)              | E.Prod(E.Sum(c1,E.Prod(E.Epsilon e1::es1))::E.Sum(c2,E.Prod(E.Epsilon e2::es2))::es) =>
237                      of (1,[e1],_)=> (changed:=true;sumIndex:=s';let                  (case G.epsToDels([E.Epsilon e1, E.Epsilon e2]@es1@es2@es)
238                          val ss=List.nth(s',((length s')-2))                  of (1,e,sx,_,_)=> (changed:=true; E.Sum(c1@c2@sx,e))
239                          in                  | (0,_,_,_,_)=>let
                             E.Sum(ss,e1) end )  
                     | _=>let  
240                          val eA=rewriteBody(E.Sum(c1,E.Prod(E.Epsilon e1::es1)))                          val eA=rewriteBody(E.Sum(c1,E.Prod(E.Epsilon e1::es1)))
241                          val eB=rewriteBody(E.Prod(E.Sum(c2,E.Prod(E.Epsilon e2::es2))::es))                          val eB=rewriteBody(E.Prod(E.Sum(c2,E.Prod(E.Epsilon e2::es2))::es))
242                          val (_,e)=F.mkProd([eA,eB])                          val (_,e)=F.mkProd([eA,eB])
243                          in e                          in e
244                          end                          end
245                      (*end case*))                      (*end case*))
                 end  
246    
247              | E.Prod(E.Delta d::es)=>let              | E.Prod(E.Delta d::es)=>let
248                  val (pre',eps, dels,post)= F.filterGreek(E.Delta d::es)                  val (pre',eps, dels,post)= F.filterGreek(E.Delta d::es)
249                  val ref x=sumIndex                  val (change,a)=G.reduceDelta(eps, dels, post)
                 val (change,i',a)=G.reduceDelta(x, eps, dels, post)  
   
250                  in (case (change,a)                  in (case (change,a)
251                      of (0, _)=> E.Prod [E.Delta d,rewriteBody(E.Prod es)]                      of (0, _)=> E.Prod [E.Delta d,rewriteBody(E.Prod es)]
252                      | (_, E.Prod p)=>let                      | (_, E.Prod p)=>let
253                          val (_, p') = F.mkProd p                          val (_, p') = F.mkProd p
254                          in (changed:=true;sumIndex:=i';p') end                          in (changed:=true;p') end
255                      | _ => (changed:=true;sumIndex:=i';a )                      | _ => (changed:=true;a )
256                      (*end case*))                      (*end case*))
257                      end                      end
258    
# Line 301  Line 273 
273    
274                             in                             in
275                if !changed                if !changed
276                  then (print(String.concat["\nN =>",Int.toString(count),"--",P.printbody(body')]);                  then let
277                  changed := false ;sumIndex:=[];loop(body',count+1))                      val _= (case testing
278                            of 1=> (print(String.concat["\nN =>",Int.toString(count),"--",P.printbody(body')]);1)
279                            | _=> 1)
280                        in
281                            (changed := false ;loop(body',count+1))
282                        end
283                  else (body',count)                  else (body',count)
284              end              end
285    
286      val (b,count) = loop(body,0)      val (b,count) = loop(body,0)
287      val _ = print(String.concat["\n out of normalize \n",P.printbody(b),"\n Final CounterXX:",Int.toString(count),"\n\n"])      val _ =(case testing
288            of 1 => (print(String.concat["\n out of normalize \n",P.printbody(b),"\n    Final CounterXX:",Int.toString(count),"\n\n"]);1)
289            | _=> 1
290            (*end case*))
291      in      in
292                  (Ein.EIN{params=params, index=index, body=b},count)                  (Ein.EIN{params=params, index=index, body=b},count)
293      end      end

Legend:
Removed from v.2603  
changed lines
  Added in v.2613

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