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 2436, Sat Sep 21 15:57:18 2013 UTC revision 2437, Mon Sep 23 22:28:42 2013 UTC
# Line 5  Line 5 
5      structure G = GenericEin      structure G = GenericEin
6      structure E = Ein      structure E = Ein
7      structure S = Specialize      structure S = Specialize
     structure R = Rewrite  
   
   
8    
9      in      in
10    
11    
   
 (*  
 If changed is true then I know the expression will run through the funciton again.  
 However, if not, then I want to make sure that every expression in the Product is examined, and not just individually but as a group.  
 Prod[t1,t2,(t3+t4)] indivually=> same  
 Prod[t1] @ Prod[t2,(t3+t4)]=> Notice rule here  
 Prod[t1] @ Add(Prod (t2, t3), Prod (t2, t4))  
 => Add( Prod[t1, Prod(t2,t3)]..)  
 => Add (Prod[t1,t2,t3]) Flattened  
   
 *)  
   
   
   
   
   
12  (*Flattens Add constructor: change, expression *)  (*Flattens Add constructor: change, expression *)
13  fun mkAdd [e]=(1,e)  fun mkAdd [e]=(1,e)
14      | mkAdd(e)=let      | mkAdd(e)=let
# Line 71  Line 52 
52    
53    
54  fun mkEps(e)= (case e  fun mkEps(e)= (case e
55      of E.Apply(E.Partial [a], E.Prod( e2::m ))=> (0,e)      of E.Apply(E.Partial [E.V a], E.Prod( e2::m ))=> (0,e)
56       | E.Apply(E.Partial [a,b], E.Prod( (E.Epsilon(i,j,k))::m ))=>       | E.Apply(E.Partial [E.V a,E.V b], E.Prod( (E.Epsilon(i,j,k))::m ))=>
57          (if(a=i andalso b=j) then (1,E.Const(0.0))          (if(a=i andalso b=j) then (1,E.Const(0.0))
58          else if(a=i andalso b=k) then (1,E.Const(0.0))          else if(a=i andalso b=k) then (1,E.Const(0.0))
59          else if(a=j andalso b=i) then (1,E.Const(0.0))          else if(a=j andalso b=i) then (1,E.Const(0.0))
# Line 136  Line 117 
117      fun doubleEps((E.Epsilon (a,b,c))::(E.Epsilon(d,e,f))::es,e3)=      fun doubleEps((E.Epsilon (a,b,c))::(E.Epsilon(d,e,f))::es,e3)=
118          let          let
119          fun createDeltas(s,t,u,v, e3)=          fun createDeltas(s,t,u,v, e3)=
120              (1,  E.Sub(E.Sum(2,E.Prod([E.Delta(s,u), E.Delta(t,v)] @e3)),              (1,  E.Sub(E.Sum(2,E.Prod([E.Delta(E.V s,E.V u), E.Delta(E.V t,E.V v)] @e3)),
121                      E.Sum(2,E.Prod([E.Delta(s,v), E.Delta(t,u)]@e3))))                      E.Sum(2,E.Prod([E.Delta(E.V s,E.V v), E.Delta(E.V t,E.V u)]@e3))))
122          in if(a=d) then createDeltas(b,c,e,f, e3)          in if(a=d) then createDeltas(b,c,e,f, e3)
123             else if(a=e) then createDeltas(b,c,f,d, e3)             else if(a=e) then createDeltas(b,c,f,d, e3)
124             else if(a=f) then createDeltas(b,c,d,e, e3)             else if(a=f) then createDeltas(b,c,d,e, e3)
# Line 239  Line 220 
220               of E.Const _=> body               of E.Const _=> body
221                | E.Tensor _ =>body                | E.Tensor _ =>body
222                | E.Field _=> body                | E.Field _=> body
223                  | E.Kernel _ =>body
224                | E.Delta _ => body                | E.Delta _ => body
225                  | E.Value _ =>body
226                | E.Epsilon _=>body                | E.Epsilon _=>body
227                | E.Conv _=> body                | E.Neg e => E.Neg(rewriteBody e)
               | E.Partial _=>body  
228                            | E.Add es => let val (b,a)= mkAdd(List.map rewriteBody es)                            | E.Add es => let val (b,a)= mkAdd(List.map rewriteBody es)
229                      in if (b=1) then ( changed:=true;a) else a end                      in if (b=1) then ( changed:=true;a) else a end
               | E.Pair es=>  E.Pair(List.map rewriteBody es)  
               | E.Value _ => body  
230                | E.Sub (a,b)=>  E.Sub(rewriteBody a, rewriteBody b)                | E.Sub (a,b)=>  E.Sub(rewriteBody a, rewriteBody b)
231                | E.Div (a, b) => E.Div(rewriteBody a, rewriteBody b)                | E.Div (a, b) => E.Div(rewriteBody a, rewriteBody b)
232                | E.Probe(u,v)=> (  E.Probe(rewriteBody u, v))                | E.Partial _=>body
233                  | E.Conv (V, alpha)=> E.Conv(rewriteBody V, alpha)
234                  | E.Probe(u,v)=>  E.Probe(rewriteBody u, rewriteBody v)
235                  | E.Image es => E.Image(List.map rewriteBody es)
236    
237    
238    (************Summation *************)
239    
240                | E.Sum(0, e)=>e                | E.Sum(0, e)=>e
241                | E.Sum(_, (E.Const c))=> E.Const c                | E.Sum(_, (E.Const c))=> E.Const c
242                | E.Sum(c,(E.Add l))=> E.Add(List.map (fn e => E.Sum(c,e)) l)                | E.Sum(c,(E.Add l))=> E.Add(List.map (fn e => E.Sum(c,e)) l)
# Line 265  Line 252 
252                     else (changed :=true;q)                     else (changed :=true;q)
253                     end )                     end )
254    
255    
256    
257                | E.Sum(c,E.Prod((E.Epsilon e1 )::(E.Epsilon e2)::xs))=>                | E.Sum(c,E.Prod((E.Epsilon e1 )::(E.Epsilon e2)::xs))=>
258                     let val (i,eps, e)= epsToDels(body)                     let val (i,eps, e)= epsToDels(body)
259                     in                     in
# Line 286  Line 275 
275    
276              | E.Sum(c, E.Apply(E.Partial p,   E.Prod((E.Delta(i,j))::e3 )))=>              | E.Sum(c, E.Apply(E.Partial p,   E.Prod((E.Delta(i,j))::e3 )))=>
277    
278                  let fun part([], e2, counter)=([], e2, counter)                  let
279                     | part(p1::ps, [E.Delta(i,j)],counter)=if (p1=j) then ([i]@ps,[],counter-1)                     fun part([], e2, counter)=([], e2, counter)
280                          else (let val (a,b,counter)=part(ps, [E.Delta(i,j)],counter)                        | part(p1::ps, [E.Delta(i,j)],counter)=
281                                if (p1=j) then ([i]@ps,[],counter-1)
282                                else (let
283                                        val (a,b,counter)=part(ps, [E.Delta(i,j)],counter)
284                          in ([p1]@a, b,counter )  end)                          in ([p1]@a, b,counter )  end)
285                  val (e1,e2,counter)= part(p, [E.Delta(i,j)],c)                  val (e1,e2,counter)= part(p, [E.Delta(i,j)],c)
286    
287                     in   (E.Sum(counter, E.Apply(E.Partial e1, E.Prod(e2@e3)))) end                     in  E.Sum(counter, E.Apply(E.Partial e1, E.Prod(e2@e3))) end
288    
289              | E.Sum(c, E.Apply(p, e))=>let              | E.Sum(c, E.Apply(p, e))=>let
290                     val e'= rewriteBody(E.Sum(c, e))                     val e'= rewriteBody(E.Sum(c, e))
# Line 301  Line 293 
293                          of E.Sum(c',exp)=> mkSumApply(E.Sum(c', E.Apply(p', exp)))                          of E.Sum(c',exp)=> mkSumApply(E.Sum(c', E.Apply(p', exp)))
294                          |_=>mkApply( E.Apply(p', e')))                          |_=>mkApply( E.Apply(p', e')))
295                     in if(i=1) then (changed :=true;e2) else e2 end                     in if(i=1) then (changed :=true;e2) else e2 end
296                  | E.Sum(c, e)=> E.Sum(c, rewriteBody e)
297    
298    
299    
300    
301    
               | E.Sum(c, e)=> E.Sum(c, rewriteBody e)  
302    
303    (************Product**********)
304                | E.Prod([e1])=>(rewriteBody e1 )                | E.Prod([e1])=>(rewriteBody e1 )
305                | E.Prod(e1::(E.Add(e2))::e3)=>                | E.Prod(e1::(E.Add(e2))::e3)=>
306                      (changed := true;                      (changed := true; E.Add(List.map (fn e=> E.Prod([e1, e]@e3)) e2))
                     E.Add(List.map (fn e=> E.Prod([e1, e]@e3)) e2))  
307                | E.Prod(e1::(E.Sub(e2,e3))::e4)=>                | E.Prod(e1::(E.Sub(e2,e3))::e4)=>
308                      ( 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 )))
309                | E.Prod[E.Partial r1,E. Conv(E.Field(id,[i]), deltas)]=>                | E.Prod[E.Partial r1,E.Conv(f, deltas)]=>
310                      (changed:=true; (                      (changed:=true; E.Conv(f,deltas@r1))
                    let  
                     val j1= List.map (fn(x)=> (i,x))  r1  
                    in E.Conv(E.Field(id,[i]), j1@deltas) end ))  
311                | E.Prod((E.Partial r1)::(E.Partial r2)::e) =>                | E.Prod((E.Partial r1)::(E.Partial r2)::e) =>
312                      (changed := true; E.Prod([E.Partial (r1@r2)] @ e)  )                      (changed := true; E.Prod([E.Partial (r1@r2)] @ e)  )
313                | E.Prod[(E.Epsilon(e1,e2,e3)), E.Tensor(_,[i1,i2])]=>  
314    
315                  | E.Prod[(E.Epsilon(e1,e2,e3)), E.Tensor(_,[E.V i1,E.V i2])]=>
316                      if(e2=i1 andalso e3=i2) then (changed :=true;E.Const(0.0))                      if(e2=i1 andalso e3=i2) then (changed :=true;E.Const(0.0))
317                      else body                      else body
318    
319                | E.Prod((E.Epsilon eps1)::es)=> (let                | E.Prod((E.Epsilon eps1)::es)=> (let
320                     val rest=(case es of [e1] => rewriteBody e1                      val rest=(case es
321                     |_=> rewriteBody(E.Prod(es)))                          of [e1] => rewriteBody e1
322                             | _=> rewriteBody( E.Prod es))
323    
324                     val (i, solution)=(case rest                     val (i, solution)=(case rest
325                          of E.Prod m=> mkProd ([E.Epsilon eps1] @m )                          of E.Prod m=> mkProd ([E.Epsilon eps1] @m )
326                              |_=>  mkProd([E.Epsilon eps1]@ [rest]))                              |_=>  mkProd([E.Epsilon eps1]@ [rest]))
327                     in if (i=1) then (changed:=true;solution)                     in if (i=1) then (changed:=true;solution)
328                     else solution end)                      else solution
329                    end)
330    
331               | E.Prod (e::es) => (let val r=rewriteBody(E.Prod es)               | E.Prod (e::es) => (let
332                     val (i,solution)= (case r of E.Prod m => mkProd([e]@m )                      val r=rewriteBody(E.Prod es)
333                        val (i,solution)= (case r
334                            of E.Prod m => mkProd([e]@m )
335                                      |_=> mkProd([e]@ [r]))                                      |_=> mkProd([e]@ [r]))
336                     in if (i=1) then (changed:=true;solution)                     in if (i=1) then (changed:=true;solution)
337                     else solution end)                          else solution
338                | E.Apply(E.Const _,_) => (E.Const(0.0))                  end)
339    
340    (**************Apply*******************)
341    
342    
343                | E.Apply(E.Partial p, E.Prod((E.Delta(i,j))::e3))=>                | E.Apply(E.Partial p, E.Prod((E.Delta(i,j))::e3))=>
344                      let fun part([], e2)=([], e2)                      let fun part([], e2)=([], e2)
345                          | part(p1::ps, [E.Delta(i,j)])=if (p1=j) then ([i]@ps,[])                            | part(p1::ps, [E.Delta(i,j)])=
346                                if (p1=j) then ([i]@ps,[])
347                                  else (let val (a,b)=part(ps, [E.Delta(i,j)])                                  else (let val (a,b)=part(ps, [E.Delta(i,j)])
348                                  in ([p1]@a, b )  end)                                  in ([p1]@a, b )  end)
349                      val (e1,e2)= part(p, [E.Delta(i,j)])                      val (e1,e2)= part(p, [E.Delta(i,j)])
350                      in   E.Apply(E.Partial e1, E.Prod(e2@e3)) end                      in   E.Apply(E.Partial e1, E.Prod(e2@e3)) end
351    
352                | E.Apply(d,e)=> ( let val (t1,t2)= mkApply(E.Apply(rewriteBody d, rewriteBody e))                | E.Apply(E.Partial d,e)=> ( let val (t1,t2)= mkApply(E.Apply(E.Partial d, rewriteBody e))
353                      in if (t1=1) then (changed :=true;t2) else t2 end )                      in if (t1=1) then (changed :=true;t2) else t2 end )
354    
355                  | E.Apply(E.Prod d,e)=> ( let val (t1,t2)= mkApply(E.Apply(rewriteBody (E.Prod d), rewriteBody e))
356                       in if (t1=1) then (changed :=true;t2) else t2 end)
357    
358                  | E.Apply _ => (print "Err Apply ";body)
359    
360    
361                |_=> body                |_=> body
362    
363              (*end case*))              (*end case*))

Legend:
Removed from v.2436  
changed lines
  Added in v.2437

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